environs/config: error for cert not found

environs/config/config_test.go

 package config_test
 
 import (
         "io/ioutil"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/testing"
         "launchpad.net/juju-core/version"
         "os"
         "path/filepath"
         stdtesting "testing"
 )
 
 func Test(t *stdtesting.T) {
         TestingT(t)
 }
 
 type ConfigSuite struct {
         testing.LoggingSuite
         home string
 }
 
 var _ = Suite(&ConfigSuite{})
 
 type attrs map[string]interface{}
 
-var configTests = []struct {
+type configTest struct {
         about string
         attrs map[string]interface{}
         err   string
-}{
+}
+
+var configTests = []configTest{
         {
                 about: "The minimum good configuration",
                 attrs: attrs{
                         "type": "my-type",
                         "name": "my-name",
                 },
         }, {
                 about: "Explicit series",
                 attrs: attrs{
                         "type":           "my-type",
@@ skipping 197 matching lines @@
                 about: "Illegal firewall mode",
                 attrs: attrs{
                         "type":          "my-type",
                         "name":          "my-name",
                         "firewall-mode": "illegal",
                 },
                 err: "invalid firewall mode in environment configuration: .*",
         },
 }
 
-var configTestFiles = []struct {
+type configTestFile struct {
         name, data string
-}{
+}
+
+var configTestFiles = []configTestFile{
         {".ssh/id_dsa.pub", "dsa"},
         {".ssh/id_rsa.pub", "rsa\n"},
         {".ssh/identity.pub", "identity"},
         {".ssh/authorized_keys", "auth0\n# first\nauth1\n\n"},
         {".ssh/authorized_keys2", "auth2\nauth3\n"},
 
         {".juju/my-name-cert.pem", caCert},
         {".juju/my-name-private-key.pem", caKey},
         {".juju/cacert2.pem", caCert2},
         {".juju/cakey2.pem", caKey2},
         {"othercert.pem", caCert3},
         {"otherkey.pem", caKey3},
 }
 
 func (*ConfigSuite) TestConfig(c *C) {
         homeDir := filepath.Join(c.MkDir(), "me")
         defer os.Setenv("HOME", os.Getenv("HOME"))
         os.Setenv("HOME", homeDir)
-
-        for _, f := range configTestFiles {
-                path := filepath.Join(homeDir, f.name)
-                err := os.MkdirAll(filepath.Dir(path), 0700)
-                c.Assert(err, IsNil)
-                err = ioutil.WriteFile(path, []byte(f.data), 0666)
-                c.Assert(err, IsNil)
-        }
+        writeFiles(c, configTestFiles)
 
         for i, test := range configTests {
                 c.Logf("test %d. %s", i, test.about)
 
                 cfg, err := config.New(test.attrs)
                 if test.err != "" {
                         c.Assert(err, ErrorMatches, test.err)
                         continue
                 }
                 c.Assert(err, IsNil)
@@ skipping 49 matching lines @@
                 if path, _ := test.attrs["ca-private-key-path"].(string); path != "" {
                         c.Assert(cfg.CAPrivateKeyPEM(), Equals, fileContents(c, path))
                 } else if k, ok := test.attrs["ca-private-key"]; ok {
                         c.Assert(cfg.CAPrivateKeyPEM(), Equals, k)
                 } else {
                         c.Assert(cfg.CAPrivateKeyPEM(), Equals, caKey)
                 }
         }
 }
 
+// We use a different set of test files for testing behaviour
+// when the CA certificate is not found, as the files
+// can't contain the default CA file.
+var certNotFoundTestFiles = []configTestFile{
+        {".ssh/id_rsa.pub", "rsa\n"},
+        {"othercert.pem", caCert3},
+        {"otherkey.pem", caKey3},
+}
+
+var caCertNotFoundTests = []configTest{
+        {
+                about: "CA cert not found",
+                attrs: attrs{
+                        "type": "my-type",
+                        "name": "my-name",
+                },
+                err: config.ErrDefaultCACertNotFound.Error(),
+        }, {
+                about: "CA cert not there but private key specified",
+                attrs: attrs{
+                        "type":           "my-type",
+                        "name":           "my-name",
+                        "ca-private-key": caKey,
+                },
+                err: "open .*my-name-cert.pem:.*",
+        }, {
+                about: "CA cert not there but private key specified as non-existent path",
+                attrs: attrs{
+                        "type":           "my-type",
+                        "name":           "my-name",
+                        "ca-private-key": "blah.pem",
+                },
+                err: "open .*my-name-cert.pem:.*",
+        }, {
+                about: "CA cert specified as non-existent path",
+                attrs: attrs{
+                        "type":         "my-type",
+                        "name":         "my-name",
+                        "ca-cert-path": ".juju/my-name-cert.pem",
+                },
+                err: "open .*my-name-cert.pem:.*",
+        },
+}
+
+func (*ConfigSuite) TestCACertNotFound(c *C) {
+        homeDir := filepath.Join(c.MkDir(), "me")
+        defer os.Setenv("HOME", os.Getenv("HOME"))
+        os.Setenv("HOME", homeDir)
+        writeFiles(c, certNotFoundTestFiles)
+
+        for i, test := range caCertNotFoundTests {
+                c.Logf("test %d. %s", i, test.about)
+
+                cfg, err := config.New(test.attrs)
+                c.Assert(err, ErrorMatches, test.err)
+                c.Assert(cfg, IsNil)
+        }
+}
+
+func writeFiles(c *C, files []configTestFile) {
+        homeDir := os.Getenv("HOME")
+        for _, f := range files {
+                path := filepath.Join(homeDir, f.name)
+                err := os.MkdirAll(filepath.Dir(path), 0700)
+                c.Assert(err, IsNil)
+                err = ioutil.WriteFile(path, []byte(f.data), 0666)
+                c.Assert(err, IsNil)
+        }
+}
+
 // fileContents returns the test file contents for the
 // given specified path (which may be relative, so
 // we compare with the base filename only).
 func fileContents(c *C, path string) string {
         for _, f := range configTestFiles {
                 if filepath.Base(f.name) == filepath.Base(path) {
                         return f.data
                 }
         }
         c.Fatalf("path attribute holds unknown test file: %q", path)
@@ skipping 111 matching lines @@
 -----BEGIN RSA PRIVATE KEY-----
 MIIBOgIBAAJAZabKgKInuOxj5vDWLwHHQtK3/45KB+32D15w94Nt83BmuGxo90lw
 -----END RSA PRIVATE KEY-----
 `[1:]
 
 var invalidCACert = `
 -----BEGIN CERTIFICATE-----
 MIIBOgIBAAJAZabKgKInuOxj5vDWLwHHQtK3/45KB+32D15w94Nt83BmuGxo90lw
 -----END CERTIFICATE-----
 `[1:]