gcloud 0.0.7 → 0.1.0

data/packages/gsutil/boto/tests/devpay/test_s3.py

@@ -1,181 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2006,2007 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 time
-import os
-import urllib
-
-from boto.s3.connection import S3Connection
-from boto.exception import S3PermissionsError
-
-# this test requires a devpay product and user token to run:
-
-AMAZON_USER_TOKEN = '{UserToken}...your token here...'
-DEVPAY_HEADERS = { 'x-amz-security-token': AMAZON_USER_TOKEN }
-
-def test():
-    print '--- running S3Connection tests (DevPay) ---'
-    c = S3Connection()
-    # create a new, empty bucket
-    bucket_name = 'test-%d' % int(time.time())
-    bucket = c.create_bucket(bucket_name, headers=DEVPAY_HEADERS)
-    # now try a get_bucket call and see if it's really there
-    bucket = c.get_bucket(bucket_name, headers=DEVPAY_HEADERS)
-    # test logging
-    logging_bucket = c.create_bucket(bucket_name + '-log', headers=DEVPAY_HEADERS)
-    logging_bucket.set_as_logging_target(headers=DEVPAY_HEADERS)
-    bucket.enable_logging(target_bucket=logging_bucket, target_prefix=bucket.name, headers=DEVPAY_HEADERS)
-    bucket.disable_logging(headers=DEVPAY_HEADERS)
-    c.delete_bucket(logging_bucket, headers=DEVPAY_HEADERS)
-    # create a new key and store it's content from a string
-    k = bucket.new_key()
-    k.name = '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, headers=DEVPAY_HEADERS)
-    fp = open('foobar', 'wb')
-    # now get the contents from s3 to a local file
-    k.get_contents_to_file(fp, headers=DEVPAY_HEADERS)
-    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, headers=DEVPAY_HEADERS)
-    file = urllib.urlopen(url)
-    assert s1 == file.read(), 'invalid URL %s' % url
-    url = k.generate_url(3600, force_http=True, headers=DEVPAY_HEADERS)
-    file = urllib.urlopen(url)
-    assert s1 == file.read(), 'invalid URL %s' % url
-    bucket.delete_key(k, headers=DEVPAY_HEADERS)
-    # 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}
-    headers.update(DEVPAY_HEADERS)
-    k.name = 'foo/bar'
-    k.set_contents_from_string(s1, headers)
-    k.name = 'foo/bas'
-    k.set_contents_from_filename('foobar', headers=DEVPAY_HEADERS)
-    k.name = 'foo/bat'
-    k.set_contents_from_string(s1, headers=DEVPAY_HEADERS)
-    k.name = 'fie/bar'
-    k.set_contents_from_string(s1, headers=DEVPAY_HEADERS)
-    k.name = 'fie/bas'
-    k.set_contents_from_string(s1, headers=DEVPAY_HEADERS)
-    k.name = 'fie/bat'
-    k.set_contents_from_string(s1, headers=DEVPAY_HEADERS)
-    # try resetting the contents to another value
-    md5 = k.md5
-    k.set_contents_from_string(s2, headers=DEVPAY_HEADERS)
-    assert k.md5 != md5
-    os.unlink('foobar')
-    all = bucket.get_all_keys(headers=DEVPAY_HEADERS)
-    assert len(all) == 6
-    rs = bucket.get_all_keys(prefix='foo', headers=DEVPAY_HEADERS)
-    assert len(rs) == 3
-    rs = bucket.get_all_keys(prefix='', delimiter='/', headers=DEVPAY_HEADERS)
-    assert len(rs) == 2
-    rs = bucket.get_all_keys(maxkeys=5, headers=DEVPAY_HEADERS)
-    assert len(rs) == 5
-    # test the lookup method
-    k = bucket.lookup('foo/bar', headers=DEVPAY_HEADERS)
-    assert isinstance(k, bucket.key_class)
-    assert k.content_type == phony_mimetype
-    k = bucket.lookup('notthere', headers=DEVPAY_HEADERS)
-    assert k == None
-    # try some metadata stuff
-    k = bucket.new_key()
-    k.name = '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)
-    k.set_contents_from_string(s1, headers=DEVPAY_HEADERS)
-    k = bucket.lookup('has_metadata', headers=DEVPAY_HEADERS)
-    assert k.get_metadata(mdkey1) == mdval1
-    assert k.get_metadata(mdkey2) == mdval2
-    k = bucket.new_key()
-    k.name = 'has_metadata'
-    k.get_contents_as_string(headers=DEVPAY_HEADERS)
-    assert k.get_metadata(mdkey1) == mdval1
-    assert k.get_metadata(mdkey2) == mdval2
-    bucket.delete_key(k, headers=DEVPAY_HEADERS)
-    # test list and iterator
-    rs1 = bucket.list(headers=DEVPAY_HEADERS)
-    num_iter = 0
-    for r in rs1:
-        num_iter = num_iter + 1
-    rs = bucket.get_all_keys(headers=DEVPAY_HEADERS)
-    num_keys = len(rs)
-    assert num_iter == num_keys
-    # try a key with a funny character
-    k = bucket.new_key()
-    k.name = 'testnewline\n'
-    k.set_contents_from_string('This is a test', headers=DEVPAY_HEADERS)
-    rs = bucket.get_all_keys(headers=DEVPAY_HEADERS)
-    assert len(rs) == num_keys + 1
-    bucket.delete_key(k, headers=DEVPAY_HEADERS)
-    rs = bucket.get_all_keys(headers=DEVPAY_HEADERS)
-    assert len(rs) == num_keys
-    # try some acl stuff
-    bucket.set_acl('public-read', headers=DEVPAY_HEADERS)
-    policy = bucket.get_acl(headers=DEVPAY_HEADERS)
-    assert len(policy.acl.grants) == 2
-    bucket.set_acl('private', headers=DEVPAY_HEADERS)
-    policy = bucket.get_acl(headers=DEVPAY_HEADERS)
-    assert len(policy.acl.grants) == 1
-    k = bucket.lookup('foo/bar', headers=DEVPAY_HEADERS)
-    k.set_acl('public-read', headers=DEVPAY_HEADERS)
-    policy = k.get_acl(headers=DEVPAY_HEADERS)
-    assert len(policy.acl.grants) == 2
-    k.set_acl('private', headers=DEVPAY_HEADERS)
-    policy = k.get_acl(headers=DEVPAY_HEADERS)
-    assert len(policy.acl.grants) == 1
-    # try the convenience methods for grants
-    # this doesn't work with devpay
-    #bucket.add_user_grant('FULL_CONTROL',
-    #                      'c1e724fbfa0979a4448393c59a8c055011f739b6d102fb37a65f26414653cd67',
-    #                      headers=DEVPAY_HEADERS)
-    try:
-        bucket.add_email_grant('foobar', 'foo@bar.com', headers=DEVPAY_HEADERS)
-    except S3PermissionsError:
-        pass
-    # now delete all keys in bucket
-    for k in all:
-        bucket.delete_key(k, headers=DEVPAY_HEADERS)
-    # now delete bucket
-
-    c.delete_bucket(bucket, headers=DEVPAY_HEADERS)
-
-    print '--- tests completed ---'
-
-if __name__ == '__main__':
-    test()

