provisioner: changed environment config. test

worker/provisioner/provisioner_test.go

 package provisioner_test
 
 import (
         "time"
 
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/environs/dummy"
         "launchpad.net/juju-core/juju/testing"
@@ skipping 48 matching lines @@
         return s.State.SetEnvironConfig(s.cfg)
 }
 
 func (s *ProvisionerSuite) stopProvisioner(c *C, p *provisioner.Provisioner) {
         c.Assert(p.Stop(), IsNil)
 }
 
 // checkStartInstance checks that an instance has been started
 // with a machine id the same as m's, and that the machine's
 // instance id has been set appropriately.
-func (s *ProvisionerSuite) checkStartInstance(c *C, m *state.Machine) {
+func (s *ProvisionerSuite) checkStartInstance(c *C, m *state.Machine, secret string) {
         for {
                 select {
                 case o := <-s.op:
                         switch o := o.(type) {
                         case dummy.OpStartInstance:
                                 c.Assert(o.Info, DeepEquals, s.StateInfo(c))
                                 c.Assert(o.MachineId, Equals, m.Id())
                                 c.Assert(o.Instance, NotNil)
                                 s.checkMachineId(c, m, o.Instance)
+                                c.Assert(o.Secret, Equals, secret)
                                 return
                         default:
                                 c.Logf("ignoring unexpected operation %#v", o)
                         }
                 case <-time.After(2 * time.Second):
                         c.Errorf("provisioner did not start an instance")
                         return
                 }
         }
 }
@@ skipping 60 matching lines @@
         id, err := m.InstanceId()
         c.Assert(err, IsNil)
         c.Assert(id, Equals, instId)
 }
 
 func (s *ProvisionerSuite) TestProvisionerStartStop(c *C) {
         p := provisioner.NewProvisioner(s.State)
         c.Assert(p.Stop(), IsNil)
 }
 
