gcloud 0.0.4 → 0.0.6

data/packages/gsutil/boto/tests/unit/dynamodb/test_types.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.  All Rights Reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+from decimal import Decimal
+from tests.unit import unittest
+
+from boto.dynamodb import types
+from boto.dynamodb.exceptions import DynamoDBNumberError
+
+
+class TestDynamizer(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def test_encoding_to_dynamodb(self):
+        dynamizer = types.Dynamizer()
+        self.assertEqual(dynamizer.encode('foo'), {'S': 'foo'})
+        self.assertEqual(dynamizer.encode(54), {'N': '54'})
+        self.assertEqual(dynamizer.encode(Decimal('1.1')), {'N': '1.1'})
+        self.assertEqual(dynamizer.encode(set([1, 2, 3])),
+                         {'NS': ['1', '2', '3']})
+        self.assertEqual(dynamizer.encode(set(['foo', 'bar'])),
+                         {'SS': ['foo', 'bar']})
+        self.assertEqual(dynamizer.encode(types.Binary('\x01')),
+                         {'B': 'AQ=='})
+        self.assertEqual(dynamizer.encode(set([types.Binary('\x01')])),
+                         {'BS': ['AQ==']})
+
+    def test_decoding_to_dynamodb(self):
+        dynamizer = types.Dynamizer()
+        self.assertEqual(dynamizer.decode({'S': 'foo'}), 'foo')
+        self.assertEqual(dynamizer.decode({'N': '54'}), 54)
+        self.assertEqual(dynamizer.decode({'N': '1.1'}), Decimal('1.1'))
+        self.assertEqual(dynamizer.decode({'NS': ['1', '2', '3']}),
+                         set([1, 2, 3]))
+        self.assertEqual(dynamizer.decode({'SS': ['foo', 'bar']}),
+                         set(['foo', 'bar']))
+        self.assertEqual(dynamizer.decode({'B': 'AQ=='}), types.Binary('\x01'))
+        self.assertEqual(dynamizer.decode({'BS': ['AQ==']}),
+                         set([types.Binary('\x01')]))
+
+    def test_float_conversion_errors(self):
+        dynamizer = types.Dynamizer()
+        # When supporting decimals, certain floats will work:
+        self.assertEqual(dynamizer.encode(1.25), {'N': '1.25'})
+        # And some will generate errors, which is why it's best
+        # to just use Decimals directly:
+        with self.assertRaises(DynamoDBNumberError):
+            dynamizer.encode(1.1)
+
+    def test_lossy_float_conversions(self):
+        dynamizer = types.LossyFloatDynamizer()
+        # Just testing the differences here, specifically float conversions:
+        self.assertEqual(dynamizer.encode(1.1), {'N': '1.1'})
+        self.assertEqual(dynamizer.decode({'N': '1.1'}), 1.1)
+
+        self.assertEqual(dynamizer.encode(set([1.1])),
+                         {'NS': ['1.1']})
+        self.assertEqual(dynamizer.decode({'NS': ['1.1', '2.2', '3.3']}),
+                         set([1.1, 2.2, 3.3]))
+
+if __name__ == '__main__':
+    unittest.main()

data/packages/gsutil/boto/tests/unit/ec2/autoscale/test_group.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python
+# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.  All Rights Reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+
+from tests.unit import unittest
+from tests.unit import AWSMockServiceTestCase
+
+from boto.ec2.autoscale import AutoScaleConnection
+from boto.ec2.autoscale.group import AutoScalingGroup
+
+
+class TestAutoScaleGroup(AWSMockServiceTestCase):
+    connection_class = AutoScaleConnection
+
+    def setUp(self):
+        super(TestAutoScaleGroup, self).setUp()
+
+    def default_body(self):
+        return """
+            <CreateLaunchConfigurationResponse>
+              <ResponseMetadata>
+                <RequestId>requestid</RequestId>
+              </ResponseMetadata>
+            </CreateLaunchConfigurationResponse>
+        """
+
+    def test_autoscaling_group_with_termination_policies(self):
+        self.set_http_response(status_code=200)
+        autoscale = AutoScalingGroup(
+            name='foo', launch_config='lauch_config',
+            min_size=1, max_size=2,
+            termination_policies=['OldestInstance', 'OldestLaunchConfiguration'])
+        self.service_connection.create_auto_scaling_group(autoscale)
+        self.assert_request_parameters({
+            'Action': 'CreateAutoScalingGroup',
+            'AutoScalingGroupName': 'foo',
+            'LaunchConfigurationName': 'lauch_config',
+            'MaxSize': 2,
+            'MinSize': 1,
+            'TerminationPolicies.member.1': 'OldestInstance',
+            'TerminationPolicies.member.2': 'OldestLaunchConfiguration',
+        }, ignore_params_values=['Version'])
+
+
+class TestParseAutoScaleGroupResponse(AWSMockServiceTestCase):
+    connection_class = AutoScaleConnection
+
+    def default_body(self):
+        return """
+          <DescribeAutoScalingGroupsResult>
+             <AutoScalingGroups>
+               <member>
+                 <Tags/>
+                 <SuspendedProcesses/>
+                 <AutoScalingGroupName>test_group</AutoScalingGroupName>
+                 <HealthCheckType>EC2</HealthCheckType>
+                 <CreatedTime>2012-09-27T20:19:47.082Z</CreatedTime>
+                 <EnabledMetrics/>
+                 <LaunchConfigurationName>test_launchconfig</LaunchConfigurationName>
+                 <Instances>
+                   <member>
+                     <HealthStatus>Healthy</HealthStatus>
+                     <AvailabilityZone>us-east-1a</AvailabilityZone>
+                     <InstanceId>i-z118d054</InstanceId>
+                     <LaunchConfigurationName>test_launchconfig</LaunchConfigurationName>
+                     <LifecycleState>InService</LifecycleState>
+                   </member>
+                 </Instances>
+                 <DesiredCapacity>1</DesiredCapacity>
+                 <AvailabilityZones>
+                   <member>us-east-1c</member>
+                   <member>us-east-1a</member>
+                 </AvailabilityZones>
+                 <LoadBalancerNames/>
+                 <MinSize>1</MinSize>
+                 <VPCZoneIdentifier/>
+                 <HealthCheckGracePeriod>0</HealthCheckGracePeriod>
+                 <DefaultCooldown>300</DefaultCooldown>
+                 <AutoScalingGroupARN>myarn</AutoScalingGroupARN>
+                 <TerminationPolicies>
+                   <member>OldestInstance</member>
+                   <member>OldestLaunchConfiguration</member>
+                 </TerminationPolicies>
+                 <MaxSize>2</MaxSize>
+               </member>
+             </AutoScalingGroups>
+          </DescribeAutoScalingGroupsResult>
+        """
+
+    def test_get_all_groups_is_parsed_correctly(self):
+        self.set_http_response(status_code=200)
+        response = self.service_connection.get_all_groups(names=['test_group'])
+        self.assertEqual(len(response), 1, response)
+        as_group = response[0]
+        self.assertEqual(as_group.availability_zones, ['us-east-1c', 'us-east-1a'])
+        self.assertEqual(as_group.default_cooldown, 300)
+        self.assertEqual(as_group.desired_capacity, 1)
+        self.assertEqual(as_group.enabled_metrics, [])
+        self.assertEqual(as_group.health_check_period, 0)
+        self.assertEqual(as_group.health_check_type, 'EC2')
+        self.assertEqual(as_group.launch_config_name, 'test_launchconfig')
+        self.assertEqual(as_group.load_balancers, [])
+        self.assertEqual(as_group.min_size, 1)
+        self.assertEqual(as_group.max_size, 2)
+        self.assertEqual(as_group.name, 'test_group')
+        self.assertEqual(as_group.suspended_processes, [])
+        self.assertEqual(as_group.tags, [])
+        self.assertEqual(as_group.termination_policies,
+                         ['OldestInstance', 'OldestLaunchConfiguration'])
+
+
+class TestDescribeTerminationPolicies(AWSMockServiceTestCase):
+    connection_class = AutoScaleConnection
+
+    def default_body(self):
+        return """
+          <DescribeTerminationPolicyTypesResponse>
+            <DescribeTerminationPolicyTypesResult>
+              <TerminationPolicyTypes>
+                <member>ClosestToNextInstanceHour</member>
+                <member>Default</member>
+                <member>NewestInstance</member>
+                <member>OldestInstance</member>
+                <member>OldestLaunchConfiguration</member>
+              </TerminationPolicyTypes>
+            </DescribeTerminationPolicyTypesResult>
+            <ResponseMetadata>
+              <RequestId>requestid</RequestId>
+            </ResponseMetadata>
+          </DescribeTerminationPolicyTypesResponse>
+        """
+
+    def test_autoscaling_group_with_termination_policies(self):
+        self.set_http_response(status_code=200)
+        response = self.service_connection.get_termination_policies()
+        self.assertListEqual(
+            response,
+            ['ClosestToNextInstanceHour', 'Default',
+             'NewestInstance', 'OldestInstance', 'OldestLaunchConfiguration'])
+
+
+if __name__ == '__main__':
+    unittest.main()

data/packages/gsutil/boto/tests/unit/ec2/test_address.py

@@ -0,0 +1,39 @@
+import mock
+import unittest
+
+from boto.ec2.address import Address
+
+class AddressTest(unittest.TestCase):
+    def setUp(self):
+        self.address = Address()
+        self.address.connection = mock.Mock()
+        self.address.public_ip = "192.168.1.1"
+
+    def check_that_attribute_has_been_set(self, name, value, attribute):
+        self.address.endElement(name, value, None)
+        self.assertEqual(getattr(self.address, attribute), value)
+
+    def test_endElement_sets_correct_attributes_with_values(self):
+        for arguments in [("publicIp", "192.168.1.1", "public_ip"),
+                          ("instanceId", 1, "instance_id"),
+                          ("domain", "some domain", "domain"),
+                          ("allocationId", 1, "allocation_id"),
+                          ("associationId", 1, "association_id"),
+                          ("somethingRandom", "somethingRandom", "somethingRandom")]:
+            self.check_that_attribute_has_been_set(arguments[0], arguments[1], arguments[2])
+
+
+    def test_release_calls_connection_release_address_with_correct_args(self):
+        self.address.release()
+        self.address.connection.release_address.assert_called_with("192.168.1.1")
+
+    def test_associate_calls_connection_associate_address_with_correct_args(self):
+        self.address.associate(1)
+        self.address.connection.associate_address.assert_called_with(1, "192.168.1.1")
+
+    def test_disassociate_calls_connection_disassociate_address_with_correct_args(self):
+        self.address.disassociate()
+        self.address.connection.disassociate_address.assert_called_with("192.168.1.1")
+
+if __name__ == "__main__":
+    unittest.main()

data/packages/gsutil/boto/tests/unit/ec2/test_blockdevicemapping.py

@@ -0,0 +1,79 @@
+import mock
+import unittest
+
+from boto.ec2.blockdevicemapping import BlockDeviceType, BlockDeviceMapping
+
+class BlockDeviceTypeTests(unittest.TestCase):
+    def setUp(self):
+        self.block_device_type = BlockDeviceType()
+
+    def check_that_attribute_has_been_set(self, name, value, attribute):
+        self.block_device_type.endElement(name, value, None)
+        self.assertEqual(getattr(self.block_device_type, attribute), value)
+
+    def test_endElement_sets_correct_attributes_with_values(self):
+        for arguments in [("volumeId", 1, "volume_id"),
+                          ("virtualName", "some name", "ephemeral_name"),
+                          ("snapshotId", 1, "snapshot_id"),
+                          ("volumeSize", 1, "size"),
+                          ("status", "some status", "status"),
+                          ("attachTime", 1, "attach_time"),
+                          ("somethingRandom", "somethingRandom", "somethingRandom")]:
+            self.check_that_attribute_has_been_set(arguments[0], arguments[1], arguments[2])
+
+    def test_endElement_with_name_NoDevice_value_true(self):
+        self.block_device_type.endElement("NoDevice", 'true', None)
+        self.assertEqual(self.block_device_type.no_device, True)
+
+    def test_endElement_with_name_NoDevice_value_other(self):
+        self.block_device_type.endElement("NoDevice", 'something else', None)
+        self.assertEqual(self.block_device_type.no_device, False)
+
+    def test_endElement_with_name_deleteOnTermination_value_true(self):
+        self.block_device_type.endElement("deleteOnTermination", "true", None)
+        self.assertEqual(self.block_device_type.delete_on_termination, True)
+
+    def test_endElement_with_name_deleteOnTermination_value_other(self):
+        self.block_device_type.endElement("deleteOnTermination", 'something else', None)
+        self.assertEqual(self.block_device_type.delete_on_termination, False)
+
+class BlockDeviceMappingTests(unittest.TestCase):
+    def setUp(self):
+        self.block_device_mapping = BlockDeviceMapping()
+
+    def block_device_type_eq(self, b1, b2):
+        if isinstance(b1, BlockDeviceType) and isinstance(b2, BlockDeviceType):
+            return all([b1.connection == b2.connection,
+                        b1.ephemeral_name == b2.ephemeral_name,
+                        b1.no_device == b2.no_device,
+                        b1.volume_id == b2.volume_id,
+                        b1.snapshot_id == b2.snapshot_id,
+                        b1.status == b2.status,
+                        b1.attach_time == b2.attach_time,
+                        b1.delete_on_termination == b2.delete_on_termination,
+                        b1.size == b2.size])
+
+    def test_startElement_with_name_ebs_sets_and_returns_current_value(self):
+        retval = self.block_device_mapping.startElement("ebs", None, None)
+        assert self.block_device_type_eq(retval, BlockDeviceType(self.block_device_mapping))
+
+    def test_startElement_with_name_virtualName_sets_and_returns_current_value(self):
+        retval = self.block_device_mapping.startElement("virtualName", None, None)
+        assert self.block_device_type_eq(retval, BlockDeviceType(self.block_device_mapping))
+
+    def test_endElement_with_name_device_sets_current_name(self):
+        self.block_device_mapping.endElement("device", "/dev/null", None)
+        self.assertEqual(self.block_device_mapping.current_name, "/dev/null")
+
+    def test_endElement_with_name_device_sets_current_name(self):
+        self.block_device_mapping.endElement("deviceName", "some device name", None)
+        self.assertEqual(self.block_device_mapping.current_name, "some device name")
+
+    def test_endElement_with_name_item_sets_current_name_key_to_current_value(self):
+        self.block_device_mapping.current_name = "some name"
+        self.block_device_mapping.current_value = "some value"
+        self.block_device_mapping.endElement("item", "some item", None)
+        self.assertEqual(self.block_device_mapping["some name"], "some value")
+
+if __name__ == "__main__":
+    unittest.main()

data/packages/gsutil/boto/tests/unit/ec2/test_connection.py

@@ -0,0 +1,480 @@
+#!/usr/bin/env python
+from tests.unit import unittest
+from tests.unit import AWSMockServiceTestCase
+
+from boto.ec2.connection import EC2Connection
+
+
+class TestEC2ConnectionBase(AWSMockServiceTestCase):
+    connection_class = EC2Connection
+
+    def setUp(self):
+        super(TestEC2ConnectionBase, self).setUp()
+        self.ec2 = self.service_connection
+
+
+class TestReservedInstanceOfferings(TestEC2ConnectionBase):
+
+    def default_body(self):
+        return """
+            <DescribeReservedInstancesOfferingsResponse>
+                <requestId>d3253568-edcf-4897-9a3d-fb28e0b3fa38</requestId>
+                    <reservedInstancesOfferingsSet>
+                    <item>
+                        <reservedInstancesOfferingId>2964d1bf71d8</reservedInstancesOfferingId>
+                        <instanceType>c1.medium</instanceType>
+                        <availabilityZone>us-east-1c</availabilityZone>
+                        <duration>94608000</duration>
+                        <fixedPrice>775.0</fixedPrice>
+                        <usagePrice>0.0</usagePrice>
+                        <productDescription>product description</productDescription>
+                        <instanceTenancy>default</instanceTenancy>
+                        <currencyCode>USD</currencyCode>
+                        <offeringType>Heavy Utilization</offeringType>
+                        <recurringCharges>
+                            <item>
+                                <frequency>Hourly</frequency>
+                                <amount>0.095</amount>
+                            </item>
+                        </recurringCharges>
+                        <marketplace>false</marketplace>
+                        <pricingDetailsSet>
+                            <item>
+                                <price>0.045</price>
+                                <count>1</count>
+                            </item>
+                        </pricingDetailsSet>
+                    </item>
+                    <item>
+                        <reservedInstancesOfferingId>2dce26e46889</reservedInstancesOfferingId>
+                        <instanceType>c1.medium</instanceType>
+                        <availabilityZone>us-east-1c</availabilityZone>
+                        <duration>94608000</duration>
+                        <fixedPrice>775.0</fixedPrice>
+                        <usagePrice>0.0</usagePrice>
+                        <productDescription>Linux/UNIX</productDescription>
+                        <instanceTenancy>default</instanceTenancy>
+                        <currencyCode>USD</currencyCode>
+                        <offeringType>Heavy Utilization</offeringType>
+                        <recurringCharges>
+                            <item>
+                                <frequency>Hourly</frequency>
+                                <amount>0.035</amount>
+                            </item>
+                        </recurringCharges>
+                        <marketplace>false</marketplace>
+                        <pricingDetailsSet/>
+                    </item>
+                </reservedInstancesOfferingsSet>
+                <nextToken>next_token</nextToken>
+            </DescribeReservedInstancesOfferingsResponse>
+        """
+
+    def test_get_reserved_instance_offerings(self):
+        self.set_http_response(status_code=200)
+        response = self.ec2.get_all_reserved_instances_offerings()
+        self.assertEqual(len(response), 2)
+        instance = response[0]
+        self.assertEqual(instance.id, '2964d1bf71d8')
+        self.assertEqual(instance.instance_type, 'c1.medium')
+        self.assertEqual(instance.availability_zone, 'us-east-1c')
+        self.assertEqual(instance.duration, 94608000)
+        self.assertEqual(instance.fixed_price, '775.0')
+        self.assertEqual(instance.usage_price, '0.0')
+        self.assertEqual(instance.description, 'product description')
+        self.assertEqual(instance.instance_tenancy, 'default')
+        self.assertEqual(instance.currency_code, 'USD')
+        self.assertEqual(instance.offering_type, 'Heavy Utilization')
+        self.assertEqual(len(instance.recurring_charges), 1)
+        self.assertEqual(instance.recurring_charges[0].frequency, 'Hourly')
+        self.assertEqual(instance.recurring_charges[0].amount, '0.095')
+        self.assertEqual(len(instance.pricing_details), 1)
+        self.assertEqual(instance.pricing_details[0].price, '0.045')
+        self.assertEqual(instance.pricing_details[0].count, '1')
+
+    def test_get_reserved_instance_offerings_params(self):
+        self.set_http_response(status_code=200)
+        self.ec2.get_all_reserved_instances_offerings(
+            reserved_instances_offering_ids=['id1','id2'],
+            instance_type='t1.micro',
+            availability_zone='us-east-1',
+            product_description='description',
+            instance_tenancy='dedicated',
+            offering_type='offering_type',
+            include_marketplace=False,
+            min_duration=100,
+            max_duration=1000,
+            max_instance_count=1,
+            next_token='next_token',
+            max_results=10
+        )
+        self.assert_request_parameters({
+            'Action': 'DescribeReservedInstancesOfferings',
+            'ReservedInstancesOfferingId.1': 'id1',
+            'ReservedInstancesOfferingId.2': 'id2',
+            'InstanceType': 't1.micro',
+            'AvailabilityZone': 'us-east-1',
+            'ProductDescription': 'description',
+            'InstanceTenancy': 'dedicated',
+            'OfferingType': 'offering_type',
+            'IncludeMarketplace': 'false',
+            'MinDuration': '100',
+            'MaxDuration': '1000',
+            'MaxInstanceCount': '1',
+            'NextToken': 'next_token',
+            'MaxResults': '10',},
+             ignore_params_values=['AWSAccessKeyId', 'SignatureMethod',
+                                   'SignatureVersion', 'Timestamp', 'Version'])
+
+
+class TestPurchaseReservedInstanceOffering(TestEC2ConnectionBase):
+    def default_body(self):
+        return """<PurchaseReservedInstancesOffering />"""
+
+    def test_serialized_api_args(self):
+        self.set_http_response(status_code=200)
+        response = self.ec2.purchase_reserved_instance_offering(
+                'offering_id', 1, (100.0, 'USD'))
+        self.assert_request_parameters({
+            'Action': 'PurchaseReservedInstancesOffering',
+            'InstanceCount': 1,
+            'ReservedInstancesOfferingId': 'offering_id',
+            'LimitPrice.Amount': '100.0',
+            'LimitPrice.CurrencyCode': 'USD',},
+             ignore_params_values=['AWSAccessKeyId', 'SignatureMethod',
+                                   'SignatureVersion', 'Timestamp',
+                                   'Version'])
+
+
+class TestCancelReservedInstancesListing(TestEC2ConnectionBase):
+    def default_body(self):
+        return """
+            <CancelReservedInstancesListingResponse>
+                <requestId>request_id</requestId>
+                <reservedInstancesListingsSet>
+                    <item>
+                        <reservedInstancesListingId>listing_id</reservedInstancesListingId>
+                        <reservedInstancesId>instance_id</reservedInstancesId>
+                        <createDate>2012-07-12T16:55:28.000Z</createDate>
+                        <updateDate>2012-07-12T16:55:28.000Z</updateDate>
+                        <status>cancelled</status>
+                        <statusMessage>CANCELLED</statusMessage>
+                        <instanceCounts>
+                            <item>
+                                <state>Available</state>
+                                <instanceCount>0</instanceCount>
+                            </item>
+                            <item>
+                                <state>Sold</state>
+                                <instanceCount>0</instanceCount>
+                            </item>
+                            <item>
+                                <state>Cancelled</state>
+                                <instanceCount>1</instanceCount>
+                            </item>
+                            <item>
+                                <state>Pending</state>
+                                <instanceCount>0</instanceCount>
+                            </item>
+                        </instanceCounts>
+                        <priceSchedules>
+                            <item>
+                                <term>5</term>
+                                <price>166.64</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>4</term>
+                                <price>133.32</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>3</term>
+                                <price>99.99</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>2</term>
+                                <price>66.66</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>1</term>
+                                <price>33.33</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                        </priceSchedules>
+                        <tagSet/>
+                        <clientToken>XqJIt1342112125076</clientToken>
+                    </item>
+                </reservedInstancesListingsSet>
+            </CancelReservedInstancesListingResponse>
+        """
+
+    def test_reserved_instances_listing(self):
+        self.set_http_response(status_code=200)
+        response = self.ec2.cancel_reserved_instances_listing()
+        self.assertEqual(len(response), 1)
+        cancellation = response[0]
+        self.assertEqual(cancellation.status, 'cancelled')
+        self.assertEqual(cancellation.status_message, 'CANCELLED')
+        self.assertEqual(len(cancellation.instance_counts), 4)
+        first = cancellation.instance_counts[0]
+        self.assertEqual(first.state, 'Available')
+        self.assertEqual(first.instance_count, 0)
+        self.assertEqual(len(cancellation.price_schedules), 5)
+        schedule = cancellation.price_schedules[0]
+        self.assertEqual(schedule.term, 5)
+        self.assertEqual(schedule.price, '166.64')
+        self.assertEqual(schedule.currency_code, 'USD')
+        self.assertEqual(schedule.active, False)
+
+
+class TestCreateReservedInstancesListing(TestEC2ConnectionBase):
+    def default_body(self):
+        return """
+            <CreateReservedInstancesListingResponse>
+                <requestId>request_id</requestId>
+                <reservedInstancesListingsSet>
+                    <item>
+                        <reservedInstancesListingId>listing_id</reservedInstancesListingId>
+                        <reservedInstancesId>instance_id</reservedInstancesId>
+                        <createDate>2012-07-17T17:11:09.449Z</createDate>
+                        <updateDate>2012-07-17T17:11:09.468Z</updateDate>
+                        <status>active</status>
+                        <statusMessage>ACTIVE</statusMessage>
+                        <instanceCounts>
+                            <item>
+                                <state>Available</state>
+                                <instanceCount>1</instanceCount>
+                            </item>
+                            <item>
+                                <state>Sold</state>
+                                <instanceCount>0</instanceCount>
+                            </item>
+                            <item>
+                                <state>Cancelled</state>
+                                <instanceCount>0</instanceCount>
+                            </item>
+                            <item>
+                                <state>Pending</state>
+                                <instanceCount>0</instanceCount>
+                            </item>
+                        </instanceCounts>
+                        <priceSchedules>
+                            <item>
+                                <term>11</term>
+                                <price>2.5</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>true</active>
+                            </item>
+                            <item>
+                                <term>10</term>
+                                <price>2.5</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>9</term>
+                                <price>2.5</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>8</term>
+                                <price>2.0</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>7</term>
+                                <price>2.0</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>6</term>
+                                <price>2.0</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>5</term>
+                                <price>1.5</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>4</term>
+                                <price>1.5</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>3</term>
+                                <price>0.7</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>2</term>
+                                <price>0.7</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                            <item>
+                                <term>1</term>
+                                <price>0.1</price>
+                                <currencyCode>USD</currencyCode>
+                                <active>false</active>
+                            </item>
+                        </priceSchedules>
+                        <tagSet/>
+                        <clientToken>myIdempToken1</clientToken>
+                    </item>
+                </reservedInstancesListingsSet>
+            </CreateReservedInstancesListingResponse>
+        """
+
+    def test_create_reserved_instances_listing(self):
+        self.set_http_response(status_code=200)
+        response = self.ec2.create_reserved_instances_listing(
+            'instance_id', 1, [('2.5', 11), ('2.0', 8)], 'client_token')
+        self.assertEqual(len(response), 1)
+        cancellation = response[0]
+        self.assertEqual(cancellation.status, 'active')
+        self.assertEqual(cancellation.status_message, 'ACTIVE')
+        self.assertEqual(len(cancellation.instance_counts), 4)
+        first = cancellation.instance_counts[0]
+        self.assertEqual(first.state, 'Available')
+        self.assertEqual(first.instance_count, 1)
+        self.assertEqual(len(cancellation.price_schedules), 11)
+        schedule = cancellation.price_schedules[0]
+        self.assertEqual(schedule.term, 11)
+        self.assertEqual(schedule.price, '2.5')
+        self.assertEqual(schedule.currency_code, 'USD')
+        self.assertEqual(schedule.active, True)
+
+        self.assert_request_parameters({
+            'Action': 'CreateReservedInstancesListing',
+            'ReservedInstancesId': 'instance_id',
+            'InstanceCount': '1',
+            'ClientToken': 'client_token',
+            'PriceSchedules.0.Price': '2.5',
+            'PriceSchedules.0.Term': '11',
+            'PriceSchedules.1.Price': '2.0',
+            'PriceSchedules.1.Term': '8',},
+             ignore_params_values=['AWSAccessKeyId', 'SignatureMethod',
+                                   'SignatureVersion', 'Timestamp',
+                                   'Version'])
+
+
+class TestDescribeSpotInstanceRequests(TestEC2ConnectionBase):
+    def default_body(self):
+        return """
+        <DescribeSpotInstanceRequestsResponse>
+            <requestId>requestid</requestId>
+            <spotInstanceRequestSet>
+                <item>
+                    <spotInstanceRequestId>sir-id</spotInstanceRequestId>
+                    <spotPrice>0.003000</spotPrice>
+                    <type>one-time</type>
+                    <state>active</state>
+                    <status>
+                        <code>fulfilled</code>
+                        <updateTime>2012-10-19T18:09:26.000Z</updateTime>
+                        <message>Your Spot request is fulfilled.</message>
+                    </status>
+                    <launchGroup>mylaunchgroup</launchGroup>
+                    <launchSpecification>
+                        <imageId>ami-id</imageId>
+                        <keyName>mykeypair</keyName>
+                        <groupSet>
+                            <item>
+                                <groupId>sg-id</groupId>
+                                <groupName>groupname</groupName>
+                            </item>
+                        </groupSet>
+                        <instanceType>t1.micro</instanceType>
+                        <monitoring>
+                            <enabled>false</enabled>
+                        </monitoring>
+                    </launchSpecification>
+                    <instanceId>i-id</instanceId>
+                    <createTime>2012-10-19T18:07:05.000Z</createTime>
+                    <productDescription>Linux/UNIX</productDescription>
+                    <launchedAvailabilityZone>us-east-1d</launchedAvailabilityZone>
+                </item>
+            </spotInstanceRequestSet>
+        </DescribeSpotInstanceRequestsResponse>
+        """
+
+    def test_describe_spot_instance_requets(self):
+        self.set_http_response(status_code=200)
+        response = self.ec2.get_all_spot_instance_requests()
+        self.assertEqual(len(response), 1)
+        spotrequest = response[0]
+        self.assertEqual(spotrequest.id, 'sir-id')
+        self.assertEqual(spotrequest.price, 0.003)
+        self.assertEqual(spotrequest.type, 'one-time')
+        self.assertEqual(spotrequest.state, 'active')
+        self.assertEqual(spotrequest.fault, None)
+        self.assertEqual(spotrequest.valid_from, None)
+        self.assertEqual(spotrequest.valid_until, None)
+        self.assertEqual(spotrequest.launch_group, 'mylaunchgroup')
+        self.assertEqual(spotrequest.launched_availability_zone, 'us-east-1d')
+        self.assertEqual(spotrequest.product_description, 'Linux/UNIX')
+        self.assertEqual(spotrequest.availability_zone_group, None)
+        self.assertEqual(spotrequest.create_time,
+                         '2012-10-19T18:07:05.000Z')
+        self.assertEqual(spotrequest.instance_id, 'i-id')
+        launch_spec = spotrequest.launch_specification
+        self.assertEqual(launch_spec.key_name, 'mykeypair')
+        self.assertEqual(launch_spec.instance_type, 't1.micro')
+        self.assertEqual(launch_spec.image_id, 'ami-id')
+        self.assertEqual(launch_spec.placement, None)
+        self.assertEqual(launch_spec.kernel, None)
+        self.assertEqual(launch_spec.ramdisk, None)
+        self.assertEqual(launch_spec.monitored, False)
+        self.assertEqual(launch_spec.subnet_id, None)
+        self.assertEqual(launch_spec.block_device_mapping, None)
+        self.assertEqual(launch_spec.instance_profile, None)
+        self.assertEqual(launch_spec.ebs_optimized, False)
+        status = spotrequest.status
+        self.assertEqual(status.code, 'fulfilled')
+        self.assertEqual(status.update_time, '2012-10-19T18:09:26.000Z')
+        self.assertEqual(status.message, 'Your Spot request is fulfilled.')
+
+
+class TestCopySnapshot(TestEC2ConnectionBase):
+    def default_body(self):
+        return """
+        <CopySnapshotResponse xmlns="http://ec2.amazonaws.com/doc/2012-12-01/">
+            <requestId>request_id</requestId>
+            <snapshotId>snap-copied-id</snapshotId>
+        </CopySnapshotResponse>
+        """
+
+    def test_copy_snapshot(self):
+        self.set_http_response(status_code=200)
+        snapshot_id = self.ec2.copy_snapshot('us-west-2', 'snap-id',
+                                             'description')
+        self.assertEqual(snapshot_id, 'snap-copied-id')
+
+        self.assert_request_parameters({
+            'Action': 'CopySnapshot',
+            'Description': 'description',
+            'SourceRegion': 'us-west-2',
+            'SourceSnapshotId': 'snap-id'},
+             ignore_params_values=['AWSAccessKeyId', 'SignatureMethod',
+                                   'SignatureVersion', 'Timestamp',
+                                   'Version'])
+
+
+if __name__ == '__main__':
+    unittest.main()