ec2test: fix filtering behaviour.

ec2_test.go

 package ec2_test
 
 import (
         "launchpad.net/goamz/aws"
         "launchpad.net/goamz/ec2"
         . "launchpad.net/gocheck"
 )
 
 var _ = Suite(&S{})
 
@@ skipping 67 matching lines @@
                 PlacementGroupName:    "group",
                 Monitoring:            true,
                 SubnetId:              "subnet-id",
                 DisableAPITermination: true,
                 ShutdownBehavior:      "terminate",
                 PrivateIPAddress:      "10.0.0.25",
         }
         resp, err := s.ec2.RunInstances(&options)
 
         req := testServer.WaitRequest()
-        c.Assert(req.Form["Action"], Equals, []string{"RunInstances"})
-        c.Assert(req.Form["ImageId"], Equals, []string{"image-id"})
-        c.Assert(req.Form["MinCount"], Equals, []string{"1"})
-        c.Assert(req.Form["MaxCount"], Equals, []string{"1"})
-        c.Assert(req.Form["KeyName"], Equals, []string{"my-keys"})
-        c.Assert(req.Form["InstanceType"], Equals, []string{"inst-type"})
-        c.Assert(req.Form["SecurityGroup.1"], Equals, []string{"g1"})
-        c.Assert(req.Form["SecurityGroup.2"], Equals, []string{"g3"})
-        c.Assert(req.Form["SecurityGroupId.1"], Equals, []string{"g2"})
-        c.Assert(req.Form["SecurityGroupId.2"], Equals, []string{"g4"})
-        c.Assert(req.Form["UserData"], Equals, []string{"MTIzNA=="})
-        c.Assert(req.Form["KernelId"], Equals, []string{"kernel-id"})
-        c.Assert(req.Form["RamdiskId"], Equals, []string{"ramdisk-id"})
-        c.Assert(req.Form["Placement.AvailabilityZone"], Equals, []string{"zone"})
-        c.Assert(req.Form["Placement.GroupName"], Equals, []string{"group"})
-        c.Assert(req.Form["Monitoring.Enabled"], Equals, []string{"true"})
-        c.Assert(req.Form["SubnetId"], Equals, []string{"subnet-id"})
-        c.Assert(req.Form["DisableApiTermination"], Equals, []string{"true"})
-        c.Assert(req.Form["InstanceInitiatedShutdownBehavior"], Equals, []string{"terminate"})
-        c.Assert(req.Form["PrivateIpAddress"], Equals, []string{"10.0.0.25"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"RunInstances"})
+        c.Assert(req.Form["ImageId"], DeepEquals, []string{"image-id"})
+        c.Assert(req.Form["MinCount"], DeepEquals, []string{"1"})
+        c.Assert(req.Form["MaxCount"], DeepEquals, []string{"1"})
+        c.Assert(req.Form["KeyName"], DeepEquals, []string{"my-keys"})
+        c.Assert(req.Form["InstanceType"], DeepEquals, []string{"inst-type"})
+        c.Assert(req.Form["SecurityGroup.1"], DeepEquals, []string{"g1"})
+        c.Assert(req.Form["SecurityGroup.2"], DeepEquals, []string{"g3"})
+        c.Assert(req.Form["SecurityGroupId.1"], DeepEquals, []string{"g2"})
+        c.Assert(req.Form["SecurityGroupId.2"], DeepEquals, []string{"g4"})
+        c.Assert(req.Form["UserData"], DeepEquals, []string{"MTIzNA=="})
+        c.Assert(req.Form["KernelId"], DeepEquals, []string{"kernel-id"})
+        c.Assert(req.Form["RamdiskId"], DeepEquals, []string{"ramdisk-id"})
+        c.Assert(req.Form["Placement.AvailabilityZone"], DeepEquals, []string{"zone"})
+        c.Assert(req.Form["Placement.GroupName"], DeepEquals, []string{"group"})
+        c.Assert(req.Form["Monitoring.Enabled"], DeepEquals, []string{"true"})
+        c.Assert(req.Form["SubnetId"], DeepEquals, []string{"subnet-id"})
+        c.Assert(req.Form["DisableApiTermination"], DeepEquals, []string{"true"})
+        c.Assert(req.Form["InstanceInitiatedShutdownBehavior"], DeepEquals, []string{"terminate"})
+        c.Assert(req.Form["PrivateIpAddress"], DeepEquals, []string{"10.0.0.25"})
 
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
         c.Assert(resp.ReservationId, Equals, "r-47a5402e")
         c.Assert(resp.OwnerId, Equals, "999988887777")