data/packages/gsutil/boto/tests/fps/test.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python
-
-from tests.unit import unittest
-import sys
-import os
-import os.path
-
-simple = True
-advanced = False
-if __name__ == "__main__":
-    devpath = os.path.relpath(os.path.join('..', '..'),
-                              start=os.path.dirname(__file__))
-    sys.path = [devpath] + sys.path
-    print '>>> advanced FPS tests; using local boto sources'
-    advanced = True
-
-from boto.fps.connection import FPSConnection
-from boto.fps.response import ComplexAmount
-
-
-class FPSTestCase(unittest.TestCase):
-
-    def setUp(self):
-        self.fps = FPSConnection(host='fps.sandbox.amazonaws.com')
-        if advanced:
-            self.activity = self.fps.get_account_activity(\
-                                StartDate='2012-01-01')
-            result = self.activity.GetAccountActivityResult
-            self.transactions = result.Transaction
-
-    @unittest.skipUnless(simple, "skipping simple test")
-    def test_get_account_balance(self):
-        response = self.fps.get_account_balance()
-        self.assertTrue(hasattr(response, 'GetAccountBalanceResult'))
-        self.assertTrue(hasattr(response.GetAccountBalanceResult,
-                                                'AccountBalance'))
-        accountbalance = response.GetAccountBalanceResult.AccountBalance
-        self.assertTrue(hasattr(accountbalance, 'TotalBalance'))
-        self.assertIsInstance(accountbalance.TotalBalance, ComplexAmount)
-        self.assertTrue(hasattr(accountbalance, 'AvailableBalances'))
-        availablebalances = accountbalance.AvailableBalances
-        self.assertTrue(hasattr(availablebalances, 'RefundBalance'))
-
-    @unittest.skipUnless(simple, "skipping simple test")
-    def test_complex_amount(self):
-        response = self.fps.get_account_balance()
-        accountbalance = response.GetAccountBalanceResult.AccountBalance
-        asfloat = float(accountbalance.TotalBalance.Value)
-        self.assertIn('.', str(asfloat))
-
-    @unittest.skipUnless(simple, "skipping simple test")
-    def test_required_arguments(self):
-        with self.assertRaises(KeyError):
-            self.fps.write_off_debt(AdjustmentAmount=123.45)
-
-    @unittest.skipUnless(simple, "skipping simple test")
-    def test_cbui_url(self):
-        inputs = {
-            'transactionAmount':    123.45,
-            'pipelineName':         'SingleUse',
-            'returnURL':            'https://localhost/',
-            'paymentReason':        'a reason for payment',
-            'callerReference':      'foo',
-        }
-        result = self.fps.cbui_url(**inputs)
-        print "cbui_url() yields {0}".format(result)
-
-    @unittest.skipUnless(simple, "skipping simple test")
-    def test_get_account_activity(self):
-        response = self.fps.get_account_activity(StartDate='2012-01-01')
-        self.assertTrue(hasattr(response, 'GetAccountActivityResult'))
-        result = response.GetAccountActivityResult
-        self.assertTrue(hasattr(result, 'BatchSize'))
-        try:
-            int(result.BatchSize)
-        except:
-            self.assertTrue(False)
-
-    @unittest.skipUnless(advanced, "skipping advanced test")
-    def test_get_transaction(self):
-        assert len(self.transactions)
-        transactionid = self.transactions[0].TransactionId
-        result = self.fps.get_transaction(TransactionId=transactionid)
-        self.assertTrue(hasattr(result.GetTransactionResult, 'Transaction'))
-
-    @unittest.skip('cosmetic')
-    def test_bad_request(self):
-        try:
-            self.fps.write_off_debt(CreditInstrumentId='foo',
-                                    AdjustmentAmount=123.45)
-        except Exception, e:
-            print e
-
-    @unittest.skip('cosmetic')
-    def test_repr(self):
-        print self.fps.get_account_balance()
-
-
-if __name__ == "__main__":
-    unittest.main()

