googlecloud 0.0.4 → 0.0.6

data/packages/gsutil/boto/tests/unit/s3/test_tagging.py

@@ -0,0 +1,47 @@
+from tests.unit import AWSMockServiceTestCase
+
+from boto.s3.connection import S3Connection
+from boto.s3.bucket import Bucket
+from boto.s3.tagging import Tag
+
+
+class TestS3Tagging(AWSMockServiceTestCase):
+    connection_class = S3Connection
+
+    def default_body(self):
+        return """
+            <Tagging>
+              <TagSet>
+                 <Tag>
+                   <Key>Project</Key>
+                   <Value>Project One</Value>
+                 </Tag>
+                 <Tag>
+                   <Key>User</Key>
+                   <Value>jsmith</Value>
+                 </Tag>
+              </TagSet>
+            </Tagging>
+        """
+
+    def test_parse_tagging_response(self):
+        self.set_http_response(status_code=200)
+        b = Bucket(self.service_connection, 'mybucket')
+        api_response = b.get_tags()
+        # The outer list is a list of tag sets.
+        self.assertEqual(len(api_response), 1)
+        # The inner list is a list of tags.
+        self.assertEqual(len(api_response[0]), 2)
+        self.assertEqual(api_response[0][0].key, 'Project')
+        self.assertEqual(api_response[0][0].value, 'Project One')
+        self.assertEqual(api_response[0][1].key, 'User')
+        self.assertEqual(api_response[0][1].value, 'jsmith')
+
+    def test_tag_equality(self):
+        t1 = Tag('foo', 'bar')
+        t2 = Tag('foo', 'bar')
+        t3 = Tag('foo', 'baz')
+        t4 = Tag('baz', 'bar')
+        self.assertEqual(t1, t2)
+        self.assertNotEqual(t1, t3)
+        self.assertNotEqual(t1, t4)