-        c.Assert(resp.SecurityGroups, Equals, []ec2.SecurityGroup{{Name: "default", Id: "sg-67ad940e"}})
-        c.Assert(len(resp.Instances), Equals, 3)
+        c.Assert(resp.SecurityGroups, DeepEquals, []ec2.SecurityGroup{{Name: "default", Id: "sg-67ad940e"}})
+        c.Assert(resp.Instances, HasLen, 3)
 
         i0 := resp.Instances[0]
         c.Assert(i0.InstanceId, Equals, "i-2ba64342")
         c.Assert(i0.InstanceType, Equals, "m1.small")
         c.Assert(i0.ImageId, Equals, "ami-60a54009")
         c.Assert(i0.Monitoring, Equals, "enabled")
         c.Assert(i0.KeyName, Equals, "example-key-name")
         c.Assert(i0.AMILaunchIndex, Equals, 0)
         c.Assert(i0.VirtType, Equals, "paravirtual")
         c.Assert(i0.Hypervisor, Equals, "xen")
@@ skipping 18 matching lines @@
         c.Assert(i2.VirtType, Equals, "paravirtual")
         c.Assert(i2.Hypervisor, Equals, "xen")
 }
 
 func (s *S) TestTerminateInstancesExample(c *C) {
         testServer.PrepareResponse(200, nil, TerminateInstancesExample)
 
         resp, err := s.ec2.TerminateInstances([]string{"i-1", "i-2"})
 
         req := testServer.WaitRequest()
-        c.Assert(req.Form["Action"], Equals, []string{"TerminateInstances"})
-        c.Assert(req.Form["InstanceId.1"], Equals, []string{"i-1"})
-        c.Assert(req.Form["InstanceId.2"], Equals, []string{"i-2"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"TerminateInstances"})
+        c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-1"})
+        c.Assert(req.Form["InstanceId.2"], DeepEquals, []string{"i-2"})
         c.Assert(req.Form["UserData"], IsNil)
         c.Assert(req.Form["KernelId"], IsNil)
         c.Assert(req.Form["RamdiskId"], IsNil)
         c.Assert(req.Form["Placement.AvailabilityZone"], IsNil)
         c.Assert(req.Form["Placement.GroupName"], IsNil)
         c.Assert(req.Form["Monitoring.Enabled"], IsNil)
         c.Assert(req.Form["SubnetId"], IsNil)
         c.Assert(req.Form["DisableApiTermination"], IsNil)
         c.Assert(req.Form["InstanceInitiatedShutdownBehavior"], IsNil)
         c.Assert(req.Form["PrivateIpAddress"], IsNil)
 
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
-        c.Assert(len(resp.StateChanges), Equals, 1)
+        c.Assert(resp.StateChanges, HasLen, 1)
         c.Assert(resp.StateChanges[0].InstanceId, Equals, "i-3ea74257")
         c.Assert(resp.StateChanges[0].CurrentState.Code, Equals, 32)
         c.Assert(resp.StateChanges[0].CurrentState.Name, Equals, "shutting-down")
         c.Assert(resp.StateChanges[0].PreviousState.Code, Equals, 16)
         c.Assert(resp.StateChanges[0].PreviousState.Name, Equals, "running")
 }
 
 func (s *S) TestDescribeInstancesExample1(c *C) {
         testServer.PrepareResponse(200, nil, DescribeInstancesExample1)
 
         filter := ec2.NewFilter()
         filter.Add("key1", "value1")
         filter.Add("key2", "value2", "value3")
 
         resp, err := s.ec2.Instances([]string{"i-1", "i-2"}, nil)
 
         req := testServer.WaitRequest()
-        c.Assert(req.Form["Action"], Equals, []string{"DescribeInstances"})
-        c.Assert(req.Form["InstanceId.1"], Equals, []string{"i-1"})
-        c.Assert(req.Form["InstanceId.2"], Equals, []string{"i-2"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeInstances"})
+        c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-1"})
+        c.Assert(req.Form["InstanceId.2"], DeepEquals, []string{"i-2"})
 
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "98e3c9a4-848c-4d6d-8e8a-b1bdEXAMPLE")
-        c.Assert(len(resp.Reservations), Equals, 2)
+        c.Assert(resp.Reservations, HasLen, 2)
 
         r0 := resp.Reservations[0]
         c.Assert(r0.ReservationId, Equals, "r-b27e30d9")
         c.Assert(r0.OwnerId, Equals, "999988887777")
         c.Assert(r0.RequesterId, Equals, "854251627541")
-        c.Assert(r0.SecurityGroups, Equals, []ec2.SecurityGroup{{Name: "default", Id: "sg-67ad940e"}})
-        c.Assert(len(r0.Instances), Equals, 1)
+        c.Assert(r0.SecurityGroups, DeepEquals, []ec2.SecurityGroup{{Name: "default", Id: "sg-67ad940e"}})
+        c.Assert(r0.Instances, HasLen, 1)
 
         r0i := r0.Instances[0]
         c.Assert(r0i.InstanceId, Equals, "i-c5cd56af")
         c.Assert(r0i.PrivateDNSName, Equals, "domU-12-31-39-10-56-34.compute-1.internal")
         c.Assert(r0i.DNSName, Equals, "ec2-174-129-165-232.compute-1.amazonaws.com")
         c.Assert(r0i.AvailZone, Equals, "us-east-1b")
 }
 
 func (s *S) TestDescribeInstancesExample2(c *C) {
         testServer.PrepareResponse(200, nil, DescribeInstancesExample2)
 
         filter := ec2.NewFilter()
         filter.Add("key1", "value1")
         filter.Add("key2", "value2", "value3")
 
         resp, err := s.ec2.Instances([]string{"i-1", "i-2"}, filter)
 
         req := testServer.WaitRequest()
-        c.Assert(req.Form["Action"], Equals, []string{"DescribeInstances"})
-        c.Assert(req.Form["InstanceId.1"], Equals, []string{"i-1"})
-        c.Assert(req.Form["InstanceId.2"], Equals, []string{"i-2"})
-        c.Assert(req.Form["Filter.1.Name"], Equals, []string{"key1"})
-        c.Assert(req.Form["Filter.1.Value.1"], Equals, []string{"value1"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeInstances"})
+        c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-1"})
+        c.Assert(req.Form["InstanceId.2"], DeepEquals, []string{"i-2"})
+        c.Assert(req.Form["Filter.1.Name"], DeepEquals, []string{"key1"})
+        c.Assert(req.Form["Filter.1.Value.1"], DeepEquals, []string{"value1"})
         c.Assert(req.Form["Filter.1.Value.2"], IsNil)
-        c.Assert(req.Form["Filter.2.Name"], Equals, []string{"key2"})
-        c.Assert(req.Form["Filter.2.Value.1"], Equals, []string{"value2"})
-        c.Assert(req.Form["Filter.2.Value.2"], Equals, []string{"value3"})
-
-        c.Assert(err, IsNil)
-        c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
-        c.Assert(len(resp.Reservations), Equals, 1)
+        c.Assert(req.Form["Filter.2.Name"], DeepEquals, []string{"key2"})
+        c.Assert(req.Form["Filter.2.Value.1"], DeepEquals, []string{"value2"})
+        c.Assert(req.Form["Filter.2.Value.2"], DeepEquals, []string{"value3"})
+
+        c.Assert(err, IsNil)
+        c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
+        c.Assert(resp.Reservations, HasLen, 1)
 
         r0 := resp.Reservations[0]
         r0i := r0.Instances[0]
         c.Assert(r0i.State.Code, Equals, 16)
         c.Assert(r0i.State.Name, Equals, "running")
 
         r0t0 := r0i.Tags[0]
         r0t1 := r0i.Tags[1]
         c.Assert(r0t0.Key, Equals, "webserver")
         c.Assert(r0t0.Value, Equals, "")
         c.Assert(r0t1.Key, Equals, "stack")
         c.Assert(r0t1.Value, Equals, "Production")
 }
 
 func (s *S) TestCreateSecurityGroupExample(c *C) {
         testServer.PrepareResponse(200, nil, CreateSecurityGroupExample)
 
         resp, err := s.ec2.CreateSecurityGroup("websrv", "Web Servers")
 
         req := testServer.WaitRequest()
-        c.Assert(req.Form["Action"], Equals, []string{"CreateSecurityGroup"})
-        c.Assert(req.Form["GroupName"], Equals, []string{"websrv"})
-        c.Assert(req.Form["GroupDescription"], Equals, []string{"Web Servers"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"CreateSecurityGroup"})
+        c.Assert(req.Form["GroupName"], DeepEquals, []string{"websrv"})
+        c.Assert(req.Form["GroupDescription"], DeepEquals, []string{"Web Servers"})
 
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
         c.Assert(resp.Name, Equals, "websrv")
         c.Assert(resp.Id, Equals, "sg-67ad940e")
 }
 
 func (s *S) TestDescribeSecurityGroupsExample(c *C) {
         testServer.PrepareResponse(200, nil, DescribeSecurityGroupsExample)
 
         resp, err := s.ec2.SecurityGroups([]ec2.SecurityGroup{{Name: "WebServers"}, {Name: "RangedPortsBySource"}}, nil)
 
         req := testServer.WaitRequest()
-        c.Assert(req.Form["Action"], Equals, []string{"DescribeSecurityGroups"})
-        c.Assert(req.Form["GroupName.1"], Equals, []string{"WebServers"})
-        c.Assert(req.Form["GroupName.2"], Equals, []string{"RangedPortsBySource"})
-
-        c.Assert(err, IsNil)
-        c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
-        c.Assert(len(resp.Groups), Equals, 2)
+        c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeSecurityGroups"})
+        c.Assert(req.Form["GroupName.1"], DeepEquals, []string{"WebServers"})
+        c.Assert(req.Form["GroupName.2"], DeepEquals, []string{"RangedPortsBySource"})
+
+        c.Assert(err, IsNil)
+        c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
+        c.Assert(resp.Groups, HasLen, 2)
 
         g0 := resp.Groups[0]
         c.Assert(g0.OwnerId, Equals, "999988887777")
         c.Assert(g0.Name, Equals, "WebServers")
         c.Assert(g0.Id, Equals, "sg-67ad940e")
         c.Assert(g0.Description, Equals, "Web Servers")
-        c.Assert(len(g0.IPPerms), Equals, 1)
+        c.Assert(g0.IPPerms, HasLen, 1)
 
         g0ipp := g0.IPPerms[0]
         c.Assert(g0ipp.Protocol, Equals, "tcp")
         c.Assert(g0ipp.FromPort, Equals, 80)
         c.Assert(g0ipp.ToPort, Equals, 80)
-        c.Assert(g0ipp.SourceIPs, Equals, []string{"0.0.0.0/0"})
+        c.Assert(g0ipp.SourceIPs, DeepEquals, []string{"0.0.0.0/0"})
 
         g1 := resp.Groups[1]
         c.Assert(g1.OwnerId, Equals, "999988887777")
         c.Assert(g1.Name, Equals, "RangedPortsBySource")
         c.Assert(g1.Id, Equals, "sg-76abc467")
         c.Assert(g1.Description, Equals, "Group A")
-        c.Assert(len(g1.IPPerms), Equals, 1)
+        c.Assert(g1.IPPerms, HasLen, 1)
 
         g1ipp := g1.IPPerms[0]
         c.Assert(g1ipp.Protocol, Equals, "tcp")
         c.Assert(g1ipp.FromPort, Equals, 6000)
         c.Assert(g1ipp.ToPort, Equals, 7000)
         c.Assert(g1ipp.SourceIPs, IsNil)
 }
 
 func (s *S) TestDescribeSecurityGroupsExampleWithFilter(c *C) {
         testServer.PrepareResponse(200, nil, DescribeSecurityGroupsExample)
 
         filter := ec2.NewFilter()
         filter.Add("ip-permission.protocol", "tcp")
         filter.Add("ip-permission.from-port", "22")
         filter.Add("ip-permission.to-port", "22")
         filter.Add("ip-permission.group-name", "app_server_group", "database_group")
 
         _, err := s.ec2.SecurityGroups(nil, filter)
 
         req := testServer.WaitRequest()
-        c.Assert(req.Form["Action"], Equals, []string{"DescribeSecurityGroups"})
-        c.Assert(req.Form["Filter.1.Name"], Equals, []string{"ip-permission.from-port"})
-        c.Assert(req.Form["Filter.1.Value.1"], Equals, []string{"22"})
-        c.Assert(req.Form["Filter.2.Name"], Equals, []string{"ip-permission.group-name"})
-        c.Assert(req.Form["Filter.2.Value.1"], Equals, []string{"app_server_group"})
-        c.Assert(req.Form["Filter.2.Value.2"], Equals, []string{"database_group"})
-        c.Assert(req.Form["Filter.3.Name"], Equals, []string{"ip-permission.protocol"})
-        c.Assert(req.Form["Filter.3.Value.1"], Equals, []string{"tcp"})
-        c.Assert(req.Form["Filter.4.Name"], Equals, []string{"ip-permission.to-port"})
-        c.Assert(req.Form["Filter.4.Value.1"], Equals, []string{"22"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeSecurityGroups"})
+        c.Assert(req.Form["Filter.1.Name"], DeepEquals, []string{"ip-permission.from-port"})
+        c.Assert(req.Form["Filter.1.Value.1"], DeepEquals, []string{"22"})
+        c.Assert(req.Form["Filter.2.Name"], DeepEquals, []string{"ip-permission.group-name"})
+        c.Assert(req.Form["Filter.2.Value.1"], DeepEquals, []string{"app_server_group"})
+        c.Assert(req.Form["Filter.2.Value.2"], DeepEquals, []string{"database_group"})
+        c.Assert(req.Form["Filter.3.Name"], DeepEquals, []string{"ip-permission.protocol"})
+        c.Assert(req.Form["Filter.3.Value.1"], DeepEquals, []string{"tcp"})
+        c.Assert(req.Form["Filter.4.Name"], DeepEquals, []string{"ip-permission.to-port"})
+        c.Assert(req.Form["Filter.4.Value.1"], DeepEquals, []string{"22"})
 
         c.Assert(err, IsNil)
 }
 
 func (s *S) TestDescribeSecurityGroupsDumpWithGroup(c *C) {
         testServer.PrepareResponse(200, nil, DescribeSecurityGroupsDump)
 
         resp, err := s.ec2.SecurityGroups(nil, nil)
 
         req := testServer.WaitRequest()
-        c.Assert(req.Form["Action"], Equals, []string{"DescribeSecurityGroups"})
-        c.Assert(err, IsNil)
-        c.Check(len(resp.Groups), Equals, 1)
-        c.Check(len(resp.Groups[0].IPPerms), Equals, 2)
+        c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeSecurityGroups"})
+        c.Assert(err, IsNil)
+        c.Check(resp.Groups, HasLen, 1)
+        c.Check(resp.Groups[0].IPPerms, HasLen, 2)
 
         ipp0 := resp.Groups[0].IPPerms[0]
         c.Assert(ipp0.SourceIPs, IsNil)
         c.Check(ipp0.Protocol, Equals, "icmp")
-        c.Assert(len(ipp0.SourceGroups), Equals, 1)
+        c.Assert(ipp0.SourceGroups, HasLen, 1)
         c.Check(ipp0.SourceGroups[0].OwnerId, Equals, "12345")
         c.Check(ipp0.SourceGroups[0].Name, Equals, "default")
         c.Check(ipp0.SourceGroups[0].Id, Equals, "sg-67ad940e")
 
         ipp1 := resp.Groups[0].IPPerms[1]
         c.Check(ipp1.Protocol, Equals, "tcp")
         c.Assert(ipp0.SourceIPs, IsNil)
-        c.Assert(len(ipp0.SourceGroups), Equals, 1)
+        c.Assert(ipp0.SourceGroups, HasLen, 1)
         c.Check(ipp1.SourceGroups[0].Id, Equals, "sg-76abc467")
         c.Check(ipp1.SourceGroups[0].OwnerId, Equals, "12345")
         c.Check(ipp1.SourceGroups[0].Name, Equals, "other")
 }
 
 func (s *S) TestDeleteSecurityGroupExample(c *C) {
         testServer.PrepareResponse(200, nil, DeleteSecurityGroupExample)
 
         resp, err := s.ec2.DeleteSecurityGroup(ec2.SecurityGroup{Name: "websrv"})
         req := testServer.WaitRequest()
 
-        c.Assert(req.Form["Action"], Equals, []string{"DeleteSecurityGroup"})
-        c.Assert(req.Form["GroupName"], Equals, []string{"websrv"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"DeleteSecurityGroup"})
+        c.Assert(req.Form["GroupName"], DeepEquals, []string{"websrv"})
         c.Assert(req.Form["GroupId"], IsNil)
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
 }
 
 func (s *S) TestDeleteSecurityGroupExampleWithId(c *C) {
         testServer.PrepareResponse(200, nil, DeleteSecurityGroupExample)
 
         // ignore return and error - we're only want to check the parameter handling.
         s.ec2.DeleteSecurityGroup(ec2.SecurityGroup{Id: "sg-67ad940e", Name: "ignored"})
         req := testServer.WaitRequest()
 
         c.Assert(req.Form["GroupName"], IsNil)
-        c.Assert(req.Form["GroupId"], Equals, []string{"sg-67ad940e"})
+        c.Assert(req.Form["GroupId"], DeepEquals, []string{"sg-67ad940e"})
 }
 
 func (s *S) TestAuthorizeSecurityGroupExample1(c *C) {
         testServer.PrepareResponse(200, nil, AuthorizeSecurityGroupIngressExample)
 
         perms := []ec2.IPPerm{{
                 Protocol:  "tcp",
                 FromPort:  80,
                 ToPort:    80,
                 SourceIPs: []string{"205.192.0.0/16", "205.159.0.0/16"},
         }}
         resp, err := s.ec2.AuthorizeSecurityGroup(ec2.SecurityGroup{Name: "websrv"}, perms)
 
         req := testServer.WaitRequest()
 
-        c.Assert(req.Form["Action"], Equals, []string{"AuthorizeSecurityGroupIngress"})
-        c.Assert(req.Form["GroupName"], Equals, []string{"websrv"})
-        c.Assert(req.Form["IpPermissions.1.IpProtocol"], Equals, []string{"tcp"})
-        c.Assert(req.Form["IpPermissions.1.FromPort"], Equals, []string{"80"})
-        c.Assert(req.Form["IpPermissions.1.ToPort"], Equals, []string{"80"})
-        c.Assert(req.Form["IpPermissions.1.IpRanges.1.CidrIp"], Equals, []string{"205.192.0.0/16"})
-        c.Assert(req.Form["IpPermissions.1.IpRanges.2.CidrIp"], Equals, []string{"205.159.0.0/16"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"AuthorizeSecurityGroupIngress"})
+        c.Assert(req.Form["GroupName"], DeepEquals, []string{"websrv"})
+        c.Assert(req.Form["IpPermissions.1.IpProtocol"], DeepEquals, []string{"tcp"})
+        c.Assert(req.Form["IpPermissions.1.FromPort"], DeepEquals, []string{"80"})
+        c.Assert(req.Form["IpPermissions.1.ToPort"], DeepEquals, []string{"80"})
+        c.Assert(req.Form["IpPermissions.1.IpRanges.1.CidrIp"], DeepEquals, []string{"205.192.0.0/16"})
+        c.Assert(req.Form["IpPermissions.1.IpRanges.2.CidrIp"], DeepEquals, []string{"205.159.0.0/16"})
 
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
 }
 
 func (s *S) TestAuthorizeSecurityGroupExample1WithId(c *C) {
         testServer.PrepareResponse(200, nil, AuthorizeSecurityGroupIngressExample)
 
         perms := []ec2.IPPerm{{
                 Protocol:  "tcp",
                 FromPort:  80,
                 ToPort:    80,
                 SourceIPs: []string{"205.192.0.0/16", "205.159.0.0/16"},
         }}
         // ignore return and error - we're only want to check the parameter handling.
         s.ec2.AuthorizeSecurityGroup(ec2.SecurityGroup{Id: "sg-67ad940e", Name: "ignored"}, perms)
 
         req := testServer.WaitRequest()
 
         c.Assert(req.Form["GroupName"], IsNil)
-        c.Assert(req.Form["GroupId"], Equals, []string{"sg-67ad940e"})
+        c.Assert(req.Form["GroupId"], DeepEquals, []string{"sg-67ad940e"})
 }
 
 func (s *S) TestAuthorizeSecurityGroupExample2(c *C) {
         testServer.PrepareResponse(200, nil, AuthorizeSecurityGroupIngressExample)
 
         perms := []ec2.IPPerm{{
                 Protocol: "tcp",
                 FromPort: 80,
                 ToPort:   81,
                 SourceGroups: []ec2.UserSecurityGroup{
                         {OwnerId: "999988887777", Name: "OtherAccountGroup"},
                         {Id: "sg-67ad940e"},
                 },
         }}
         resp, err := s.ec2.AuthorizeSecurityGroup(ec2.SecurityGroup{Name: "websrv"}, perms)
 
         req := testServer.WaitRequest()
 
-        c.Assert(req.Form["Action"], Equals, []string{"AuthorizeSecurityGroupIngress"})
-        c.Assert(req.Form["GroupName"], Equals, []string{"websrv"})
-        c.Assert(req.Form["IpPermissions.1.IpProtocol"], Equals, []string{"tcp"})
-        c.Assert(req.Form["IpPermissions.1.FromPort"], Equals, []string{"80"})
-        c.Assert(req.Form["IpPermissions.1.ToPort"], Equals, []string{"81"})
-        c.Assert(req.Form["IpPermissions.1.Groups.1.UserId"], Equals, []string{"999988887777"})
-        c.Assert(req.Form["IpPermissions.1.Groups.1.GroupName"], Equals, []string{"OtherAccountGroup"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"AuthorizeSecurityGroupIngress"})
+        c.Assert(req.Form["GroupName"], DeepEquals, []string{"websrv"})
+        c.Assert(req.Form["IpPermissions.1.IpProtocol"], DeepEquals, []string{"tcp"})
+        c.Assert(req.Form["IpPermissions.1.FromPort"], DeepEquals, []string{"80"})
+        c.Assert(req.Form["IpPermissions.1.ToPort"], DeepEquals, []string{"81"})
+        c.Assert(req.Form["IpPermissions.1.Groups.1.UserId"], DeepEquals, []string{"999988887777"})
+        c.Assert(req.Form["IpPermissions.1.Groups.1.GroupName"], DeepEquals, []string{"OtherAccountGroup"})
         c.Assert(req.Form["IpPermissions.1.Groups.2.UserId"], IsNil)
         c.Assert(req.Form["IpPermissions.1.Groups.2.GroupName"], IsNil)
-        c.Assert(req.Form["IpPermissions.1.Groups.2.GroupId"], Equals, []string{"sg-67ad940e"})
+        c.Assert(req.Form["IpPermissions.1.Groups.2.GroupId"], DeepEquals, []string{"sg-67ad940e"})
 
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
 }
 
 func (s *S) TestRevokeSecurityGroupExample(c *C) {
         // RevokeSecurityGroup is implemented by the same code as AuthorizeSecurityGroup
         // so there's no need to duplicate all the tests.
         testServer.PrepareResponse(200, nil, RevokeSecurityGroupIngressExample)
 
         resp, err := s.ec2.RevokeSecurityGroup(ec2.SecurityGroup{Name: "websrv"}, nil)
 
         req := testServer.WaitRequest()
 
-        c.Assert(req.Form["Action"], Equals, []string{"RevokeSecurityGroupIngress"})
-        c.Assert(req.Form["GroupName"], Equals, []string{"websrv"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"RevokeSecurityGroupIngress"})
+        c.Assert(req.Form["GroupName"], DeepEquals, []string{"websrv"})
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
 }
 
 func (s *S) TestCreateTags(c *C) {
         testServer.PrepareResponse(200, nil, CreateTagsExample)
 
         resp, err := s.ec2.CreateTags([]string{"ami-1a2b3c4d", "i-7f4d3a2b"}, []ec2.Tag{{"webserver", ""}, {"stack", "Production"}})
 
         req := testServer.WaitRequest()
-        c.Assert(req.Form["ResourceId.1"], Equals, []string{"ami-1a2b3c4d"})
-        c.Assert(req.Form["ResourceId.2"], Equals, []string{"i-7f4d3a2b"})
-        c.Assert(req.Form["Tag.1.Key"], Equals, []string{"webserver"})
-        c.Assert(req.Form["Tag.1.Value"], Equals, []string{""})
-        c.Assert(req.Form["Tag.2.Key"], Equals, []string{"stack"})
-        c.Assert(req.Form["Tag.2.Value"], Equals, []string{"Production"})
+        c.Assert(req.Form["ResourceId.1"], DeepEquals, []string{"ami-1a2b3c4d"})
+        c.Assert(req.Form["ResourceId.2"], DeepEquals, []string{"i-7f4d3a2b"})
+        c.Assert(req.Form["Tag.1.Key"], DeepEquals, []string{"webserver"})
+        c.Assert(req.Form["Tag.1.Value"], DeepEquals, []string{""})
+        c.Assert(req.Form["Tag.2.Key"], DeepEquals, []string{"stack"})
+        c.Assert(req.Form["Tag.2.Value"], DeepEquals, []string{"Production"})
 
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
 }
 
 func (s *S) TestStartInstances(c *C) {
         testServer.PrepareResponse(200, nil, StartInstancesExample)
 
         resp, err := s.ec2.StartInstances("i-10a64379")
         req := testServer.WaitRequest()
 
-        c.Assert(req.Form["Action"], Equals, []string{"StartInstances"})
-        c.Assert(req.Form["InstanceId.1"], Equals, []string{"i-10a64379"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"StartInstances"})
+        c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-10a64379"})
 
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
 
         s0 := resp.StateChanges[0]
         c.Assert(s0.InstanceId, Equals, "i-10a64379")
         c.Assert(s0.CurrentState.Code, Equals, 0)
         c.Assert(s0.CurrentState.Name, Equals, "pending")
         c.Assert(s0.PreviousState.Code, Equals, 80)
         c.Assert(s0.PreviousState.Name, Equals, "stopped")
 }
 
 func (s *S) TestStopInstances(c *C) {
         testServer.PrepareResponse(200, nil, StopInstancesExample)
 
         resp, err := s.ec2.StopInstances("i-10a64379")
         req := testServer.WaitRequest()
 
-        c.Assert(req.Form["Action"], Equals, []string{"StopInstances"})
-        c.Assert(req.Form["InstanceId.1"], Equals, []string{"i-10a64379"})
+        c.Assert(req.Form["Action"], DeepEquals, []string{"StopInstances"})
+        c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-10a64379"})
 
         c.Assert(err, IsNil)
         c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
 
         s0 := resp.StateChanges[0]
         c.Assert(s0.InstanceId, Equals, "i-10a64379")
         c.Assert(s0.CurrentState.Code, Equals, 64)
         c.Assert(s0.CurrentState.Name, Equals, "stopping")
         c.Assert(s0.PreviousState.Code, Equals, 16)
         c.Assert(s0.PreviousState.Name, Equals, "running")
 }
 
 func (s *S) TestRebootInstances(c *C) {
         testServer.PrepareResponse(200, nil, RebootInstancesExample)
 
         resp, err := s.ec2.RebootInstances("i-10a64379")
         req := testServer.WaitRequest()
 
-        c.Assert(req.Form["Action"], Equals, []string{"RebootInstances"})
-        c.Assert(req.Form["InstanceId.1"], Equals, []string{"i-10a64379"})
-
-        c.Assert(err, IsNil)
-        c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
-}
+        c.Assert(req.Form["Action"], DeepEquals, []string{"RebootInstances"})
+        c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-10a64379"})
+
+        c.Assert(err, IsNil)
+        c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
+}