data/packages/gsutil/boto/tests/fps/test_verify_signature.py

@@ -1,12 +0,0 @@
-from boto.fps.connection import FPSConnection
-
-def test():
-    conn = FPSConnection()
-    # example response from the docs
-    params = 'expiry=08%2F2015&signature=ynDukZ9%2FG77uSJVb5YM0cadwHVwYKPMKOO3PNvgADbv6VtymgBxeOWEhED6KGHsGSvSJnMWDN%2FZl639AkRe9Ry%2F7zmn9CmiM%2FZkp1XtshERGTqi2YL10GwQpaH17MQqOX3u1cW4LlyFoLy4celUFBPq1WM2ZJnaNZRJIEY%2FvpeVnCVK8VIPdY3HMxPAkNi5zeF2BbqH%2BL2vAWef6vfHkNcJPlOuOl6jP4E%2B58F24ni%2B9ek%2FQH18O4kw%2FUJ7ZfKwjCCI13%2BcFybpofcKqddq8CuUJj5Ii7Pdw1fje7ktzHeeNhF0r9siWcYmd4JaxTP3NmLJdHFRq2T%2FgsF3vK9m3gw%3D%3D&signatureVersion=2&signatureMethod=RSA-SHA1&certificateUrl=https%3A%2F%2Ffps.sandbox.amazonaws.com%2Fcerts%2F090909%2FPKICert.pem&tokenID=A5BB3HUNAZFJ5CRXIPH72LIODZUNAUZIVP7UB74QNFQDSQ9MN4HPIKISQZWPLJXF&status=SC&callerReference=callerReferenceMultiUse1'
-    endpoint = 'http://vamsik.desktop.amazon.com:8080/ipn.jsp'
-    conn.verify_signature(endpoint, params)
-
-
-if __name__ == '__main__':
-    test()

