gcloud 0.0.4 → 0.0.6

data/packages/gsutil/boto/tests/integration/s3/other_cacerts.txt

@@ -0,0 +1,70 @@
+# Certifcate Authority certificates for validating SSL connections.
+#
+# This file contains PEM format certificates generated from
+# http://mxr.mozilla.org/seamonkey/source/security/nss/lib/ckfw/builtins/certdata.txt
+#
+# ***** BEGIN LICENSE BLOCK *****
+# Version: MPL 1.1/GPL 2.0/LGPL 2.1
+#
+# The contents of this file are subject to the Mozilla Public License Version
+# 1.1 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+# for the specific language governing rights and limitations under the
+# License.
+#
+# The Original Code is the Netscape security libraries.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1994-2000
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#
+# Alternatively, the contents of this file may be used under the terms of
+# either the GNU General Public License Version 2 or later (the "GPL"), or
+# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+# in which case the provisions of the GPL or the LGPL are applicable instead
+# of those above. If you wish to allow use of your version of this file only
+# under the terms of either the GPL or the LGPL, and not to allow others to
+# use your version of this file under the terms of the MPL, indicate your
+# decision by deleting the provisions above and replace them with the notice
+# and other provisions required by the GPL or the LGPL. If you do not delete
+# the provisions above, a recipient may use your version of this file under
+# the terms of any one of the MPL, the GPL or the LGPL.
+#
+# ***** END LICENSE BLOCK *****
+
+
+Comodo CA Limited, CN=Trusted Certificate Services
+==================================================
+
+-----BEGIN CERTIFICATE-----
+MIIEQzCCAyugAwIBAgIBATANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJHQjEb
+MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
+GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDElMCMGA1UEAwwcVHJ1c3RlZCBDZXJ0
+aWZpY2F0ZSBTZXJ2aWNlczAeFw0wNDAxMDEwMDAwMDBaFw0yODEyMzEyMzU5NTla
+MH8xCzAJBgNVBAYTAkdCMRswGQYDVQQIDBJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAO
+BgNVBAcMB1NhbGZvcmQxGjAYBgNVBAoMEUNvbW9kbyBDQSBMaW1pdGVkMSUwIwYD
+VQQDDBxUcnVzdGVkIENlcnRpZmljYXRlIFNlcnZpY2VzMIIBIjANBgkqhkiG9w0B
+AQEFAAOCAQ8AMIIBCgKCAQEA33FvNlhTWvI2VFeAxHQIIO0Yfyod5jWaHiWsnOWW
+fnJSoBVC21ndZHoa0Lh73TkVvFVIxO06AOoxEbrycXQaZ7jPM8yoMa+j49d/vzMt
+TGo87IvDktJTdyR0nAducPy9C1t2ul/y/9c3S0pgePfw+spwtOpZqqPOSC+pw7IL
+fhdyFgymBwwbOM/JYrc/oJOlh0Hyt3BAd9i+FHzjqMB6juljatEPmsbS9Is6FARW
+1O24zG71++IsWL1/T2sr92AkWCTOJu80kTrV44HQsvAEAtdbtz6SrGsSivnkBbA7
+kUlcsutT6vifR4buv5XAwAaf0lteERv0xwQ1KdJVXOTt6wIDAQABo4HJMIHGMB0G
+A1UdDgQWBBTFe1i97doladL3WRaoszLAeydb9DAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zCBgwYDVR0fBHwwejA8oDqgOIY2aHR0cDovL2NybC5jb21v
+ZG9jYS5jb20vVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMuY3JsMDqgOKA2hjRo
+dHRwOi8vY3JsLmNvbW9kby5uZXQvVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMu
+Y3JsMA0GCSqGSIb3DQEBBQUAA4IBAQDIk4E7ibSvuIQSTI3S8NtwuleGFTQQuS9/
+HrCoiWChisJ3DFBKmwCL2Iv0QeLQg4pKHBQGsKNoBXAxMKdTmw7pSqBYaWcOrp32
+pSxBvzwGa+RZzG0Q8ZZvH9/0BAKkn0U+yNj6NkZEUD+Cl5EfKNsYEYwq5GWDVxIS
+jBc/lDb+XbDABHcTuPQV1T84zJQ6VdCsmPW6AF/ghhmBeC8owH7TzEIK9a5QoNE+
+xqFx7D+gIIxmOom0jtTYsU0lR+4viMi14QVFwL4Ucd56/Y57fU0IlqUSc/Atyjcn
+dBInTMu2l+nZrghtWjlA3QVHdWpaIbOjGM9O9y5Xt5hwXsjEeLBi
+-----END CERTIFICATE-----

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

