gcloud 0.0.7 → 0.1.0

data/packages/gsutil/boto/tests/unit/glacier/test_vault.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.  All Rights Reserved
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-import unittest
-from cStringIO import StringIO
-
-import mock
-from mock import ANY
-
-from boto.glacier import vault
-
-
-class TestVault(unittest.TestCase):
-    def setUp(self):
-        self.size_patch = mock.patch('os.path.getsize')
-        self.getsize = self.size_patch.start()
-        self.api = mock.Mock()
-        self.vault = vault.Vault(self.api, None)
-        self.vault.name = 'myvault'
-        self.mock_open = mock.mock_open()
-        stringio = StringIO('content')
-        self.mock_open.return_value.read = stringio.read
-
-    def tearDown(self):
-        self.size_patch.stop()
-
-    def test_upload_archive_small_file(self):
-        self.getsize.return_value = 1
-
-        self.api.upload_archive.return_value = {'ArchiveId': 'archive_id'}
-        with mock.patch('boto.glacier.vault.open', self.mock_open,
-                        create=True):
-            archive_id = self.vault.upload_archive(
-                'filename', 'my description')
-        self.assertEqual(archive_id, 'archive_id')
-        self.api.upload_archive.assert_called_with(
-            'myvault', self.mock_open.return_value,
-            mock.ANY, mock.ANY, 'my description')
-
-    def test_small_part_size_is_obeyed(self):
-        self.vault.DefaultPartSize = 2 * 1024 * 1024
-        self.vault.create_archive_writer = mock.Mock()
-
-        self.getsize.return_value = 1
-
-        with mock.patch('boto.glacier.vault.open', self.mock_open,
-                        create=True):
-            self.vault.create_archive_from_file('myfile')
-        # The write should be created with the default part size of the
-        # instance (2 MB).
-        self.vault.create_archive_writer.assert_called_with(
-                description=mock.ANY, part_size=self.vault.DefaultPartSize)
-
-    def test_large_part_size_is_obeyed(self):
-        self.vault.DefaultPartSize = 8 * 1024 * 1024
-        self.vault.create_archive_writer = mock.Mock()
-        self.getsize.return_value = 1
-        with mock.patch('boto.glacier.vault.open', self.mock_open,
-                        create=True):
-            self.vault.create_archive_from_file('myfile')
-        # The write should be created with the default part size of the
-        # instance (8 MB).
-        self.vault.create_archive_writer.assert_called_with(
-            description=mock.ANY, part_size=self.vault.DefaultPartSize)
-
-
-class TestConcurrentUploads(unittest.TestCase):
-
-    def test_concurrent_upload_file(self):
-        v = vault.Vault(None, None)
-        with mock.patch('boto.glacier.vault.ConcurrentUploader') as c:
-            c.return_value.upload.return_value = 'archive_id'
-            archive_id = v.concurrent_create_archive_from_file(
-                'filename', 'my description')
-            c.return_value.upload.assert_called_with('filename',
-                                                     'my description')
-        self.assertEqual(archive_id, 'archive_id')
-
-
-if __name__ == '__main__':
-    unittest.main()

data/packages/gsutil/boto/tests/unit/glacier/test_writer.py

