environs/ec2: bootstrap

environs/ec2/local_test.go

 package ec2_test
 
 import (
         "fmt"
         "launchpad.net/goamz/aws"
         amzec2 "launchpad.net/goamz/ec2"
         "launchpad.net/goamz/ec2/ec2test"
         "launchpad.net/goamz/s3"
         "launchpad.net/goamz/s3/s3test"
         . "launchpad.net/gocheck"
         "launchpad.net/goyaml"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/ec2"
         "launchpad.net/juju-core/environs/jujutest"
         "launchpad.net/juju-core/state"
-        "launchpad.net/juju-core/testing"
+        "launchpad.net/juju-core/state/testing"
+        coretesting "launchpad.net/juju-core/testing"
         "launchpad.net/juju-core/version"
         "strings"
 )
 
 // you need to make sure the region you use here
 // has entries in the images/query txt files.
 var functionalConfig = []byte(`
 environments:
   sample:
     type: ec2
@@ skipping 16 matching lines @@
         for _, name := range envs.Names() {
                 Suite(&localServerSuite{
                         Tests: jujutest.Tests{
                                 Environs: envs,
                                 Name:     name,
                         },
                 })
                 Suite(&localLiveSuite{
                         LiveTests: LiveTests{
                                 LiveTests: jujutest.LiveTests{
-                                        Environs: envs,
-                                        Name:     name,
+                                        Environs:       envs,
+                                        Name:           name,
+                                        CanOpenState:   false, // ec2test mock server returns an invalid dns address
+                                        HasProvisioner: false,

[niemeyer, 2012/07/06 19:44:56]

Please revert to original state.

[dave_cheney.net, 2012/07/09 00:52:58]

Done.

                                 },
                         },
                 })
         }
 }
 
 // localLiveSuite runs tests from LiveTests using a fake
 // EC2 server that runs within the test process itself.
 type localLiveSuite struct {
-        testing.LoggingSuite
+        coretesting.LoggingSuite
+        testing.StateSuite
         LiveTests
         srv localServer
         env environs.Environ
 }
 
 func (t *localLiveSuite) SetUpSuite(c *C) {
         ec2.UseTestImageData(true)
         t.srv.startServer(c)
         t.LiveTests.SetUpSuite(c)
         t.env = t.LiveTests.Env
         ec2.ShortTimeouts(true)
 }
 
 func (t *localLiveSuite) TearDownSuite(c *C) {
         t.LiveTests.TearDownSuite(c)
         t.srv.stopServer(c)
         t.env = nil
         ec2.ShortTimeouts(false)
         ec2.UseTestImageData(false)
 }
 
 func (t *localLiveSuite) SetUpTest(c *C) {
         t.LoggingSuite.SetUpTest(c)
+        t.StateSuite.SetUpTest(c)
         t.LiveTests.SetUpTest(c)
 }
 
 func (t *localLiveSuite) TearDownTest(c *C) {
         t.LiveTests.TearDownTest(c)
+        t.StateSuite.TearDownTest(c)
         t.LoggingSuite.TearDownTest(c)
 }
 
 // localServer represents a fake EC2 server running within
 // the test process itself.
 type localServer struct {
         ec2srv *ec2test.Server
         s3srv  *s3test.Server
 }
 
 func (srv *localServer) startServer(c *C) {
         var err error
         srv.ec2srv, err = ec2test.NewServer()
         if err != nil {
                 c.Fatalf("cannot start ec2 test server: %v", err)
         }
         srv.s3srv, err = s3test.NewServer()
         if err != nil {
                 c.Fatalf("cannot start s3 test server: %v", err)
         }
         aws.Regions["test"] = aws.Region{
-                Name:        "test",
-                EC2Endpoint: srv.ec2srv.URL(),
-                S3Endpoint:  srv.s3srv.URL(),
+                Name:                 "test",
+                EC2Endpoint:          srv.ec2srv.URL(),
+                S3Endpoint:           srv.s3srv.URL(),
                 S3LocationConstraint: true,
         }
         s3inst := s3.New(aws.Auth{}, aws.Regions["test"])
         putFakeTools(c, ec2.BucketStorage(s3inst.Bucket("public-tools")))
         srv.addSpice(c)
 }
 
 // putFakeTools sets up a bucket containing something
 // that looks like a tools archive so test methods
 // that start an instance can succeed even though they
 // do not upload tools.
 func putFakeTools(c *C, s environs.StorageWriter) {
         path := environs.ToolsPath(version.Current, environs.CurrentSeries, environs.CurrentArch)
         c.Logf("putting fake tools at %v", path)
         toolsContents := "tools archive, honest guv"
         err := s.Put(path, strings.NewReader(toolsContents), int64(len(toolsContents)))
-        if err != nil {
-                c.Fatal(err)
-        }
+        c.Assert(err, IsNil)
 }
 
 // addSpice adds some "spice" to the local server
 // by adding state that may cause tests to fail.
 func (srv *localServer) addSpice(c *C) {
         states := []amzec2.InstanceState{
                 ec2test.ShuttingDown,
                 ec2test.Terminated,
                 ec2test.Stopped,
         }
@@ skipping 10 matching lines @@
         delete(aws.Regions, "test")
 }
 
 // localServerSuite contains tests that run against a fake EC2 server
 // running within the test process itself.  These tests can test things that
 // would be unreasonably slow or expensive to test on a live Amazon server.
 // It starts a new local ec2test server for each test.  The server is
 // accessed by using the "test" region, which is changed to point to the
 // network address of the local server.
 type localServerSuite struct {
-        testing.LoggingSuite
+        coretesting.LoggingSuite
+        testing.StateSuite
         jujutest.Tests
         srv localServer
         env environs.Environ
 }
 
 func (t *localServerSuite) SetUpSuite(c *C) {
         ec2.UseTestImageData(true)
         t.Tests.SetUpSuite(c)
         ec2.ShortTimeouts(true)
 }
 
 func (t *localServerSuite) TearDownSuite(c *C) {
         t.Tests.TearDownSuite(c)
         ec2.ShortTimeouts(false)
         ec2.UseTestImageData(false)
 }
 
 func (t *localServerSuite) SetUpTest(c *C) {
         t.LoggingSuite.SetUpTest(c)
+        t.StateSuite.SetUpTest(c)
         t.srv.startServer(c)
         t.Tests.SetUpTest(c)
         t.env = t.Tests.Env
 }
 
 func (t *localServerSuite) TearDownTest(c *C) {
         t.Tests.TearDownTest(c)
         t.srv.stopServer(c)
+        t.StateSuite.TearDownTest(c)
         t.LoggingSuite.TearDownTest(c)
 }
 
 func (t *localServerSuite) TestBootstrapInstanceUserDataAndState(c *C) {
         policy := t.env.AssignmentPolicy()
         c.Assert(policy, Equals, state.AssignUnused)
 
         err := t.env.Bootstrap(true)
         c.Assert(err, IsNil)
 
@@ skipping 47 matching lines @@
         // TODO check for machine agent
         ec2.CheckScripts(c, x, fmt.Sprintf("JUJU_ZOOKEEPER='%s%s'", bootstrapDNS, ec2.ZkPortSuffix), true)
         ec2.CheckScripts(c, x, fmt.Sprintf("JUJU_MACHINE_ID=1"), true)
 
         err = t.env.Destroy(append(insts, inst1))
         c.Assert(err, IsNil)
 
         _, err = ec2.LoadState(t.env)
         c.Assert(err, NotNil)
 }