environs: add Environs.Config method

environs/config_test.go

 // Copyright 2011, 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package environs_test
 
 import (
         "os"
         "path/filepath"
 
         gc "launchpad.net/gocheck"
@@ skipping 49 matching lines @@
 environments:
     only:
         foo: bar
 `, "only", `environment "only" has no type`,
         }, {`
 environments:
     only:
         foo: bar
         type: crazy
 `, "only", `environment "only" has an unknown provider type "crazy"`,
-        }, {`
-environments:
-    only:
-        type: dummy
-`, "only", `.*state-server: expected bool, got nothing`,
         },
 }
 
 func (suite) TestInvalidEnv(c *gc.C) {
         defer testing.MakeFakeHomeNoEnvironments(c, "only").Restore()
         for i, t := range invalidEnvTests {
                 c.Logf("running test %v", i)
                 es, err := environs.ReadEnvironsBytes([]byte(t.env))
                 c.Check(err, gc.IsNil)
-                e, err := es.Open(t.name)
+                cfg, err := es.Config(t.name)
                 c.Check(err, gc.ErrorMatches, t.err)
-                c.Check(e, gc.IsNil)
+                c.Check(cfg, gc.IsNil)
         }
 }
 
 func (suite) TestNoEnv(c *gc.C) {
         defer testing.MakeFakeHomeNoEnvironments(c).Restore()
         es, err := environs.ReadEnvirons("")
         c.Assert(es, gc.IsNil)
         c.Assert(err, jc.Satisfies, environs.IsNoEnv)
 }
 
 var configTests = []struct {
         env   string
-        check func(c *gc.C, es *environs.Environs)
+        check func(c *gc.C, envs *environs.Environs)
 }{
         {`
 environments:
     only:
         type: dummy
         state-server: false
-`, func(c *gc.C, es *environs.Environs) {
-                e, err := es.Open("")
+`, func(c *gc.C, envs *environs.Environs) {
+                cfg, err := envs.Config("")
                 c.Assert(err, gc.IsNil)
-                c.Assert(e.Name(), gc.Equals, "only")
+                c.Assert(cfg.Name(), gc.Equals, "only")
         }}, {`
 default:
     invalid
 environments:
     valid:
         type: dummy
         state-server: false
     invalid:
         type: crazy
-`, func(c *gc.C, es *environs.Environs) {
-                e, err := es.Open("")
+`, func(c *gc.C, envs *environs.Environs) {
+                cfg, err := envs.Config("")
                 c.Assert(err, gc.ErrorMatches, `environment "invalid" has an unknown provider type "crazy"`)
-                c.Assert(e, gc.IsNil)
-                e, err = es.Open("valid")
+                c.Assert(cfg, gc.IsNil)
+                cfg, err = envs.Config("valid")
                 c.Assert(err, gc.IsNil)
-                c.Assert(e.Name(), gc.Equals, "valid")
+                c.Assert(cfg.Name(), gc.Equals, "valid")
         }}, {`
 environments:
     one:
         type: dummy
         state-server: false
     two:
         type: dummy
         state-server: false
-`, func(c *gc.C, es *environs.Environs) {
-                e, err := es.Open("")
+`, func(c *gc.C, envs *environs.Environs) {
+                cfg, err := envs.Config("")
                 c.Assert(err, gc.ErrorMatches, `no default environment found`)
-                c.Assert(e, gc.IsNil)
+                c.Assert(cfg, gc.IsNil)
         }},
 }
 
 func (suite) TestConfig(c *gc.C) {
         defer testing.MakeFakeHomeNoEnvironments(c, "only", "valid", "one", "two").Restore()
         for i, t := range configTests {
                 c.Logf("running test %v", i)
-                es, err := environs.ReadEnvironsBytes([]byte(t.env))
+                envs, err := environs.ReadEnvironsBytes([]byte(t.env))
                 c.Assert(err, gc.IsNil)
-                t.check(c, es)
+                t.check(c, envs)
         }
 }
 
 func (suite) TestDefaultConfigFile(c *gc.C) {
         defer testing.MakeEmptyFakeHome(c).Restore()
 
         env := `
 environments:
     only:
         type: dummy
         state-server: false
         authorized-keys: i-am-a-key
 `
         outfile, err := environs.WriteEnvirons("", env)
         c.Assert(err, gc.IsNil)
         path := testing.HomePath(".juju", "environments.yaml")
         c.Assert(path, gc.Equals, outfile)
 
-        es, err := environs.ReadEnvirons("")
+        envs, err := environs.ReadEnvirons("")
         c.Assert(err, gc.IsNil)
-        e, err := es.Open("")
+        cfg, err := envs.Config("")
         c.Assert(err, gc.IsNil)
-        c.Assert(e.Name(), gc.Equals, "only")
+        c.Assert(cfg.Name(), gc.Equals, "only")
 }
 
 func (suite) TestConfigPerm(c *gc.C) {
         defer testing.MakeSampleHome(c).Restore()
 
         path := testing.HomePath(".juju")
         info, err := os.Lstat(path)
         c.Assert(err, gc.IsNil)
         oldPerm := info.Mode().Perm()
         env := `
@@ skipping 24 matching lines @@
     only:
         type: dummy
         state-server: false
         authorized-keys: i-am-a-key
 `
         path := filepath.Join(c.MkDir(), "a-file")
         outfile, err := environs.WriteEnvirons(path, env)
         c.Assert(err, gc.IsNil)
         c.Assert(path, gc.Equals, outfile)
 
-        es, err := environs.ReadEnvirons(path)
+        envs, err := environs.ReadEnvirons(path)
         c.Assert(err, gc.IsNil)
-        e, err := es.Open("")
+        cfg, err := envs.Config("")
         c.Assert(err, gc.IsNil)
-        c.Assert(e.Name(), gc.Equals, "only")
+        c.Assert(cfg.Name(), gc.Equals, "only")
 }
 
 func (suite) TestConfigRoundTrip(c *gc.C) {
         cfg, err := config.New(config.NoDefaults, dummySampleConfig())
         c.Assert(err, gc.IsNil)
         provider, err := environs.Provider(cfg.Type())
         c.Assert(err, gc.IsNil)
         cfg, err = provider.Validate(cfg, nil)
         c.Assert(err, gc.IsNil)
         env, err := environs.New(cfg)
@@ skipping 21 matching lines @@
 
         cfg1, err := environs.BootstrapConfig(cfg)
         c.Assert(err, gc.IsNil)
 
         expect := cfg.AllAttrs()
         delete(expect, "secret")
         expect["admin-secret"] = ""
         expect["ca-private-key"] = ""
         c.Assert(cfg1.AllAttrs(), gc.DeepEquals, expect)
 }