@@ -1,185 +0,0 @@
-# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.  All Rights Reserved
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-from hashlib import sha256
-import itertools
-from StringIO import StringIO
-
-from tests.unit import unittest
-from mock import (
-    call,
-    Mock,
-    patch,
-    sentinel,
-)
-from nose.tools import assert_equal
-
-from boto.glacier.layer1 import Layer1
-from boto.glacier.vault import Vault
-from boto.glacier.writer import Writer, resume_file_upload
-from boto.glacier.utils import bytes_to_hex, chunk_hashes, tree_hash
-
-
-def create_mock_vault():
-    vault = Mock(spec=Vault)
-    vault.layer1 = Mock(spec=Layer1)
-    vault.layer1.complete_multipart_upload.return_value = dict(
-        ArchiveId=sentinel.archive_id)
-    vault.name = sentinel.vault_name
-    return vault
-
-
-def partify(data, part_size):
-    for i in itertools.count(0):
-        start = i * part_size
-        part = data[start:start+part_size]
-        if part:
-            yield part
-        else:
-            return
-
-
-def calculate_mock_vault_calls(data, part_size, chunk_size):
-    upload_part_calls = []
-    data_tree_hashes = []
-    for i, data_part in enumerate(partify(data, part_size)):
-        start = i * part_size
-        end = start + len(data_part)
-        data_part_tree_hash_blob = tree_hash(
-            chunk_hashes(data_part, chunk_size))
-        data_part_tree_hash = bytes_to_hex(data_part_tree_hash_blob)
-        data_part_linear_hash = sha256(data_part).hexdigest()
-        upload_part_calls.append(
-            call.layer1.upload_part(
-                sentinel.vault_name, sentinel.upload_id,
-                data_part_linear_hash, data_part_tree_hash,
-                (start, end - 1), data_part))
-        data_tree_hashes.append(data_part_tree_hash_blob)
-
-    return upload_part_calls, data_tree_hashes
-
-
-def check_mock_vault_calls(vault, upload_part_calls, data_tree_hashes,
-                           data_len):
-    vault.layer1.upload_part.assert_has_calls(
-        upload_part_calls, any_order=True)
-    assert_equal(
-        len(upload_part_calls), vault.layer1.upload_part.call_count)
-
-    data_tree_hash = bytes_to_hex(tree_hash(data_tree_hashes))
-    vault.layer1.complete_multipart_upload.assert_called_once_with(
-        sentinel.vault_name, sentinel.upload_id, data_tree_hash, data_len)
-
-
-class TestWriter(unittest.TestCase):
-    def setUp(self):
-        super(TestWriter, self).setUp()
-        self.vault = create_mock_vault()
-        self.chunk_size = 2 # power of 2
-        self.part_size = 4 # power of 2
-        upload_id = sentinel.upload_id
-        self.writer = Writer(
-            self.vault, upload_id, self.part_size, self.chunk_size)
-
-    def check_write(self, write_list):
-        for write_data in write_list:
-            self.writer.write(write_data)
-        self.writer.close()
-
-        data = ''.join(write_list)
-        upload_part_calls, data_tree_hashes = calculate_mock_vault_calls(
-            data, self.part_size, self.chunk_size)
-        check_mock_vault_calls(
-            self.vault, upload_part_calls, data_tree_hashes, len(data))
-
-    def test_single_byte_write(self):
-        self.check_write(['1'])
-
-    def test_one_part_write(self):
-        self.check_write(['1234'])
-
-    def test_split_write_1(self):
-        self.check_write(['1', '234'])
-
-    def test_split_write_2(self):
-        self.check_write(['12', '34'])
-
-    def test_split_write_3(self):
-        self.check_write(['123', '4'])
-
-    def test_one_part_plus_one_write(self):
-        self.check_write(['12345'])
-
-    def test_returns_archive_id(self):
-        self.writer.write('1')
-        self.writer.close()
-        self.assertEquals(sentinel.archive_id, self.writer.get_archive_id())
-
-    def test_upload_id(self):
-        self.assertEquals(sentinel.upload_id, self.writer.upload_id)
-
-
-class TestResume(unittest.TestCase):
-    def setUp(self):
-        super(TestResume, self).setUp()
-        self.vault = create_mock_vault()
-        self.chunk_size = 2 # power of 2
-        self.part_size = 4 # power of 2
-
-    def check_no_resume(self, data, resume_set=set()):
-        fobj = StringIO(data)
-        part_hash_map = {}
-        for part_index in resume_set:
-            start = self.part_size * part_index
-            end = start + self.part_size
-            part_data = data[start:end]
-            part_hash_map[part_index] = tree_hash(
-                chunk_hashes(part_data, self.chunk_size))
-
-        resume_file_upload(
-            self.vault, sentinel.upload_id, self.part_size, fobj,
-            part_hash_map, self.chunk_size)
-
-        upload_part_calls, data_tree_hashes = calculate_mock_vault_calls(
-            data, self.part_size, self.chunk_size)
-        resume_upload_part_calls = [
-            call for part_index, call in enumerate(upload_part_calls)
-                    if part_index not in resume_set]
-        check_mock_vault_calls(
-            self.vault, resume_upload_part_calls, data_tree_hashes, len(data))
-
-    def test_one_part_no_resume(self):
-        self.check_no_resume('1234')
-
-    def test_two_parts_no_resume(self):
-        self.check_no_resume('12345678')
-
-    def test_one_part_resume(self):
-        self.check_no_resume('1234', resume_set=set([0]))
-
-    def test_two_parts_one_resume(self):
-        self.check_no_resume('12345678', resume_set=set([1]))
-
-    def test_returns_archive_id(self):
-        archive_id = resume_file_upload(
-            self.vault, sentinel.upload_id, self.part_size, StringIO('1'), {},
-            self.chunk_size)
-        self.assertEquals(sentinel.archive_id, archive_id)

