state: add initial config map to Initialise

state/state_test.go

 package state_test
 
 import (
         "fmt"
         . "launchpad.net/gocheck"
         "launchpad.net/gozk/zookeeper"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/juju/testing"
         "launchpad.net/juju-core/state"
         coretesting "launchpad.net/juju-core/testing"
@@ skipping 25 matching lines @@
 }
 
 type StateSuite struct {
         ConnSuite
 }
 
 var _ = Suite(&StateSuite{})
 
 func (s *StateSuite) TestInitialize(c *C) {
         // Check that initialization of an already-initialized state succeeds.
-        st, err := state.Initialize(s.StateInfo(c))
+        st, err := state.Initialize(s.StateInfo(c), nil)
         c.Assert(err, IsNil)
         c.Assert(st, NotNil)
         st.Close()
 
         // Check that Open blocks until Initialize has succeeded.
         coretesting.ZkRemoveTree(s.zkConn, "/")
 
         errc := make(chan error)
         go func() {
                 st, err := state.Open(s.StateInfo(c))
                 errc <- err
                 if st != nil {
                         st.Close()
                 }
         }()
 
         // Wait a little while to verify that it's actually blocking.
         time.Sleep(200 * time.Millisecond)
         select {
         case err := <-errc:
                 c.Fatalf("state.Open did not block (returned error %v)", err)
         default:
         }
 
-        st, err = state.Initialize(s.StateInfo(c))
+        st, err = state.Initialize(s.StateInfo(c), nil)
         c.Assert(err, IsNil)
         c.Assert(st, NotNil)
         defer st.Close()
 
         select {
         case err := <-errc:
                 c.Assert(err, IsNil)
         case <-time.After(1e9):
                 c.Fatalf("state.Open blocked forever")
         }
 }
 
-func (s *StateSuite) TestEnvironConfig(c *C) {
-        _, err := s.zkConn.Set("/environment", "type: dummy\nname: foo\n", -1)
+func (s *StateSuite) TestInitalizeWithConfig(c *C) {
+        // clean existing state
+        coretesting.ZkRemoveTree(s.zkConn, "/")
+
+        m := map[string]interface{}{
+                "name":            "only",
+                "type":            "dummy",
+                "zookeeper":       true,
+                "authorized-keys": "i-am-a-key",
+        }
+        st, err := state.Initialize(s.StateInfo(c), m)
         c.Assert(err, IsNil)
-
-        env, err := s.State.EnvironConfig()
+        c.Assert(st, NotNil)
+        defer st.Close()
+        env, err := st.EnvironConfig()
         env.Read()
         c.Assert(err, IsNil)
-        c.Assert(env.Map(), DeepEquals, map[string]interface{}{"type": "dummy", "name": "foo"})
+        c.Assert(env.Map(), DeepEquals, m)
 }
 
 type environConfig map[string]interface{}
 
 var environmentWatchTests = []struct {
         key   string
         value interface{}
         want  map[string]interface{}
 }{
         {"provider", "dummy", environConfig{"provider": "dummy"}},
         {"secret", "shhh", environConfig{"provider": "dummy", "secret": "shhh"}},
         {"provider", "aws", environConfig{"provider": "aws", "secret": "shhh"}},
 }
 
 func (s *StateSuite) TestWatchEnvironment(c *C) {
         // Blank out the environment created by JujuConnSuite,
         // so that we know what we have.
         _, err := s.zkConn.Set("/environment", "", -1)
         c.Assert(err, IsNil)
-
         // fetch the /environment key as a *ConfigNode
         environConfigWatcher := s.State.WatchEnvironConfig()
         defer func() {
                 c.Assert(environConfigWatcher.Stop(), IsNil)
         }()
 
         config, ok := <-environConfigWatcher.Changes()
         c.Assert(ok, Equals, true)
 
         for i, test := range environmentWatchTests {
@@ skipping 328 matching lines @@
 func (*StateSuite) TestSortPorts(c *C) {
         for _, t := range sortPortsTests {
                 p := make([]state.Port, len(t.have))
                 copy(p, t.have)
                 state.SortPorts(p)
                 c.Check(p, DeepEquals, t.want)
                 state.SortPorts(p)
                 c.Check(p, DeepEquals, t.want)
         }
 }