googlecloud 0.0.4 → 0.0.6

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

@@ -0,0 +1,181 @@
+#!/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

@@ -0,0 +1,100 @@
+#!/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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,209 @@
+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()