Make agent/tools and remove state.Tools

cmd/jujud/upgrade_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package main
 
 import (
         "fmt"
         "io/ioutil"
         "path/filepath"
         "time"
 
         . "launchpad.net/gocheck"
 
-        "launchpad.net/juju-core/agent"
+        "launchpad.net/juju-core/agent/tools"
         "launchpad.net/juju-core/environs/dummy"
         envtesting "launchpad.net/juju-core/environs/testing"
-        "launchpad.net/juju-core/environs/tools"
         "launchpad.net/juju-core/state"
         coretesting "launchpad.net/juju-core/testing"
         "launchpad.net/juju-core/version"
         "launchpad.net/juju-core/worker"
 )
 
 var _ = Suite(&UpgraderSuite{})
 
 type UpgraderSuite struct {
         oldVersion version.Binary
         agentSuite
 }
 
 func (s *UpgraderSuite) SetUpTest(c *C) {
         s.JujuConnSuite.SetUpTest(c)
         s.oldVersion = version.Current
 }
 
 func (s *UpgraderSuite) TearDownTest(c *C) {
         version.Current = s.oldVersion
         s.JujuConnSuite.TearDownTest(c)
 }
 
 func (s *UpgraderSuite) TestUpgraderStop(c *C) {
-        u := s.startUpgrader(c, &state.Tools{Binary: version.Current})
+        u := s.startUpgrader(c, &tools.Tools{Binary: version.Current})
         err := u.Stop()
         c.Assert(err, IsNil)
 }
 
 var _ worker.Worker = (*Upgrader)(nil)
 
 var (
         v200     = version.MustParse("2.0.0")
         t200p64  = version.MustParseBinary("2.0.0-precise-amd64")
         t200p32  = version.MustParseBinary("2.0.0-precise-i386")
@@ skipping 78 matching lines @@
 }}
 
 func (s *UpgraderSuite) TestUpgrader(c *C) {
         for i, test := range upgraderTests {
                 c.Logf("\ntest %d: %s", i, test.about)
                 // Note: primeTools sets version.Current...
                 currentTools := s.primeTools(c, test.current)
                 // ...but it also puts tools in storage we don't need, which is why we
                 // don't clean up garbage from earlier runs first.
                 envtesting.RemoveAllTools(c, s.Conn.Environ)
-                uploaded := make(map[version.Binary]*state.Tools)
+                uploaded := make(map[version.Binary]*tools.Tools)
                 for _, vers := range test.available {
                         tools := s.uploadTools(c, vers)
                         uploaded[vers] = tools
                 }
 
                 func() {
                         u := s.startUpgrader(c, currentTools)
                         defer u.Stop()
                         s.proposeVersion(c, test.propose)
                         s.State.StartSync()
                         if test.upgrade.Number == version.Zero {
                                 assertNothingHappens(c, u)
                                 c.Assert(u.Stop(), IsNil)
                                 return
                         }
 
                         ug := waitDeath(c, u)
-                        tools := uploaded[test.upgrade]
-                        c.Check(ug.NewTools, DeepEquals, tools)
+                        newTools := uploaded[test.upgrade]
+                        c.Check(ug.NewTools, DeepEquals, newTools)
                         c.Check(ug.OldTools.Binary, Equals, version.Current)
                         c.Check(ug.DataDir, Equals, s.DataDir())
                         c.Check(ug.AgentName, Equals, "testagent")
 
                         // Check that the upgraded version was really downloaded.
-                        path := agent.SharedToolsDir(s.DataDir(), tools.Binary)
+                        path := tools.SharedToolsDir(s.DataDir(), newTools.Binary)
                         data, err := ioutil.ReadFile(filepath.Join(path, "jujud"))
                         c.Check(err, IsNil)
-                        c.Check(string(data), Equals, "jujud contents "+tools.Binary.String())
+                        c.Check(string(data), Equals, "jujud contents "+newTools.Binary.String())
                 }()
         }
 }
 
 func (s *UpgraderSuite) TestStillWorksAfterBadVersions(c *C) {
         currentTools := s.primeTools(c, t200p64)
         envtesting.RemoveAllTools(c, s.Conn.Environ)
         u := s.startUpgrader(c, currentTools)
         defer u.Stop()
 
@@ skipping 93 matching lines @@
 func (s *UpgraderSuite) removeVersion(c *C, vers version.Binary) {
         name := tools.StorageName(vers)
         err := s.Conn.Environ.Storage().Remove(name)
         c.Assert(err, IsNil)
 }
 
 func (s *UpgraderSuite) TestUpgraderReadyErrorUpgrade(c *C) {
         currentTools := s.primeTools(c, version.MustParseBinary("2.0.2-foo-bar"))
         ug := &UpgradeReadyError{
                 AgentName: "foo",
-                OldTools:  &state.Tools{Binary: version.MustParseBinary("2.0.0-foo-bar")},
+                OldTools:  &tools.Tools{Binary: version.MustParseBinary("2.0.0-foo-bar")},
                 NewTools:  currentTools,
                 DataDir:   s.DataDir(),
         }
         err := ug.ChangeAgentTools()
         c.Assert(err, IsNil)
-        d := agent.ToolsDir(s.DataDir(), "foo")
+        d := tools.ToolsDir(s.DataDir(), "foo")
         data, err := ioutil.ReadFile(filepath.Join(d, "jujud"))
         c.Assert(err, IsNil)
         c.Assert(string(data), Equals, "jujud contents 2.0.2-foo-bar")
 }
 func assertNothingHappens(c *C, u *Upgrader) {
         done := make(chan error, 1)
         go func() {
                 done <- u.Wait()
         }()
         select {
         case got := <-done:
                 c.Fatalf("expected nothing to happen, got %#v", got)
         case <-time.After(coretesting.ShortWait):
         }
 }
 
 func assertEvent(c *C, event <-chan string, want string) {
         select {
         case got := <-event:
                 c.Assert(got, Equals, want)
         case <-time.After(coretesting.LongWait):
                 c.Fatalf("no event received; expected %q", want)
         }
 }
 
 // startUpgrader starts the upgrader using the given machine,
 // expecting to see it set the given agent tools.
-func (s *UpgraderSuite) startUpgrader(c *C, expectTools *state.Tools) *Upgrader {
-        as := testAgentState(make(chan *state.Tools))
+func (s *UpgraderSuite) startUpgrader(c *C, expectTools *tools.Tools) *Upgrader {
+        as := testAgentState(make(chan *tools.Tools))
         u := NewUpgrader(s.State, as, s.DataDir())
         select {
         case tools := <-as:
                 c.Assert(tools, DeepEquals, expectTools)
         case <-time.After(coretesting.LongWait):
                 c.Fatalf("upgrader did not set agent tools")
         }
         return u
 }
 
 func waitDeath(c *C, u *Upgrader) *UpgradeReadyError {
         done := make(chan error, 1)
         go func() {
                 done <- u.Wait()
         }()
         select {
         case err := <-done:
                 c.Assert(err, FitsTypeOf, &UpgradeReadyError{})
                 return err.(*UpgradeReadyError)
         case <-time.After(coretesting.LongWait):
                 c.Fatalf("upgrader did not die as expected")
         }
         panic("unreachable")
 }
 
-type testAgentState chan *state.Tools
+type testAgentState chan *tools.Tools
 
-func (as testAgentState) SetAgentTools(tools *state.Tools) error {
+func (as testAgentState) SetAgentTools(tools *tools.Tools) error {
         t := *tools
         as <- &t
         return nil
 }
 
 func (as testAgentState) Tag() string {
         return "testagent"
 }
 
 func (as testAgentState) Life() state.Life {
         panic("unimplemented")
 }
 
 func (as testAgentState) SetMongoPassword(string) error {
         panic("unimplemented")
 }