Merge lp:~oubiwann/txaws/474353-storage-ec2-symmetry into lp:txaws

[Duncan McGreggor]

[Duncan McGreggor (oubiwann)]

This branch refactors the txaws.storage code (and renames it to txaws.s3) to match the work that was done in txaws.ec2. This includes code implementation as well as unit test idioms.

Once this branch is merged, work will begin immediately on the following:
 * bug #475571: Create s3_error_wrapper
 * bug #484858: Add storage scripts

The the remaining list of storage tickets in the queue, be sure to see this blueprint:
  https://blueprints.edge.launchpad.net/txaws/+spec/improve-s3-support

[Duncan McGreggor (oubiwann)]

Landscape trunk has been tested against this branch.

=== added file 'txaws/client/base.py'
--- txaws/client/base.py	1970-01-01 00:00:00 +0000
+++ txaws/client/base.py	2009-11-28 01:10:27 +0000
@@ -0,0 +1,75 @@
+from twisted.internet import reactor, ssl
+from twisted.web.client import HTTPClientFactory
+
+from txaws.util import parse
+from txaws.credentials import AWSCredentials
+from txaws.service import AWSServiceEndpoint
+
+
+class BaseClient(object):
+    """Create an AWS client.
+
+    @param creds: User authentication credentials to use.
+    @param endpoint: The service endpoint URI.
+    @param query_factory: The class or function that produces a query
+        object for making requests to the EC2 service.
+    """
+    def __init__(self, creds=None, endpoint=None, query_factory=None):
+        if creds is None:
+            creds = AWSCredentials()
+        if endpoint is None:
+            endpoint = AWSServiceEndpoint()
+        self.creds = creds
+        self.endpoint = endpoint
+        self.query_factory = query_factory
+
+
+class BaseQuery(object):
+
+    def __init__(self, action=None, creds=None, endpoint=None):
+        if not action:
+            raise TypeError("The query requires an action parameter.")
+        self.factory = HTTPClientFactory
+        self.action = action
+        self.creds = creds
+        self.endpoint = endpoint
+        self.client = None
+
+    def get_page(self, url, *args, **kwds):
+        """
+        Define our own get_page method so that we can easily override the
+        factory when we need to. This was copied from the following:
+            * twisted.web.client.getPage
+            * twisted.web.client._makeGetterFactory
+        """
+        contextFactory = None
+        scheme, host, port, path = parse(url)
+        self.client = self.factory(url, *args, **kwds)
+        if scheme == 'https':
+            contextFactory = ssl.ClientContextFactory()
+            reactor.connectSSL(host, port, self.client, contextFactory)
+        else:
+            reactor.connectTCP(host, port, self.client)
+        return self.client.deferred
+
+    def get_request_headers(self, *args, **kwds):
+        """
+        A convenience method for obtaining the headers that were sent to the
+        S3 server.
+
+        The AWS S3 API depends upon setting headers. This method is provided as
+        a convenience for debugging issues with the S3 communications.
+        """
+        if self.client:
+            return self.client.headers
+
+    def get_response_headers(self, *args, **kwargs):
+        """
+        A convenience method for obtaining the headers that were sent from the
+        S3 server.
+
+        The AWS S3 API depends upon setting headers. This method is used by the
+        head_object API call for getting a S3 object's metadata.
+        """
+        if self.client:
+            return self.client.response_headers

=== modified file 'txaws/client/gui/gtk.py'
--- txaws/client/gui/gtk.py	2009-11-06 22:16:13 +0000
+++ txaws/client/gui/gtk.py	2009-11-28 01:10:27 +0000
@@ -70,7 +70,6 @@
 
     def from_gnomekeyring(self):
         # Try for gtk gui specific credentials.
-        creds = None
         try:
             items = gnomekeyring.find_items_sync(
                 gnomekeyring.ITEM_GENERIC_SECRET,
@@ -129,8 +128,6 @@
         deferred.addCallbacks(self.shutdown_instances, self.show_error)
 
     def save_key(self, response_id, data):
-        # handle the dialog
-        dialog = self.password_dialog
         try:
             if data != gtk.RESPONSE_ACCEPT:
                 # User cancelled. They can ask for the password again somehow.
@@ -204,6 +201,6 @@
         from twisted.internet import gtk2reactor
         gtk2reactor.install()
         from twisted.internet import reactor
-    status = AWSStatusIcon(reactor)
+    AWSStatusIcon(reactor)
     gobject.set_application_name("aws-status")
     reactor.run()

=== added directory 'txaws/client/tests'
=== added file 'txaws/client/tests/__init__.py'
=== added file 'txaws/client/tests/test_client.py'
--- txaws/client/tests/test_client.py	1970-01-01 00:00:00 +0000
+++ txaws/client/tests/test_client.py	2009-11-28 01:10:27 +0000
@@ -0,0 +1,110 @@
+import os
+
+from twisted.internet import reactor
+from twisted.protocols.policies import WrappingFactory
+from twisted.python import log
+from twisted.python.filepath import FilePath
+from twisted.web.client import HTTPClientFactory
+from twisted.web import server, static
+
+from txaws.client.base import BaseClient, BaseQuery
+from txaws.testing.base import TXAWSTestCase
+
+
+class BaseClientTestCase(TXAWSTestCase):
+
+    def test_creation(self):
+        client = BaseClient("creds", "endpoint", "query factory")
+        self.assertEquals(client.creds, "creds")
+        self.assertEquals(client.endpoint, "endpoint")
+        self.assertEquals(client.query_factory, "query factory")
+
+
+class BaseQueryTestCase(TXAWSTestCase):
+
+    def setUp(self):
+        self.cleanupServerConnections = 0
+        name = self.mktemp()
+        os.mkdir(name)
+        FilePath(name).child("file").setContent("0123456789")
+        r = static.File(name)
+        self.site = server.Site(r, timeout=None)
+        self.wrapper = WrappingFactory(self.site)
+        self.port = self._listen(self.wrapper)
+        self.portno = self.port.getHost().port
+
+    def tearDown(self):
+        # If the test indicated it might leave some server-side connections
+        # around, clean them up.
+        connections = self.wrapper.protocols.keys()
+        # If there are fewer server-side connections than requested,
+        # that's okay.  Some might have noticed that the client closed
+        # the connection and cleaned up after themselves.
+        for n in range(min(len(connections), self.cleanupServerConnections)):
+            proto = connections.pop()
+            log.msg("Closing %r" % (proto,))
+            proto.transport.loseConnection()
+        if connections:
+            log.msg("Some left-over connections; this test is probably buggy.")
+        return self.port.stopListening()
+
+    def _listen(self, site):
+        return reactor.listenTCP(0, site, interface="127.0.0.1")
+
+    def _get_url(self, path):
+        return "http://127.0.0.1:%d/%s" % (self.portno, path)
+
+    def test_creation(self):
+        query = BaseQuery("an action", "creds", "http://endpoint")
+        self.assertEquals(query.factory, HTTPClientFactory)
+        self.assertEquals(query.action, "an action")
+        self.assertEquals(query.creds, "creds")
+        self.assertEquals(query.endpoint, "http://endpoint")
+
+    def test_init_requires_action(self):
+        self.assertRaises(TypeError, BaseQuery)
+
+    def test_init_requires_creds(self):
+        self.assertRaises(TypeError, BaseQuery, None)
+
+    def test_get_page(self):
+        query = BaseQuery("an action", "creds", "http://endpoint")
+        d = query.get_page(self._get_url("file"))
+        d.addCallback(self.assertEquals, "0123456789")
+        return d
+
+    def test_get_request_headers_no_client(self):
+
+        query = BaseQuery("an action", "creds", "http://endpoint")
+        results = query.get_request_headers()
+        self.assertEquals(results, None)
+
+    def test_get_request_headers_with_client(self):
+
+        def check_results(results):
+            self.assertEquals(results.keys(), [])
+            self.assertEquals(results.values(), [])
+
+        query = BaseQuery("an action", "creds", "http://endpoint")
+        d = query.get_page(self._get_url("file"))
+        d.addCallback(query.get_request_headers)
+        return d.addCallback(check_results)
+
+    def test_get_response_headers_no_client(self):
+
+        query = BaseQuery("an action", "creds", "http://endpoint")
+        results = query.get_response_headers()
+        self.assertEquals(results, None)
+
+    def test_get_response_headers_with_client(self):
+
+        def check_results(results):
+            self.assertEquals(sorted(results.keys()), [
+                "accept-ranges", "content-length", "content-type", "date",
+                "last-modified", "server"])
+            self.assertEquals(len(results.values()), 6)
+
+        query = BaseQuery("an action", "creds", "http://endpoint")
+        d = query.get_page(self._get_url("file"))
+        d.addCallback(query.get_response_headers)
+        return d.addCallback(check_results)

=== modified file 'txaws/credentials.py'
--- txaws/credentials.py	2009-10-21 19:40:18 +0000
+++ txaws/credentials.py	2009-11-28 01:10:27 +0000
@@ -5,7 +5,7 @@
 
 import os
 
-from txaws.util import hmac_sha256
+from txaws.util import hmac_sha256, hmac_sha1
 
 
 __all__ = ["AWSCredentials"]
@@ -38,6 +38,9 @@
         if not self.secret_key:
             raise ValueError("Could not find %s" % ENV_SECRET_KEY)
 
-    def sign(self, bytes):
+    def sign(self, bytes, hash_type="sha256"):
         """Sign some bytes."""
-        return hmac_sha256(self.secret_key, bytes)
+        if hash_type == "sha256":
+            return hmac_sha256(self.secret_key, bytes)
+        elif hash_type == "sha1":
+            return hmac_sha1(self.secret_key, bytes)

=== modified file 'txaws/ec2/client.py'
--- txaws/ec2/client.py	2009-10-28 19:59:33 +0000
+++ txaws/ec2/client.py	2009-11-28 01:10:27 +0000
@@ -10,18 +10,15 @@
 from base64 import b64encode
 from xml.parsers.expat import ExpatError
 
-from twisted.internet import reactor, ssl
 from twisted.web import http
-from twisted.web.client import HTTPClientFactory
 from twisted.web.error import Error as TwistedWebError
 
 from txaws import version
-from txaws.credentials import AWSCredentials
+from txaws.client.base import BaseClient, BaseQuery
 from txaws.ec2 import model
 from txaws.ec2.exception import EC2Error
 from txaws.exception import AWSResponseParseError
-from txaws.service import AWSServiceEndpoint
-from txaws.util import iso8601time, parse, XML
+from txaws.util import iso8601time, XML
 
 
 __all__ = ["EC2Client"]
@@ -49,7 +46,7 @@
         try:
             fallback_error = EC2Error(xml_payload, error.value.status,
                                  error.value.message, error.value.response)
-        except (ExpatError, AWSResponseParseError), parse_error:
+        except (ExpatError, AWSResponseParseError):
             error_message = http.RESPONSES.get(http_status)
             fallback_error = TwistedWebError(http_status, error_message,
                                         error.value.response)
@@ -58,32 +55,23 @@
         error.raiseException()
 
 
-class EC2Client(object):
+class EC2Client(BaseClient):
     """A client for EC2."""
 
     def __init__(self, creds=None, endpoint=None, query_factory=None):
-        """Create an EC2Client.
-
-        @param creds: User authentication credentials to use.
-        @param endpoint: The service endpoint URI.
-        @param query_factory: The class or function that produces a query
-            object for making requests to the EC2 service.
-        """
-        self.creds = creds or AWSCredentials()
-        self.endpoint = endpoint or AWSServiceEndpoint()
         if query_factory is None:
-            self.query_factory = Query
-        else:
-            self.query_factory = query_factory
+            query_factory = Query
+        super(EC2Client, self).__init__(creds, endpoint, query_factory)
 
     def describe_instances(self, *instance_ids):
         """Describe current instances."""
-        instanceset = {}
+        instances= {}
         for pos, instance_id in enumerate(instance_ids):
-            instanceset["InstanceId.%d" % (pos + 1)] = instance_id
-        q = self.query_factory("DescribeInstances", self.creds, self.endpoint,
-            instanceset)
-        d = q.submit()
+            instances["InstanceId.%d" % (pos + 1)] = instance_id
+        query = self.query_factory(
+            action="DescribeInstances", creds=self.creds,
+            endpoint=self.endpoint, other_params=instances)
+        d = query.submit()
         return d.addCallback(self._parse_describe_instances)
 
     def _parse_instances_set(self, root, reservation):
@@ -176,9 +164,10 @@
             params["KernelId"] = kernel_id
         if ramdisk_id is not None:
             params["RamdiskId"] = ramdisk_id
-        q = self.query_factory(
-            "RunInstances", self.creds, self.endpoint, params)
-        d = q.submit()
+        query = self.query_factory(
+            action="RunInstances", creds=self.creds, endpoint=self.endpoint, 
+            other_params=params)
+        d = query.submit()
         return d.addCallback(self._parse_run_instances)
 
     def _parse_run_instances(self, xml_bytes):
@@ -208,12 +197,13 @@
         @return: A deferred which on success gives an iterable of
             (id, old-state, new-state) tuples.
         """
-        instanceset = {}
+        instances = {}
         for pos, instance_id in enumerate(instance_ids):
-            instanceset["InstanceId.%d" % (pos+1)] = instance_id
-        q = self.query_factory("TerminateInstances", self.creds, self.endpoint,
-                               instanceset)
-        d = q.submit()
+            instances["InstanceId.%d" % (pos+1)] = instance_id
+        query = self.query_factory(
+            action="TerminateInstances", creds=self.creds,
+            endpoint=self.endpoint, other_params=instances)
+        d = query.submit()
         return d.addCallback(self._parse_terminate_instances)
 
     def _parse_terminate_instances(self, xml_bytes):
@@ -237,12 +227,13 @@
         @return: A C{Deferred} that will fire with a list of L{SecurityGroup}s
             retrieved from the cloud.
         """
-        group_names = None
+        group_names = {}
         if names:
             group_names = dict([("GroupName.%d" % (i+1), name)
                                 for i, name in enumerate(names)])
-        query = self.query_factory("DescribeSecurityGroups", self.creds,
-                                   self.endpoint, group_names)
+        query = self.query_factory(
+            action="DescribeSecurityGroups", creds=self.creds,
+            endpoint=self.endpoint, other_params=group_names)
         d = query.submit()
         return d.addCallback(self._parse_describe_security_groups)
 
@@ -295,8 +286,9 @@
             success of the operation.
         """
         parameters = {"GroupName":  name, "GroupDescription": description}
-        query = self.query_factory("CreateSecurityGroup", self.creds,
-                                   self.endpoint, parameters)
+        query = self.query_factory(
+            action="CreateSecurityGroup", creds=self.creds,
+            endpoint=self.endpoint, other_params=parameters)
         d = query.submit()
         return d.addCallback(self._parse_truth_return)
 
@@ -311,8 +303,9 @@
             success of the operation.
         """
         parameter = {"GroupName":  name}
-        query = self.query_factory("DeleteSecurityGroup", self.creds,
-                                   self.endpoint, parameter)
+        query = self.query_factory(
+            action="DeleteSecurityGroup", creds=self.creds,
+            endpoint=self.endpoint, other_params=parameter)
         d = query.submit()
         return d.addCallback(self._parse_truth_return)
 
@@ -367,8 +360,9 @@
                    "all the ip parameters.")
             raise ValueError(msg)
         parameters["GroupName"] = group_name