@@ -0,0 +1,263 @@
+# -*- 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 Bucket
+"""
+
+import unittest
+import time
+
+from boto.exception import S3ResponseError
+from boto.s3.connection import S3Connection
+from boto.s3.bucketlogging import BucketLogging
+from boto.s3.lifecycle import Lifecycle
+from boto.s3.lifecycle import Transition
+from boto.s3.lifecycle import Rule
+from boto.s3.acl import Grant
+from boto.s3.tagging import Tags, TagSet
+from boto.s3.lifecycle import Lifecycle, Expiration, Transition
+from boto.s3.website import RedirectLocation
+
+
+class S3BucketTest (unittest.TestCase):
+    s3 = True
+
+    def setUp(self):
+        self.conn = S3Connection()
+        self.bucket_name = 'bucket-%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_next_marker(self):
+        expected = ["a/", "b", "c"]
+        for key_name in expected:
+            key = self.bucket.new_key(key_name)
+            key.set_contents_from_string(key_name)
+
+        # Normal list of first 2 keys will have
+        # no NextMarker set, so we use last key to iterate
+        # last element will be "b" so no issue.
+        rs = self.bucket.get_all_keys(max_keys=2)
+        for element in rs:
+            pass
+        self.assertEqual(element.name, "b")
+        self.assertEqual(rs.next_marker, None)
+
+        # list using delimiter of first 2 keys will have
+        # a NextMarker set (when truncated). As prefixes
+        # are grouped together at the end, we get "a/" as
+        # last element, but luckily we have next_marker.
+        rs = self.bucket.get_all_keys(max_keys=2, delimiter="/")
+        for element in rs:
+            pass
+        self.assertEqual(element.name, "a/")
+        self.assertEqual(rs.next_marker, "b")
+
+        # ensure bucket.list() still works by just
+        # popping elements off the front of expected.
+        rs = self.bucket.list()
+        for element in rs:
+            self.assertEqual(element.name, expected.pop(0))
+        self.assertEqual(expected, [])
+
+    def test_logging(self):
+        # use self.bucket as the target bucket so that teardown
+        # will delete any log files that make it into the bucket
+        # automatically and all we have to do is delete the
+        # source bucket.
+        sb_name = "src-" + self.bucket_name
+        sb = self.conn.create_bucket(sb_name)
+        # grant log write perms to target bucket using canned-acl
+        self.bucket.set_acl("log-delivery-write")
+        target_bucket = self.bucket_name
+        target_prefix = u"jp/ログ/"
+        # Check existing status is disabled
+        bls = sb.get_logging_status()
+        self.assertEqual(bls.target, None)
+        # Create a logging status and grant auth users READ PERM
+        authuri = "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
+        authr = Grant(permission="READ", type="Group", uri=authuri)
+        sb.enable_logging(target_bucket, target_prefix=target_prefix, grants=[authr])
+        # Check the status and confirm its set.
+        bls = sb.get_logging_status()
+        self.assertEqual(bls.target, target_bucket)
+        self.assertEqual(bls.prefix, target_prefix)
+        self.assertEqual(len(bls.grants), 1)
+        self.assertEqual(bls.grants[0].type, "Group")
+        self.assertEqual(bls.grants[0].uri, authuri)
+        # finally delete the src bucket
+        sb.delete()
+
+    def test_tagging(self):
+        tagging = """
+            <Tagging>
+              <TagSet>
+                 <Tag>
+                   <Key>tagkey</Key>
+                   <Value>tagvalue</Value>
+                 </Tag>
+              </TagSet>
+            </Tagging>
+        """
+        self.bucket.set_xml_tags(tagging)
+        response = self.bucket.get_tags()
+        self.assertEqual(response[0][0].key, 'tagkey')
+        self.assertEqual(response[0][0].value, 'tagvalue')
+        self.bucket.delete_tags()
+        try:
+            self.bucket.get_tags()
+        except S3ResponseError, e:
+            self.assertEqual(e.code, 'NoSuchTagSet')
+        except Exception, e:
+            self.fail("Wrong exception raised (expected S3ResponseError): %s"
+                      % e)
+        else:
+            self.fail("Expected S3ResponseError, but no exception raised.")
+
+    def test_tagging_from_objects(self):
+        """Create tags from python objects rather than raw xml."""
+        t = Tags()
+        tag_set = TagSet()
+        tag_set.add_tag('akey', 'avalue')
+        tag_set.add_tag('anotherkey', 'anothervalue')
+        t.add_tag_set(tag_set)
+        self.bucket.set_tags(t)
+        response = self.bucket.get_tags()
+        self.assertEqual(response[0][0].key, 'akey')
+        self.assertEqual(response[0][0].value, 'avalue')
+        self.assertEqual(response[0][1].key, 'anotherkey')
+        self.assertEqual(response[0][1].value, 'anothervalue')
+
+    def test_website_configuration(self):
+        response = self.bucket.configure_website('index.html')
+        self.assertTrue(response)
+        config = self.bucket.get_website_configuration()
+        self.assertEqual(config, {'WebsiteConfiguration':
+                                  {'IndexDocument': {'Suffix': 'index.html'}}})
+        config2, xml = self.bucket.get_website_configuration_with_xml()
+        self.assertEqual(config, config2)
+        self.assertTrue('<Suffix>index.html</Suffix>' in xml, xml)
+
+    def test_website_redirect_all_requests(self):
+        response = self.bucket.configure_website(
+            redirect_all_requests_to=RedirectLocation('example.com'))
+        config = self.bucket.get_website_configuration()
+        self.assertEqual(config, {
+            'WebsiteConfiguration': {
+                'RedirectAllRequestsTo': {
+                    'HostName': 'example.com'}}})
+
+        # Can configure the protocol as well.
+        response = self.bucket.configure_website(
+            redirect_all_requests_to=RedirectLocation('example.com', 'https'))
+        config = self.bucket.get_website_configuration()
+        self.assertEqual(config, {
+            'WebsiteConfiguration': {'RedirectAllRequestsTo': {
+                'HostName': 'example.com',
+                'Protocol': 'https',
+            }}}
+        )
+
+    def test_lifecycle(self):
+        lifecycle = Lifecycle()
+        lifecycle.add_rule('myid', '', 'Enabled', 30)
+        self.assertTrue(self.bucket.configure_lifecycle(lifecycle))
+        response = self.bucket.get_lifecycle_config()
+        self.assertEqual(len(response), 1)
+        actual_lifecycle = response[0]
+        self.assertEqual(actual_lifecycle.id, 'myid')
+        self.assertEqual(actual_lifecycle.prefix, '')
+        self.assertEqual(actual_lifecycle.status, 'Enabled')
+        self.assertEqual(actual_lifecycle.transition, None)
+
+    def test_lifecycle_with_glacier_transition(self):
+        lifecycle = Lifecycle()
+        transition = Transition(days=30, storage_class='GLACIER')
+        rule = Rule('myid', prefix='', status='Enabled', expiration=None,
+                    transition=transition)
+        lifecycle.append(rule)
+        self.assertTrue(self.bucket.configure_lifecycle(lifecycle))
+        response = self.bucket.get_lifecycle_config()
+        transition = response[0].transition
+        self.assertEqual(transition.days, 30)
+        self.assertEqual(transition.storage_class, 'GLACIER')
+        self.assertEqual(transition.date, None)
+
+    def test_lifecycle_multi(self):
+        date = '2022-10-12T00:00:00.000Z'
+        sc = 'GLACIER'
+        lifecycle = Lifecycle()
+        lifecycle.add_rule("1", "1/", "Enabled", 1)
+        lifecycle.add_rule("2", "2/", "Enabled", Expiration(days=2))
+        lifecycle.add_rule("3", "3/", "Enabled", Expiration(date=date))
+        lifecycle.add_rule("4", "4/", "Enabled", None,
+            Transition(days=4, storage_class=sc))
+        lifecycle.add_rule("5", "5/", "Enabled", None,
+            Transition(date=date, storage_class=sc))
+        # set the lifecycle
+        self.bucket.configure_lifecycle(lifecycle)
+        # read the lifecycle back
+        readlifecycle = self.bucket.get_lifecycle_config();
+        for rule in readlifecycle:
+            if rule.id == "1":
+                self.assertEqual(rule.prefix, "1/")
+                self.assertEqual(rule.expiration.days, 1)
+            elif rule.id == "2":
+                self.assertEqual(rule.prefix, "2/")
+                self.assertEqual(rule.expiration.days, 2)
+            elif rule.id == "3":
+                self.assertEqual(rule.prefix, "3/")
+                self.assertEqual(rule.expiration.date, date)
+            elif rule.id == "4":
+                self.assertEqual(rule.prefix, "4/")
+                self.assertEqual(rule.transition.days, 4)
+                self.assertEqual(rule.transition.storage_class, sc)
+            elif rule.id == "5":
+                self.assertEqual(rule.prefix, "5/")
+                self.assertEqual(rule.transition.date, date)
+                self.assertEqual(rule.transition.storage_class, sc)
+            else:
+                self.fail("unexpected id %s" % rule.id)
+
+    def test_lifecycle_jp(self):
+        # test lifecycle with Japanese prefix
+        name = "Japanese files"
+        prefix = u"日本語/"
+        days = 30
+        lifecycle = Lifecycle()
+        lifecycle.add_rule(name, prefix, "Enabled", days)
+        # set the lifecycle
+        self.bucket.configure_lifecycle(lifecycle)
+        # read the lifecycle back
+        readlifecycle = self.bucket.get_lifecycle_config();
+        for rule in readlifecycle:
+            self.assertEqual(rule.id, name)
+            self.assertEqual(rule.expiration.days, days)
+            #Note: Boto seems correct? AWS seems broken?
+            #self.assertEqual(rule.prefix, prefix)

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

@@ -0,0 +1,40 @@
+# Copyright (c) 2012 Mitch Garnaat http://garnaat.org/
+# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.
+# All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+"""
+Check that all of the certs on SQS endpoints validate.
+"""
+
+import unittest
+import boto.s3
+
+
+class CertVerificationTest(unittest.TestCase):
+
+    s3 = True
+    ssl = True
+
+    def test_certs(self):
+        for region in boto.s3.regions():
+            c = region.connect()
+            c.get_all_buckets()

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

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2006-2011 Mitch Garnaat http://garnaat.org/
+#
+# 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 S3Connection
+"""
+
+import unittest
+import time
+import os
+import urllib
+import urlparse
+import httplib
+from boto.s3.connection import S3Connection
+from boto.s3.bucket import Bucket
+from boto.exception import S3PermissionsError, S3ResponseError
+
+
+class S3ConnectionTest (unittest.TestCase):
+    s3 = True
+
+    def test_1_basic(self):
+        print '--- running S3Connection tests ---'
+        c = S3Connection()
+        # create a new, empty bucket
+        bucket_name = 'test-%d' % int(time.time())
+        bucket = c.create_bucket(bucket_name)
+        # now try a get_bucket call and see if it's really there
+        bucket = c.get_bucket(bucket_name)
+        # test logging
+        logging_bucket = c.create_bucket(bucket_name + '-log')
+        logging_bucket.set_as_logging_target()
+        bucket.enable_logging(target_bucket=logging_bucket, target_prefix=bucket.name)
+        bucket.disable_logging()
+        c.delete_bucket(logging_bucket)
+        k = bucket.new_key('foobar')
+        s1 = 'This is a test of file upload and download'
+        s2 = 'This is a second string to test file upload and download'
+        k.set_contents_from_string(s1)
+        fp = open('foobar', 'wb')
+        # now get the contents from s3 to a local file
+        k.get_contents_to_file(fp)
+        fp.close()
+        fp = open('foobar')
+        # check to make sure content read from s3 is identical to original
+        assert s1 == fp.read(), 'corrupted file'
+        fp.close()
+        # test generated URLs
+        url = k.generate_url(3600)
+        file = urllib.urlopen(url)
+        assert s1 == file.read(), 'invalid URL %s' % url
+        url = k.generate_url(3600, force_http=True)
+        file = urllib.urlopen(url)
+        assert s1 == file.read(), 'invalid URL %s' % url
+        url = k.generate_url(3600, force_http=True, headers={'x-amz-x-token' : 'XYZ'})
+        file = urllib.urlopen(url)
+        assert s1 == file.read(), 'invalid URL %s' % url
+        rh = {'response-content-disposition': 'attachment; filename="foo.txt"'}
+        url = k.generate_url(60, response_headers=rh)
+        file = urllib.urlopen(url)
+        assert s1 == file.read(), 'invalid URL %s' % url
+        #test whether amperands and to-be-escaped characters work in header filename
+        rh = {'response-content-disposition': 'attachment; filename="foo&z%20ar&ar&zar&bar.txt"'}
+        url = k.generate_url(60, response_headers=rh, force_http=True)
+        file = urllib.urlopen(url)
+        assert s1 == file.read(), 'invalid URL %s' % url
+        # overwrite foobar contents with a PUT
+        url = k.generate_url(3600, 'PUT', force_http=True, policy='private', reduced_redundancy=True)
+        up = urlparse.urlsplit(url)
+        con = httplib.HTTPConnection(up.hostname, up.port)
+        con.request("PUT", up.path + '?' + up.query, body="hello there")
+        resp = con.getresponse()
+        assert 200 == resp.status
+        assert "hello there" == k.get_contents_as_string()
+        bucket.delete_key(k)
+        # test a few variations on get_all_keys - first load some data
+        # for the first one, let's override the content type
+        phony_mimetype = 'application/x-boto-test'
+        headers = {'Content-Type': phony_mimetype}
+        k.name = 'foo/bar'
+        k.set_contents_from_string(s1, headers)
+        k.name = 'foo/bas'
+        k.set_contents_from_filename('foobar')
+        k.name = 'foo/bat'
+        k.set_contents_from_string(s1)
+        k.name = 'fie/bar'
+        k.set_contents_from_string(s1)
+        k.name = 'fie/bas'
+        k.set_contents_from_string(s1)
+        k.name = 'fie/bat'
+        k.set_contents_from_string(s1)
+        # try resetting the contents to another value
+        md5 = k.md5
+        k.set_contents_from_string(s2)
+        assert k.md5 != md5
+        os.unlink('foobar')
+        all = bucket.get_all_keys()
+        assert len(all) == 6
+        rs = bucket.get_all_keys(prefix='foo')
+        assert len(rs) == 3
+        rs = bucket.get_all_keys(prefix='', delimiter='/')
+        assert len(rs) == 2
+        rs = bucket.get_all_keys(maxkeys=5)
+        assert len(rs) == 5
+        # test the lookup method
+        k = bucket.lookup('foo/bar')
+        assert isinstance(k, bucket.key_class)
+        assert k.content_type == phony_mimetype
+        k = bucket.lookup('notthere')
+        assert k == None
+        # try some metadata stuff
+        k = bucket.new_key('has_metadata')
+        mdkey1 = 'meta1'
+        mdval1 = 'This is the first metadata value'
+        k.set_metadata(mdkey1, mdval1)
+        mdkey2 = 'meta2'
+        mdval2 = 'This is the second metadata value'
+        k.set_metadata(mdkey2, mdval2)
+        # try a unicode metadata value
+        mdval3 = u'föö'
+        mdkey3 = 'meta3'
+        k.set_metadata(mdkey3, mdval3)
+        k.set_contents_from_string(s1)
+        k = bucket.lookup('has_metadata')
+        assert k.get_metadata(mdkey1) == mdval1
+        assert k.get_metadata(mdkey2) == mdval2
+        assert k.get_metadata(mdkey3) == mdval3
+        k = bucket.new_key('has_metadata')
+        k.get_contents_as_string()
+        assert k.get_metadata(mdkey1) == mdval1
+        assert k.get_metadata(mdkey2) == mdval2
+        assert k.get_metadata(mdkey3) == mdval3
+        bucket.delete_key(k)
+        # test list and iterator
+        rs1 = bucket.list()
+        num_iter = 0
+        for r in rs1:
+            num_iter = num_iter + 1
+        rs = bucket.get_all_keys()
+        num_keys = len(rs)
+        assert num_iter == num_keys
+        # try a key with a funny character
+        k = bucket.new_key('testnewline\n')
+        k.set_contents_from_string('This is a test')
+        rs = bucket.get_all_keys()
+        assert len(rs) == num_keys + 1
+        bucket.delete_key(k)
+        rs = bucket.get_all_keys()
+        assert len(rs) == num_keys
+        # try some acl stuff
+        bucket.set_acl('public-read')
+        policy = bucket.get_acl()
+        assert len(policy.acl.grants) == 2
+        bucket.set_acl('private')
+        policy = bucket.get_acl()
+        assert len(policy.acl.grants) == 1
+        k = bucket.lookup('foo/bar')
+        k.set_acl('public-read')
+        policy = k.get_acl()
+        assert len(policy.acl.grants) == 2
+        k.set_acl('private')
+        policy = k.get_acl()
+        assert len(policy.acl.grants) == 1
+        # try the convenience methods for grants
+        bucket.add_user_grant('FULL_CONTROL',
+                              'c1e724fbfa0979a4448393c59a8c055011f739b6d102fb37a65f26414653cd67')
+        try:
+            bucket.add_email_grant('foobar', 'foo@bar.com')
+        except S3PermissionsError:
+            pass
+        # now try to create an RRS key
+        k = bucket.new_key('reduced_redundancy')
+        k.set_contents_from_string('This key has reduced redundancy',
+                                   reduced_redundancy=True)
+
+        # now try to inject a response header
+        data = k.get_contents_as_string(response_headers={'response-content-type' : 'foo/bar'})
+        assert k.content_type == 'foo/bar'
+        
+        # now delete all keys in bucket
+        for k in bucket:
+            if k.name == 'reduced_redundancy':
+                assert k.storage_class == 'REDUCED_REDUNDANCY'
+            bucket.delete_key(k)
+        # now delete bucket
+        time.sleep(5)
+        c.delete_bucket(bucket)
+        print '--- tests completed ---'
+
+    def test_basic_anon(self):
+        auth_con = S3Connection()
+        # create a new, empty bucket
+        bucket_name = 'test-%d' % int(time.time())
+        auth_bucket = auth_con.create_bucket(bucket_name)
+
+        # try read the bucket anonymously
+        anon_con = S3Connection(anon=True)
+        anon_bucket = Bucket(anon_con, bucket_name)
+        try:
+            iter(anon_bucket.list()).next()
+            self.fail("anon bucket list should fail")
+        except S3ResponseError:
+            pass
+
+        # give bucket anon user access and anon read again
+        auth_bucket.set_acl('public-read')
+        try:
+            iter(anon_bucket.list()).next()
+            self.fail("not expecting contents")
+        except S3ResponseError, e:
+            self.fail("We should have public-read access, but received "
+                      "an error: %s" % e)
+        except StopIteration:
+            pass
+
+        # cleanup
+        auth_con.delete_bucket(auth_bucket)
+
+    def test_error_code_populated(self):
+        c = S3Connection()
+        try:
+            c.create_bucket('bad$bucket$name')
+        except S3ResponseError, e:
+            self.assertEqual(e.error_code, 'InvalidBucketName')
+        else:
+            self.fail("S3ResponseError not raised.")