ec2test: fix filtering behaviour.

ec2t_test.go

 package ec2_test
 
 import (
         "fmt"
         "launchpad.net/goamz/aws"
         "launchpad.net/goamz/ec2"
         "launchpad.net/goamz/ec2/ec2test"
         . "launchpad.net/gocheck"
         "sort"
 )
@@ skipping 56 matching lines @@
         c.Assert(err, IsNil)
         c.Assert(inst, NotNil)
         c.Assert(inst.Instances[0].DNSName, Equals, inst.Instances[0].InstanceId+".example.com")
 
         id := inst.Instances[0].InstanceId
 
         defer s.ec2.TerminateInstances([]string{id})
 
         tinst := s.srv.srv.Instance(id)
         c.Assert(tinst, NotNil)
-        c.Assert(tinst.UserData, Equals, data)
+        c.Assert(tinst.UserData, DeepEquals, data)
 }
 
 // AmazonServerSuite runs the ec2test server tests against a live EC2 server.
 // It will only be activated if the -all flag is specified.
 type AmazonServerSuite struct {
         srv AmazonServer
         ServerTests
 }
 
 var _ = Suite(&AmazonServerSuite{})
@@ skipping 15 matching lines @@
 }
 
 func terminateInstances(c *C, e *ec2.EC2, insts []*ec2.Instance) {
         var ids []string
         for _, inst := range insts {
                 if inst != nil {
                         ids = append(ids, inst.InstanceId)
                 }
         }
         _, err := e.TerminateInstances(ids)
-        c.Check(err, IsNil, Bug("%d INSTANCES LEFT RUNNING!!!", len(ids)))
+        c.Check(err, IsNil, Commentf("%d INSTANCES LEFT RUNNING!!!", len(ids)))
 }
 
 func (s *ServerTests) makeTestGroup(c *C, name, descr string) ec2.SecurityGroup {
         // Clean it up if a previous test left it around.
         _, err := s.ec2.DeleteSecurityGroup(ec2.SecurityGroup{Name: name})
         if err != nil && err.(*ec2.Error).Code != "InvalidGroup.NotFound" {
                 c.Fatalf("delete security group: %v", err)
         }
 
         resp, err := s.ec2.CreateSecurityGroup(name, descr)
         c.Assert(err, IsNil)
         c.Assert(resp.Name, Equals, name)
         return resp.SecurityGroup
 }
 
 func (s *ServerTests) TestIPPerms(c *C) {
         g0 := s.makeTestGroup(c, "goamz-test0", "ec2test group 0")
         defer s.ec2.DeleteSecurityGroup(g0)
 
         g1 := s.makeTestGroup(c, "goamz-test1", "ec2test group 1")
         defer s.ec2.DeleteSecurityGroup(g1)
 
         resp, err := s.ec2.SecurityGroups([]ec2.SecurityGroup{g0, g1}, nil)
         c.Assert(err, IsNil)
-        c.Assert(len(resp.Groups), Equals, 2)
-        c.Assert(len(resp.Groups[0].IPPerms), Equals, 0)
-        c.Assert(len(resp.Groups[1].IPPerms), Equals, 0)
+        c.Assert(resp.Groups, HasLen, 2)
+        c.Assert(resp.Groups[0].IPPerms, HasLen, 0)
+        c.Assert(resp.Groups[1].IPPerms, HasLen, 0)
 
         ownerId := resp.Groups[0].OwnerId
 
         // test some invalid parameters
         // TODO more
         _, err = s.ec2.AuthorizeSecurityGroup(g0, []ec2.IPPerm{{
                 Protocol:  "tcp",
                 FromPort:  0,
                 ToPort:    1024,
                 SourceIPs: []string{"z127.0.0.1/24"},
@@ skipping 16 matching lines @@
         }, {
                 Protocol:  "tcp",
                 FromPort:  2000,
                 ToPort:    2001,
                 SourceIPs: []string{"200.1.1.34/32"},
         }})
         c.Assert(err, IsNil)
 
         resp, err = s.ec2.SecurityGroups([]ec2.SecurityGroup{g0}, nil)
         c.Assert(err, IsNil)
-        c.Assert(len(resp.Groups), Equals, 1)
-        c.Assert(len(resp.Groups[0].IPPerms), Equals, 1)
+        c.Assert(resp.Groups, HasLen, 1)
+        c.Assert(resp.Groups[0].IPPerms, HasLen, 1)
 
         perm := resp.Groups[0].IPPerms[0]
         srcg := perm.SourceGroups
-        c.Assert(len(srcg), Equals, 2)
+        c.Assert(srcg, HasLen, 2)
 
         // Normalize so we don't care about returned order.
         if srcg[0].Name == g1.Name {
                 srcg[0], srcg[1] = srcg[1], srcg[0]
         }
         c.Check(srcg[0].Name, Equals, g0.Name)
         c.Check(srcg[0].Id, Equals, g0.Id)
         c.Check(srcg[0].OwnerId, Equals, ownerId)
         c.Check(srcg[1].Name, Equals, g1.Name)
         c.Check(srcg[1].Id, Equals, g1.Id)
         c.Check(srcg[1].OwnerId, Equals, ownerId)
 
         sort.Strings(perm.SourceIPs)
-        c.Check(perm.SourceIPs, Equals, []string{"127.0.0.0/24", "200.1.1.34/32"})
+        c.Check(perm.SourceIPs, DeepEquals, []string{"127.0.0.0/24", "200.1.1.34/32"})
 
         // Check that we can't delete g1 (because g0 is using it)
         _, err = s.ec2.DeleteSecurityGroup(g1)
         c.Assert(err, NotNil)
         c.Check(err.(*ec2.Error).Code, Equals, "InvalidGroup.InUse")
 
         _, err = s.ec2.RevokeSecurityGroup(g0, []ec2.IPPerm{{
                 Protocol:     "tcp",
                 FromPort:     2000,
                 ToPort:       2001,
                 SourceGroups: []ec2.UserSecurityGroup{{Id: g1.Id}},
         }, {
                 Protocol:  "tcp",
                 FromPort:  2000,
                 ToPort:    2001,
                 SourceIPs: []string{"200.1.1.34/32"},
         }})
         c.Assert(err, IsNil)
 
         resp, err = s.ec2.SecurityGroups([]ec2.SecurityGroup{g0}, nil)
         c.Assert(err, IsNil)
-        c.Assert(len(resp.Groups), Equals, 1)
-        c.Assert(len(resp.Groups[0].IPPerms), Equals, 1)
+        c.Assert(resp.Groups, HasLen, 1)
+        c.Assert(resp.Groups[0].IPPerms, HasLen, 1)
 
         perm = resp.Groups[0].IPPerms[0]
         srcg = perm.SourceGroups
-        c.Assert(len(srcg), Equals, 1)
+        c.Assert(srcg, HasLen, 1)
         c.Check(srcg[0].Name, Equals, g0.Name)
         c.Check(srcg[0].Id, Equals, g0.Id)
         c.Check(srcg[0].OwnerId, Equals, ownerId)
 
-        c.Check(perm.SourceIPs, Equals, []string{"127.0.0.0/24"})
+        c.Check(perm.SourceIPs, DeepEquals, []string{"127.0.0.0/24"})
 
         // We should be able to delete g1 now because we've removed its only use.
         _, err = s.ec2.DeleteSecurityGroup(g1)
         c.Assert(err, IsNil)
 
         _, err = s.ec2.DeleteSecurityGroup(g0)
         c.Assert(err, IsNil)
 
         f := ec2.NewFilter()
         f.Add("group-id", g0.Id, g1.Id)
         resp, err = s.ec2.SecurityGroups(nil, f)
         c.Assert(err, IsNil)
-        c.Assert(len(resp.Groups), Equals, 0)
+        c.Assert(resp.Groups, HasLen, 0)
 }
 
 func (s *ServerTests) TestDuplicateIPPerm(c *C) {
         name := "goamz-test"
         descr := "goamz security group for tests"
 
         // Clean it up, if a previous test left it around and avoid leaving it around.
         s.ec2.DeleteSecurityGroup(ec2.SecurityGroup{Name: name})
         defer s.ec2.DeleteSecurityGroup(ec2.SecurityGroup{Name: name})
 
@@ skipping 66 matching lines @@
 
         tests := []struct {
                 instanceIds []string     // instanceIds argument to Instances method.
                 filters     []filterSpec // filters argument to Instances method.
                 resultIds   []string     // set of instance ids of expected results.
                 allowExtra  bool         // resultIds may be incomplete.
                 err         string       // expected error.
         }{
                 // check that Instances returns all instances.
                 {
-                        nil,
-                        nil,
-                        ids(0, 1, 2),
-                        true,
-                        "",
+                        resultIds:  ids(0, 1, 2),
+                        allowExtra:  true,
                 },
                 // check that specifying two instance ids returns them.
                 {
-                        ids(0, 2),
-                        nil,
-                        ids(0, 2),
-                        false,
-                        "",
+                        instanceIds: ids(0, 2),
+                        resultIds:  ids(0, 2),
                 },
                 // check that specifying a non-existent instance id gives an error
                 {
-                        append(ids(0), "i-deadbeef12345"),
-                        nil,
-                        nil,
-                        false,
-                        `.*\(InvalidInstanceID\.NotFound\)`,
+                        instanceIds: append(ids(0), "i-deadbeef12345"),
+                        err:         `.*\(InvalidInstanceID\.NotFound\)`,
                 },
                 // check that a filter allowed both instances returns both of them.
                 {
-                        nil,
-                        []filterSpec{
+                        filters: []filterSpec{
                                 {"instance-id", ids(0, 2)},
                         },
-                        ids(0, 2),
-                        false,
-                        "",
+                        resultIds: ids(0, 2),
                 },
                 // check that a filter allowing only one instance returns it.
                 {
-                        nil,
-                        []filterSpec{
+                        filters: []filterSpec{
                                 {"instance-id", ids(1)},
                         },
-                        ids(1),
-                        false,
-                        "",
+                        resultIds: ids(1),
                 },
                 // check that a filter allowing no instances returns none
                 {
-                        nil,
-                        []filterSpec{
+                        filters: []filterSpec{
                                 {"instance-id", []string{"i-deadbeef12345"}},
                         },
-                        nil,
-                        false,
-                        "",
-                },
-                {
-                        nil,
-                        []filterSpec{
+                },
+                {
+                        filters: []filterSpec{
                                 {"group-id", []string{group1.Id}},
                         },
-                        ids(0, 1),
-                        false,
-                        "",
-                },
-                {
-                        nil,
-                        []filterSpec{
+                        resultIds: ids(0, 1),
+                },
+                {
+                        filters: []filterSpec{
                                 {"group-name", []string{group1.Name}},
                         },
-                        ids(0, 1),
-                        false,
-                        "",
-                },
-                {
-                        nil,
-                        []filterSpec{
+                        resultIds: ids(0, 1),
+                },
+                {
+                        filters: []filterSpec{
                                 {"image-id", []string{imageId}},
                         },
-                        ids(0, 1),
-                        true,
-                        "",
+                        resultIds: ids(0, 1),
+                        allowExtra: true,
                 },
                 // combination filters.
                 {
-                        nil,
-                        []filterSpec{
+                        filters: []filterSpec{
                                 {"image-id", []string{imageId, imageId2}},
                                 {"group-name", []string{group1.Name}},
                         },
-                        ids(0, 1),
-                        false,
-                        "",
-                },
-                {
-                        nil,
-                        []filterSpec{
+                        resultIds: ids(0, 1),
+                },
+                {
+                        filters: []filterSpec{
                                 {"image-id", []string{imageId2}},
                                 {"group-name", []string{group1.Name}},
                         },
-                        nil,
-                        false,
-                        "",
                 },
         }
         for i, t := range tests {
+                c.Logf("test %d", i)
                 var f *ec2.Filter
                 if t.filters != nil {
                         f = ec2.NewFilter()
                         for _, spec := range t.filters {
                                 f.Add(spec.name, spec.values...)
                         }
                 }
                 resp, err := s.ec2.Instances(t.instanceIds, f)
                 if t.err != "" {
-                        c.Check(err, ErrorMatches, t.err, Bug("test %d", i))
+                        c.Check(err, ErrorMatches, t.err)
                         continue
                 }
-                c.Assert(err, IsNil, Bug("test %d", i))
+                c.Assert(err, IsNil)
                 insts := make(map[string]*ec2.Instance)
                 for _, r := range resp.Reservations {
                         for j := range r.Instances {
                                 inst := &r.Instances[j]
-                                c.Check(insts[inst.InstanceId], IsNil, Bug("test %d, duplicate instance id: %q", i, inst.InstanceId))
+                                c.Check(insts[inst.InstanceId], IsNil, Commentf("duplicate instance id: %q", inst.InstanceId))
                                 insts[inst.InstanceId] = inst
                         }
                 }
                 if !t.allowExtra {
-                        c.Check(len(insts), Equals, len(t.resultIds), Bug("test %d, expected %d instances got %#v", i, len(t.resultIds), insts))
+                        c.Check(insts, HasLen, len(t.resultIds), Commentf("expected %d instances got %#v", len(t.resultIds), insts))
                 }
                 for j, id := range t.resultIds {
-                        c.Check(insts[id], NotNil, Bug("test %d, instance id %d (%q) not found; got %#v", i, j, id, insts))
+                        c.Check(insts[id], NotNil, Commentf("instance id %d (%q) not found; got %#v", j, id, insts))
                 }
         }
 }
 
 func idsOnly(gs []ec2.SecurityGroup) []ec2.SecurityGroup {
         for i := range gs {
                 gs[i].Name = ""
         }
         return gs
 }
@@ skipping 139 matching lines @@
                 c.Logf("test %d", i)
                 var f *ec2.Filter
                 if t.filters != nil {
                         f = ec2.NewFilter()
                         for _, spec := range t.filters {
                                 f.Add(spec.name, spec.values...)
                         }
                 }
                 resp, err := s.ec2.SecurityGroups(t.groups, f)
                 if t.err != "" {
-                        c.Check(err, ErrorMatches, t.err, Bug("test %d", i))
+                        c.Check(err, ErrorMatches, t.err)
                         continue
                 }
-                c.Assert(err, IsNil, Bug("test %d", i))
+                c.Assert(err, IsNil)
                 groups := make(map[string]*ec2.SecurityGroup)
                 for j := range resp.Groups {
                         group := &resp.Groups[j].SecurityGroup
-                        c.Check(groups[group.Id], IsNil, Bug("duplicate group id: %q", group.Id))
+                        c.Check(groups[group.Id], IsNil, Commentf("duplicate group id: %q", group.Id))
                         groups[group.Id] = group
                 }
                 if !t.allowExtra {
-                        c.Check(len(groups), Equals, len(t.results), Bug("expected %d groups got %#v", len(t.results), groups))
+                        c.Check(groups, HasLen, len(t.results))
                 }
                 for j, g := range t.results {
                         rg := groups[g.Id]
-                        c.Assert(rg, NotNil, Bug("group %d (%v) not found; got %#v", j, g, groups))
-                        c.Check(rg.Name, Equals, g.Name, Bug("group %d (%v)", j, g))
-                }
-        }
-}
+                        c.Assert(rg, NotNil, Commentf("group %d (%v) not found; got %#v", j, g, groups))
+                        c.Check(rg.Name, Equals, g.Name, Commentf("group %d (%v)", j, g))
+                }
+        }
+}