-        query = self.query_factory("AuthorizeSecurityGroupIngress", self.creds,
-                                   self.endpoint, parameters)
+        query = self.query_factory(
+            action="AuthorizeSecurityGroupIngress", creds=self.creds,
+            endpoint=self.endpoint, other_params=parameters)
         d = query.submit()
         return d.addCallback(self._parse_truth_return)
 
@@ -451,8 +445,9 @@
                    "all the ip parameters.")
             raise ValueError(msg)
         parameters["GroupName"] = group_name
-        query = self.query_factory("RevokeSecurityGroupIngress", self.creds,
-                                   self.endpoint, parameters)
+        query = self.query_factory(
+            action="RevokeSecurityGroupIngress", creds=self.creds,
+            endpoint=self.endpoint, other_params=parameters)
         d = query.submit()
         return d.addCallback(self._parse_truth_return)
 
@@ -489,9 +484,10 @@
         volumeset = {}
         for pos, volume_id in enumerate(volume_ids):
             volumeset["VolumeId.%d" % (pos + 1)] = volume_id
-        q = self.query_factory(
-            "DescribeVolumes", self.creds, self.endpoint, volumeset)
-        d = q.submit()
+        query = self.query_factory(
+            action="DescribeVolumes", creds=self.creds, endpoint=self.endpoint,
+            other_params=volumeset)
+        d = query.submit()
         return d.addCallback(self._parse_describe_volumes)
 
     def _parse_describe_volumes(self, xml_bytes):
@@ -532,9 +528,10 @@
             params["Size"] = str(size)
         if snapshot_id is not None:
             params["SnapshotId"] = snapshot_id
-        q = self.query_factory(
-            "CreateVolume", self.creds, self.endpoint, params)
-        d = q.submit()
+        query = self.query_factory(
+            action="CreateVolume", creds=self.creds, endpoint=self.endpoint,
+            other_params=params)
+        d = query.submit()
         return d.addCallback(self._parse_create_volume)
 
     def _parse_create_volume(self, xml_bytes):
@@ -553,9 +550,10 @@
         return volume
 
     def delete_volume(self, volume_id):
-        q = self.query_factory(
-            "DeleteVolume", self.creds, self.endpoint, {"VolumeId": volume_id})
-        d = q.submit()
+        query = self.query_factory(
+            action="DeleteVolume", creds=self.creds, endpoint=self.endpoint,
+            other_params={"VolumeId": volume_id})
+        d = query.submit()
         return d.addCallback(self._parse_truth_return)
 
     def describe_snapshots(self, *snapshot_ids):
@@ -563,9 +561,10 @@
         snapshot_set = {}
         for pos, snapshot_id in enumerate(snapshot_ids):
             snapshot_set["SnapshotId.%d" % (pos + 1)] = snapshot_id
-        q = self.query_factory(
-            "DescribeSnapshots", self.creds, self.endpoint, snapshot_set)
-        d = q.submit()
+        query = self.query_factory(
+            action="DescribeSnapshots", creds=self.creds,
+            endpoint=self.endpoint, other_params=snapshot_set)
+        d = query.submit()
         return d.addCallback(self._parse_snapshots)
 
     def _parse_snapshots(self, xml_bytes):
@@ -587,10 +586,10 @@
 
     def create_snapshot(self, volume_id):
         """Create a new snapshot of an existing volume."""
-        q = self.query_factory(
-            "CreateSnapshot", self.creds, self.endpoint,
-            {"VolumeId": volume_id})
-        d = q.submit()
+        query = self.query_factory(
+            action="CreateSnapshot", creds=self.creds, endpoint=self.endpoint,
+            other_params={"VolumeId": volume_id})
+        d = query.submit()
         return d.addCallback(self._parse_create_snapshot)
 
     def _parse_create_snapshot(self, xml_bytes):
@@ -608,19 +607,19 @@
 
     def delete_snapshot(self, snapshot_id):
         """Remove a previously created snapshot."""
-        q = self.query_factory(
-            "DeleteSnapshot", self.creds, self.endpoint,
-            {"SnapshotId": snapshot_id})
-        d = q.submit()
+        query = self.query_factory(
+            action="DeleteSnapshot", creds=self.creds, endpoint=self.endpoint,
+            other_params={"SnapshotId": snapshot_id})
+        d = query.submit()
         return d.addCallback(self._parse_truth_return)
 
     def attach_volume(self, volume_id, instance_id, device):
         """Attach the given volume to the specified instance at C{device}."""
-        q = self.query_factory(
-            "AttachVolume", self.creds, self.endpoint,
-            {"VolumeId": volume_id, "InstanceId": instance_id,
-             "Device": device})
-        d = q.submit()
+        query = self.query_factory(
+            action="AttachVolume", creds=self.creds, endpoint=self.endpoint,
+            other_params={"VolumeId": volume_id, "InstanceId": instance_id,
+                          "Device": device})
+        d = query.submit()
         return d.addCallback(self._parse_attach_volume)
 
     def _parse_attach_volume(self, xml_bytes):
@@ -633,12 +632,13 @@
 
     def describe_keypairs(self, *keypair_names):
         """Returns information about key pairs available."""
-        keypair_set = {}
-        for pos, keypair_name in enumerate(keypair_names):
-            keypair_set["KeyPair.%d" % (pos + 1)] = keypair_name
-        q = self.query_factory("DescribeKeyPairs", self.creds, self.endpoint,
-                               keypair_set)
-        d = q.submit()
+        keypairs = {}
+        for index, keypair_name in enumerate(keypair_names):
+            keypairs["KeyPair.%d" % (index + 1)] = keypair_name
+        query = self.query_factory(
+            action="DescribeKeyPairs", creds=self.creds,
+            endpoint=self.endpoint, other_params=keypairs)
+        d = query.submit()
         return d.addCallback(self._parse_describe_keypairs)
 
     def _parse_describe_keypairs(self, xml_bytes):
@@ -658,10 +658,10 @@
         Create a new 2048 bit RSA key pair and return a unique ID that can be
         used to reference the created key pair when launching new instances.
         """
-        q = self.query_factory(
-            "CreateKeyPair", self.creds, self.endpoint,
-            {"KeyName": keypair_name})
-        d = q.submit()
+        query = self.query_factory(
+            action="CreateKeyPair", creds=self.creds, endpoint=self.endpoint,
+            other_params={"KeyName": keypair_name})
+        d = query.submit()
         return d.addCallback(self._parse_create_keypair)
 
     def _parse_create_keypair(self, xml_bytes):
@@ -673,10 +673,10 @@
 
     def delete_keypair(self, keypair_name):
         """Delete a given keypair."""
-        q = self.query_factory(
-            "DeleteKeyPair", self.creds, self.endpoint,
-            {"KeyName": keypair_name})
-        d = q.submit()
+        query = self.query_factory(
+            action="DeleteKeyPair", creds=self.creds, endpoint=self.endpoint,
+            other_params={"KeyName": keypair_name})
+        d = query.submit()
         return d.addCallback(self._parse_truth_return)
 
     def allocate_address(self):
@@ -686,9 +686,11 @@
 
         @return: the IP address allocated.
         """
-        q = self.query_factory(
-            "AllocateAddress", self.creds, self.endpoint, {})
-        d = q.submit()
+        # XXX remove empty other_params
+        query = self.query_factory(
+            action="AllocateAddress", creds=self.creds, endpoint=self.endpoint, 
+            other_params={})
+        d = query.submit()
         return d.addCallback(self._parse_allocate_address)
 
     def _parse_allocate_address(self, xml_bytes):
@@ -701,10 +703,10 @@
 
         @return: C{True} if the operation succeeded.
         """
-        q = self.query_factory(
-            "ReleaseAddress", self.creds, self.endpoint,
-            {"PublicIp": address})
-        d = q.submit()
+        query = self.query_factory(
+            action="ReleaseAddress", creds=self.creds, endpoint=self.endpoint,
+            other_params={"PublicIp": address})
+        d = query.submit()
         return d.addCallback(self._parse_truth_return)
 
     def associate_address(self, instance_id, address):
@@ -714,10 +716,11 @@
 
         @return: C{True} if the operation succeeded.
         """
-        q = self.query_factory(
-            "AssociateAddress", self.creds, self.endpoint,
-            {"InstanceId": instance_id, "PublicIp": address})
-        d = q.submit()
+        query = self.query_factory(
+            action="AssociateAddress", creds=self.creds,
+            endpoint=self.endpoint,
+            other_params={"InstanceId": instance_id, "PublicIp": address})
+        d = query.submit()
         return d.addCallback(self._parse_truth_return)
 
     def disassociate_address(self, address):
@@ -726,10 +729,10 @@
         C{associate_address}. This is an idempotent operation, so it can be
         called several times without error.
         """
-        q = self.query_factory(
-            "DisassociateAddress", self.creds, self.endpoint,
-            {"PublicIp": address})
-        d = q.submit()
+        query = self.query_factory(
+            action="DisassociateAddress", creds=self.creds,
+            endpoint=self.endpoint, other_params={"PublicIp": address})
+        d = query.submit()
         return d.addCallback(self._parse_truth_return)
 
     def describe_addresses(self, *addresses):
@@ -744,9 +747,10 @@
         address_set = {}
         for pos, address in enumerate(addresses):
             address_set["PublicIp.%d" % (pos + 1)] = address
-        q = self.query_factory(
-            "DescribeAddresses", self.creds, self.endpoint, address_set)
-        d = q.submit()
+        query = self.query_factory(
+            action="DescribeAddresses", creds=self.creds,
+            endpoint=self.endpoint, other_params=address_set)
+        d = query.submit()
         return d.addCallback(self._parse_describe_addresses)
 
     def _parse_describe_addresses(self, xml_bytes):
@@ -763,8 +767,9 @@
         if names:
             zone_names = dict([("ZoneName.%d" % (i+1), name)
                                 for i, name in enumerate(names)])
-        query = self.query_factory("DescribeAvailabilityZones", self.creds,
-                                   self.endpoint, zone_names)
+        query = self.query_factory(
+            action="DescribeAvailabilityZones", creds=self.creds,
+            endpoint=self.endpoint, other_params=zone_names)
         d = query.submit()
         return d.addCallback(self._parse_describe_availability_zones)
 
@@ -778,51 +783,53 @@
         return results
 
 
-class Query(object):
+class Query(BaseQuery):
     """A query that may be submitted to EC2."""
 
-    def __init__(self, action, creds, endpoint, other_params=None,
-                 time_tuple=None, api_version=None):
+    def __init__(self, other_params=None, time_tuple=None, api_version=None,
+                 *args, **kwargs):
         """Create a Query to submit to EC2."""
-        self.factory = HTTPClientFactory
-        self.creds = creds
-        self.endpoint = endpoint
+        super(Query, self).__init__(*args, **kwargs)
         # Currently, txAWS only supports version 2008-12-01
         if api_version is None:
-            api_version = version.aws_api
+            api_version = version.ec2_api
         self.params = {
             "Version": api_version,
             "SignatureVersion": "2",
             "SignatureMethod": "HmacSHA256",
-            "Action": action,
+            "Action": self.action,
             "AWSAccessKeyId": self.creds.access_key,
             "Timestamp": iso8601time(time_tuple),
             }
         if other_params:
             self.params.update(other_params)
 
-    def canonical_query_params(self):
+    def get_canonical_query_params(self):
         """Return the canonical query params (used in signing)."""
         result = []
         for key, value in self.sorted_params():
             result.append("%s=%s" % (self.encode(key), self.encode(value)))
         return "&".join(result)
 
-    def encode(self, a_string):
+    def encode(self, string):
         """Encode a_string as per the canonicalisation encoding rules.
 
         See the AWS dev reference page 90 (2008-12-01 version).
         @return: a_string encoded.
         """
-        return quote(a_string, safe="~")
+        return quote(string, safe="~")
 
     def signing_text(self):
         """Return the text to be signed when signing the query."""
         result = "%s\n%s\n%s\n%s" % (self.endpoint.method, self.endpoint.host,
                                      self.endpoint.path,
-                                     self.canonical_query_params())
+                                     self.get_canonical_query_params())
         return result
 
+    def sorted_params(self):
+        """Return the query parameters sorted appropriately for signing."""
+        return sorted(self.params.items())
+
     def sign(self):
         """Sign this query using its built in credentials.
 