data/packages/gsutil/boto/tests/integration/beanstalk/test_wrapper.py

@@ -1,209 +0,0 @@
-import unittest
-import random
-import time
-from functools import partial
-
-from boto.beanstalk.wrapper import Layer1Wrapper
-import boto.beanstalk.response as response
-
-
-class BasicSuite(unittest.TestCase):
-    def setUp(self):
-        self.random_id = str(random.randint(1, 1000000))
-        self.app_name = 'app-' + self.random_id
-        self.app_version = 'version-' + self.random_id
-        self.template = 'template-' + self.random_id
-        self.environment = 'environment-' + self.random_id
-        self.beanstalk = Layer1Wrapper()
-
-
-class MiscSuite(BasicSuite):
-    def test_check_dns_availability(self):
-        result = self.beanstalk.check_dns_availability('amazon')
-        self.assertIsInstance(result, response.CheckDNSAvailabilityResponse,
-                              'incorrect response object returned')
-        self.assertFalse(result.available)
-
-
-class TestApplicationObjects(BasicSuite):
-    def create_application(self):
-        # This method is used for any API calls that require an application
-        # object.  This also adds a cleanup step to automatically delete the
-        # app when the test is finished.  No assertions are performed
-        # here.  If you want to validate create_application, don't use this
-        # method.
-        self.beanstalk.create_application(application_name=self.app_name)
-        self.addCleanup(partial(self.beanstalk.delete_application,
-                                application_name=self.app_name))
-
-    def test_create_delete_application_version(self):
-        # This will create an app, create an app version, delete the app
-        # version, and delete the app.  For each API call we check that the
-        # return type is what we expect and that a few attributes have the
-        # correct values.
-        app_result = self.beanstalk.create_application(application_name=self.app_name)
-        self.assertIsInstance(app_result, response.CreateApplicationResponse)
-        self.assertEqual(app_result.application.application_name, self.app_name)
-
-        version_result = self.beanstalk.create_application_version(
-            application_name=self.app_name, version_label=self.app_version)
-        self.assertIsInstance(version_result, response.CreateApplicationVersionResponse)
-        self.assertEqual(version_result.application_version.version_label,
-                         self.app_version)
-        result = self.beanstalk.delete_application_version(
-            application_name=self.app_name, version_label=self.app_version)
-        self.assertIsInstance(result, response.DeleteApplicationVersionResponse)
-        result = self.beanstalk.delete_application(
-            application_name=self.app_name
-        )
-        self.assertIsInstance(result, response.DeleteApplicationResponse)
-
-    def test_create_configuration_template(self):
-        self.create_application()
-        result = self.beanstalk.create_configuration_template(
-            application_name=self.app_name, template_name=self.template,
-            solution_stack_name='32bit Amazon Linux running Tomcat 6')
-        self.assertIsInstance(
-            result, response.CreateConfigurationTemplateResponse)
-        self.assertEqual(result.solution_stack_name,
-                         '32bit Amazon Linux running Tomcat 6')
-
-    def test_create_storage_location(self):
-        result = self.beanstalk.create_storage_location()
-        self.assertIsInstance(result, response.CreateStorageLocationResponse)
-
-    def test_update_application(self):
-        self.create_application()
-        result = self.beanstalk.update_application(application_name=self.app_name)
-        self.assertIsInstance(result, response.UpdateApplicationResponse)
-
-    def test_update_application_version(self):
-        self.create_application()
-        self.beanstalk.create_application_version(
-            application_name=self.app_name, version_label=self.app_version)
-        result = self.beanstalk.update_application_version(
-            application_name=self.app_name, version_label=self.app_version)
-        self.assertIsInstance(
-            result, response.UpdateApplicationVersionResponse)
-
-
-class GetSuite(BasicSuite):
-    def test_describe_applications(self):
-        result = self.beanstalk.describe_applications()
-        self.assertIsInstance(result, response.DescribeApplicationsResponse)
-
-    def test_describe_application_versions(self):
-        result = self.beanstalk.describe_application_versions()
-        self.assertIsInstance(result,
-                              response.DescribeApplicationVersionsResponse)
-
-
-    def test_describe_configuration_options(self):
-        result = self.beanstalk.describe_configuration_options()
-        self.assertIsInstance(result,
-                              response.DescribeConfigurationOptionsResponse)
-
-    def test_12_describe_environments(self):
-        result = self.beanstalk.describe_environments()
-        self.assertIsInstance(
-            result, response.DescribeEnvironmentsResponse)
-
-    def test_14_describe_events(self):
-        result = self.beanstalk.describe_events()
-        self.assertIsInstance(result, response.DescribeEventsResponse)
-
-    def test_15_list_available_solution_stacks(self):
-        result = self.beanstalk.list_available_solution_stacks()
-        self.assertIsInstance(
-            result, response.ListAvailableSolutionStacksResponse)
-        self.assertIn('32bit Amazon Linux running Tomcat 6',
-                      result.solution_stacks)
-
-
-
-class TestsWithEnvironment(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.random_id = str(random.randint(1, 1000000))
-        cls.app_name = 'app-' + cls.random_id
-        cls.environment = 'environment-' + cls.random_id
-        cls.template = 'template-' + cls.random_id
-
-        cls.beanstalk = Layer1Wrapper()
-        cls.beanstalk.create_application(application_name=cls.app_name)
-        cls.beanstalk.create_configuration_template(
-            application_name=cls.app_name, template_name=cls.template,
-            solution_stack_name='32bit Amazon Linux running Tomcat 6')
-        cls.app_version = 'version-' + cls.random_id
-        cls.beanstalk.create_application_version(
-            application_name=cls.app_name, version_label=cls.app_version)
-        cls.beanstalk.create_environment(cls.app_name, cls.environment,
-                                         template_name=cls.template)
-        cls.wait_for_env(cls.environment)
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.beanstalk.delete_application(application_name=cls.app_name,
-                                         terminate_env_by_force=True)
-        cls.wait_for_env(cls.environment, 'Terminated')
-
-    @classmethod
-    def wait_for_env(cls, env_name, status='Ready'):
-        while not cls.env_ready(env_name, status):
-            time.sleep(15)
-
-    @classmethod
-    def env_ready(cls, env_name, desired_status):
-        result = cls.beanstalk.describe_environments(
-            application_name=cls.app_name, environment_names=env_name)
-        status = result.environments[0].status
-        return status == desired_status
-
-    def test_describe_environment_resources(self):
-        result = self.beanstalk.describe_environment_resources(
-            environment_name=self.environment)
-        self.assertIsInstance(
-            result, response.DescribeEnvironmentResourcesResponse)
-
-    def test_describe_configuration_settings(self):
-        result = self.beanstalk.describe_configuration_settings(
-            application_name=self.app_name, environment_name=self.environment)
-        self.assertIsInstance(
-            result, response.DescribeConfigurationSettingsResponse)
-
-    def test_request_environment_info(self):
-        result = self.beanstalk.request_environment_info(
-            environment_name=self.environment, info_type='tail')
-        self.assertIsInstance(result, response.RequestEnvironmentInfoResponse)
-        self.wait_for_env(self.environment)
-        result = self.beanstalk.retrieve_environment_info(
-            environment_name=self.environment, info_type='tail')
-        self.assertIsInstance(result, response.RetrieveEnvironmentInfoResponse)
-
-    def test_rebuild_environment(self):
-        result = self.beanstalk.rebuild_environment(
-            environment_name=self.environment)
-        self.assertIsInstance(result, response.RebuildEnvironmentResponse)
-        self.wait_for_env(self.environment)
-
-    def test_restart_app_server(self):
-        result = self.beanstalk.restart_app_server(
-            environment_name=self.environment)
-        self.assertIsInstance(result, response.RestartAppServerResponse)
-        self.wait_for_env(self.environment)
-
-    def test_update_configuration_template(self):
-        result = self.beanstalk.update_configuration_template(
-            application_name=self.app_name, template_name=self.template)
-        self.assertIsInstance(
-            result, response.UpdateConfigurationTemplateResponse)
-
-    def test_update_environment(self):
-        result = self.beanstalk.update_environment(
-            environment_name=self.environment)
-        self.assertIsInstance(result, response.UpdateEnvironmentResponse)
-        self.wait_for_env(self.environment)
-
-
-if __name__ == '__main__':
-    unittest.main()