environs/jujutest: use AttemptStrategy

environs/ec2/live_test.go

 package ec2_test
 
 import (
         "crypto/rand"
         "fmt"
         "io"
         "io/ioutil"
         amzec2 "launchpad.net/goamz/ec2"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/ec2"
         "launchpad.net/juju-core/environs/jujutest"
         "launchpad.net/juju-core/juju/testing"
         coretesting "launchpad.net/juju-core/testing"
         "strings"
-        "time"
 )
 
 // amazonConfig holds the environments configuration
 // for running the amazon EC2 integration tests.
 //
 // This is missing keys for security reasons; set the following environment variables
 // to make the Amazon testing work:
 //  access-key: $AWS_ACCESS_KEY_ID
 //  secret-key: $AWS_SECRET_ACCESS_KEY
 var amazonConfig = fmt.Sprintf(`
@@ skipping 19 matching lines @@
 }
 
 func registerAmazonTests() {
         envs, err := environs.ReadEnvironsBytes([]byte(amazonConfig))
         if err != nil {
                 panic(fmt.Errorf("cannot parse amazon tests config data: %v", err))
         }
         for _, name := range envs.Names() {
                 Suite(&LiveTests{
                         LiveTests: jujutest.LiveTests{
-                                Environs:         envs,
-                                Name:             name,
-                                ConsistencyDelay: 5 * time.Second,
-                                CanOpenState:     true,
-                                HasProvisioner:   true,
+                                Environs:       envs,
+                                Name:           name,
+                                Attempt:        *ec2.ShortAttempt,
+                                CanOpenState:   true,
+                                HasProvisioner: true,
                         },
                 })
         }
 }
 
 // LiveTests contains tests that can be run against the Amazon servers.
 // Each test runs using the same ec2 connection.
 type LiveTests struct {
         coretesting.LoggingSuite
         jujutest.LiveTests
@@ skipping 155 matching lines @@
         }
 }
 
 func (t *LiveTests) TestDestroy(c *C) {
         s := t.Env.Storage()
         err := s.Put("foo", strings.NewReader("foo"), 3)
         c.Assert(err, IsNil)
         err = s.Put("bar", strings.NewReader("bar"), 3)
         c.Assert(err, IsNil)
 
-        // Check that bucket exists, so we can be sure
+        // Check that the bucket exists, so we can be sure
         // we have checked correctly that it's been destroyed.
         names, err := s.List("")
         c.Assert(err, IsNil)
         c.Assert(len(names) >= 2, Equals, true)
 
         t.Destroy(c)
-        for i := 0; i < 30; i++ {
+        for a := ec2.ShortAttempt.Start(); a.Next(); {
                 names, err = s.List("")
                 if len(names) == 0 {
                         break
                 }
-                time.Sleep(100 * time.Millisecond)
         }
         c.Assert(names, HasLen, 0)
 }
 
 func checkPortAllowed(c *C, perms []amzec2.IPPerm, port int) {
         for _, perm := range perms {
                 if perm.FromPort == port {
                         c.Check(perm.Protocol, Equals, "tcp")
                         c.Check(perm.ToPort, Equals, port)
                         c.Check(perm.SourceIPs, DeepEquals, []string{"0.0.0.0/0"})
@@ skipping 46 matching lines @@
 
         err = t.Env.StopInstances([]environs.Instance{inst0, inst1, inst2})
         c.Check(err, IsNil)
 
         var insts []environs.Instance
 
         // We need the retry logic here because we are waiting
         // for Instances to return an error, and it will not retry
         // if it succeeds.
         gone := false
-        for i := 0; i < 30; i++ {
+        for a := ec2.ShortAttempt.Start(); a.Next(); {
                 insts, err = t.Env.Instances([]string{inst0.Id(), inst2.Id()})
                 if err == environs.ErrPartialInstances {
                         // instances not gone yet.
-                        time.Sleep(100 * time.Millisecond)
                         continue
                 }
                 if err == environs.ErrNoInstances {
                         gone = true
                         break
                 }
                 c.Fatalf("error getting instances: %v", err)
         }
         if !gone {
                 c.Errorf("after termination, instances remaining: %v", insts)
@@ skipping 69 matching lines @@
 }
 
 func hasSecurityGroup(r amzec2.Reservation, g amzec2.SecurityGroup) bool {
         for _, rg := range r.SecurityGroups {
                 if rg.Id == g.Id {
                         return true
                 }
         }
         return false
 }