@@ -832,27 +839,6 @@
         """
         self.params["Signature"] = self.creds.sign(self.signing_text())
 
-    def sorted_params(self):
-        """Return the query parameters sorted appropriately for signing."""
-        return sorted(self.params.items())
-
-    def get_page(self, url, *args, **kwds):
-        """
-        Define our own get_page method so that we can easily override the
-        factory when we need to. This was copied from the following:
-            * twisted.web.client.getPage
-            * twisted.web.client._makeGetterFactory
-        """
-        contextFactory = None
-        scheme, host, port, path = parse(url)
-        factory = self.factory(url, *args, **kwds)
-        if scheme == 'https':
-            contextFactory = ssl.ClientContextFactory()
-            reactor.connectSSL(host, port, factory, contextFactory)
-        else:
-            reactor.connectTCP(host, port, factory)
-        return factory.deferred
-
     def submit(self):
         """Submit this query.
 
@@ -860,7 +846,7 @@
         """
         self.sign()
         url = "%s?%s" % (self.endpoint.get_uri(),
-                         self.canonical_query_params())
-        deferred = self.get_page(url, method=self.endpoint.method)
-        deferred.addErrback(ec2_error_wrapper)
-        return deferred
+                         self.get_canonical_query_params())
+        d = self.get_page(url, method=self.endpoint.method)
+        d.addErrback(ec2_error_wrapper)
+        return d

=== modified file 'txaws/ec2/exception.py'
--- txaws/ec2/exception.py	2009-11-13 23:56:18 +0000
+++ txaws/ec2/exception.py	2009-11-28 01:10:27 +0000
@@ -86,6 +86,7 @@
     def parse(self, xml_bytes=""):
         if not xml_bytes:
             xml_bytes = self.original
+        self.original = xml_bytes
         tree = XML(xml_bytes.strip())
         self._check_for_html(tree)
         self._set_request_id(tree)

=== modified file 'txaws/ec2/tests/test_client.py'
--- txaws/ec2/tests/test_client.py	2009-11-13 21:13:23 +0000
+++ txaws/ec2/tests/test_client.py	2009-11-28 01:10:27 +0000
@@ -73,14 +73,18 @@
         self.assertEqual(creds, ec2.creds)
 
     def test_describe_availability_zones_single(self):
+
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}):
                 self.assertEqual(action, "DescribeAvailabilityZones")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
                 self.assertEqual(
-                    {"ZoneName.1": "us-east-1a"},
-                    other_params)
+                    other_params,
+                    {"ZoneName.1": "us-east-1a"})
+
             def submit(self):
                 return succeed(
                     payload.sample_describe_availability_zones_single_result)
@@ -99,11 +103,15 @@
         return d
 
     def test_describe_availability_zones_multiple(self):
+
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeAvailabilityZones")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
+
             def submit(self):
                 return succeed(
                     payload.sample_describe_availability_zones_multiple_results)
@@ -190,14 +198,19 @@
         self.check_parsed_instances(results)
 
     def test_describe_instances(self):
+
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeInstances")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
-                self.assertEquals(params, {})
+                self.assertEquals(other_params, {})
+
             def submit(self):
                 return succeed(payload.sample_describe_instances_result)
+
         creds = AWSCredentials("foo", "bar")
         ec2 = client.EC2Client(creds, query_factory=StubQuery)
         d = ec2.describe_instances()
@@ -205,15 +218,20 @@
         return d
 
     def test_describe_instances_required(self):
+
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeInstances")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
-                self.assertEquals(params, {})
+                self.assertEquals(other_params, {})
+
             def submit(self):
                 return succeed(
                     payload.sample_required_describe_instances_result)
+
         creds = AWSCredentials("foo", "bar")
         ec2 = client.EC2Client(creds, query_factory=StubQuery)
         d = ec2.describe_instances()
@@ -221,18 +239,23 @@
         return d
 
     def test_describe_instances_specific_instances(self):
+
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeInstances")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"InstanceId.1": "i-16546401",
                      "InstanceId.2": "i-49873415"})
+
             def submit(self):
                 return succeed(
                     payload.sample_required_describe_instances_result)
+
         creds = AWSCredentials("foo", "bar")
         ec2 = client.EC2Client(creds, query_factory=StubQuery)
         d = ec2.describe_instances("i-16546401", "i-49873415")
@@ -240,24 +263,30 @@
         return d
 
     def test_terminate_instances(self):
+
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "TerminateInstances")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
                 self.assertEqual(
-                    {"InstanceId.1": "i-1234", "InstanceId.2": "i-5678"},
-                    other_params)
+                    other_params,
+                    {"InstanceId.1": "i-1234", "InstanceId.2": "i-5678"})
+
             def submit(self):
                 return succeed(payload.sample_terminate_instances_result)
+
+        def check_transition(changes):
+            self.assertEqual([("i-1234", "running", "shutting-down"),
+                ("i-5678", "shutting-down", "shutting-down")], sorted(changes))
+
         creds = AWSCredentials("foo", "bar")
         endpoint = AWSServiceEndpoint(uri=EC2_ENDPOINT_US)
         ec2 = client.EC2Client(creds=creds, endpoint=endpoint,
                                query_factory=StubQuery)
         d = ec2.terminate_instances("i-1234", "i-5678")
-        def check_transition(changes):
-            self.assertEqual([("i-1234", "running", "shutting-down"),
-                ("i-5678", "shutting-down", "shutting-down")], sorted(changes))
         d.addCallback(check_transition)
         return d
 
@@ -289,17 +318,20 @@
     def test_run_instances(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "RunInstances")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"ImageId": "ami-1234", "MaxCount": "2", "MinCount": "1",
                      "SecurityGroup.1": u"group1", "KeyName": u"default",
                      "UserData": "Zm9v", "InstanceType": u"m1.small",
                      "Placement.AvailabilityZone": u"us-east-1b",
                      "KernelId": u"k-1234", "RamdiskId": u"r-1234"})
+
             def submit(self):
                 return succeed(
                     payload.sample_run_instances_result)
@@ -322,11 +354,14 @@
         using XML data received from the cloud.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeSecurityGroups")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
-                self.assertEqual(other_params, None)
+                self.assertEqual(other_params, {})
+
             def submit(self):
                 return succeed(payload.sample_describe_security_groups_result)
 
@@ -354,11 +389,14 @@
         information about more than one L{SecurityGroup}.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeSecurityGroups")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
-                self.assertEqual(other_params, None)
+                self.assertEqual(other_params, {})
+
             def submit(self):
                 return succeed(
                     payload.sample_describe_security_groups_multiple_result)
@@ -401,11 +439,14 @@
         security group names to limit results to.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeSecurityGroups")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
                 self.assertEqual(other_params, {"GroupName.1": "WebServers"})
+
             def submit(self):
                 return succeed(payload.sample_describe_security_groups_result)
 
@@ -425,7 +466,9 @@
         operation.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "CreateSecurityGroup")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
@@ -433,6 +476,7 @@
                     "GroupName": "WebServers",
                     "GroupDescription": "The group for the web server farm.",
                     })
+
             def submit(self):
                 return succeed(payload.sample_create_security_group)
 
@@ -450,13 +494,16 @@
         operation.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DeleteSecurityGroup")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
                 self.assertEqual(other_params, {
                     "GroupName": "WebServers",
                     })
+
             def submit(self):
                 return succeed(payload.sample_delete_security_group)
 
@@ -472,13 +519,16 @@
         that another group uses in that other group's policy.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DeleteSecurityGroup")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
                 self.assertEqual(other_params, {
                     "GroupName": "GroupReferredTo",
                     })
+
             def submit(self):
                 error = EC2Error(payload.sample_delete_security_group_failure)
                 return fail(error)
@@ -504,7 +554,9 @@
         way.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "AuthorizeSecurityGroupIngress")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
@@ -513,6 +565,7 @@
                     "SourceSecurityGroupName": "AppServers",
                     "SourceSecurityGroupOwnerId": "123456789123",
                     })
+
             def submit(self):
                 return succeed(payload.sample_authorize_security_group)
 
@@ -532,7 +585,9 @@
         way.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "AuthorizeSecurityGroupIngress")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
@@ -541,6 +596,7 @@
                     "FromPort": "22", "ToPort": "80",
                     "IpProtocol": "tcp", "CidrIp": "0.0.0.0/0",
                     })
+
             def submit(self):
                 return succeed(payload.sample_authorize_security_group)
 
@@ -580,7 +636,9 @@
         operation.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "AuthorizeSecurityGroupIngress")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
@@ -589,6 +647,7 @@
                     "SourceSecurityGroupName": "AppServers",
                     "SourceSecurityGroupOwnerId": "123456789123",
                     })
+
             def submit(self):
                 return succeed(payload.sample_authorize_security_group)
 
@@ -606,7 +665,9 @@
         operation.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "AuthorizeSecurityGroupIngress")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
@@ -615,6 +676,7 @@
                     "FromPort": "22", "ToPort": "80",
                     "IpProtocol": "tcp", "CidrIp": "0.0.0.0/0",
                     })
+
             def submit(self):
                 return succeed(payload.sample_authorize_security_group)
 
@@ -634,7 +696,9 @@
         way.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "RevokeSecurityGroupIngress")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
@@ -643,6 +707,7 @@
                     "SourceSecurityGroupName": "AppServers",
                     "SourceSecurityGroupOwnerId": "123456789123",
                     })
+
             def submit(self):
                 return succeed(payload.sample_revoke_security_group)
 
@@ -662,7 +727,9 @@
         way.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "RevokeSecurityGroupIngress")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
@@ -671,6 +738,7 @@
                     "FromPort": "22", "ToPort": "80",
                     "IpProtocol": "tcp", "CidrIp": "0.0.0.0/0",
                     })
+
             def submit(self):
                 return succeed(payload.sample_revoke_security_group)
 
@@ -710,7 +778,9 @@
         operation.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "RevokeSecurityGroupIngress")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
@@ -719,6 +789,7 @@
                     "SourceSecurityGroupName": "AppServers",
                     "SourceSecurityGroupOwnerId": "123456789123",
                     })
+
             def submit(self):
                 return succeed(payload.sample_revoke_security_group)
 
@@ -736,7 +807,9 @@
         operation.
         """
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, other_params=None):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "RevokeSecurityGroupIngress")
                 self.assertEqual(creds.access_key, "foo")
                 self.assertEqual(creds.secret_key, "bar")
@@ -745,6 +818,7 @@
                     "FromPort": "22", "ToPort": "80",
                     "IpProtocol": "tcp", "CidrIp": "0.0.0.0/0",
                     })
+
             def submit(self):
                 return succeed(payload.sample_revoke_security_group)
 
@@ -784,11 +858,13 @@
     def test_describe_volumes(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeVolumes")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
-                self.assertEquals(params, {})
+                self.assertEquals(other_params, {})
 
             def submit(self):
                 return succeed(payload.sample_describe_volumes_result)
@@ -802,12 +878,14 @@
     def test_describe_specified_volumes(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeVolumes")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"VolumeId.1": "vol-4282672b"})
 
             def submit(self):
@@ -832,11 +910,13 @@
     def test_describe_snapshots(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeSnapshots")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
-                self.assertEquals(params, {})
+                self.assertEquals(other_params, {})
 
             def submit(self):
                 return succeed(payload.sample_describe_snapshots_result)
@@ -850,12 +930,14 @@
     def test_describe_specified_snapshots(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeSnapshots")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"SnapshotId.1": "snap-78a54011"})
 
             def submit(self):
@@ -870,13 +952,15 @@
     def test_create_volume(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "CreateVolume")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
                 self.assertEqual(
-                    {"AvailabilityZone": "us-east-1", "Size": "800"},
-                    params)
+                    other_params,
+                    {"AvailabilityZone": "us-east-1", "Size": "800"})
 
             def submit(self):
                 return succeed(payload.sample_create_volume_result)
@@ -897,14 +981,16 @@
     def test_create_volume_with_snapshot(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "CreateVolume")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
                 self.assertEqual(
+                    other_params,
                     {"AvailabilityZone": "us-east-1",
-                     "SnapshotId": "snap-12345678"},
-                    params)
+                     "SnapshotId": "snap-12345678"})
 
             def submit(self):
                 return succeed(payload.sample_create_volume_result)
@@ -939,13 +1025,15 @@
     def test_delete_volume(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DeleteVolume")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
                 self.assertEqual(
-                    {"VolumeId": "vol-4282672b"},
-                    params)
+                    other_params,
+                    {"VolumeId": "vol-4282672b"})
 
             def submit(self):
                 return succeed(payload.sample_delete_volume_result)
@@ -959,13 +1047,15 @@
     def test_create_snapshot(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "CreateSnapshot")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
                 self.assertEqual(
-                    {"VolumeId": "vol-4d826724"},
-                    params)
+                    other_params,
+                    {"VolumeId": "vol-4d826724"})
 
             def submit(self):
                 return succeed(payload.sample_create_snapshot_result)
@@ -987,13 +1077,15 @@
     def test_delete_snapshot(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DeleteSnapshot")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
                 self.assertEqual(
-                    {"SnapshotId": "snap-78a54011"},
-                    params)
+                    other_params,
+                    {"SnapshotId": "snap-78a54011"})
 
             def submit(self):
                 return succeed(payload.sample_delete_snapshot_result)
@@ -1007,14 +1099,16 @@
     def test_attach_volume(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "AttachVolume")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
                 self.assertEqual(
+                    other_params,
                     {"VolumeId": "vol-4d826724", "InstanceId": "i-6058a509",
-                     "Device": "/dev/sdh"},
-                    params)
+                     "Device": "/dev/sdh"})
 
             def submit(self):
                 return succeed(payload.sample_attach_volume_result)
