state: remove ProposedTools.

environs/jujutest/livetests.go

 package jujutest
 
 import (
         "fmt"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/environs"
+        "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/juju"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/version"
         "time"
 )
 
 // TestStartStop is similar to Tests.TestStartStop except
 // that it does not assume a pristine environment.
 func (t *LiveTests) TestStartStop(c *C) {
         insts, err := t.Env.Instances(nil)
@@ skipping 133 matching lines @@
         // check that we can bootstrap after destroy
         t.BootstrapOnce(c)
 }
 
 func (t *LiveTests) TestBootstrapProvisioner(c *C) {
         if !t.CanOpenState || !t.HasProvisioner {
                 c.Skip(fmt.Sprintf("skipping provisioner test, CanOpenState: %v, HasProvisioner: %v", t.CanOpenState, t.HasProvisioner))
         }
         t.BootstrapOnce(c)
 
-        // TODO(dfc) constructing a juju.Conn by hand is a code smell.
-        conn, err := juju.NewConnFromAttrs(t.Env.Config().AllAttrs())
-        c.Assert(err, IsNil)
-
-        st, err := conn.State()
-        c.Assert(err, IsNil)
+        conn, err := juju.NewConn(t.Env)
+        c.Assert(err, IsNil)
+        defer conn.Close()
 
         // Check that we can upgrade the machine agent on the bootstrap machine.
-        m, err := st.Machine(0)
-        c.Assert(err, IsNil)
-
-        t.checkUpgradeMachineAgent(c, st, m)
+        m, err := conn.State.Machine(0)
+        c.Assert(err, IsNil)
+
+        // Check that the agent version has made it through the
+        // bootstrap process (it's optional in the config.Config)
+        cfg, err := conn.State.EnvironConfig()
+        c.Assert(err, IsNil)
+        c.Check(cfg.AgentVersion(), Equals, version.Current.Number)
+
+        t.checkUpgradeMachineAgent(c, conn.State, m)
 
         // place a new machine into the state
-        m, err = st.AddMachine()
+        m, err = conn.State.AddMachine()
         c.Assert(err, IsNil)
 
         t.assertStartInstance(c, m)
 
         // now remove it
-        c.Assert(st.RemoveMachine(m.Id()), IsNil)
+        c.Assert(conn.State.RemoveMachine(m.Id()), IsNil)
 
         // watch the PA remove it
         t.assertStopInstance(c, m)
         assertInstanceId(c, m, nil)
-
-        err = st.Close()
-        c.Assert(err, IsNil)
 }
 
 func (t *LiveTests) checkUpgradeMachineAgent(c *C, st *state.State, m *state.Machine) {
         // First watch the machine agent's to make sure that the its
         // current tools are set appropriately.
         w := m.Watch()
 
         var gotTools *state.Tools
         for _ = range w.Changes() {
                 tools, err := m.AgentTools()
@@ skipping 10 matching lines @@
 
         c.Logf("putting testing version of juju tools")
 
         newVersion := version.Current
         newVersion.Patch++
         upgradeTools, err := environs.PutTools(t.Env.Storage(), &newVersion)
         c.Assert(err, IsNil)
 
         // Check that the put version really is the version we expect.
         c.Assert(upgradeTools.Binary, Equals, newVersion)
-        err = st.SetAgentVersion(newVersion.Number)
+        err = setStateAgentVersion(st, newVersion.Number)
+        c.Assert(err, IsNil)
 
         c.Logf("waiting for upgrade")
         _, ok := <-w.Changes()
         if !ok {
                 c.Fatalf("watcher died: %v", w.Err())
         }
         tools, err := m.AgentTools()
         c.Assert(err, IsNil)
-        c.Assert(tools, DeepEquals, upgradeTools)
+        // N.B. We can't test that the URL is the same because there's
+        // no guarantee that it is, even though it might be referring to
+        // the same thing.
+        c.Assert(tools.Binary, DeepEquals, upgradeTools.Binary)
         c.Logf("upgrade successful!")
+}
+
+// setStateAgentVersion sets the current agent version in the
+// state's environment configuration.
+func setStateAgentVersion(st *state.State, vers version.Number) error {
+        cfg, err := st.EnvironConfig()
+        if err != nil {
+                return err
+        }
+        attrs := cfg.AllAttrs()
+        attrs["agent-version"] = vers.String()
+        cfg, err = config.New(attrs)
+        if err != nil {
+                panic(fmt.Errorf("config refused agent-version: %v", err))
+        }
+        return st.SetEnvironConfig(cfg)
 }
 
 var waitAgent = environs.AttemptStrategy{
         Total: 30 * time.Second,
         Delay: 1 * time.Second,
 }
 
 func (t *LiveTests) assertStartInstance(c *C, m *state.Machine) {
         // Wait for machine to get an instance id.
         for a := waitAgent.Start(); a.Next(); {
@@ skipping 106 matching lines @@
         }
 
         inst, err := t.Env.StartInstance(4, InvalidStateInfo, tools)
         if inst != nil {
                 err := t.Env.StopInstances([]environs.Instance{inst})
                 c.Check(err, IsNil)
         }
         c.Assert(inst, IsNil)
         c.Assert(err, ErrorMatches, "cannot find image.*")
 }