data/packages/gsutil/boto/tests/unit/s3/test_uri.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python
+# Copyright (c) 2013 Google, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import boto
+import tempfile
+import urllib
+from boto.exception import InvalidUriError
+from boto import storage_uri
+from boto.s3.keyfile import KeyFile
+from tests.integration.s3.mock_storage_service import MockBucket
+from tests.integration.s3.mock_storage_service import MockBucketStorageUri
+from tests.integration.s3.mock_storage_service import MockConnection
+from tests.unit import unittest
+
+"""Unit tests for StorageUri interface."""
+
+class UriTest(unittest.TestCase):
+
+    def test_provider_uri(self):
+        for prov in ('gs', 's3'):
+            uri_str = '%s://' % prov
+            uri = boto.storage_uri(uri_str, validate=False,
+                suppress_consec_slashes=False)
+            self.assertEqual(prov, uri.scheme)
+            self.assertEqual(uri_str, uri.uri)
+            self.assertFalse(hasattr(uri, 'versionless_uri'))
+            self.assertEqual('', uri.bucket_name)
+            self.assertEqual('', uri.object_name)
+            self.assertEqual(None, uri.version_id)
+            self.assertEqual(None, uri.generation)
+            self.assertEqual(uri.names_provider(), True)
+            self.assertEqual(uri.names_container(), True)
+            self.assertEqual(uri.names_bucket(), False)
+            self.assertEqual(uri.names_object(), False)
+            self.assertEqual(uri.names_directory(), False)
+            self.assertEqual(uri.names_file(), False)
+            self.assertEqual(uri.is_stream(), False)
+            self.assertEqual(uri.is_version_specific, False)
+
+    def test_bucket_uri_no_trailing_slash(self):
+        for prov in ('gs', 's3'):
+            uri_str = '%s://bucket' % prov
+            uri = boto.storage_uri(uri_str, validate=False,
+                suppress_consec_slashes=False)
+            self.assertEqual(prov, uri.scheme)
+            self.assertEqual('%s/' % uri_str, uri.uri)
+            self.assertFalse(hasattr(uri, 'versionless_uri'))
+            self.assertEqual('bucket', uri.bucket_name)
+            self.assertEqual('', uri.object_name)
+            self.assertEqual(None, uri.version_id)
+            self.assertEqual(None, uri.generation)
+            self.assertEqual(uri.names_provider(), False)
+            self.assertEqual(uri.names_container(), True)
+            self.assertEqual(uri.names_bucket(), True)
+            self.assertEqual(uri.names_object(), False)
+            self.assertEqual(uri.names_directory(), False)
+            self.assertEqual(uri.names_file(), False)
+            self.assertEqual(uri.is_stream(), False)
+            self.assertEqual(uri.is_version_specific, False)
+
+    def test_bucket_uri_with_trailing_slash(self):
+        for prov in ('gs', 's3'):
+            uri_str = '%s://bucket/' % prov
+            uri = boto.storage_uri(uri_str, validate=False,
+                suppress_consec_slashes=False)
+            self.assertEqual(prov, uri.scheme)
+            self.assertEqual(uri_str, uri.uri)
+            self.assertFalse(hasattr(uri, 'versionless_uri'))
+            self.assertEqual('bucket', uri.bucket_name)
+            self.assertEqual('', uri.object_name)
+            self.assertEqual(None, uri.version_id)
+            self.assertEqual(None, uri.generation)
+            self.assertEqual(uri.names_provider(), False)
+            self.assertEqual(uri.names_container(), True)
+            self.assertEqual(uri.names_bucket(), True)
+            self.assertEqual(uri.names_object(), False)
+            self.assertEqual(uri.names_directory(), False)
+            self.assertEqual(uri.names_file(), False)
+            self.assertEqual(uri.is_stream(), False)
+            self.assertEqual(uri.is_version_specific, False)
+
+    def test_non_versioned_object_uri(self):
+        for prov in ('gs', 's3'):
+            uri_str = '%s://bucket/obj/a/b' % prov
+            uri = boto.storage_uri(uri_str, validate=False,
+                suppress_consec_slashes=False)
+            self.assertEqual(prov, uri.scheme)
+            self.assertEqual(uri_str, uri.uri)
+            self.assertEqual(uri_str, uri.versionless_uri)
+            self.assertEqual('bucket', uri.bucket_name)
+            self.assertEqual('obj/a/b', uri.object_name)
+            self.assertEqual(None, uri.version_id)
+            self.assertEqual(None, uri.generation)
+            self.assertEqual(uri.names_provider(), False)
+            self.assertEqual(uri.names_container(), False)
+            self.assertEqual(uri.names_bucket(), False)
+            self.assertEqual(uri.names_object(), True)
+            self.assertEqual(uri.names_directory(), False)
+            self.assertEqual(uri.names_file(), False)
+            self.assertEqual(uri.is_stream(), False)
+            self.assertEqual(uri.is_version_specific, False)
+
+    def test_versioned_gs_object_uri(self):
+        uri_str = 'gs://bucket/obj/a/b#1359908801674000'
+        uri = boto.storage_uri(uri_str, validate=False,
+            suppress_consec_slashes=False)
+        self.assertEqual('gs', uri.scheme)
+        self.assertEqual(uri_str, uri.uri)
+        self.assertEqual('gs://bucket/obj/a/b', uri.versionless_uri)
+        self.assertEqual('bucket', uri.bucket_name)
+        self.assertEqual('obj/a/b', uri.object_name)
+        self.assertEqual(None, uri.version_id)
+        self.assertEqual(1359908801674000, uri.generation)
+        self.assertEqual(uri.names_provider(), False)
+        self.assertEqual(uri.names_container(), False)
+        self.assertEqual(uri.names_bucket(), False)
+        self.assertEqual(uri.names_object(), True)
+        self.assertEqual(uri.names_directory(), False)
+        self.assertEqual(uri.names_file(), False)
+        self.assertEqual(uri.is_stream(), False)
+        self.assertEqual(uri.is_version_specific, True)
+
+    def test_versioned_gs_object_uri_with_legacy_generation_value(self):
+        uri_str = 'gs://bucket/obj/a/b#1'
+        uri = boto.storage_uri(uri_str, validate=False,
+            suppress_consec_slashes=False)
+        self.assertEqual('gs', uri.scheme)
+        self.assertEqual(uri_str, uri.uri)
+        self.assertEqual('gs://bucket/obj/a/b', uri.versionless_uri)
+        self.assertEqual('bucket', uri.bucket_name)
+        self.assertEqual('obj/a/b', uri.object_name)
+        self.assertEqual(None, uri.version_id)
+        self.assertEqual(1, uri.generation)
+        self.assertEqual(uri.names_provider(), False)
+        self.assertEqual(uri.names_container(), False)
+        self.assertEqual(uri.names_bucket(), False)
+        self.assertEqual(uri.names_object(), True)
+        self.assertEqual(uri.names_directory(), False)
+        self.assertEqual(uri.names_file(), False)
+        self.assertEqual(uri.is_stream(), False)
+        self.assertEqual(uri.is_version_specific, True)
+
+    def test_roundtrip_versioned_gs_object_uri_parsed(self):
+        uri_str = 'gs://bucket/obj#1359908801674000'
+        uri = boto.storage_uri(uri_str, validate=False,
+            suppress_consec_slashes=False)
+        roundtrip_uri = boto.storage_uri(uri.uri, validate=False,
+            suppress_consec_slashes=False)
+        self.assertEqual(uri.uri, roundtrip_uri.uri)
+        self.assertEqual(uri.is_version_specific, True)
+
+    def test_versioned_s3_object_uri(self):
+        uri_str = 's3://bucket/obj/a/b#eMuM0J15HkJ9QHlktfNP5MfA.oYR2q6S'
+        uri = boto.storage_uri(uri_str, validate=False,
+            suppress_consec_slashes=False)
+        self.assertEqual('s3', uri.scheme)
+        self.assertEqual(uri_str, uri.uri)
+        self.assertEqual('s3://bucket/obj/a/b', uri.versionless_uri)
+        self.assertEqual('bucket', uri.bucket_name)
+        self.assertEqual('obj/a/b', uri.object_name)
+        self.assertEqual('eMuM0J15HkJ9QHlktfNP5MfA.oYR2q6S', uri.version_id)
+        self.assertEqual(None, uri.generation)
+        self.assertEqual(uri.names_provider(), False)
+        self.assertEqual(uri.names_container(), False)
+        self.assertEqual(uri.names_bucket(), False)
+        self.assertEqual(uri.names_object(), True)
+        self.assertEqual(uri.names_directory(), False)
+        self.assertEqual(uri.names_file(), False)
+        self.assertEqual(uri.is_stream(), False)
+        self.assertEqual(uri.is_version_specific, True)
+
+    def test_explicit_file_uri(self):
+        tmp_dir = tempfile.tempdir
+        uri_str = 'file://%s' % urllib.pathname2url(tmp_dir)
+        uri = boto.storage_uri(uri_str, validate=False,
+            suppress_consec_slashes=False)
+        self.assertEqual('file', uri.scheme)
+        self.assertEqual(uri_str, uri.uri)
+        self.assertFalse(hasattr(uri, 'versionless_uri'))
+        self.assertEqual('', uri.bucket_name)
+        self.assertEqual(tmp_dir, uri.object_name)
+        self.assertFalse(hasattr(uri, 'version_id'))
+        self.assertFalse(hasattr(uri, 'generation'))
+        self.assertFalse(hasattr(uri, 'is_version_specific'))
+        self.assertEqual(uri.names_provider(), False)
+        self.assertEqual(uri.names_bucket(), False)
+        # Don't check uri.names_container(), uri.names_directory(),
+        # uri.names_file(), or uri.names_object(), because for file URIs these
+        # functions look at the file system and apparently unit tests run
+        # chroot'd.
+        self.assertEqual(uri.is_stream(), False)
+
+    def test_implicit_file_uri(self):
+        tmp_dir = tempfile.tempdir
+        uri_str = '%s' % urllib.pathname2url(tmp_dir)
+        uri = boto.storage_uri(uri_str, validate=False,
+            suppress_consec_slashes=False)
+        self.assertEqual('file', uri.scheme)
+        self.assertEqual('file://%s' % tmp_dir, uri.uri)
+        self.assertFalse(hasattr(uri, 'versionless_uri'))
+        self.assertEqual('', uri.bucket_name)
+        self.assertEqual(tmp_dir, uri.object_name)
+        self.assertFalse(hasattr(uri, 'version_id'))
+        self.assertFalse(hasattr(uri, 'generation'))
+        self.assertFalse(hasattr(uri, 'is_version_specific'))
+        self.assertEqual(uri.names_provider(), False)
+        self.assertEqual(uri.names_bucket(), False)
+        # Don't check uri.names_container(), uri.names_directory(),
+        # uri.names_file(), or uri.names_object(), because for file URIs these
+        # functions look at the file system and apparently unit tests run
+        # chroot'd.
+        self.assertEqual(uri.is_stream(), False)
+
+    def test_gs_object_uri_contains_sharp_not_matching_version_syntax(self):
+        uri_str = 'gs://bucket/obj#13a990880167400'
+        uri = boto.storage_uri(uri_str, validate=False,
+            suppress_consec_slashes=False)
+        self.assertEqual('gs', uri.scheme)
+        self.assertEqual(uri_str, uri.uri)
+        self.assertEqual('gs://bucket/obj#13a990880167400',
+                         uri.versionless_uri)
+        self.assertEqual('bucket', uri.bucket_name)
+        self.assertEqual('obj#13a990880167400', uri.object_name)
+        self.assertEqual(None, uri.version_id)
+        self.assertEqual(None, uri.generation)
+        self.assertEqual(uri.names_provider(), False)
+        self.assertEqual(uri.names_container(), False)
+        self.assertEqual(uri.names_bucket(), False)
+        self.assertEqual(uri.names_object(), True)
+        self.assertEqual(uri.names_directory(), False)
+        self.assertEqual(uri.names_file(), False)
+        self.assertEqual(uri.is_stream(), False)
+        self.assertEqual(uri.is_version_specific, False)
+
+    def test_invalid_scheme(self):
+        uri_str = 'mars://bucket/object'
+        try:
+            boto.storage_uri(uri_str, validate=False,
+                suppress_consec_slashes=False)
+        except InvalidUriError as e:
+            self.assertIn('Unrecognized scheme', e.message)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/packages/gsutil/boto/tests/unit/s3/test_website.py