@@ -1042,10 +1136,12 @@
     def test_single_describe_keypairs(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeKeyPairs")
                 self.assertEqual("foo", creds)
-                self.assertEquals(params, {})
+                self.assertEquals(other_params, {})
 
             def submit(self):
                 return succeed(payload.sample_single_describe_keypairs_result)
@@ -1070,10 +1166,12 @@
                 "1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:70")
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeKeyPairs")
                 self.assertEqual("foo", creds)
-                self.assertEquals(params, {})
+                self.assertEquals(other_params, {})
 
             def submit(self):
                 return succeed(
@@ -1087,11 +1185,13 @@
     def test_describe_specified_keypairs(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeKeyPairs")
                 self.assertEqual("foo", creds)
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"KeyPair.1": "gsg-keypair"})
 
             def submit(self):
@@ -1116,11 +1216,13 @@
             self.assertEquals(len(keypair.material), 1670)
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "CreateKeyPair")
                 self.assertEqual("foo", creds)
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"KeyName": "example-key-name"})
 
             def submit(self):
@@ -1134,12 +1236,14 @@
     def test_delete_keypair_true_result(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DeleteKeyPair")
                 self.assertEqual("foo", creds)
                 self.assertEqual("http:///", endpoint.get_uri())
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"KeyName": "example-key-name"})
 
             def submit(self):
@@ -1153,12 +1257,14 @@
     def test_delete_keypair_false_result(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DeleteKeyPair")
                 self.assertEqual("foo", creds)
                 self.assertEqual("http:///", endpoint.get_uri())
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"KeyName": "example-key-name"})
 
             def submit(self):
@@ -1172,12 +1278,14 @@
     def test_delete_keypair_no_result(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DeleteKeyPair")
                 self.assertEqual("foo", creds)
                 self.assertEqual("http:///", endpoint.get_uri())
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"KeyName": "example-key-name"})
 
             def submit(self):
@@ -1298,40 +1406,38 @@
         self.endpoint = AWSServiceEndpoint(uri=EC2_ENDPOINT_US)
 
     def test_init_minimum(self):
-        query = client.Query("DescribeInstances", self.creds, self.endpoint)
+        query = client.Query(
+            action="DescribeInstances", creds=self.creds,
+            endpoint=self.endpoint)
         self.assertTrue("Timestamp" in query.params)
         del query.params["Timestamp"]
         self.assertEqual(
+            query.params,
             {"AWSAccessKeyId": "foo",
              "Action": "DescribeInstances",
              "SignatureMethod": "HmacSHA256",
              "SignatureVersion": "2",
-             "Version": "2008-12-01"},
-            query.params)
-
-    def test_init_requires_action(self):
-        self.assertRaises(TypeError, client.Query)
-
-    def test_init_requires_creds(self):
-        self.assertRaises(TypeError, client.Query, None)
+             "Version": "2008-12-01"})
 
     def test_init_other_args_are_params(self):
-        query = client.Query("DescribeInstances", self.creds, self.endpoint,
-            {"InstanceId.0": "12345"},
+        query = client.Query(
+            action="DescribeInstances", creds=self.creds,
+            endpoint=self.endpoint, other_params={"InstanceId.0": "12345"},
             time_tuple=(2007,11,12,13,14,15,0,0,0))
         self.assertEqual(
+            query.params,
             {"AWSAccessKeyId": "foo",
              "Action": "DescribeInstances",
              "InstanceId.0": "12345",
              "SignatureMethod": "HmacSHA256",
              "SignatureVersion": "2",
              "Timestamp": "2007-11-12T13:14:15Z",
-             "Version": "2008-12-01"},
-            query.params)
+             "Version": "2008-12-01"})
 
     def test_sorted_params(self):
