gcloud 0.0.4 → 0.0.6

data/packages/gsutil/boto/tests/integration/s3/test_mfa.py

@@ -0,0 +1,95 @@
+# Copyright (c) 2010 Mitch Garnaat http://garnaat.org/
+# Copyright (c) 2010, Eucalyptus Systems, Inc.
+# All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+"""
+Some unit tests for S3 MfaDelete with versioning
+"""
+
+import unittest
+import time
+from nose.plugins.attrib import attr
+
+from boto.s3.connection import S3Connection
+from boto.exception import S3ResponseError
+from boto.s3.deletemarker import DeleteMarker
+
+
+@attr('notdefault', 's3mfa')
+class S3MFATest (unittest.TestCase):
+
+    def setUp(self):
+        self.conn = S3Connection()
+        self.bucket_name = 'mfa-%d' % int(time.time())
+        self.bucket = self.conn.create_bucket(self.bucket_name)
+
+    def tearDown(self):
+        for k in self.bucket.list_versions():
+            self.bucket.delete_key(k.name, version_id=k.version_id)
+        self.bucket.delete()
+
+    def test_mfadel(self):
+        # Enable Versioning with MfaDelete
+        mfa_sn = raw_input('MFA S/N: ')
+        mfa_code = raw_input('MFA Code: ')
+        self.bucket.configure_versioning(True, mfa_delete=True, mfa_token=(mfa_sn, mfa_code))
+
+        # Check enabling mfa worked.
+        i = 0
+        for i in range(1, 8):
+            time.sleep(2**i)
+            d = self.bucket.get_versioning_status()
+            if d['Versioning'] == 'Enabled' and d['MfaDelete'] == 'Enabled':
+                break
+        self.assertEqual('Enabled', d['Versioning'])
+        self.assertEqual('Enabled', d['MfaDelete'])
+
+        # Add a key to the bucket
+        k = self.bucket.new_key('foobar')
+        s1 = 'This is v1'
+        k.set_contents_from_string(s1)
+        v1 = k.version_id
+
+        # Now try to delete v1 without the MFA token
+        try:
+            self.bucket.delete_key('foobar', version_id=v1)
+            self.fail("Must fail if not using MFA token")
+        except S3ResponseError:
+            pass
+
+        # Now try delete again with the MFA token
+        mfa_code = raw_input('MFA Code: ')
+        self.bucket.delete_key('foobar', version_id=v1, mfa_token=(mfa_sn, mfa_code))
+
+        # Next suspend versioning and disable MfaDelete on the bucket
+        mfa_code = raw_input('MFA Code: ')
+        self.bucket.configure_versioning(False, mfa_delete=False, mfa_token=(mfa_sn, mfa_code))
+
+        # Lastly, check disabling mfa worked.
+        i = 0
+        for i in range(1, 8):
+            time.sleep(2**i)
+            d = self.bucket.get_versioning_status()
+            if d['Versioning'] == 'Suspended' and d['MfaDelete'] != 'Enabled':
+                break
+        self.assertEqual('Suspended', d['Versioning'])
+        self.assertNotEqual('Enabled', d['MfaDelete'])

data/packages/gsutil/boto/tests/integration/s3/test_multidelete.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2011 Mitch Garnaat http://garnaat.org/
+# All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+"""
+Some unit tests for the S3 MultiDelete
+"""
+
+import unittest
+import time
+from boto.s3.key import Key
+from boto.s3.deletemarker import DeleteMarker
+from boto.s3.prefix import Prefix
+from boto.s3.connection import S3Connection
+from boto.exception import S3ResponseError
+
+class S3MultiDeleteTest(unittest.TestCase):
+    s3 = True
+
+    def setUp(self):
+        self.conn = S3Connection()
+        self.bucket_name = 'multidelete-%d' % int(time.time())
+        self.bucket = self.conn.create_bucket(self.bucket_name)
+
+    def tearDown(self):
+        for key in self.bucket:
+            key.delete()
+        self.bucket.delete()
+
+    def test_delete_nothing(self):
+        result = self.bucket.delete_keys([])
+        self.assertEqual(len(result.deleted), 0)
+        self.assertEqual(len(result.errors), 0)
+
+    def test_delete_illegal(self):
+        result = self.bucket.delete_keys([{"dict":"notallowed"}])
+        self.assertEqual(len(result.deleted), 0)
+        self.assertEqual(len(result.errors), 1)
+
+    def test_delete_mix(self):
+        result = self.bucket.delete_keys(["king",
+                                          ("mice", None),
+                                          Key(name="regular"),
+                                          Key(),
+                                          Prefix(name="folder/"),
+                                          DeleteMarker(name="deleted"),
+                                          {"bad":"type"}])
+        self.assertEqual(len(result.deleted), 4)
+        self.assertEqual(len(result.errors), 3)
+
+    def test_delete_quietly(self):
+        result = self.bucket.delete_keys(["king"], quiet=True)
+        self.assertEqual(len(result.deleted), 0)
+        self.assertEqual(len(result.errors), 0)
+
+    def test_delete_must_escape(self):
+        result = self.bucket.delete_keys([Key(name=">_<;")])
+        self.assertEqual(len(result.deleted), 1)
+        self.assertEqual(len(result.errors), 0)
+
+    def test_delete_unknown_version(self):
+        no_ver = Key(name="no")
+        no_ver.version_id = "version"
+        result = self.bucket.delete_keys([no_ver])
+        self.assertEqual(len(result.deleted), 0)
+        self.assertEqual(len(result.errors), 1)
+
+    def test_delete_kanji(self):
+        result = self.bucket.delete_keys([u"漢字", Key(name=u"日本語")])
+        self.assertEqual(len(result.deleted), 2)
+        self.assertEqual(len(result.errors), 0)
+
+    def test_delete_empty_by_list(self):
+        result = self.bucket.delete_keys(self.bucket.list())
+        self.assertEqual(len(result.deleted), 0)
+        self.assertEqual(len(result.errors), 0)
+
+    def test_delete_kanji_by_list(self):
+        for key_name in [u"漢字", u"日本語", u"テスト"]:
+            key = self.bucket.new_key(key_name)
+            key.set_contents_from_string('this is a test')
+        result = self.bucket.delete_keys(self.bucket.list())
+        self.assertEqual(len(result.deleted), 3)
+        self.assertEqual(len(result.errors), 0)
+
+    def test_delete_with_prefixes(self):
+        for key_name in ["a", "a/b", "b"]:
+            key = self.bucket.new_key(key_name)
+            key.set_contents_from_string('this is a test')
+
+        # First delete all "files": "a" and "b"
+        result = self.bucket.delete_keys(self.bucket.list(delimiter="/"))
+        self.assertEqual(len(result.deleted), 2)
+        # Using delimiter will cause 1 common prefix to be listed
+        # which will be skipped as an error.
+        self.assertEqual(len(result.errors), 1)
+        self.assertEqual(result.errors[0].key, "a/")
+
+        # Next delete any remaining objects: "a/b"
+        result = self.bucket.delete_keys(self.bucket.list())
+        self.assertEqual(len(result.deleted), 1)
+        self.assertEqual(len(result.errors), 0)
+        self.assertEqual(result.deleted[0].key, "a/b")
+
+    def test_delete_too_many_versions(self):
+        # configure versioning first
+        self.bucket.configure_versioning(True)
+
+        # Add 1000 initial versions as DMs by deleting them :-)
+        # Adding 1000 objects is painful otherwise...
+        key_names = ['key-%03d' % i for i in range(0, 1000)]
+        result = self.bucket.delete_keys(key_names)
+        self.assertEqual(len(result.deleted), 1000)
+        self.assertEqual(len(result.errors), 0)
+
+        # delete them again to create 1000 more delete markers
+        result = self.bucket.delete_keys(key_names)
+        self.assertEqual(len(result.deleted), 1000)
+        self.assertEqual(len(result.errors), 0)
+
+        # Sometimes takes AWS sometime to settle
+        time.sleep(10)
+
+        # delete all versions to delete 2000 objects.
+        # this tests the 1000 limit.
+        result = self.bucket.delete_keys(self.bucket.list_versions())
+        self.assertEqual(len(result.deleted), 2000)
+        self.assertEqual(len(result.errors), 0)
+
+    def test_1(self):
+        nkeys = 100
+        
+        # create a bunch of keynames
+        key_names = ['key-%03d' % i for i in range(0, nkeys)]
+
+        # create the corresponding keys
+        for key_name in key_names:
+            key = self.bucket.new_key(key_name)
+            key.set_contents_from_string('this is a test')
+
+        # now count keys in bucket
+        n = 0
+        for key in self.bucket:
+            n += 1
+
+        self.assertEqual(n, nkeys)
+
+        # now delete them all
+        result = self.bucket.delete_keys(key_names)
+
+        self.assertEqual(len(result.deleted), nkeys)
+        self.assertEqual(len(result.errors), 0)
+        
+        time.sleep(5)
+        
+        # now count keys in bucket
+        n = 0
+        for key in self.bucket:
+            n += 1
+
+        self.assertEqual(n, 0)

data/packages/gsutil/boto/tests/integration/s3/test_multipart.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2011 Mitch Garnaat http://garnaat.org/
+# All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+"""
+Some unit tests for the S3 MultiPartUpload
+"""
+
+# Note:
+# Multipart uploads require at least one part. If you upload
+# multiple parts then all parts except the last part has to be
+# bigger than 5M. Hence we just use 1 part so we can keep
+# things small and still test logic.
+
+import unittest
+import time
+import StringIO
+from boto.s3.connection import S3Connection
+
+
+class S3MultiPartUploadTest(unittest.TestCase):
+    s3 = True
+
+    def setUp(self):
+        self.conn = S3Connection(is_secure=False)
+        self.bucket_name = 'multipart-%d' % int(time.time())
+        self.bucket = self.conn.create_bucket(self.bucket_name)
+
+    def tearDown(self):
+        for key in self.bucket:
+            key.delete()
+        self.bucket.delete()
+
+    def test_abort(self):
+        key_name = u"テスト"
+        mpu = self.bucket.initiate_multipart_upload(key_name)
+        mpu.cancel_upload()
+
+    def test_complete_ascii(self):
+        key_name = "test"
+        mpu = self.bucket.initiate_multipart_upload(key_name)
+        fp = StringIO.StringIO("small file")
+        mpu.upload_part_from_file(fp, part_num=1)
+        fp.close()
+        cmpu = mpu.complete_upload()
+        self.assertEqual(cmpu.key_name, key_name)
+        self.assertNotEqual(cmpu.etag, None)
+
+    def test_complete_japanese(self):
+        key_name = u"テスト"
+        mpu = self.bucket.initiate_multipart_upload(key_name)
+        fp = StringIO.StringIO("small file")
+        mpu.upload_part_from_file(fp, part_num=1)
+        fp.close()
+        cmpu = mpu.complete_upload()
+        # LOL... just found an Amazon bug when it returns the
+        # key in the completemultipartupload result. AWS returns
+        # ??? instead of the correctly encoded key name. We should
+        # fix this to the comment line below when amazon fixes this
+        # and this test starts failing due to below assertion.
+        self.assertEqual(cmpu.key_name, "???")
+        #self.assertEqual(cmpu.key_name, key_name)
+        self.assertNotEqual(cmpu.etag, None)
+
+    def test_list_japanese(self):
+        key_name = u"テスト"
+        mpu = self.bucket.initiate_multipart_upload(key_name)
+        rs = self.bucket.list_multipart_uploads()
+        # New bucket, so only one upload expected
+        lmpu = iter(rs).next()
+        self.assertEqual(lmpu.id, mpu.id)
+        self.assertEqual(lmpu.key_name, key_name)
+        # Abort using the one returned in the list
+        lmpu.cancel_upload()
+
+    def test_list_multipart_uploads(self):
+        key_name = u"テスト"
+        mpus = []
+        mpus.append(self.bucket.initiate_multipart_upload(key_name))
+        mpus.append(self.bucket.initiate_multipart_upload(key_name))
+        rs = self.bucket.list_multipart_uploads()
+        # uploads (for a key) are returned in time initiated asc order
+        for lmpu in rs:
+            ompu = mpus.pop(0)
+            self.assertEqual(lmpu.key_name, ompu.key_name)
+            self.assertEqual(lmpu.id, ompu.id)
+        self.assertEqual(0, len(mpus))
+
+    def test_four_part_file(self):
+        key_name = "k"
+        contents = "01234567890123456789"
+        sfp = StringIO.StringIO(contents)
+
+        # upload 20 bytes in 4 parts of 5 bytes each
+        mpu = self.bucket.initiate_multipart_upload(key_name)
+        mpu.upload_part_from_file(sfp, part_num=1, size=5)
+        mpu.upload_part_from_file(sfp, part_num=2, size=5)
+        mpu.upload_part_from_file(sfp, part_num=3, size=5)
+        mpu.upload_part_from_file(sfp, part_num=4, size=5)
+        sfp.close()
+
+        etags = {}
+        pn = 0
+        for part in mpu:
+            pn += 1
+            self.assertEqual(5, part.size)
+            etags[pn] = part.etag
+        self.assertEqual(pn, 4)
+        # etags for 01234
+        self.assertEqual(etags[1], etags[3])
+        # etags for 56789
+        self.assertEqual(etags[2], etags[4])
+        # etag 01234 != etag 56789
+        self.assertNotEqual(etags[1], etags[2])
+
+        # parts are too small to compete as each part must
+        # be a min of 5MB so so we'll assume that is enough
+        # testing and abort the upload.
+        mpu.cancel_upload()

data/packages/gsutil/boto/tests/integration/s3/test_pool.py

@@ -0,0 +1,246 @@
+# Copyright (c) 2011 Brian Beach
+# All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+"""
+Some multi-threading tests of boto in a greenlet environment.
+"""
+
+import boto
+import time
+import uuid
+
+from StringIO import StringIO
+
+from threading import Thread
+
+def spawn(function, *args, **kwargs):
+    """
+    Spawns a new thread.  API is the same as
+    gevent.greenlet.Greenlet.spawn.
+    """
+    t = Thread(target = function, args = args, kwargs = kwargs)
+    t.start()
+    return t
+
+def put_object(bucket, name):
+    bucket.new_key(name).set_contents_from_string(name)
+
+def get_object(bucket, name):
+    assert bucket.get_key(name).get_contents_as_string() == name
+
+def test_close_connections():
+    """
+    A test that exposes the problem where connections are returned to the
+    connection pool (and closed) before the caller reads the response.
+    
+    I couldn't think of a way to test it without greenlets, so this test
+    doesn't run as part of the standard test suite.  That way, no more
+    dependencies are added to the test suite.
+    """
+    
+    print "Running test_close_connections"
+
+    # Connect to S3
+    s3 = boto.connect_s3()
+
+    # Clean previous tests.
+    for b in s3.get_all_buckets():
+        if b.name.startswith('test-'):
+            for key in b.get_all_keys():
+                key.delete()
+            b.delete()
+
+    # Make a test bucket
+    bucket = s3.create_bucket('test-%d' % int(time.time()))
+
+    # Create 30 threads that each create an object in S3.  The number
+    # 30 is chosen because it is larger than the connection pool size
+    # (20). 
+    names = [str(uuid.uuid4) for _ in range(30)]
+    threads = [
+        spawn(put_object, bucket, name)
+        for name in names
+        ]
+    for t in threads:
+        t.join()
+
+    # Create 30 threads to read the contents of the new objects.  This
+    # is where closing the connection early is a problem, because
+    # there is a response that needs to be read, and it can't be read
+    # if the connection has already been closed.
+    threads = [
+        spawn(get_object, bucket, name)
+        for name in names
+        ]
+    for t in threads:
+        t.join()
+
+# test_reuse_connections needs to read a file that is big enough that
+# one read() call on the socket won't read the whole thing.  
+BIG_SIZE = 10000
+
+class WriteAndCount(object):
+
+    """
+    A file-like object that counts the number of characters written.
+    """
+
+    def __init__(self):
+        self.size = 0
+
+    def write(self, data):
+        self.size += len(data)
+        time.sleep(0) # yield to other threads
+
+def read_big_object(s3, bucket, name, count):
+    for _ in range(count):
+        key = bucket.get_key(name)
+        out = WriteAndCount()
+        key.get_contents_to_file(out)
+        if out.size != BIG_SIZE:
+            print out.size, BIG_SIZE
+        assert out.size == BIG_SIZE
+        print "    pool size:", s3._pool.size()
+
+class LittleQuerier(object):
+
+    """
+    An object that manages a thread that keeps pulling down small
+    objects from S3 and checking the answers until told to stop.
+    """
+
+    def __init__(self, bucket, small_names):
+        self.running = True
+        self.bucket = bucket
+        self.small_names = small_names
+        self.thread = spawn(self.run)
+
+    def stop(self):
+        self.running = False
+        self.thread.join()
+
+    def run(self):
+        count = 0
+        while self.running:
+            i = count % 4
+            key = self.bucket.get_key(self.small_names[i])
+            expected = str(i)
+            rh = { 'response-content-type' : 'small/' + str(i) }
+            actual = key.get_contents_as_string(response_headers = rh)
+            if expected != actual:
+                print "AHA:", repr(expected), repr(actual)
+            assert expected == actual
+            count += 1
+
+def test_reuse_connections():
+    """
+    This test is an attempt to expose problems because of the fact
+    that boto returns connections to the connection pool before
+    reading the response.  The strategy is to start a couple big reads
+    from S3, where it will take time to read the response, and then
+    start other requests that will reuse the same connection from the
+    pool while the big response is still being read.
+
+    The test passes because of an interesting combination of factors.
+    I was expecting that it would fail because two threads would be
+    reading the same connection at the same time.  That doesn't happen
+    because httplib catches the problem before it happens and raises
+    an exception.
+
+    Here's the sequence of events:
+
+       - Thread 1: Send a request to read a big S3 object.
+       - Thread 1: Returns connection to pool.
+       - Thread 1: Start reading the body if the response.
+
+       - Thread 2: Get the same connection from the pool.
+       - Thread 2: Send another request on the same connection.
+       - Thread 2: Try to read the response, but
+                   HTTPConnection.get_response notices that the
+                   previous response isn't done reading yet, and
+                   raises a ResponseNotReady exception.
+       - Thread 2: _mexe catches the exception, does not return the
+                   connection to the pool, gets a new connection, and
+                   retries.
+
+       - Thread 1: Finish reading the body of its response.
+       
+       - Server:   Gets the second request on the connection, and
+                   sends a response.  This response is ignored because
+                   the connection has been dropped on the client end.
+
+    If you add a print statement in HTTPConnection.get_response at the
+    point where it raises ResponseNotReady, and then run this test,
+    you can see that it's happening.
+    """
+
+    print "Running test_reuse_connections"
+
+    # Connect to S3
+    s3 = boto.connect_s3()
+
+    # Make a test bucket
+    bucket = s3.create_bucket('test-%d' % int(time.time()))
+
+    # Create some small objects in S3.
+    small_names = [str(uuid.uuid4()) for _ in range(4)]
+    for (i, name) in enumerate(small_names):
+        bucket.new_key(name).set_contents_from_string(str(i))
+
+    # Wait, clean the connection pool, and make sure it's empty.
+    print "    waiting for all connections to become stale"
+    time.sleep(s3._pool.STALE_DURATION + 1)
+    s3._pool.clean()
+    assert s3._pool.size() == 0
+    print "    pool is empty"
+    
+    # Create a big object in S3.
+    big_name = str(uuid.uuid4())
+    contents = "-" * BIG_SIZE
+    bucket.new_key(big_name).set_contents_from_string(contents)
+
+    # Start some threads to read it and check that they are reading
+    # the correct thing.  Each thread will read the object 40 times.
+    threads = [
+        spawn(read_big_object, s3, bucket, big_name, 20)
+        for _ in range(5)
+        ]
+
+    # Do some other things that may (incorrectly) re-use the same
+    # connections while the big objects are being read.
+    queriers = [
+        LittleQuerier(bucket, small_names)
+        for _ in range(5)
+        ]
+
+    # Clean up.
+    for t in threads:
+        t.join()
+    for q in queriers:
+        q.stop()
+
+def main():
+    test_close_connections()
+    test_reuse_connections()
+
+if __name__ == '__main__':
+    main()