state: add CACert to Info.

state/state_test.go

 package state_test
 
 import (
         "fmt"
         "labix.org/v2/mgo/bson"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/testing"
@@ skipping 381 matching lines @@
 
 func (s *StateSuite) TestEnvironConfig(c *C) {
         initial := map[string]interface{}{
                 "name":            "test",
                 "type":            "test",
                 "authorized-keys": "i-am-a-key",
                 "default-series":  "precise",
                 "development":     true,
                 "firewall-mode":   "",
                 "admin-secret":    "",
+                "ca-cert":         testing.CACert,
+                "ca-private-key":  "",
         }
         cfg, err := config.New(initial)
         c.Assert(err, IsNil)
         st, err := state.Initialize(state.TestingStateInfo(), cfg)
         c.Assert(err, IsNil)
         st.Close()
         c.Assert(err, IsNil)
         cfg, err = s.State.EnvironConfig()
         c.Assert(err, IsNil)
         current := cfg.AllAttrs()
@@ skipping 11 matching lines @@
 }
 
 func (s *StateSuite) TestEnvironConfigWithAdminSecret(c *C) {
         attrs := map[string]interface{}{
                 "name":            "test",
                 "type":            "test",
                 "authorized-keys": "i-am-a-key",
                 "default-series":  "precise",
                 "development":     true,
                 "admin-secret":    "foo",
+                "ca-cert":         testing.CACert,
+                "ca-private-key":  "",
         }
         cfg, err := config.New(attrs)
         c.Assert(err, IsNil)
         _, err = state.Initialize(state.TestingStateInfo(), cfg)
         c.Assert(err, ErrorMatches, "admin-secret should never be written to the state")
 
         delete(attrs, "admin-secret")
         cfg, err = config.New(attrs)
         st, err := state.Initialize(state.TestingStateInfo(), cfg)
         c.Assert(err, IsNil)
@@ skipping 340 matching lines @@
 
 func (s *StateSuite) TestInitialize(c *C) {
         m := map[string]interface{}{
                 "type":            "dummy",
                 "name":            "lisboa",
                 "authorized-keys": "i-am-a-key",
                 "default-series":  "precise",
                 "development":     true,
                 "firewall-mode":   "",
                 "admin-secret":    "",
+                "ca-cert":         testing.CACert,
+                "ca-private-key":  "",
         }
         cfg, err := config.New(m)
         c.Assert(err, IsNil)
         st, err := state.Initialize(state.TestingStateInfo(), cfg)
         c.Assert(err, IsNil)
         c.Assert(st, NotNil)
         defer st.Close()
         env, err := st.EnvironConfig()
         c.Assert(env.AllAttrs(), DeepEquals, m)
 }
 
 func (s *StateSuite) TestDoubleInitialize(c *C) {
         m := map[string]interface{}{
                 "type":            "dummy",
                 "name":            "lisboa",
                 "authorized-keys": "i-am-a-key",
                 "default-series":  "precise",
                 "development":     true,
                 "firewall-mode":   "",
                 "admin-secret":    "",
+                "ca-cert":         testing.CACert,
+                "ca-private-key":  "",
         }
         cfg, err := config.New(m)
         c.Assert(err, IsNil)
         st, err := state.Initialize(state.TestingStateInfo(), cfg)
         c.Assert(err, IsNil)
         c.Assert(st, NotNil)
         env1, err := st.EnvironConfig()
         st.Close()
 
         // initialize again, there should be no error and the
         // environ config should not change.
         m = map[string]interface{}{
                 "type":            "dummy",
                 "name":            "sydney",
                 "authorized-keys": "i-am-not-an-animal",
                 "default-series":  "xanadu",
                 "development":     false,
                 "firewall-mode":   "",
                 "admin-secret":    "",
+                "ca-cert":         testing.CACert,
+                "ca-private-key":  "",
         }
         cfg, err = config.New(m)
         c.Assert(err, IsNil)
         st, err = state.Initialize(state.TestingStateInfo(), cfg)
         c.Assert(err, IsNil)
         c.Assert(st, NotNil)
         env2, err := st.EnvironConfig()
         st.Close()
 
         c.Assert(env1.AllAttrs(), DeepEquals, env2.AllAttrs())
@@ skipping 34 matching lines @@
         assertService("foo-2foo", true)
 }
 
 type attrs map[string]interface{}
 
 var watchEnvironConfigTests = []attrs{
         {
                 "type":            "my-type",
                 "name":            "my-name",
                 "authorized-keys": "i-am-a-key",
+                "ca-cert":         testing.CACert,
+                "ca-private-key":  "",
         },
         {
                 // Add an attribute.
                 "type":            "my-type",
                 "name":            "my-name",
                 "default-series":  "my-series",
                 "authorized-keys": "i-am-a-key",
+                "ca-cert":         testing.CACert,
+                "ca-private-key":  "",
         },
         {
                 // Set a new attribute value.
                 "type":            "my-type",
                 "name":            "my-new-name",
                 "default-series":  "my-series",
                 "authorized-keys": "i-am-a-key",
+                "ca-cert":         testing.CACert,
+                "ca-private-key":  "",
         },
 }
 
 func (s *StateSuite) TestWatchEnvironConfig(c *C) {
         watcher := s.State.WatchEnvironConfig()
         defer func() {
                 c.Assert(watcher.Stop(), IsNil)
         }()
         for i, test := range watchEnvironConfigTests {
                 c.Logf("test %d", i)
@@ skipping 41 matching lines @@
         case <-time.After(500 * time.Millisecond):
                 c.Fatalf("did not get change")
         }
 }
 
 func (s *StateSuite) TestWatchEnvironConfigInvalidConfig(c *C) {
         m := map[string]interface{}{
                 "type":            "dummy",
                 "name":            "lisboa",
                 "authorized-keys": "i-am-a-key",
+                "ca-cert":         testing.CACert,
+                "ca-private-key":  "",
         }
         cfg1, err := config.New(m)
         c.Assert(err, IsNil)
         st, err := state.Initialize(state.TestingStateInfo(), cfg1)
         c.Assert(err, IsNil)
         st.Close()
 
         // Corrupt the environment configuration.
         settings := s.Session.DB("juju").C("settings")
         err = settings.UpdateId("e", bson.D{{"$unset", bson.D{{"name", 1}}}})
@@ skipping 25 matching lines @@
         case <-done:
                 c.Fatalf("configuration returned too soon")
         case <-time.After(100 * time.Millisecond):
         }
 
         // Fix the configuration.
         cfg2, err := config.New(map[string]interface{}{
                 "type":            "dummy",
                 "name":            "lisboa",
                 "authorized-keys": "new-key",
+                "ca-cert":         testing.CACert,
+                "ca-private-key":  "",
         })
         c.Assert(err, IsNil)
         err = s.State.SetEnvironConfig(cfg2)
         c.Assert(err, IsNil)
 
         s.State.StartSync()
         select {
         case cfg3 := <-done:
                 c.Assert(cfg3.AllAttrs(), DeepEquals, cfg2.AllAttrs())
         case <-time.After(5 * time.Second):
@@ skipping 145 matching lines @@
         c.Assert(err, IsNil)
 
         // Check that removing the password is idempotent.
         err = s.State.SetAdminPassword("")
         c.Assert(err, IsNil)
 
         info.Password = ""
         err = tryOpenState(info)
         c.Assert(err, IsNil)
 }