-func (s *ProvisionerSuite) TestProvisionerEnvironmentChange(c *C) {
-        p := provisioner.NewProvisioner(s.State)
-        defer s.stopProvisioner(c, p)
-        // Twiddle with the environment configuration.
-        cfg, err := s.State.EnvironConfig()
-        c.Assert(err, IsNil)
-        cfgAttrs := cfg.AllAttrs()
-        cfgAttrs["name"] = "testing2"
-        cfg, err = config.New(cfgAttrs)
-        c.Assert(err, IsNil)
-        err = s.State.SetEnvironConfig(cfg)
-        c.Assert(err, IsNil)
-        cfgAttrs["name"] = "testing3"
-        cfg, err = config.New(cfgAttrs)
-        c.Assert(err, IsNil)
-        err = s.State.SetEnvironConfig(cfg)
-        c.Assert(err, IsNil)
-}
-
 func (s *ProvisionerSuite) TestProvisionerStopOnStateClose(c *C) {
         st, err := state.Open(s.StateInfo(c))
         c.Assert(err, IsNil)
         p := provisioner.NewProvisioner(st)
 
         p.CloseState()
 
         // must use Check to avoid leaking PA
         c.Check(p.Wait(), ErrorMatches, ".* zookeeper is closing")
         c.Assert(p.Stop(), ErrorMatches, ".* zookeeper is closing")
 }
 
 // Start and stop one machine, watch the PA.
 func (s *ProvisionerSuite) TestSimple(c *C) {
         p := provisioner.NewProvisioner(s.State)
         defer s.stopProvisioner(c, p)
 
         // place a new machine into the state
         m, err := s.State.AddMachine()
         c.Assert(err, IsNil)
 
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "pork")
 
         // now remove it
         c.Assert(s.State.RemoveMachine(m.Id()), IsNil)
 
         // watch the PA remove it
         s.checkStopInstance(c)
         s.checkMachineId(c, m, nil)
 }
 
 func (s *ProvisionerSuite) TestProvisioningDoesNotOccurWithAnInvalidEnvironment(c *C) {
@@ skipping 21 matching lines @@
         // try to create a machine
         m, err := s.State.AddMachine()
         c.Assert(err, IsNil)
 
         // the PA should not create it
         s.checkNotStartInstance(c)
 
         err = s.fixEnvironment()
         c.Assert(err, IsNil)
 
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "pork")
 }
 
 func (s *ProvisionerSuite) TestProvisioningDoesOccurAfterInvalidEnvironmentPublished(c *C) {
         p := provisioner.NewProvisioner(s.State)
         defer s.stopProvisioner(c, p)
 
         // place a new machine into the state
         m, err := s.State.AddMachine()
         c.Assert(err, IsNil)
 
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "pork")
 
         err = s.invalidateEnvironment()
         c.Assert(err, IsNil)
 
         // create a second machine
         m, err = s.State.AddMachine()
         c.Assert(err, IsNil)
 
         // the PA should create it using the old environment
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "pork")
 }
 
 func (s *ProvisionerSuite) TestProvisioningDoesNotProvisionTheSameMachineAfterRestart(c *C) {
         p := provisioner.NewProvisioner(s.State)
         // we are not using defer s.stopProvisioner(c, p) because we need to control when·
         // the PA is restarted in this test. tf. Methods like Fatalf and Assert should not be used.
 
         // create a machine
         m, err := s.State.AddMachine()
         c.Check(err, IsNil)
 
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "pork")
 
         // restart the PA
         c.Check(p.Stop(), IsNil)
 
         p = provisioner.NewProvisioner(s.State)
 
         // check that there is only one machine known
         machines, err := p.AllMachines()
         c.Check(err, IsNil)
         c.Check(len(machines), Equals, 1)
         c.Check(machines[0].Id(), Equals, 0)
 
         // the PA should not create it a second time
         s.checkNotStartInstance(c)
 
         c.Assert(p.Stop(), IsNil)
 }
 
 func (s *ProvisionerSuite) TestProvisioningStopsUnknownInstances(c *C) {
         p := provisioner.NewProvisioner(s.State)
         // we are not using defer s.stopProvisioner(c, p) because we need to control when·
         // the PA is restarted in this test. Methods like Fatalf and Assert should not be used.
 
         // create a machine
         m, err := s.State.AddMachine()
         c.Check(err, IsNil)
 
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "pork")
 
         // create a second machine
         m, err = s.State.AddMachine()
         c.Check(err, IsNil)
 
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "pork")
 
         // stop the PA
         c.Check(p.Stop(), IsNil)
 
         // remove the machine
         err = s.State.RemoveMachine(m.Id())
         c.Check(err, IsNil)
 
         // start a new provisioner
         p = provisioner.NewProvisioner(s.State)
 
         s.checkStopInstance(c)
 
         c.Assert(p.Stop(), IsNil)
 }
 
 // This check is different from the one above as it catches the edge case
 // where the final machine has been removed from the state while the PA was·
 // not running.·
 func (s *ProvisionerSuite) TestProvisioningStopsOnlyUnknownInstances(c *C) {
         p := provisioner.NewProvisioner(s.State)
         // we are not using defer s.stopProvisioner(c, p) because we need to control when·
         // the PA is restarted in this test. Methods like Fatalf and Assert should not be used.
 
         // create a machine
         m, err := s.State.AddMachine()
         c.Check(err, IsNil)
 
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "pork")
 
         // stop the PA
         c.Check(p.Stop(), IsNil)
 
         // remove the machine
         err = s.State.RemoveMachine(m.Id())
         c.Check(err, IsNil)
 
         machines, err := s.State.AllMachines()
         c.Check(err, IsNil)
         c.Check(len(machines), Equals, 0) // it's really gone···
 
         // start a new provisioner
         p = provisioner.NewProvisioner(s.State)
 
         s.checkStopInstance(c)
 
         c.Assert(p.Stop(), IsNil)
 }
 
 func (s *ProvisionerSuite) TestProvisioningRecoversAfterInvalidEnvironmentPublished(c *C) {
+        // TODO(mue) Add secret testing.
+        // go test -gocheck.f TestProvisioningRecoversAfterInvalidEnvironmentPublished
         p := provisioner.NewProvisioner(s.State)
         defer s.stopProvisioner(c, p)
 
         // place a new machine into the state
         m, err := s.State.AddMachine()
         c.Assert(err, IsNil)
 
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "pork")
 
         err = s.invalidateEnvironment()
         c.Assert(err, IsNil)
 
         // create a second machine
         m, err = s.State.AddMachine()
         c.Assert(err, IsNil)
 
         // the PA should create it using the old environment
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "pork")
 
         err = s.fixEnvironment()
         c.Assert(err, IsNil)
 
+        cfg, err := s.State.EnvironConfig()
+        c.Assert(err, IsNil)
+        attrs := cfg.AllAttrs()
+        attrs["secret"] = "beef"
+        cfg, err = config.New(attrs)
+        c.Assert(err, IsNil)
+        err = s.State.SetEnvironConfig(cfg)
+
         // create a third machine
         m, err = s.State.AddMachine()
         c.Assert(err, IsNil)
 
         // the PA should create it using the new environment
-        s.checkStartInstance(c, m)
+        s.checkStartInstance(c, m, "beef")
 }