-        query = client.Query("DescribeInstances", self.creds, self.endpoint,
-            {"fun": "games"},
+        query = client.Query(
+            action="DescribeInstances", creds=self.creds,
+            endpoint=self.endpoint, other_params={"fun": "games"},
             time_tuple=(2007,11,12,13,14,15,0,0,0))
         self.assertEqual([
             ("AWSAccessKeyId", "foo"),
@@ -1346,29 +1452,36 @@
     def test_encode_unreserved(self):
         all_unreserved = ("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
             "abcdefghijklmnopqrstuvwxyz0123456789-_.~")
-        query = client.Query("DescribeInstances", self.creds, self.endpoint)
+        query = client.Query(
+            action="DescribeInstances", creds=self.creds,
+            endpoint=self.endpoint)
         self.assertEqual(all_unreserved, query.encode(all_unreserved))
 
     def test_encode_space(self):
         """This may be just "url encode", but the AWS manual isn't clear."""
-        query = client.Query("DescribeInstances", self.creds, self.endpoint)
+        query = client.Query(
+            action="DescribeInstances", creds=self.creds,
+            endpoint=self.endpoint)
         self.assertEqual("a%20space", query.encode("a space"))
 
     def test_canonical_query(self):
-        query = client.Query("DescribeInstances", self.creds, self.endpoint,
-            {"fu n": "g/ames", "argwithnovalue":"",
-             "InstanceId.1": "i-1234"},
+        query = client.Query(
+            action="DescribeInstances", creds=self.creds,
+            endpoint=self.endpoint,
+            other_params={"fu n": "g/ames", "argwithnovalue":"",
+                          "InstanceId.1": "i-1234"},
             time_tuple=(2007,11,12,13,14,15,0,0,0))
         expected_query = ("AWSAccessKeyId=foo&Action=DescribeInstances"
             "&InstanceId.1=i-1234"
             "&SignatureMethod=HmacSHA256&SignatureVersion=2&"
             "Timestamp=2007-11-12T13%3A14%3A15Z&Version=2008-12-01&"
             "argwithnovalue=&fu%20n=g%2Fames")
-        self.assertEqual(expected_query, query.canonical_query_params())
+        self.assertEqual(expected_query, query.get_canonical_query_params())
 
     def test_signing_text(self):
-        query = client.Query("DescribeInstances", self.creds, self.endpoint,
-            time_tuple=(2007,11,12,13,14,15,0,0,0))
+        query = client.Query(
+            action="DescribeInstances", creds=self.creds,
+            endpoint=self.endpoint, time_tuple=(2007,11,12,13,14,15,0,0,0))
         signing_text = ("GET\n%s\n/\n" % self.endpoint.host +
             "AWSAccessKeyId=foo&Action=DescribeInstances&"
             "SignatureMethod=HmacSHA256&SignatureVersion=2&"
@@ -1376,7 +1489,9 @@
         self.assertEqual(signing_text, query.signing_text())
 
     def test_sign(self):
-        query = client.Query("DescribeInstances", self.creds, self.endpoint,
+        query = client.Query(
+            action="DescribeInstances", creds=self.creds,
+            endpoint=self.endpoint,
             time_tuple=(2007, 11, 12, 13, 14, 15, 0, 0, 0))
         query.sign()
         self.assertEqual("aDmLr0Ktjsmt17UJD/EZf6DrfKWT1JW0fq2FDUCOPic=",
@@ -1401,7 +1516,7 @@
             self.assertEquals(error.response, payload.sample_ec2_error_message)
 
         query = client.Query(
-            'BadQuery', self.creds, self.endpoint,
+            action='BadQuery', creds=self.creds, endpoint=self.endpoint,
             time_tuple=(2009,8,15,13,14,15,0,0,0))
 
         failure = query.submit()
@@ -1426,7 +1541,7 @@
             self.assertEquals(error.status, status)
 
         query = client.Query(
-            'BadQuery', self.creds, self.endpoint,
+            action='BadQuery', creds=self.creds, endpoint=self.endpoint,
             time_tuple=(2009,8,15,13,14,15,0,0,0))
 
         failure = query.submit()
@@ -1455,7 +1570,7 @@
                 "We encountered an internal error. Please try again.")
 
         query = client.Query(
-            'BadQuery', self.creds, self.endpoint,
+            action='BadQuery', creds=self.creds, endpoint=self.endpoint,
             time_tuple=(2009,8,15,13,14,15,0,0,0))
 
         failure = query.submit()
@@ -1510,14 +1625,13 @@
     def test_get_page(self):
         """Copied from twisted.web.test.test_webclient."""
         query = client.Query(
-            'DummyQuery', self.creds, self.endpoint,
+            action="DummyQuery", creds=self.creds, endpoint=self.endpoint,
             time_tuple=(2009,8,17,13,14,15,0,0,0))
         deferred = query.get_page(self.get_url("file"))
         deferred.addCallback(self.assertEquals, "0123456789")
         return deferred
 
 
-
 class EC2ClientAddressTestCase(TXAWSTestCase):
 
     def setUp(self):
@@ -1528,11 +1642,13 @@
     def test_describe_addresses(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeAddresses")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
-                self.assertEquals(params, {})
+                self.assertEquals(other_params, {})
 
             def submit(self):
                 return succeed(payload.sample_describe_addresses_result)
@@ -1548,12 +1664,14 @@
     def test_describe_specified_addresses(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DescribeAddresses")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"PublicIp.1": "67.202.55.255"})
 
             def submit(self):
@@ -1570,12 +1688,14 @@
     def test_associate_address(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "AssociateAddress")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
                 self.assertEquals(
-                    params,
+                    other_params,
                     {"InstanceId": "i-28a64341", "PublicIp": "67.202.55.255"})
 
             def submit(self):
@@ -1590,11 +1710,13 @@
     def test_allocate_address(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "AllocateAddress")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
-                self.assertEquals(params, {})
+                self.assertEquals(other_params, {})
 
             def submit(self):
                 return succeed(payload.sample_allocate_address_result)
@@ -1608,11 +1730,13 @@
     def test_release_address(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "ReleaseAddress")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
-                self.assertEquals(params, {"PublicIp": "67.202.55.255"})
+                self.assertEquals(other_params, {"PublicIp": "67.202.55.255"})
 
             def submit(self):
                 return succeed(payload.sample_release_address_result)
@@ -1626,11 +1750,13 @@
     def test_disassociate_address(self):
 
         class StubQuery(object):
-            def __init__(stub, action, creds, endpoint, params):
+
+            def __init__(stub, action="", creds=None, endpoint=None,
+                         other_params={}): 
                 self.assertEqual(action, "DisassociateAddress")
                 self.assertEqual(self.creds, creds)
                 self.assertEqual(self.endpoint, endpoint)
-                self.assertEquals(params, {"PublicIp": "67.202.55.255"})
+                self.assertEquals(other_params, {"PublicIp": "67.202.55.255"})
 
             def submit(self):
                 return succeed(payload.sample_disassociate_address_result)

=== modified file 'txaws/ec2/tests/test_exception.py'
--- txaws/ec2/tests/test_exception.py	2009-11-13 23:43:19 +0000
+++ txaws/ec2/tests/test_exception.py	2009-11-28 01:10:27 +0000
@@ -77,7 +77,7 @@
     def test_parse_with_xml(self):
         xml1 = "<dummy1 />"
         xml2 = "<dummy2 />"
-        error = EC2Error(xml2)
+        error = EC2Error(xml1)
         error.parse(xml2)
         self.assertEquals(error.original, xml2)
 

=== renamed directory 'txaws/storage' => 'txaws/s3'
=== modified file 'txaws/s3/client.py'
--- txaws/storage/client.py	2009-09-05 01:13:43 +0000
+++ txaws/s3/client.py	2009-11-28 01:10:27 +0000
@@ -1,3 +1,8 @@
+# Copyright (C) 2008 Tristan Seligmann <[e-mail]>
+# Copyright (C) 2009 Canonical Ltd
+# Copyright (C) 2009 Duncan McGreggor <[e-mail]>
+# Licenced under the txaws licence available at /LICENSE in the txaws source.
+
 """
 Client wrapper for Amazon's Simple Storage Service.
 
@@ -6,173 +11,245 @@
 Various API-incompatible changes are planned in order to expose missing
 functionality in this wrapper.
 """
+import mimetypes
+
+from twisted.web.http import datetimeToString
 
 from epsilon.extime import Time
 
-from twisted.web.client import getPage
-from twisted.web.http import datetimeToString
-
-from txaws.service import AWSServiceEndpoint
+from txaws.client.base import BaseClient, BaseQuery
+from txaws.s3 import model
+from txaws.service import AWSServiceEndpoint, S3_ENDPOINT
 from txaws.util import XML, calculate_md5
 
 
-class S3Request(object):
-
-    def __init__(self, verb, bucket=None, object_name=None, data="",
-                 content_type=None, metadata={}, creds=None, endpoint=None):
-        self.verb = verb
+class URLContext(object):
+    """
+    The hosts and the paths that form an S3 endpoint change depending upon the
+    context in which they are called. Sometimes the bucket name is in the host,
+    sometimes in the path. What's more, the behaviour against live AWS
+    resources doesn't seem to match the AWS documentation.
+    """
+    def __init__(self, service_endpoint, bucket="", object_name=""):
+        self.endpoint = service_endpoint
+        self.bucket = bucket
+        self.object_name = object_name
+
+    def get_host(self):
+        if not self.bucket:
+            return self.endpoint.get_host()
+        else:
+            return "%s.%s" % (self.bucket, self.endpoint.get_host())
+
+    def get_path(self):
+        path = "/"
+        if self.bucket is not None and self.object_name:
+            if self.object_name.startswith("/"):
+                path = self.object_name
+            else:
+                path += self.object_name
+        return path
+
+    def get_url(self):
+        return "%s://%s%s" % (
+            self.endpoint.scheme, self.get_host(), self.get_path())
+
+
+class BucketURLContext(URLContext):
+    """
+    This URL context class provides a means of overriding the standard
+    behaviour of the URLContext object so that when creating or deleting a
+    bucket, the appropriate URL is obtained.
+
+    When creating and deleting buckets on AWS, if the host is set as documented
+    (bucketname.s3.amazonaws.com), a 403 error is returned. When, however, one
+    sets the host without the bucket name prefix, the operation is completed
+    successfully.
+    """
+    def get_host(self):
+        return self.endpoint.get_host()
+
+    def get_path(self):
+        return "/%s" % (self.bucket)
+
+
+class S3Client(BaseClient):
+    """A client for S3."""
+
+    def __init__(self, creds=None, endpoint=None, query_factory=None):
+        if query_factory is None:
+            query_factory = Query
+        super(S3Client, self).__init__(creds, endpoint, query_factory)
+
+    def list_buckets(self):
+        """
+        List all buckets.
+
+        Returns a list of all the buckets owned by the authenticated sender of
+        the request.
+        """
+        query = self.query_factory(
+            action="GET", creds=self.creds, endpoint=self.endpoint)
+        d = query.submit()
+        return d.addCallback(self._parse_list_buckets)
+
+    def _parse_list_buckets(self, xml_bytes):
+        """
+        Parse XML bucket list response.
+        """
+        root = XML(xml_bytes)
+        buckets = []
+        for bucket_data in root.find("Buckets"):
+            name = bucket_data.findtext("Name")
+            date_text = bucket_data.findtext("CreationDate")
+            date_time = Time.fromISO8601TimeAndDate(date_text).asDatetime()
+            bucket = model.Bucket(name, date_time)
+            buckets.append(bucket)
+        return buckets
+
+    def create_bucket(self, bucket):
+        """
+        Create a new bucket.
+        """
+        query = self.query_factory(
+            action="PUT", creds=self.creds, endpoint=self.endpoint,
+            bucket=bucket)
+        url_context = BucketURLContext(self.endpoint, bucket)
+        return query.submit(url_context)
+
+    def delete_bucket(self, bucket):
+        """
+        Delete a bucket.
+
+        The bucket must be empty before it can be deleted.
+        """
+        query = self.query_factory(
+            action="DELETE", creds=self.creds, endpoint=self.endpoint,
+            bucket=bucket)
+        url_context = BucketURLContext(self.endpoint, bucket)
+        return query.submit(url_context)
+
+    def put_object(self, bucket, object_name, data, content_type=None,
+                   metadata={}):
+        """
+        Put an object in a bucket.
+
+        Any existing object of the same name will be replaced.
+        """
+        query = self.query_factory(
+            action="PUT", creds=self.creds, endpoint=self.endpoint,
+            bucket=bucket, object_name=object_name, data=data,
+            content_type=content_type, metadata=metadata)
+        return query.submit()
+
+    def get_object(self, bucket, object_name):
+        """
+        Get an object from a bucket.
+        """
+        query = self.query_factory(
+            action="GET", creds=self.creds, endpoint=self.endpoint,
+            bucket=bucket, object_name=object_name)
+        return query.submit()
+
+    def head_object(self, bucket, object_name):
+        """
+        Retrieve object metadata only.
+        """
+        query = self.query_factory(
+            action="HEAD", creds=self.creds, endpoint=self.endpoint,
+            bucket=bucket, object_name=object_name)
+        d = query.submit()
+        return d.addCallback(query.get_response_headers)
+
+    def delete_object(self, bucket, object_name):
+        """
+        Delete an object from a bucket.
+
+        Once deleted, there is no method to restore or undelete an object.
+        """
+        query = self.query_factory(
+            action="DELETE", creds=self.creds, endpoint=self.endpoint,
+            bucket=bucket, object_name=object_name)
+        return query.submit()
+
+
+class Query(BaseQuery):
+    """A query for submission to the S3 service."""
+
+    def __init__(self, bucket=None, object_name=None, data="",
+                 content_type=None, metadata={}, *args, **kwargs):
+        super(Query, self).__init__(*args, **kwargs)
         self.bucket = bucket
         self.object_name = object_name
         self.data = data
         self.content_type = content_type
         self.metadata = metadata
-        self.creds = creds
-        self.endpoint = endpoint
         self.date = datetimeToString()
-
-    def get_path(self):
-        path = "/"
-        if self.bucket is not None:
-            path += self.bucket
-            if self.object_name is not None:
-                path += "/" + self.object_name
-        return path
-
-    def get_uri(self):
-        if self.endpoint is None:
-            self.endpoint = AWSServiceEndpoint()
-        self.endpoint.set_path(self.get_path())
-        return self.endpoint.get_uri()
+        if not self.endpoint or not self.endpoint.host:
+            self.endpoint = AWSServiceEndpoint(S3_ENDPOINT)
+        self.endpoint.set_method(self.action)
+
+    def set_content_type(self):
+        if self.object_name and not self.content_type:
+            # XXX nothing is currently done with the encoding... we may
+            # need to in the future
+            self.content_type, encoding = mimetypes.guess_type(
+                self.object_name, strict=False)
 
     def get_headers(self):
         headers = {"Content-Length": len(self.data),
                    "Content-MD5": calculate_md5(self.data),
                    "Date": self.date}
-
         for key, value in self.metadata.iteritems():
             headers["x-amz-meta-" + key] = value
-
+        # Before we check if the content type is set, let's see if we can set
+        # it by guessing the the mimetype.
+        self.set_content_type()
         if self.content_type is not None:
             headers["Content-Type"] = self.content_type
-
         if self.creds is not None:
-            signature = self.get_signature(headers)
+            signature = self.sign(headers)
             headers["Authorization"] = "AWS %s:%s" % (
                 self.creds.access_key, signature)
         return headers
 
-    def get_canonicalized_resource(self):
-        return self.get_path()
-
     def get_canonicalized_amz_headers(self, headers):
-        result = ""
-        headers = [(name.lower(), value) for name, value in headers.iteritems()
+        headers = [
+            (name.lower(), value) for name, value in headers.iteritems()
             if name.lower().startswith("x-amz-")]
         headers.sort()
+        # XXX missing spec implementation:
+        # 1) txAWS doesn't currently combine headers with the same name
+        # 2) txAWS doesn't currently unfold long headers
         return "".join("%s:%s\n" % (name, value) for name, value in headers)
 
-    def get_signature(self, headers):
-        text = (self.verb + "\n" + 
+    def get_canonicalized_resource(self):
+        resource = "/"
+        if self.bucket:
+            resource += self.bucket
+            if self.object_name:
+                resource += "/%s" % self.object_name
+        return resource
+
+    def sign(self, headers):
+
+        text = (self.action + "\n" +
                 headers.get("Content-MD5", "") + "\n" +
                 headers.get("Content-Type", "") + "\n" +
                 headers.get("Date", "") + "\n" +
                 self.get_canonicalized_amz_headers(headers) +
                 self.get_canonicalized_resource())
-        return self.creds.sign(text)
-
-    def submit(self):
-        return self.get_page(url=self.get_uri(), method=self.verb,
-                             postdata=self.data, headers=self.get_headers())
-
-    def get_page(self, *a, **kw):
-        return getPage(*a, **kw)
-
-
-class S3(object):
-
-    request_factory = S3Request
-
-    def __init__(self, creds, endpoint):
-        self.creds = creds
-        self.endpoint = endpoint
-
-    def make_request(self, *a, **kw):
-        """
-        Create a request with the arguments passed in.
-
-        This uses the request_factory attribute, adding the creds and endpoint
-        to the arguments passed in.
-        """
-        return self.request_factory(creds=self.creds, endpoint=self.endpoint,
-                                    *a, **kw)
-
-    def _parse_bucket_list(self, response):
-        """
-        Parse XML bucket list response.
-        """
-        root = XML(response)
-        for bucket in root.find("Buckets"):
-            timeText = bucket.findtext("CreationDate")
-            yield {
-                "name": bucket.findtext("Name"),
-                "created": Time.fromISO8601TimeAndDate(timeText),
-                }
-
-    def list_buckets(self):
-        """
-        List all buckets.
-
-        Returns a list of all the buckets owned by the authenticated sender of
-        the request.
-        """
-        deferred = self.make_request("GET").submit()
-        deferred.addCallback(self._parse_bucket_list)
-        return deferred
-
-    def create_bucket(self, bucket):
-        """
-        Create a new bucket.
-        """
-        return self.make_request("PUT", bucket).submit()
-
-    def delete_bucket(self, bucket):
-        """
-        Delete a bucket.
-
-        The bucket must be empty before it can be deleted.
-        """
-        return self.make_request("DELETE", bucket).submit()
-
-    def put_object(self, bucket, object_name, data, content_type=None,
-                   metadata={}):
-        """
-        Put an object in a bucket.
-
-        Any existing object of the same name will be replaced.
-        """
-        return self.make_request("PUT", bucket, object_name, data,
-                                 content_type, metadata).submit()
-
-    def get_object(self, bucket, object_name):
-        """
-        Get an object from a bucket.
-        """
-        return self.make_request("GET", bucket, object_name).submit()
-
-    def head_object(self, bucket, object_name):
-        """
-        Retrieve object metadata only.
-
-        This is like get_object, but the object's content is not retrieved.
-        Currently the metadata is not returned to the caller either, so this
-        method is mostly useless, and only provided for completeness.
-        """
-        return self.make_request("HEAD", bucket, object_name).submit()
-
-    def delete_object(self, bucket, object_name):
-        """
-        Delete an object from a bucket.
-
-        Once deleted, there is no method to restore or undelete an object.
-        """
-        return self.make_request("DELETE", bucket, object_name).submit()
+        return self.creds.sign(text, hash_type="sha1")
+
+    def submit(self, url_context=None):
+        if not url_context:
+            url_context = URLContext(
+                self.endpoint, self.bucket, self.object_name)
+        d = self.get_page(
+            url_context.get_url(), method=self.action, postdata=self.data,
+            headers=self.get_headers())
+        # XXX - we need an error wrapper like we have for ec2... but let's
+        # wait until the new error-wrapper branch has landed, and possibly
+        # generalize a base class for all clients.
+        #d.addErrback(s3_error_wrapper)
+        return d

=== added file 'txaws/s3/model.py'
--- txaws/s3/model.py	1970-01-01 00:00:00 +0000
+++ txaws/s3/model.py	2009-11-28 01:10:27 +0000
@@ -0,0 +1,16 @@
+class Bucket(object):
+    """An Amazon S3 storage bucket."""
+
+    def __init__(self, name, creation_date):
+        self.name = name
+        self.creation_date = creation_date
+
+
+class FileChunk(object):
+    """
+    An Amazon S3 file chunk.
+
+    S3 returns file chunks, 10 MB at a time, until the entire file is returned.
+    These chunks need to be assembled once they are all returned.
+    """
+

=== modified file 'txaws/s3/tests/test_client.py'
--- txaws/storage/tests/test_client.py	2009-09-05 01:13:43 +0000
+++ txaws/s3/tests/test_client.py	2009-11-28 01:10:27 +0000
@@ -1,71 +1,363 @@
-from datetime import datetime
-
-from epsilon.extime import Time
-
 from twisted.internet.defer import succeed
 
 from txaws.credentials import AWSCredentials
+from txaws.s3 import client
 from txaws.service import AWSServiceEndpoint
-from txaws.storage.client import S3, S3Request
+from txaws.testing import payload
 from txaws.testing.base import TXAWSTestCase
 from txaws.util import calculate_md5
 
 
-
-class StubbedS3Request(S3Request):
-
-    def get_page(self, url, method, postdata, headers):
-        self.getPageArgs = (url, method, postdata, headers)
-        return succeed("")
-
-
-class RequestTestCase(TXAWSTestCase):
+class URLContextTestCase(TXAWSTestCase):
+
+    endpoint = AWSServiceEndpoint("https://s3.amazonaws.com/")
+
+    def test_get_host_with_no_bucket(self):
+        url_context = client.URLContext(self.endpoint)
+        self.assertEquals(url_context.get_host(), "s3.amazonaws.com")
+
+    def test_get_host_with_bucket(self):
+        url_context = client.URLContext(self.endpoint, "mystuff")
+        self.assertEquals(url_context.get_host(), "mystuff.s3.amazonaws.com")
+
+    def test_get_path_with_no_bucket(self):
+        url_context = client.URLContext(self.endpoint)
+        self.assertEquals(url_context.get_path(), "/")
+
+    def test_get_path_with_bucket(self):
+        url_context = client.URLContext(self.endpoint, bucket="mystuff")
+        self.assertEquals(url_context.get_path(), "/")
+
+    def test_get_path_with_bucket_and_object(self):
+        url_context = client.URLContext(
+            self.endpoint, bucket="mystuff", object_name="/images/thing.jpg")
+        self.assertEquals(url_context.get_host(), "mystuff.s3.amazonaws.com")
+        self.assertEquals(url_context.get_path(), "/images/thing.jpg")
+
+    def test_get_path_with_bucket_and_object_without_slash(self):
+        url_context = client.URLContext(
+            self.endpoint, bucket="mystuff", object_name="images/thing.jpg")
+        self.assertEquals(url_context.get_host(), "mystuff.s3.amazonaws.com")
+        self.assertEquals(url_context.get_path(), "/images/thing.jpg")
+
+    def test_get_url_with_custom_endpoint(self):
+        endpoint = AWSServiceEndpoint("http://localhost/")
+        url_context = client.URLContext(endpoint)
+        self.assertEquals(url_context.endpoint.get_uri(), "http://localhost/")
+        self.assertEquals( url_context.get_url(), "http://localhost/")
+
+    def test_get_uri_with_endpoint_bucket_and_object(self):
+        endpoint = AWSServiceEndpoint("http://localhost/")
+        url_context = client.URLContext(
+            endpoint, bucket="mydocs", object_name="notes.txt")
+        self.assertEquals(
+            url_context.get_url(),
+            "http://mydocs.localhost/notes.txt")
+
+
+class BucketURLContextTestCase(TXAWSTestCase):
+
+    endpoint = AWSServiceEndpoint("https://s3.amazonaws.com/")
+
+    def test_get_host_with_bucket(self):
+        url_context = client.BucketURLContext(self.endpoint, "mystuff")
+        self.assertEquals(url_context.get_host(), "s3.amazonaws.com")
+        self.assertEquals(url_context.get_path(), "/mystuff")
+
+
+class S3ClientTestCase(TXAWSTestCase):
+
+    def setUp(self):
+        TXAWSTestCase.setUp(self)
+        self.creds = AWSCredentials(
+            access_key="accessKey", secret_key="secretKey")
+        self.endpoint = AWSServiceEndpoint()
+
+    def test_list_buckets(self):
+
+        class StubQuery(client.Query):
+
+            def __init__(query, action, creds, endpoint):
+                super(StubQuery, query).__init__(
+                    action=action, creds=creds)
+                self.assertEquals(action, "GET")
+                self.assertEqual(creds.access_key, "foo")
+                self.assertEqual(creds.secret_key, "bar")
+                self.assertEqual(query.bucket, None)
+                self.assertEqual(query.object_name, None)
+                self.assertEqual(query.data, "")
+                self.assertEqual(query.metadata, {})
+
+            def submit(query):
+                return succeed(payload.sample_list_buckets_result)
+
+        def check_list_buckets(results):
+            bucket1, bucket2 = results
+            self.assertEquals(bucket1.name, "quotes")
+            self.assertEquals(
+                bucket1.creation_date.timetuple(),
+                (2006, 2, 3, 16, 45, 9, 4, 34, 0))
+            self.assertEquals(bucket2.name, "samples")
+            self.assertEquals(
+                bucket2.creation_date.timetuple(),
+                (2006, 2, 3, 16, 41, 58, 4, 34, 0))
+
+        creds = AWSCredentials("foo", "bar")
+        s3 = client.S3Client(creds, query_factory=StubQuery)
+        d = s3.list_buckets()
+        return d.addCallback(check_list_buckets)
+
+    def test_create_bucket(self):
+
+        class StubQuery(client.Query):
+
+            def __init__(query, action, creds, endpoint, bucket=None):
+                super(StubQuery, query).__init__(
+                    action=action, creds=creds, bucket=bucket)
+                self.assertEquals(action, "PUT")
+                self.assertEqual(creds.access_key, "foo")
+                self.assertEqual(creds.secret_key, "bar")
+                self.assertEqual(query.bucket, "mybucket")
+                self.assertEqual(query.object_name, None)
+                self.assertEqual(query.data, "")
+                self.assertEqual(query.metadata, {})
+
+            def submit(query, url_context=None):
+                return succeed(None)
+
+        creds = AWSCredentials("foo", "bar")
+        s3 = client.S3Client(creds, query_factory=StubQuery)
+        return s3.create_bucket("mybucket")
+
+    def test_delete_bucket(self):
+
+        class StubQuery(client.Query):
+
+            def __init__(query, action, creds, endpoint, bucket=None):
+                super(StubQuery, query).__init__(
+                    action=action, creds=creds, bucket=bucket)
+                self.assertEquals(action, "DELETE")
+                self.assertEqual(creds.access_key, "foo")
+                self.assertEqual(creds.secret_key, "bar")
+                self.assertEqual(query.bucket, "mybucket")
+                self.assertEqual(query.object_name, None)
+                self.assertEqual(query.data, "")
+                self.assertEqual(query.metadata, {})
+
+            def submit(query, url_context=None):
+                return succeed(None)
+
+        creds = AWSCredentials("foo", "bar")
+        s3 = client.S3Client(creds, query_factory=StubQuery)
+        return s3.delete_bucket("mybucket")
+
+    def test_put_object(self):
+
+        class StubQuery(client.Query):
+
+            def __init__(query, action, creds, endpoint, bucket=None,
+                object_name=None, data=None, content_type=None,
+                metadata=None):
+                super(StubQuery, query).__init__(
+                    action=action, creds=creds, bucket=bucket,
+                    object_name=object_name, data=data,
+                    content_type=content_type, metadata=metadata)
+                self.assertEqual(action, "PUT")
+                self.assertEqual(creds.access_key, "foo")
+                self.assertEqual(creds.secret_key, "bar")
+                self.assertEqual(query.bucket, "mybucket")
+                self.assertEqual(query.object_name, "objectname")
+                self.assertEqual(query.data, "some data")
+                self.assertEqual(query.content_type, "text/plain")
+                self.assertEqual(query.metadata, {"key": "some meta data"})
+
+            def submit(query):
+                return succeed(None)
+
+        creds = AWSCredentials("foo", "bar")
+        s3 = client.S3Client(creds, query_factory=StubQuery)
+        return s3.put_object(
+            "mybucket", "objectname", "some data", content_type="text/plain",
+            metadata={"key": "some meta data"})
+
+    def test_get_object(self):
+
+        class StubQuery(client.Query):
+
+            def __init__(query, action, creds, endpoint, bucket=None,
+                object_name=None, data=None, content_type=None,
+                metadata=None):
+                super(StubQuery, query).__init__(
+                    action=action, creds=creds, bucket=bucket,
+                    object_name=object_name, data=data,
+                    content_type=content_type, metadata=metadata)
+                self.assertEqual(action, "GET")
+                self.assertEqual(creds.access_key, "foo")
+                self.assertEqual(creds.secret_key, "bar")
+                self.assertEqual(query.bucket, "mybucket")
+                self.assertEqual(query.object_name, "objectname")
+
+            def submit(query):
+                return succeed(None)
+
+        creds = AWSCredentials("foo", "bar")
+        s3 = client.S3Client(creds, query_factory=StubQuery)
+        return s3.get_object("mybucket", "objectname")
+
+    def test_head_object(self):
+
+        class StubQuery(client.Query):
+
+            def __init__(query, action, creds, endpoint, bucket=None,
+                object_name=None, data=None, content_type=None,
+                metadata=None):
+                super(StubQuery, query).__init__(
+                    action=action, creds=creds, bucket=bucket,
+                    object_name=object_name, data=data,
+                    content_type=content_type, metadata=metadata)
+                self.assertEqual(action, "HEAD")
+                self.assertEqual(creds.access_key, "foo")
+                self.assertEqual(creds.secret_key, "bar")
+                self.assertEqual(query.bucket, "mybucket")
+                self.assertEqual(query.object_name, "objectname")
+
+            def submit(query):
+                return succeed(None)
+
+        creds = AWSCredentials("foo", "bar")
+        s3 = client.S3Client(creds, query_factory=StubQuery)
+        return s3.head_object("mybucket", "objectname")
+
+    def test_delete_object(self):
+
+        class StubQuery(client.Query):
+
+            def __init__(query, action, creds, endpoint, bucket=None,
+                object_name=None, data=None, content_type=None,
+                metadata=None):
+                super(StubQuery, query).__init__(
+                    action=action, creds=creds, bucket=bucket,
+                    object_name=object_name, data=data,
+                    content_type=content_type, metadata=metadata)
+                self.assertEqual(action, "DELETE")
+                self.assertEqual(creds.access_key, "foo")
+                self.assertEqual(creds.secret_key, "bar")
+                self.assertEqual(query.bucket, "mybucket")
+                self.assertEqual(query.object_name, "objectname")
+
+            def submit(query):
+                return succeed(None)
+
+        creds = AWSCredentials("foo", "bar")
+        s3 = client.S3Client(creds, query_factory=StubQuery)
+        return s3.delete_object("mybucket", "objectname")
+
+
+class QueryTestCase(TXAWSTestCase):
 
     creds = AWSCredentials(access_key="fookeyid", secret_key="barsecretkey")
-    endpoint = AWSServiceEndpoint("https://s3.amazonaws.com/")
-
-    def test_get_uri_with_endpoint(self):
-        endpoint = AWSServiceEndpoint("http://localhost/")
-        request = S3Request("PUT", endpoint=endpoint)
-        self.assertEquals(request.endpoint.get_uri(), "http://localhost/")
-        self.assertEquals(request.get_uri(), "http://localhost/")
-
-    def test_get_uri_with_endpoint_bucket_and_object(self):
-        endpoint = AWSServiceEndpoint("http://localhost/")
-        request = S3Request("PUT", bucket="mybucket", object_name="myobject",
-                            endpoint=endpoint)
-        self.assertEquals(
-            request.get_uri(),
-            "http://localhost/mybucket/myobject")
-
-    def test_get_uri_with_no_endpoint(self):
-        request = S3Request("PUT")
-        self.assertEquals(request.endpoint, None)
-        self.assertEquals(request.get_uri(), "http:///")
-
-    def test_get_path_with_bucket_and_object(self):
-        request = S3Request("PUT", bucket="mybucket", object_name="myobject")
-        self.assertEquals(request.get_path(), "/mybucket/myobject")
-
-    def test_get_path_with_no_bucket_or_object(self):
-        request = S3Request("PUT")
-        self.assertEquals(request.get_path(), "/")
-
-    def test_objectRequest(self):
+    endpoint = AWSServiceEndpoint("https://choopy.s3.amazonaws.com/")
+
+    def test_default_creation(self):
+        query = client.Query(action="PUT")
+        self.assertEquals(query.bucket, None)
+        self.assertEquals(query.object_name, None)
+        self.assertEquals(query.data, "")
+        self.assertEquals(query.content_type, None)
+        self.assertEquals(query.metadata, {})
+
+    def test_default_endpoint(self):
+        query = client.Query(action="PUT")
+        self.assertEquals(self.endpoint.host, "choopy.s3.amazonaws.com")
+        self.assertEquals(query.endpoint.host, "s3.amazonaws.com")
+        self.assertEquals(self.endpoint.method, "GET")
+        self.assertEquals(query.endpoint.method, "PUT")
+
+    def test_set_content_type_no_object_name(self):
+        query = client.Query(action="PUT")
+        query.set_content_type()
+        self.assertEquals(query.content_type, None)
+
+    def test_set_content_type(self):
+        query = client.Query(action="PUT", object_name="advicedog.jpg")
+        query.set_content_type()
+        self.assertEquals(query.content_type, "image/jpeg")
+
+    def test_set_content_type_with_content_type_already_set(self):
+        query = client.Query(
+            action="PUT", object_name="data.txt", content_type="text/csv")
+        query.set_content_type()
+        self.assertNotEquals(query.content_type, "text/plain")
+        self.assertEquals(query.content_type, "text/csv")
+
+    def test_get_headers(self):
+        query = client.Query(
+            action="GET", creds=self.creds, bucket="mystuff",
+            object_name="/images/thing.jpg")
+        headers = query.get_headers()
+        self.assertEquals(headers.get("Content-Type"), "image/jpeg")
+        self.assertEquals(headers.get("Content-Length"), 0)
+        self.assertEquals(
+            headers.get("Content-MD5"), "1B2M2Y8AsgTpgAmY7PhCfg==")
+        self.assertTrue(len(headers.get("Date")) > 25)
+        self.assertTrue(
+            headers.get("Authorization").startswith("AWS fookeyid:"))
+        self.assertTrue(len(headers.get("Authorization")) > 40)
+
+    def test_get_headers_with_data(self):
+        query = client.Query(
+            action="GET", creds=self.creds, bucket="mystuff",
+            object_name="/images/thing.jpg", data="BINARY IMAGE DATA")
+        headers = query.get_headers()
+        self.assertEquals(headers.get("Content-Type"), "image/jpeg")
+        self.assertEquals(headers.get("Content-Length"), 17)
+        self.assertTrue(len(headers.get("Date")) > 25)
+        self.assertTrue(
+            headers.get("Authorization").startswith("AWS fookeyid:"))
+        self.assertTrue(len(headers.get("Authorization")) > 40)
+
+    def test_get_canonicalized_amz_headers(self):
+        query = client.Query(
+            action="SomeThing", metadata={"a": 1, "b": 2, "c": 3})
+        headers = query.get_headers()
+        self.assertEquals(
+            sorted(headers.keys()),
+            ["Content-Length", "Content-MD5", "Date", "x-amz-meta-a",
+             "x-amz-meta-b", "x-amz-meta-c"])
+        amz_headers = query.get_canonicalized_amz_headers(headers)
+        self.assertEquals(
+            amz_headers,
+            "x-amz-meta-a:1\nx-amz-meta-b:2\nx-amz-meta-c:3\n")
+
+    def test_get_canonicalized_resource(self):
+        query = client.Query(action="PUT", bucket="images")
+        result = query.get_canonicalized_resource()
+        self.assertEquals(result, "/images")
+
+    def test_get_canonicalized_resource_with_object_name(self):
+        query = client.Query(
+            action="PUT", bucket="images", object_name="advicedog.jpg")
+        result = query.get_canonicalized_resource()
+        self.assertEquals(result, "/images/advicedog.jpg")
+
+    def test_sign(self):
+        query = client.Query(action="PUT", creds=self.creds)
+        signed = query.sign({})
+        self.assertEquals(signed, "H6UJCNHizzXZCGPl7wM6nL6tQdo=")
+        
+    def test_object_query(self):
         """
         Test that a request addressing an object is created correctly.
         """
         DATA = "objectData"
         DIGEST = "zhdB6gwvocWv/ourYUWMxA=="
 
-        request = S3Request("PUT", "somebucket", "object/name/here", DATA,
-                            content_type="text/plain", metadata={"foo": "bar"},
-                            creds=self.creds, endpoint=self.endpoint)
-        request.get_signature = lambda headers: "TESTINGSIG="
-        self.assertEqual(request.verb, "PUT")
-        self.assertEqual(
-            request.get_uri(),
-            "https://s3.amazonaws.com/somebucket/object/name/here")
+        request = client.Query(
+            action="PUT", bucket="somebucket", object_name="object/name/here",
+            data=DATA, content_type="text/plain", metadata={"foo": "bar"},
+            creds=self.creds, endpoint=self.endpoint)
+        request.sign = lambda headers: "TESTINGSIG="
+        self.assertEqual(request.action, "PUT")
         headers = request.get_headers()
         self.assertNotEqual(headers.pop("Date"), "")
         self.assertEqual(
@@ -77,212 +369,63 @@
                 "x-amz-meta-foo": "bar"})
         self.assertEqual(request.data, "objectData")
 
-    def test_bucketRequest(self):
+    def test_bucket_query(self):
         """
         Test that a request addressing a bucket is created correctly.
         """
         DIGEST = "1B2M2Y8AsgTpgAmY7PhCfg=="
 
-        request = S3Request("GET", "somebucket", creds=self.creds,
-                            endpoint=self.endpoint)
-        request.get_signature = lambda headers: "TESTINGSIG="
-        self.assertEqual(request.verb, "GET")
-        self.assertEqual(
-            request.get_uri(), "https://s3.amazonaws.com/somebucket")
-        headers = request.get_headers()
+        query = client.Query(
+            action="GET", bucket="somebucket", creds=self.creds,
+            endpoint=self.endpoint)
+        query.sign = lambda headers: "TESTINGSIG="
+        self.assertEqual(query.action, "GET")
+        headers = query.get_headers()
         self.assertNotEqual(headers.pop("Date"), "")
         self.assertEqual(
             headers, {
             "Authorization": "AWS fookeyid:TESTINGSIG=",
             "Content-Length": 0,
             "Content-MD5": DIGEST})
-        self.assertEqual(request.data, "")
+        self.assertEqual(query.data, "")
 
     def test_submit(self):
         """
         Submitting the request should invoke getPage correctly.
         """
-        request = StubbedS3Request("GET", "somebucket", creds=self.creds,
-                                   endpoint=self.endpoint)
-
-        def _postCheck(result):
-            self.assertEqual(result, "")
-
-            url, method, postdata, headers = request.getPageArgs
-            self.assertEqual(url, request.get_uri())
-            self.assertEqual(method, request.verb)
-            self.assertEqual(postdata, request.data)
-            self.assertEqual(headers, request.get_headers())
-
-        return request.submit().addCallback(_postCheck)
-
-    def test_authenticationTestCases(self):
-        request = S3Request("GET", creds=self.creds, endpoint=self.endpoint)
-        request.get_signature = lambda headers: "TESTINGSIG="
-        request.date = "Wed, 28 Mar 2007 01:29:59 +0000"
-
-        headers = request.get_headers()
+        class StubQuery(client.Query):
+
+            def __init__(query, action, creds, endpoint, bucket):
+                super(StubQuery, query).__init__(
+                    action=action, creds=creds, bucket=bucket)
+                self.assertEquals(action, "GET")
+                self.assertEqual(creds.access_key, "fookeyid")
+                self.assertEqual(creds.secret_key, "barsecretkey")
+                self.assertEqual(query.bucket, "somebucket")
+                self.assertEqual(query.object_name, None)
+                self.assertEqual(query.data, "")
+                self.assertEqual(query.metadata, {})
+
+            def submit(query):
+                return succeed("")
+
+        query = StubQuery(action="GET", creds=self.creds,
+                          endpoint=self.endpoint, bucket="somebucket")
+        return query.submit()
+
+    def test_authentication(self):
+        query = client.Query(
+            action="GET", creds=self.creds, endpoint=self.endpoint)
+        query.sign = lambda headers: "TESTINGSIG="
+        query.date = "Wed, 28 Mar 2007 01:29:59 +0000"
+
+        headers = query.get_headers()
         self.assertEqual(
             headers["Authorization"], 
             "AWS fookeyid:TESTINGSIG=")
 
 
-class InertRequest(S3Request):
-    """
-    Inert version of S3Request.
-
-    The submission action is stubbed out to return the provided response.
-    """
-    submitted = False
-
-    def __init__(self, *a, **kw):
-        self.response = kw.pop("response")
-        super(InertRequest, self).__init__(*a, **kw)
-
-    def submit(self):
-        """
-        Return the canned result instead of performing a network operation.
-        """
-        self.submitted = True
-        return succeed(self.response)
-
-
-class TestableS3(S3):
-    """
-    Testable version of S3.
-
-    This subclass stubs request_factory to use InertRequest, making it easy to
-    assert things about the requests that are created in response to various
-    operations.
-    """
-    response = None
-
-    def request_factory(self, *a, **kw):
-        req = InertRequest(response=self.response, *a, **kw)
-        self._lastRequest = req
-        return req
-
-
-samples = {
-    "ListAllMyBucketsResult":
-    """<?xml version="1.0" encoding="UTF-8"?>
-<ListAllMyBucketsResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
-  <Owner>
-    <ID>bcaf1ffd86f41caff1a493dc2ad8c2c281e37522a640e161ca5fb16fd081034f</ID>
-    <DisplayName>webfile</DisplayName>
-  </Owner>
-  <Buckets>
-    <Bucket>
-      <Name>quotes</Name>
-      <CreationDate>2006-02-03T16:45:09.000Z</CreationDate>
-    </Bucket>
-    <Bucket>
-      <Name>samples</Name>
-      <CreationDate>2006-02-03T16:41:58.000Z</CreationDate>
-    </Bucket>
-  </Buckets>
-</ListAllMyBucketsResult>""",
-    }
-
-
-class WrapperTests(TXAWSTestCase):
-
-    def setUp(self):
-        TXAWSTestCase.setUp(self)
-        self.creds = AWSCredentials(
-            access_key="accessKey", secret_key="secretKey")
-        self.endpoint = AWSServiceEndpoint()
-        self.s3 = TestableS3(creds=self.creds, endpoint=self.endpoint)
-
-    def test_make_request(self):
-        """
-        Test that make_request passes in the credentials object.
-        """
-        marker = object()
-
-        def _cb(*a, **kw):
-            self.assertEqual(kw["creds"], self.creds)
-            self.assertEqual(kw["endpoint"], self.endpoint)
-            return marker
-
-        self.s3.request_factory = _cb
-        self.assertIdentical(self.s3.make_request("GET"), marker)
-
-    def test_list_buckets(self):
-        self.s3.response = samples["ListAllMyBucketsResult"]
-        d = self.s3.list_buckets()
-
-        req = self.s3._lastRequest
-        self.assertTrue(req.submitted)
-        self.assertEqual(req.verb, "GET")
-        self.assertEqual(req.bucket, None)
-        self.assertEqual(req.object_name, None)
-
-        def _check_result(buckets):
-            self.assertEqual(
-                list(buckets),
-                [{"name": u"quotes",
-                  "created": Time.fromDatetime(
-                    datetime(2006, 2, 3, 16, 45, 9))},
-                 {"name": u"samples",
-                  "created": Time.fromDatetime(
-                    datetime(2006, 2, 3, 16, 41, 58))}])
-        return d.addCallback(_check_result)
-
-    def test_create_bucket(self):
-        self.s3.create_bucket("foo")
-        req = self.s3._lastRequest
-        self.assertTrue(req.submitted)
-        self.assertEqual(req.verb, "PUT")
-        self.assertEqual(req.bucket, "foo")
-        self.assertEqual(req.object_name, None)
-
-    def test_delete_bucket(self):
-        self.s3.delete_bucket("foo")
-        req = self.s3._lastRequest
-        self.assertTrue(req.submitted)
-        self.assertEqual(req.verb, "DELETE")
-        self.assertEqual(req.bucket, "foo")
-        self.assertEqual(req.object_name, None)
-
-    def test_put_object(self):
-        self.s3.put_object(
-            "foobucket", "foo", "data", "text/plain", {"foo": "bar"})
-        req = self.s3._lastRequest
-        self.assertTrue(req.submitted)
-        self.assertEqual(req.verb, "PUT")
-        self.assertEqual(req.bucket, "foobucket")
-        self.assertEqual(req.object_name, "foo")
-        self.assertEqual(req.data, "data")
-        self.assertEqual(req.content_type, "text/plain")
-        self.assertEqual(req.metadata, {"foo": "bar"})
-
-    def test_get_object(self):
-        self.s3.get_object("foobucket", "foo")
-        req = self.s3._lastRequest
-        self.assertTrue(req.submitted)
-        self.assertEqual(req.verb, "GET")
-        self.assertEqual(req.bucket, "foobucket")
-        self.assertEqual(req.object_name, "foo")
-
-    def test_head_object(self):
-        self.s3.head_object("foobucket", "foo")
-        req = self.s3._lastRequest
-        self.assertTrue(req.submitted)
-        self.assertEqual(req.verb, "HEAD")
-        self.assertEqual(req.bucket, "foobucket")
-        self.assertEqual(req.object_name, "foo")
-
-    def test_delete_object(self):
-        self.s3.delete_object("foobucket", "foo")
-        req = self.s3._lastRequest
-        self.assertTrue(req.submitted)
-        self.assertEqual(req.verb, "DELETE")
-        self.assertEqual(req.bucket, "foobucket")
-        self.assertEqual(req.object_name, "foo")
-
-
 class MiscellaneousTests(TXAWSTestCase):
 
-    def test_contentMD5(self):
+    def test_content_md5(self):
         self.assertEqual(calculate_md5("somedata"), "rvr3UC1SmUw7AZV2NqPN0g==")

=== modified file 'txaws/service.py'
--- txaws/service.py	2009-10-12 07:08:05 +0000
+++ txaws/service.py	2009-11-28 01:10:27 +0000
@@ -12,6 +12,7 @@
 REGION_EU = "EU"
 EC2_ENDPOINT_US = "https://us-east-1.ec2.amazonaws.com/"
 EC2_ENDPOINT_EU = "https://eu-west-1.ec2.amazonaws.com/"
+S3_ENDPOINT = "https://s3.amazonaws.com/"
 DEFAULT_PORT = 80
 
 
@@ -38,6 +39,12 @@
         self.port = port
         self.path = path
 
+    def set_host(self, host):
+        self.host = host
+
+    def get_host(self):
+        return self.host
+
     def set_path(self, path):
         self.path = path
 
@@ -48,6 +55,9 @@
             uri = "%s:%s" % (uri, self.port)
         return uri + self.path
 
+    def set_method(self, method):
+        self.method = method
+
 
 class AWSServiceRegion(object):
     """
@@ -65,19 +75,24 @@
     @param uri: an endpoint URI that, if provided, will override the region
         parameter.
     """
+    # XXX update unit test to check for both ec2 and s3 endpoints
     def __init__(self, creds=None, access_key="", secret_key="",
-                 region=REGION_US, uri=""):
+                 region=REGION_US, uri="", ec2_uri="", s3_uri=""):
         if not creds:
             creds = AWSCredentials(access_key, secret_key)
         self.creds = creds
+        # Provide backwards compatibility for the "uri" parameter.
+        if uri and not ec2_uri:
+            ec2_uri = uri
+        if not ec2_uri and region == REGION_US:
+            ec2_uri = EC2_ENDPOINT_US
+        elif not ec2_uri and region == REGION_EU:
+            ec2_uri = EC2_ENDPOINT_EU
+        if not s3_uri:
+            s3_uri = S3_ENDPOINT
         self._clients = {}
-        if uri:
-            ec2_endpoint = uri
-        elif region == REGION_US:
-            ec2_endpoint = EC2_ENDPOINT_US
-        elif region == REGION_EU:
-            ec2_endpoint = EC2_ENDPOINT_EU
-        self.ec2_endpoint = AWSServiceEndpoint(uri=ec2_endpoint)
+        self.ec2_endpoint = AWSServiceEndpoint(uri=ec2_uri)
+        self.s3_endpoint = AWSServiceEndpoint(uri=s3_uri)
 
     def get_client(self, cls, purge_cache=False, *args, **kwds):
         """
@@ -100,3 +115,11 @@
             self.creds = creds
         return self.get_client(EC2Client, creds=self.creds,
                                endpoint=self.ec2_endpoint, query_factory=None)
+
+    def get_s3_client(self, creds=None):
+        from txaws.s3.client import S3Client
+
+        if creds:
+            self.creds = creds
+        return self.get_client(S3Client, creds=self.creds,
+                               endpoint=self.s3_endpoint, query_factory=None)

=== modified file 'txaws/testing/payload.py'
--- txaws/testing/payload.py	2009-11-13 23:39:02 +0000
+++ txaws/testing/payload.py	2009-11-28 01:10:27 +0000
@@ -1,4 +1,4 @@
-from txaws.version import aws_api
+from txaws import version
 
 
 sample_required_describe_instances_result = """\
@@ -34,7 +34,7 @@
     </item>
   </reservationSet>
 </DescribeInstancesResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_describe_instances_result = """\
@@ -78,7 +78,7 @@
     </item>
   </reservationSet>
 </DescribeInstancesResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_run_instances_result = """\
@@ -145,7 +145,7 @@
     </item>
   </instancesSet>
 </RunInstancesResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 sample_terminate_instances_result = """\
 <?xml version="1.0"?>
@@ -175,7 +175,7 @@
     </item>
   </instancesSet>
 </TerminateInstancesResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_describe_security_groups_result = """\
@@ -203,7 +203,7 @@
     </item>
   </securityGroupInfo>
 </DescribeSecurityGroupsResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_describe_security_groups_multiple_result = """\
@@ -265,14 +265,14 @@
     </item>
   </securityGroupInfo>
 </DescribeSecurityGroupsResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_create_security_group = """\
 <CreateSecurityGroupResponse xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>true</return>
 </CreateSecurityGroupResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_duplicate_create_security_group_result = """\
@@ -305,7 +305,7 @@
 <DeleteSecurityGroupResponse xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>true</return>
 </DeleteSecurityGroupResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_delete_security_group_failure = """\
@@ -326,14 +326,14 @@
 <AuthorizeSecurityGroupIngressResponse xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>true</return>
 </AuthorizeSecurityGroupIngressResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_revoke_security_group = """\
 <RevokeSecurityGroupIngressResponse xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>true</return>
 </RevokeSecurityGroupIngressResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_describe_volumes_result = """\
@@ -360,7 +360,7 @@
     </item>
   </volumeSet>
 </DescribeVolumesResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_describe_snapshots_result = """\
@@ -376,7 +376,7 @@
     </item>
   </snapshotSet>
 </DescribeSnapshotsResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_create_volume_result = """\
@@ -389,7 +389,7 @@
   <availabilityZone>us-east-1a</availabilityZone>
   <snapshotId></snapshotId>
 </CreateVolumeResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_delete_volume_result = """\
@@ -397,7 +397,7 @@
 <DeleteVolumeResponse xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>true</return>
 </DeleteVolumeResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_create_snapshot_result = """\
@@ -409,7 +409,7 @@
   <startTime>2008-05-07T12:51:50.000Z</startTime>
   <progress></progress>
 </CreateSnapshotResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_delete_snapshot_result = """\
@@ -417,7 +417,7 @@
 <DeleteSnapshotResponse xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>true</return>
 </DeleteSnapshotResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_attach_volume_result = """\
@@ -429,7 +429,7 @@
   <status>attaching</status>
   <attachTime>2008-05-07T11:51:50.000Z</attachTime>
 </AttachVolumeResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_ec2_error_message = """\
@@ -474,7 +474,7 @@
     </item>
   </keySet>
 </DescribeKeyPairsResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_multiple_describe_keypairs_result = """\
@@ -491,7 +491,7 @@
     </item>
   </keySet>
 </DescribeKeyPairsResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_create_keypair_result = """\
@@ -523,7 +523,7 @@
 2ERKKdwz0ZL9SWq6VTdhr/5G994CK72fy5WhyERbDjUIdHaK3M849JJuf8cSrvSb4g==
 -----END RSA PRIVATE KEY-----</keyMaterial>
 </CreateKeyPairResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_delete_keypair_true_result = """\
@@ -531,7 +531,7 @@
 <DeleteKeyPair xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>true</return>
 </DeleteKeyPair>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_delete_keypair_false_result = """\
@@ -539,14 +539,14 @@
 <DeleteKeyPair xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>false</return>
 </DeleteKeyPair>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_delete_keypair_no_result = """\
 <?xml version="1.0"?>
 <DeleteKeyPair xmlns="http://ec2.amazonaws.com/doc/%s/">
 </DeleteKeyPair>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_duplicate_keypair_result = """\
@@ -568,7 +568,7 @@
 <AllocateAddressResponse xmlns="http://ec2.amazonaws.com/doc/%s/">
   <publicIp>67.202.55.255</publicIp>
 </AllocateAddressResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_release_address_result = """\
@@ -576,7 +576,7 @@
 <ReleaseAddressResponse xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>true</return>
 </ReleaseAddressResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_associate_address_result = """\
@@ -584,7 +584,7 @@
 <AssociateAddressResponse xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>true</return>
 </AssociateAddressResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_disassociate_address_result = """\
@@ -592,7 +592,7 @@
 <DisassociateAddressResponse xmlns="http://ec2.amazonaws.com/doc/%s/">
   <return>true</return>
 </DisassociateAddressResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_describe_addresses_result = """\
@@ -607,7 +607,7 @@
     </item>
   </addressesSet>
 </DescribeAddressesResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_describe_availability_zones_single_result = """\
@@ -619,7 +619,7 @@
     </item>
   </availabilityZoneInfo>
 </DescribeAvailabilityZonesResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_describe_availability_zones_multiple_results = """\
@@ -639,7 +639,7 @@
     </item>
   </availabilityZoneInfo>
 </DescribeAvailabilityZonesResponse>
-""" % (aws_api,)
+""" % (version.ec2_api,)
 
 
 sample_invalid_client_token_result = """\
@@ -656,6 +656,42 @@
 """
 
 
+sample_list_buckets_result = """\
+<?xml version="1.0" encoding="UTF-8"?>
+<ListAllMyBucketsResult xmlns="http://s3.amazonaws.com/doc/%s/">
+  <Owner>
+    <ID>bcaf1ffd86f41caff1a493dc2ad8c2c281e37522a640e161ca5fb16fd081034f</ID>
+    <DisplayName>webfile</DisplayName>
+  </Owner>
+  <Buckets>
+    <Bucket>
+      <Name>quotes</Name>
+      <CreationDate>2006-02-03T16:45:09.000Z</CreationDate>
+    </Bucket>
+    <Bucket>
+      <Name>samples</Name>
+      <CreationDate>2006-02-03T16:41:58.000Z</CreationDate>
+    </Bucket>
+  </Buckets>
+</ListAllMyBucketsResult>
+""" % (version.s3_api,)
+
+
+sample_s3_signature_mismatch = """\
+<?xml version="1.0" encoding="UTF-8"?>
+<Error>
+  <Code>SignatureDoesNotMatch</Code>
+  <Message>The request signature we calculated does not match the signature you provided. Check your key and signing method.</Message>
+  <StringToSignBytes>47 45 54 0a 31 42 32 4d 32 59 38 41 73 67 54 70 67 41 6d 59 37 50 68 43 66 67 3d 3d 0a 0a 54 68 75 2c 20 30 35 20 4e 6f 76 20 32 30 30 39 20 32 31 3a 33 33 3a 32 39 20 47 4d 54 0a 2f</StringToSignBytes>
+  <RequestId>AB9216C8640751B2</RequestId>
+  <HostId>sAPBpmFdsOsgUUwtSLsiT6KIwP1mPbmrYY0xUoahzJE263qmABkTaqzGhHddgOq5</HostId>
+  <SignatureProvided>ltowhdrbjaQ8dQc9VS5MxzJfsPJZi0BZHEzJC3r9pzU=</SignatureProvided>
+  <StringToSign>GET\n1B2M2Y8AsgTpgAmY7PhCfg==\n\nThu, 05 Nov 2009 21:33:29 GMT\n/</StringToSign>
+  <AWSAccessKeyId>SOMEKEYID</AWSAccessKeyId>
+</Error>
+"""
+
+
 sample_server_internal_error_result = """\
 <?xml version="1.0" encoding="UTF-8"?>
 <Error>

=== modified file 'txaws/tests/test_service.py'
--- txaws/tests/test_service.py	2009-08-28 20:07:55 +0000
+++ txaws/tests/test_service.py	2009-11-28 01:10:27 +0000
@@ -3,6 +3,7 @@
 
 from txaws.credentials import AWSCredentials
 from txaws.ec2.client import EC2Client
+from txaws.s3.client import S3Client
 from txaws.service import (AWSServiceEndpoint, AWSServiceRegion,
                            EC2_ENDPOINT_EU, EC2_ENDPOINT_US, REGION_EU)
 from txaws.testing.base import TXAWSTestCase
@@ -21,6 +22,11 @@
         self.assertEquals(endpoint.path, "/")
         self.assertEquals(endpoint.method, "GET")
 
+    def test_custom_method(self):
+        endpoint = AWSServiceEndpoint(
+            uri="http://service/endpoint", method="PUT")
+        self.assertEquals(endpoint.method, "PUT")
+
     def test_parse_uri(self):
         self.assertEquals(self.endpoint.scheme, "http")
         self.assertEquals(self.endpoint.host, "my.service")
@@ -34,11 +40,6 @@
         self.assertEquals(endpoint.port, 8080)
         self.assertEquals(endpoint.path, "/endpoint")
 
-    def test_custom_method(self):
-        endpoint = AWSServiceEndpoint(uri="http://service/endpoint",
-                                      method="PUT")
-        self.assertEquals(endpoint.method, "PUT")
-
     def test_get_uri(self):
         uri = self.endpoint.get_uri()
         self.assertEquals(uri, "http://my.service/da_endpoint")
@@ -49,13 +50,25 @@
         new_uri = endpoint.get_uri()
         self.assertEquals(new_uri, uri)
 
+    def test_set_host(self):
+        self.assertEquals(self.endpoint.host, "my.service")
+        self.endpoint.set_host("newhost.com")
+        self.assertEquals(self.endpoint.host, "newhost.com")
+
+    def test_get_host(self):
+        self.assertEquals(self.endpoint.host, self.endpoint.get_host())
+
     def test_set_path(self):
-        original_path = self.endpoint.path
         self.endpoint.set_path("/newpath")
         self.assertEquals(
             self.endpoint.get_uri(),
             "http://my.service/newpath")
 
+    def test_set_method(self):
+        self.assertEquals(self.endpoint.method, "GET")
+        self.endpoint.set_method("PUT")
+        self.assertEquals(self.endpoint.method, "PUT")
+
 
 class AWSServiceRegionTestCase(TXAWSTestCase):
 
@@ -74,25 +87,34 @@
         self.assertEquals(region.creds.secret_key, "quux")
 
     def test_creation_with_keys_and_creds(self):
+        """
+        creds take precedence over individual access key/secret key pairs.
+        """
         region = AWSServiceRegion(self.creds, access_key="baz",
                                   secret_key="quux")
-        self.assertEquals(self.creds.access_key, "foo")
-        self.assertEquals(self.creds.secret_key, "bar")
+        self.assertEquals(region.creds.access_key, "foo")
+        self.assertEquals(region.creds.secret_key, "bar")
 
     def test_creation_with_uri(self):
-        region = AWSServiceRegion(creds=self.creds, uri="http://foo/bar")
+        region = AWSServiceRegion(
+            creds=self.creds, ec2_uri="http://foo/bar")
+        self.assertEquals(region.ec2_endpoint.get_uri(), "http://foo/bar")
+
+    def test_creation_with_uri_backwards_compatible(self):
+        region = AWSServiceRegion(
+            creds=self.creds, uri="http://foo/bar")
         self.assertEquals(region.ec2_endpoint.get_uri(), "http://foo/bar")
 
     def test_creation_with_uri_and_region(self):
-        region = AWSServiceRegion(creds=self.creds, region=REGION_EU,
-                                  uri="http://foo/bar")
+        region = AWSServiceRegion(
+            creds=self.creds, region=REGION_EU, ec2_uri="http://foo/bar")
         self.assertEquals(region.ec2_endpoint.get_uri(), "http://foo/bar")
 
     def test_creation_with_region_override(self):
         region = AWSServiceRegion(creds=self.creds, region=REGION_EU)
         self.assertEquals(region.ec2_endpoint.get_uri(), EC2_ENDPOINT_EU)
 
-    def test_get_client_with_empty_cache(self):
+    def test_get_ec2_client_with_empty_cache(self):
         key = str(EC2Client) + str(self.creds) + str(self.region.ec2_endpoint)
         original_client = self.region._clients.get(key)
         new_client = self.region.get_client(
@@ -101,7 +123,14 @@
         self.assertTrue(isinstance(new_client, EC2Client))
         self.assertNotEquals(original_client, new_client)
 
-    def test_get_client_from_cache(self):
+    def test_get_ec2_client_from_cache_default(self):
+        client1 = self.region.get_ec2_client()
+        client2 = self.region.get_ec2_client()
+        self.assertTrue(isinstance(client1, EC2Client))
+        self.assertTrue(isinstance(client2, EC2Client))
+        self.assertEquals(client1, client2)
+
+    def test_get_ec2_client_from_cache(self):
         client1 = self.region.get_client(
             EC2Client, creds=self.creds, endpoint=self.region.ec2_endpoint)
         client2 = self.region.get_client(
@@ -110,7 +139,7 @@
         self.assertTrue(isinstance(client2, EC2Client))
         self.assertEquals(client1, client2)
 
-    def test_get_client_from_cache_with_purge(self):
+    def test_get_ec2_client_from_cache_with_purge(self):
         client1 = self.region.get_client(
             EC2Client, creds=self.creds, endpoint=self.region.ec2_endpoint,
             purge_cache=True)
@@ -121,10 +150,11 @@
         self.assertTrue(isinstance(client2, EC2Client))
         self.assertNotEquals(client1, client2)
 
-    def test_get_ec2_client_from_cache(self):
-        client1 = self.region.get_ec2_client(self.creds)
-        client2 = self.region.get_ec2_client(self.creds)
-        self.assertEquals(self.creds, self.region.creds)
-        self.assertTrue(isinstance(client1, EC2Client))
-        self.assertTrue(isinstance(client2, EC2Client))
-        self.assertEquals(client1, client2)
+    def test_get_s3_client_with_empty_cache(self):
+        key = str(S3Client) + str(self.creds) + str(self.region.s3_endpoint)
+        original_client = self.region._clients.get(key)
+        new_client = self.region.get_client(
+            S3Client, creds=self.creds, endpoint=self.region.s3_endpoint)
+        self.assertEquals(original_client, None)
+        self.assertTrue(isinstance(new_client, S3Client))
+        self.assertNotEquals(original_client, new_client)

=== modified file 'txaws/tests/test_util.py'
--- txaws/tests/test_util.py	2009-09-05 00:26:12 +0000
+++ txaws/tests/test_util.py	2009-11-28 01:10:27 +0000
@@ -63,7 +63,7 @@
         elements of its return tuple, even when passed an URL which has
         previously been passed to L{urlparse} as a C{unicode} string.
         """
-        badInput = u"http://example.com/path"
+        badInput = u"http://example1.com/path"
         goodInput = badInput.encode("ascii")
         urlparse(badInput)
         scheme, host, port, path = parse(goodInput)

=== modified file 'txaws/util.py'
--- txaws/util.py	2009-10-21 19:40:18 +0000
+++ txaws/util.py	2009-11-28 01:10:27 +0000
@@ -93,4 +93,4 @@
             port = defaultPort
     if path == "":
         path = "/"
-    return scheme, host, port, path
+    return (str(scheme), str(host), port, str(path))

=== modified file 'txaws/version.py'
--- txaws/version.py	2009-08-31 20:07:58 +0000
+++ txaws/version.py	2009-11-28 01:10:27 +0000
@@ -1,2 +1,3 @@
 txaws = "0.0.1"
-aws_api = "2008-12-01"
+ec2_api = "2008-12-01"
+s3_api = "2006-03-01"