Providers are responsible for selecting tools

environs/manual/bootstrap_test.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package manual
 
 import (
         "os"
 
         gc "launchpad.net/gocheck"
 
         "launchpad.net/juju-core/environs"
+        "launchpad.net/juju-core/environs/bootstrap"
         "launchpad.net/juju-core/environs/filestorage"
         "launchpad.net/juju-core/environs/storage"
         "launchpad.net/juju-core/environs/tools"
         "launchpad.net/juju-core/instance"
         "launchpad.net/juju-core/juju/testing"
-        "launchpad.net/juju-core/provider/common"
 )
 
 type bootstrapSuite struct {
         testing.JujuConnSuite
         env *localStorageEnviron
 }
 
 var _ = gc.Suite(&bootstrapSuite{})
 
 type localStorageEnviron struct {
@@ skipping 46 matching lines @@
                 DataDir:       "/var/lib/juju",
                 Environ:       s.env,
                 PossibleTools: toolsList,
         }
 }
 
 func (s *bootstrapSuite) TestBootstrap(c *gc.C) {
         args := s.getArgs(c)
         args.Host = "ubuntu@" + args.Host
 
-        defer FakeSSH{Series: s.Conn.Environ.Config().DefaultSeries()}.Install(c).Restore()
+        defer fakeSSH{Series: s.Conn.Environ.Config().DefaultSeries()}.install(c).Restore()
         err := Bootstrap(args)
         c.Assert(err, gc.IsNil)
 
-        bootstrapState, err := common.LoadState(s.env.Storage())
+        bootstrapState, err := bootstrap.LoadState(s.env.Storage())
         c.Assert(err, gc.IsNil)
         c.Assert(
                 bootstrapState.StateInstances,
                 gc.DeepEquals,
                 []instance.Id{BootstrapInstanceId},
         )
 
         // Do it all again; this should work, despite the fact that
         // there's a bootstrap state file. Existence for that is
         // checked in general bootstrap code (environs/bootstrap).
-        defer FakeSSH{Series: s.Conn.Environ.Config().DefaultSeries()}.Install(c).Restore()
+        defer fakeSSH{Series: s.Conn.Environ.Config().DefaultSeries()}.install(c).Restore()
         err = Bootstrap(args)
         c.Assert(err, gc.IsNil)
 
         // We *do* check that the machine has no juju* upstart jobs, though.
-        defer InstallFakeSSH(c, "", "/etc/init/jujud-machine-0.conf", 0).Restore()
+        defer installFakeSSH(c, "", "/etc/init/jujud-machine-0.conf", 0).Restore()
         err = Bootstrap(args)
         c.Assert(err, gc.Equals, ErrProvisioned)
 }
 
 func (s *bootstrapSuite) TestBootstrapSkipDetection(c *gc.C) {
         args := s.getArgs(c)
         hc, err := instance.ParseHardware("arch=amd64")
         c.Assert(err, gc.IsNil)
 
         type test struct {
@@ skipping 11 matching lines @@
                 hc:     &hc,
         }, {
                 series: "precise",
                 hc:     &hc,
         }}
 
         for i, test := range tests {
                 c.Logf("test %d: %+v", i, test)
                 args.Series = test.series
                 args.HardwareCharacteristics = test.hc
-                var ssh FakeSSH
+                var ssh fakeSSH
                 if args.Series != "" && args.HardwareCharacteristics != nil {
                         // If neither series nor hardware-characteristics
                         // is missing, detection is skipped.
                         ssh.SkipDetection = true
                 }
-                defer ssh.Install(c).Restore()
+                defer ssh.install(c).Restore()
                 err = Bootstrap(args)
                 c.Assert(err, gc.IsNil)
         }
 }
 
 func (s *bootstrapSuite) TestBootstrapScriptFailure(c *gc.C) {
         args := s.getArgs(c)
         args.Host = "ubuntu@" + args.Host
         series := s.Conn.Environ.Config().DefaultSeries()
-        defer FakeSSH{Series: series, ProvisionAgentExitCode: 1}.Install(c).Restore()
+        defer fakeSSH{Series: series, ProvisionAgentExitCode: 1}.install(c).Restore()
         err := Bootstrap(args)
         c.Assert(err, gc.NotNil)
 
         // Since the script failed, the state file should have been
         // removed from storage.
-        _, err = common.LoadState(s.env.Storage())
+        _, err = bootstrap.LoadState(s.env.Storage())
         c.Check(err, gc.Equals, environs.ErrNotBootstrapped)
 }
 
 func (s *bootstrapSuite) TestBootstrapEmptyDataDir(c *gc.C) {
         args := s.getArgs(c)
         args.DataDir = ""
         c.Assert(Bootstrap(args), gc.ErrorMatches, "data-dir argument is empty")
 }
 
 func (s *bootstrapSuite) TestBootstrapEmptyHost(c *gc.C) {
         args := s.getArgs(c)
         args.Host = ""
         c.Assert(Bootstrap(args), gc.ErrorMatches, "host argument is empty")
 }
 
 func (s *bootstrapSuite) TestBootstrapNilEnviron(c *gc.C) {
         args := s.getArgs(c)
         args.Environ = nil
         c.Assert(Bootstrap(args), gc.ErrorMatches, "environ argument is nil")
 }
 
 func (s *bootstrapSuite) TestBootstrapNoMatchingTools(c *gc.C) {
         // Empty tools list.
         args := s.getArgs(c)
         args.PossibleTools = nil
         series := s.Conn.Environ.Config().DefaultSeries()
-        defer FakeSSH{Series: series, SkipProvisionAgent: true}.Install(c).Restore()
+        defer fakeSSH{Series: series, SkipProvisionAgent: true}.install(c).Restore()
         c.Assert(Bootstrap(args), gc.ErrorMatches, "no matching tools available")
 
         // Non-empty list, but none that match the series/arch.
-        defer FakeSSH{Series: "edgy", SkipProvisionAgent: true}.Install(c).Restore()
+        defer fakeSSH{Series: "edgy", SkipProvisionAgent: true}.install(c).Restore()
         args = s.getArgs(c)
         c.Assert(Bootstrap(args), gc.ErrorMatches, "no matching tools available")
 }