@@ -0,0 +1,188 @@
+# Copyright (c) 2013 Amazon.com, Inc. or its affiliates.  All Rights Reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+
+from tests.unit import unittest
+import xml.dom.minidom
+
+from boto.s3.website import WebsiteConfiguration
+from boto.s3.website import RedirectLocation
+from boto.s3.website import RoutingRules
+from boto.s3.website import Condition
+from boto.s3.website import RoutingRules
+from boto.s3.website import RoutingRule
+from boto.s3.website import Redirect
+
+
+def pretty_print_xml(text):
+    text = ''.join(t.strip() for t in text.splitlines())
+    x = xml.dom.minidom.parseString(text)
+    return x.toprettyxml()
+
+
+class TestS3WebsiteConfiguration(unittest.TestCase):
+    maxDiff = None
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_suffix_only(self):
+        config = WebsiteConfiguration(suffix='index.html')
+        xml = config.to_xml()
+        self.assertIn(
+            '<IndexDocument><Suffix>index.html</Suffix></IndexDocument>', xml)
+
+    def test_suffix_and_error(self):
+        config = WebsiteConfiguration(suffix='index.html',
+                                      error_key='error.html')
+        xml = config.to_xml()
+        self.assertIn(
+            '<ErrorDocument><Key>error.html</Key></ErrorDocument>', xml)
+
+    def test_redirect_all_request_to_with_just_host(self):
+        location = RedirectLocation(hostname='example.com')
+        config = WebsiteConfiguration(redirect_all_requests_to=location)
+        xml = config.to_xml()
+        self.assertIn(
+            ('<RedirectAllRequestsTo><HostName>'
+             'example.com</HostName></RedirectAllRequestsTo>'), xml)
+
+    def test_redirect_all_requests_with_protocol(self):
+        location = RedirectLocation(hostname='example.com', protocol='https')
+        config = WebsiteConfiguration(redirect_all_requests_to=location)
+        xml = config.to_xml()
+        self.assertIn(
+            ('<RedirectAllRequestsTo><HostName>'
+             'example.com</HostName>\n<Protocol>https</Protocol>'
+             '</RedirectAllRequestsTo>'), xml)
+
+    def test_routing_rules_key_prefix(self):
+        x = pretty_print_xml
+        # This rule redirects requests for docs/* to documentation/*
+        rules = RoutingRules()
+        condition = Condition(key_prefix='docs/')
+        redirect = Redirect(replace_key_prefix='documents/')
+        rules.add_rule(RoutingRule(condition, redirect))
+        config = WebsiteConfiguration(suffix='index.html', routing_rules=rules)
+        xml = config.to_xml()
+
+        expected_xml = """<?xml version="1.0" encoding="UTF-8"?>
+            <WebsiteConfiguration xmlns='http://s3.amazonaws.com/doc/2006-03-01/'>
+              <IndexDocument>
+                <Suffix>index.html</Suffix>
+              </IndexDocument>
+              <RoutingRules>
+                <RoutingRule>
+                <Condition>
+                  <KeyPrefixEquals>docs/</KeyPrefixEquals>
+                </Condition>
+                <Redirect>
+                  <ReplaceKeyPrefixWith>documents/</ReplaceKeyPrefixWith>
+                </Redirect>
+                </RoutingRule>
+              </RoutingRules>
+            </WebsiteConfiguration>
+        """
+        self.assertEqual(x(expected_xml), x(xml))
+
+    def test_routing_rules_to_host_on_404(self):
+        x = pretty_print_xml
+        # Another example from the docs:
+        # Redirect requests to a specific host in the event of a 404.
+        # Also, the redirect inserts a report-404/.  For example,
+        # if you request a page ExamplePage.html and it results
+        # in a 404, the request is routed to a page report-404/ExamplePage.html
+        rules = RoutingRules()
+        condition = Condition(http_error_code=404)
+        redirect = Redirect(hostname='example.com',
+                            replace_key_prefix='report-404/')
+        rules.add_rule(RoutingRule(condition, redirect))
+        config = WebsiteConfiguration(suffix='index.html', routing_rules=rules)
+        xml = config.to_xml()
+
+        expected_xml = """<?xml version="1.0" encoding="UTF-8"?>
+            <WebsiteConfiguration xmlns='http://s3.amazonaws.com/doc/2006-03-01/'>
+              <IndexDocument>
+                <Suffix>index.html</Suffix>
+              </IndexDocument>
+              <RoutingRules>
+                <RoutingRule>
+                <Condition>
+                  <HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals>
+                </Condition>
+                <Redirect>
+                  <HostName>example.com</HostName>
+                  <ReplaceKeyPrefixWith>report-404/</ReplaceKeyPrefixWith>
+                </Redirect>
+                </RoutingRule>
+              </RoutingRules>
+            </WebsiteConfiguration>
+        """
+        self.assertEqual(x(expected_xml), x(xml))
+
+    def test_key_prefix(self):
+        x = pretty_print_xml
+        rules = RoutingRules()
+        condition = Condition(key_prefix="images/")
+        redirect = Redirect(replace_key='folderdeleted.html')
+        rules.add_rule(RoutingRule(condition, redirect))
+        config = WebsiteConfiguration(suffix='index.html', routing_rules=rules)
+        xml = config.to_xml()
+
+        expected_xml = """<?xml version="1.0" encoding="UTF-8"?>
+            <WebsiteConfiguration xmlns='http://s3.amazonaws.com/doc/2006-03-01/'>
+              <IndexDocument>
+                <Suffix>index.html</Suffix>
+              </IndexDocument>
+              <RoutingRules>
+                <RoutingRule>
+                <Condition>
+                  <KeyPrefixEquals>images/</KeyPrefixEquals>
+                </Condition>
+                <Redirect>
+                  <ReplaceKeyWith>folderdeleted.html</ReplaceKeyWith>
+                </Redirect>
+                </RoutingRule>
+              </RoutingRules>
+            </WebsiteConfiguration>
+        """
+        self.assertEqual(x(expected_xml), x(xml))
+
+    def test_builders(self):
+        x = pretty_print_xml
+        # This is a more declarative way to create rules.
+        # First the long way.
+        rules = RoutingRules()
+        condition = Condition(http_error_code=404)
+        redirect = Redirect(hostname='example.com',
+                            replace_key_prefix='report-404/')
+        rules.add_rule(RoutingRule(condition, redirect))
+        xml = rules.to_xml()
+
+        # Then the more concise way.
+        rules2 = RoutingRules().add_rule(
+            RoutingRule.when(http_error_code=404).then_redirect(
+                hostname='example.com', replace_key_prefix='report-404/'))
+        xml2 = rules2.to_xml()
+        self.assertEqual(x(xml), x(xml2))