environs: fixes for gocheck changes.

environs/ec2/live_test.go

 package ec2_test
 
 import (
         "crypto/rand"
         "fmt"
         "io"
         amzec2 "launchpad.net/goamz/ec2"
         . "launchpad.net/gocheck"
         "launchpad.net/juju/go/environs"
         "launchpad.net/juju/go/environs/ec2"
@@ skipping 90 matching lines @@
         // Create a same-named group for the second instance
         // before starting it, to check that it's reused correctly.
         oldMachineGroup := createGroup(c, ec2conn, groups[2].Name, "old machine group")
 
         inst1, err := t.Env.StartInstance(99, jujutest.InvalidStateInfo)
         c.Assert(err, IsNil)
         defer t.Env.StopInstances([]environs.Instance{inst1})
 
         groupsResp, err := ec2conn.SecurityGroups(groups, nil)
         c.Assert(err, IsNil)
-        c.Assert(len(groupsResp.Groups), Equals, len(groups))
+        c.Assert(groupsResp.Groups, HasLen, len(groups))
 
         // For each group, check that it exists and record its id.
         for i, group := range groups {
                 found := false
                 for _, g := range groupsResp.Groups {
                         if g.Name == group.Name {
                                 groups[i].Id = g.Id
                                 info[i] = g
                                 found = true
                                 break
                         }
                 }
                 if !found {
                         c.Fatalf("group %q not found", group.Name)
                 }
         }
 
         // The old juju group should have been reused.
         c.Check(groups[0].Id, Equals, oldJujuGroup.Id)
 
         // Check that it authorizes the correct ports and there
         // are no extra permissions (in particular we are checking
         // that the unneeded permission that we added earlier
         // has been deleted).
         perms := info[0].IPPerms
-        c.Assert(len(perms), Equals, 2, Bug("got security groups %#v", perms))
+        c.Assert(perms, HasLen, 2)
         checkPortAllowed(c, perms, 22)
         checkPortAllowed(c, perms, 2181)
 
         // The old machine group should have been reused also.
         c.Check(groups[2].Id, Equals, oldMachineGroup.Id)
 
         // Check that each instance is part of the correct groups.
         resp, err := ec2conn.Instances([]string{inst0.Id(), inst1.Id()}, nil)
         c.Assert(err, IsNil)
-        c.Assert(len(resp.Reservations), Equals, 2, Bug("reservations %#v", resp.Reservations))
+        c.Assert(resp.Reservations, HasLen, 2)
         for _, r := range resp.Reservations {
-                c.Assert(len(r.Instances), Equals, 1)
+                c.Assert(r.Instances, HasLen, 1)
                 // each instance must be part of the general juju group.
-                msg := Bug("reservation %#v", r)
+                msg := Commentf("reservation %#v", r)
                 c.Assert(hasSecurityGroup(r, groups[0]), Equals, true, msg)
                 inst := r.Instances[0]
                 switch inst.InstanceId {
                 case inst0.Id():
                         c.Assert(hasSecurityGroup(r, groups[1]), Equals, true, msg)
                         c.Assert(hasSecurityGroup(r, groups[2]), Equals, false, msg)
                 case inst1.Id():
                         c.Assert(hasSecurityGroup(r, groups[2]), Equals, true, msg)
                         c.Assert(hasSecurityGroup(r, groups[1]), Equals, false, msg)
                 default:
                         c.Errorf("unknown instance found: %v", inst)
                 }
         }
 }
 
 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, Equals, []string{"0.0.0.0/0"})
-                        c.Check(len(perm.SourceGroups), Equals, 0)
+                        c.Check(perm.SourceIPs, DeepEquals, []string{"0.0.0.0/0"})
+                        c.Check(perm.SourceGroups, HasLen, 0)
                         return
                 }
         }
         c.Errorf("ip port permission not found for %d in %#v", port, perms)
 }
 
 func (t *LiveTests) TestStopInstances(c *C) {
         // It would be nice if this test was in jujutest, but
         // there's no way for jujutest to fabricate a valid-looking
         // instance id.
         inst0, err := t.Env.StartInstance(40, jujutest.InvalidStateInfo)
         c.Assert(err, IsNil)
 
         inst1 := ec2.FabricateInstance(inst0, "i-aaaaa")
 
         inst2, err := t.Env.StartInstance(41, jujutest.InvalidStateInfo)
         c.Assert(err, IsNil)
 
         err = t.Env.StopInstances([]environs.Instance{inst0, inst1, inst2})
         c.Check(err, IsNil)
 
         insts, err := t.Env.Instances([]string{inst0.Id(), inst2.Id()})
         c.Check(err, Equals, environs.ErrMissingInstance)
-        c.Check(len(insts), Equals, 0)
+        c.Check(insts, HasLen, 0)
 }
 
 // createGroup creates a new EC2 group and returns it. If it already exists,
 // it revokes all its permissions and returns the existing group.
 func createGroup(c *C, ec2conn *amzec2.EC2, name, descr string) amzec2.SecurityGroup {
         resp, err := ec2conn.CreateSecurityGroup(name, descr)
         if err == nil {
                 return resp.SecurityGroup
         }
         if err.(*amzec2.Error).Code != "InvalidGroup.Duplicate" {
@@ skipping 11 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
 }