data/packages/gsutil/boto/tests/unit/provider/test_provider.py

@@ -1,176 +0,0 @@
-#!/usr/bin/env python
-from datetime import datetime, timedelta
-
-from tests.unit import unittest
-import mock
-
-from boto import provider
-
-
-class TestProvider(unittest.TestCase):
-    def setUp(self):
-        self.environ = {}
-        self.config = {}
-
-        self.metadata_patch = mock.patch('boto.utils.get_instance_metadata')
-        self.config_patch = mock.patch('boto.provider.config.get',
-                                       self.get_config)
-        self.has_config_patch = mock.patch('boto.provider.config.has_option',
-                                           self.has_config)
-        self.environ_patch = mock.patch('os.environ', self.environ)
-
-        self.get_instance_metadata = self.metadata_patch.start()
-        self.config_patch.start()
-        self.has_config_patch.start()
-        self.environ_patch.start()
-
-
-    def tearDown(self):
-        self.metadata_patch.stop()
-        self.config_patch.stop()
-        self.has_config_patch.stop()
-        self.environ_patch.stop()
-
-    def has_config(self, section_name, key):
-        try:
-            self.config[section_name][key]
-            return True
-        except KeyError:
-            return False
-
-    def get_config(self, section_name, key):
-        try:
-            return self.config[section_name][key]
-        except KeyError:
-            return None
-
-    def test_passed_in_values_are_used(self):
-        p = provider.Provider('aws', 'access_key', 'secret_key', 'security_token')
-        self.assertEqual(p.access_key, 'access_key')
-        self.assertEqual(p.secret_key, 'secret_key')
-        self.assertEqual(p.security_token, 'security_token')
-
-    def test_environment_variables_are_used(self):
-        self.environ['AWS_ACCESS_KEY_ID'] = 'env_access_key'
-        self.environ['AWS_SECRET_ACCESS_KEY'] = 'env_secret_key'
-        p = provider.Provider('aws')
-        self.assertEqual(p.access_key, 'env_access_key')
-        self.assertEqual(p.secret_key, 'env_secret_key')
-        self.assertIsNone(p.security_token)
-
-    def test_config_values_are_used(self):
-        self.config = {
-            'Credentials': {
-                'aws_access_key_id': 'cfg_access_key',
-                'aws_secret_access_key': 'cfg_secret_key',
-            }
-        }
-        p = provider.Provider('aws')
-        self.assertEqual(p.access_key, 'cfg_access_key')
-        self.assertEqual(p.secret_key, 'cfg_secret_key')
-        self.assertIsNone(p.security_token)
-
-    def test_keyring_is_used(self):
-        self.config = {
-            'Credentials': {
-                'aws_access_key_id': 'cfg_access_key',
-                'keyring': 'test',
-            }
-        }
-        import sys
-        try:
-            import keyring
-            imported = True
-        except ImportError:
-            sys.modules['keyring'] = keyring = type(mock)('keyring', '')
-            imported = False
-
-        try:
-            with mock.patch('keyring.get_password', create=True):
-                keyring.get_password.side_effect = (
-                    lambda kr, login: kr+login+'pw')
-                p = provider.Provider('aws')
-                self.assertEqual(p.access_key, 'cfg_access_key')
-                self.assertEqual(p.secret_key, 'testcfg_access_keypw')
-                self.assertIsNone(p.security_token)
-        finally:
-            if not imported:
-                del sys.modules['keyring']
-
-    def test_env_vars_beat_config_values(self):
-        self.environ['AWS_ACCESS_KEY_ID'] = 'env_access_key'
-        self.environ['AWS_SECRET_ACCESS_KEY'] = 'env_secret_key'
-        self.config = {
-            'Credentials': {
-                'aws_access_key_id': 'cfg_access_key',
-                'aws_secret_access_key': 'cfg_secret_key',
-            }
-        }
-        p = provider.Provider('aws')
-        self.assertEqual(p.access_key, 'env_access_key')
-        self.assertEqual(p.secret_key, 'env_secret_key')
-        self.assertIsNone(p.security_token)
-
-    def test_metadata_server_credentials(self):
-        instance_config = {
-            'iam': {
-                'security-credentials': {
-                    'allowall': {u'AccessKeyId': u'iam_access_key',
-                                 u'Code': u'Success',
-                                 u'Expiration': u'2012-09-01T03:57:34Z',
-                                 u'LastUpdated': u'2012-08-31T21:43:40Z',
-                                 u'SecretAccessKey': u'iam_secret_key',
-                                 u'Token': u'iam_token',
-                                 u'Type': u'AWS-HMAC'}
-                }
-            }
-        }
-        self.get_instance_metadata.return_value = instance_config
-        p = provider.Provider('aws')
-        self.assertEqual(p.access_key, 'iam_access_key')
-        self.assertEqual(p.secret_key, 'iam_secret_key')
-        self.assertEqual(p.security_token, 'iam_token')
-
-    def test_refresh_credentials(self):
-        now = datetime.now()
-        first_expiration = (now + timedelta(seconds=10)).strftime(
-            "%Y-%m-%dT%H:%M:%SZ")
-        credentials = {
-            u'AccessKeyId': u'first_access_key',
-            u'Code': u'Success',
-            u'Expiration': first_expiration,
-            u'LastUpdated': u'2012-08-31T21:43:40Z',
-            u'SecretAccessKey': u'first_secret_key',
-            u'Token': u'first_token',
-            u'Type': u'AWS-HMAC'
-        }
-        instance_config = {
-            'iam': {
-                'security-credentials': {
-                    'allowall': credentials
-                }
-            }
-        }
-        self.get_instance_metadata.return_value = instance_config
-        p = provider.Provider('aws')
-        self.assertEqual(p.access_key, 'first_access_key')
-        self.assertEqual(p.secret_key, 'first_secret_key')
-        self.assertEqual(p.security_token, 'first_token')
-        self.assertIsNotNone(p._credential_expiry_time)
-
-        # Now set the expiration to something in the past.
-        expired = now - timedelta(seconds=20)
-        p._credential_expiry_time = expired
-        credentials['AccessKeyId'] = 'second_access_key'
-        credentials['SecretAccessKey'] = 'second_secret_key'
-        credentials['Token'] = 'second_token'
-        self.get_instance_metadata.return_value = instance_config
-
-        # Now upon attribute access, the credentials should be updated.
-        self.assertEqual(p.access_key, 'second_access_key')
-        self.assertEqual(p.secret_key, 'second_secret_key')
-        self.assertEqual(p.security_token, 'second_token')
-
-
-if __name__ == '__main__':
-    unittest.main()