Remove control-bucket from environmnts.yaml

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"
 
         . "launchpad.net/gocheck"
@@ skipping 200 matching lines @@
         c.Assert(e.Name(), Equals, "only")
 }
 
 func (suite) TestEnvironmentWithLocalConfig(c *C) {
         defer testing.MakeFakeHomeNoEnvironments(c, "blah").Restore()
 
         attrs := map[string]interface{}{
                 "admin-secret": "secret",
                 "local-attr":   "foo",
         }
-        ls := config.NewLocalConfig(attrs)
-        err := config.WriteLocalConfig("blah", ls)
+        ls := environs.NewLocalConfig(attrs)
+        err := environs.WriteLocalConfig("blah", ls)
         c.Assert(err, IsNil)
 
         env := `
 environments:
     blah:
         type: dummy
         state-server: false
         authorized-keys: i-am-a-key
 `
         outfile, err := environs.WriteEnvirons("", env)
         c.Assert(err, IsNil)
         path := testing.HomePath(".juju", "environments.yaml")
         c.Assert(path, Equals, outfile)
 
         e, err := environs.NewFromName("blah")
         c.Assert(err, IsNil)
         attrs = e.Config().AllAttrs()
         c.Assert(attrs["admin-secret"], Equals, "secret")
         c.Assert(attrs["local-attr"], Equals, "foo")
 }
 
 func (suite) TestLocalConfigDifferentEnvironment(c *C) {
         defer testing.MakeFakeHomeNoEnvironments(c, "blah").Restore()
 
         attrs := map[string]interface{}{
                 "admin-secret": "secret",
                 "local-attr":   "foo",
         }
-        ls := config.NewLocalConfig(attrs)
-        err := config.WriteLocalConfig("foo", ls)
+        ls := environs.NewLocalConfig(attrs)
+        err := environs.WriteLocalConfig("foo", ls)
         c.Assert(err, IsNil)
 
         env := `
 environments:
     blah:
         type: dummy
         state-server: false
         authorized-keys: i-am-a-key
 `
         outfile, err := environs.WriteEnvirons("", env)
         c.Assert(err, IsNil)
         path := testing.HomePath(".juju", "environments.yaml")
         c.Assert(path, Equals, outfile)
 
         e, err := environs.NewFromName("blah")
         c.Assert(err, IsNil)
         attrs = e.Config().AllAttrs()
         c.Assert(attrs["admin-secret"], Equals, "")
         c.Assert(attrs["local-attr"], Equals, "dummy-local-attr")
+}
+
+type hasLocalConfig struct{}
+
+func (lc *hasLocalConfig) LocalAttrs(cfg *config.Config) environs.LocalConfig {
+        return *environs.NewLocalConfig(map[string]interface{}{
+                "local-attr":    cfg.AllAttrs()["local-attr"],
+                "override-attr": cfg.AllAttrs()["override-attr"],
+        })
+}
+
+func (lc *hasLocalConfig) InitLocalAttrs(cfgAttrs map[string]interface{}) environs.LocalConfig {
+        attrs := cfgAttrs
+        attrs["local-attr"] = "foobar"
+        attrs["override-attr"] = "override"
+        return *environs.NewLocalConfig(attrs)
+}
+
+// mergeWithLocal works as expected when local config exists already for the specified environment.
+func (suite) TestNewWithLocalExisting(c *C) {
+        files := []testing.TestFile{
+                {".ssh/identity.pub", "identity"},
+        }
+        h := testing.MakeFakeHomeWithFiles(c, files)
+        defer h.Restore()
+
+        localAttrs := map[string]interface{}{
+                "local-attr":    "some-attr",
+                "override-attr": "foo",
+        }
+        localCfg := environs.NewLocalConfig(localAttrs)
+        err := environs.WriteLocalConfig("blah", localCfg)
+        c.Assert(err, IsNil)
+        allAttr, err := environs.MergeWithLocal(
+                &hasLocalConfig{},
+                map[string]interface{}{"type": "my-type", "name": "blah", "override-attr": "some-other-attr"})
+        c.Assert(err, IsNil)
+        c.Assert(allAttr["name"], Equals, "blah")
+        c.Assert(allAttr["local-attr"], Equals, "some-attr")
+        c.Assert(allAttr["override-attr"], Equals, "some-other-attr")
+}
+
+// mergeWithLocal works as expected when there is no existing local config for the specified environment.
+func (suite) TestNewWithLocalNonExisting(c *C) {
+        files := []testing.TestFile{
+                {".ssh/identity.pub", "identity"},
+        }
+        h := testing.MakeFakeHomeWithFiles(c, files)
+        defer h.Restore()
+
+        // Create a local config for some other environ.
+        localAttrs := map[string]interface{}{
+                "local-attr": "local-attr",
+        }
+        localCfg := environs.NewLocalConfig(localAttrs)
+        err := environs.WriteLocalConfig("something", localCfg)
+        c.Assert(err, IsNil)
+        allAttr, err := environs.MergeWithLocal(&hasLocalConfig{}, map[string]interface{}{"type": "my-type", "name": "blah"})
+        c.Assert(err, IsNil)
+        c.Check(allAttr["local-attr"], Equals, "foobar")
+        c.Assert(allAttr["override-attr"], Equals, "override")
 }
 
 func (suite) TestConfigRoundTrip(c *C) {
         cfg, err := config.New(map[string]interface{}{
                 "name":            "bladaam",
                 "type":            "dummy",
                 "state-server":    false,
                 "authorized-keys": "i-am-a-key",
                 "ca-cert":         testing.CACert,
                 "ca-private-key":  "",
@@ skipping 24 matching lines @@
         c.Assert(err, IsNil)
         cfg1, err := environs.BootstrapConfig(cfg)
         c.Assert(err, IsNil)
 
         expect := cfg.AllAttrs()
         delete(expect, "secret")
         expect["admin-secret"] = ""
         expect["ca-private-key"] = ""
         c.Assert(cfg1.AllAttrs(), DeepEquals, expect)
 }