Deferring implicit connection behavior from storage.api to Bucket.

Author: dhermes

gcloud/storage/__init__.py

@@ -83,7 +83,7 @@ def set_default_bucket(bucket=None):
         bucket_name = os.getenv(_BUCKET_ENV_VAR_NAME)
         connection = get_default_connection()
 
-        if bucket_name is not None and connection is not None:
+        if bucket_name is not None:
             bucket = Bucket(bucket_name, connection=connection)
 
     if bucket is not None:

gcloud/storage/api.py

@@ -46,14 +46,11 @@ def lookup_bucket(bucket_name, connection=None):
     :type connection: :class:`gcloud.storage.connection.Connection` or
                       ``NoneType``
     :param connection: Optional. The connection to use when sending requests.
-                       If not provided, falls back to default.
+                       If not provided, Bucket() will fall back to default.
 
     :rtype: :class:`gcloud.storage.bucket.Bucket`
     :returns: The bucket matching the name provided or None if not found.
     """
-    if connection is None:
-        connection = get_default_connection()
-
     try:
         return get_bucket(bucket_name, connection=connection)
     except NotFound:
@@ -116,15 +113,11 @@ def get_bucket(bucket_name, connection=None):
     :type connection: :class:`gcloud.storage.connection.Connection` or
                       ``NoneType``
     :param connection: Optional. The connection to use when sending requests.
-                       If not provided, falls back to default.
+                       If not provided, Bucket() will fall back to default.
 
     :rtype: :class:`gcloud.storage.bucket.Bucket`
     :returns: The bucket matching the name provided.
-    :raises: :class:`gcloud.exceptions.NotFound`
     """
-    if connection is None:
-        connection = get_default_connection()
-
     bucket = Bucket(bucket_name, connection=connection)
     bucket._reload_properties()
     return bucket
@@ -143,6 +136,9 @@ def create_bucket(bucket_name, project=None, connection=None):
 
     This implements "storage.buckets.insert".
 
+    If the bucket already exists, will raise
+    :class:`gcloud.exceptions.Conflict`.
+
     :type project: string
     :param project: Optional. The project to use when creating bucket.
                     If not provided, falls back to default.
@@ -153,25 +149,13 @@ def create_bucket(bucket_name, project=None, connection=None):
     :type connection: :class:`gcloud.storage.connection.Connection` or
                       ``NoneType``
     :param connection: Optional. The connection to use when sending requests.
-                       If not provided, falls back to default.
+                       If not provided, Bucket() will fall back to default.
 
     :rtype: :class:`gcloud.storage.bucket.Bucket`
     :returns: The newly created bucket.
-    :raises: :class:`gcloud.exceptions.Conflict` if
-             there is a confict (bucket already exists, invalid name, etc.)
     """
-    if connection is None:
-        connection = get_default_connection()
-    if project is None:
-        project = get_default_project()
-
-    query_params = {'project': project}
-    response = connection.api_request(method='POST', path='/b',
-                                      query_params=query_params,
-                                      data={'name': bucket_name})
-    name = response.get('name')
-    bucket = Bucket(name, connection=connection)
-    bucket._properties = response
+    bucket = Bucket(bucket_name, connection=connection)
+    bucket.create(project)
     return bucket
 
 

gcloud/storage/bucket.py

@@ -36,6 +36,7 @@
 import os
 import six
 
+from gcloud._helpers import get_default_project
 from gcloud.exceptions import NotFound
 from gcloud.storage._helpers import _PropertyMixin
 from gcloud.storage._helpers import _scalar_property
@@ -127,6 +128,34 @@ def exists(self):
         except NotFound:
             return False
 
+    def create(self, project=None):
+        """Creates current bucket.
+
+        If the bucket already exists, will raise
+        :class:`gcloud.exceptions.Conflict`.
+
+        This implements "storage.buckets.insert".
+
+        :type project: string
+        :param project: Optional. The project to use when creating bucket.
+                        If not provided, falls back to default.
+
+        :rtype: :class:`gcloud.storage.bucket.Bucket`
+        :returns: The newly created bucket.
+        :raises: :class:`EnvironmentError` if the project is not given and
+                 can't be inferred.
+        """
+        if project is None:
+            project = get_default_project()
+        if project is None:
+            raise EnvironmentError('Project could not be inferred '
+                                   'from environment.')
+
+        query_params = {'project': project}
+        self._properties = self.connection.api_request(
+            method='POST', path='/b', query_params=query_params,
+            data={'name': self.name})
+
     @property
     def acl(self):
         """Create our ACL on demand."""

gcloud/storage/test_api.py

@@ -62,11 +62,15 @@ def _lookup_bucket_hit_helper(self, use_default=False):
         if use_default:
             with _monkey_defaults(connection=conn):
                 bucket = self._callFUT(BLOB_NAME)
+            # In the default case, the bucket never has a connection
+            # bound to it.
+            self.assertTrue(bucket._connection is None)
         else:
             bucket = self._callFUT(BLOB_NAME, connection=conn)
+            # In the explicit case, the bucket has a connection bound to it.
+            self.assertTrue(bucket._connection is conn)
 
         self.assertTrue(isinstance(bucket, Bucket))
-        self.assertTrue(bucket.connection is conn)
         self.assertEqual(bucket.name, BLOB_NAME)
         self.assertEqual(http._called_with['method'], 'GET')
         self.assertEqual(http._called_with['uri'], URI)
@@ -187,11 +191,15 @@ def _get_bucket_hit_helper(self, use_default=False):
         if use_default:
             with _monkey_defaults(connection=conn):
                 bucket = self._callFUT(BLOB_NAME)
+            # In the default case, the bucket never has a connection
+            # bound to it.
+            self.assertTrue(bucket._connection is None)
         else:
             bucket = self._callFUT(BLOB_NAME, connection=conn)
+            # In the explicit case, the bucket has a connection bound to it.
+            self.assertTrue(bucket._connection is conn)
 
         self.assertTrue(isinstance(bucket, Bucket))
-        self.assertTrue(bucket.connection is conn)
         self.assertEqual(bucket.name, BLOB_NAME)
         self.assertEqual(http._called_with['method'], 'GET')
         self.assertEqual(http._called_with['uri'], URI)
@@ -232,11 +240,15 @@ def _create_bucket_success_helper(self, project, use_default=False):
             with _base_monkey_defaults(project=project):
                 with _monkey_defaults(connection=conn):
                     bucket = self._callFUT(BLOB_NAME)
+            # In the default case, the bucket never has a connection
+            # bound to it.
+            self.assertTrue(bucket._connection is None)
         else:
             bucket = self._callFUT(BLOB_NAME, project=project, connection=conn)
+            # In the explicit case, the bucket has a connection bound to it.
+            self.assertTrue(bucket._connection is conn)
 
         self.assertTrue(isinstance(bucket, Bucket))
-        self.assertTrue(bucket.connection is conn)
         self.assertEqual(bucket.name, BLOB_NAME)
         self.assertEqual(http._called_with['method'], 'POST')
         self.assertEqual(http._called_with['uri'], URI)

gcloud/storage/test_bucket.py

@@ -182,6 +182,43 @@ def api_request(cls, *args, **kwargs):
         expected_cw = [((), expected_called_kwargs)]
         self.assertEqual(_FakeConnection._called_with, expected_cw)
 
+    def test_create_no_project(self):
+        from gcloud._testing import _monkey_defaults
+        BUCKET_NAME = 'bucket-name'
+        bucket = self._makeOne(BUCKET_NAME)
+        with _monkey_defaults(project=None):
+            self.assertRaises(EnvironmentError, bucket.create)
+
+    def test_create_hit_explicit_project(self):
+        BUCKET_NAME = 'bucket-name'
+        DATA = {'name': BUCKET_NAME}
+        connection = _Connection(DATA)
+        PROJECT = 'PROJECT'
+        bucket = self._makeOne(BUCKET_NAME, connection=connection)
+        bucket.create(PROJECT)
+
+        kw, = connection._requested
+        self.assertEqual(kw['method'], 'POST')
+        self.assertEqual(kw['path'], '/b')
+        self.assertEqual(kw['query_params'], {'project': PROJECT})
+        self.assertEqual(kw['data'], DATA)
+
+    def test_create_hit_implicit_project(self):
+        from gcloud._testing import _monkey_defaults
+        BUCKET_NAME = 'bucket-name'
+        DATA = {'name': BUCKET_NAME}
+        connection = _Connection(DATA)
+        PROJECT = 'PROJECT'
+        bucket = self._makeOne(BUCKET_NAME, connection=connection)
+        with _monkey_defaults(project=PROJECT):
+            bucket.create()
+
+        kw, = connection._requested
+        self.assertEqual(kw['method'], 'POST')
+        self.assertEqual(kw['path'], '/b')
+        self.assertEqual(kw['query_params'], {'project': PROJECT})
+        self.assertEqual(kw['data'], DATA)
+
     def test_acl_property(self):
         from gcloud.storage.acl import BucketACL
         bucket = self._makeOne()

regression/storage.py

@@ -51,9 +51,9 @@ def setUp(self):
         self.case_buckets_to_delete = []
 
     def tearDown(self):
-        with storage.Batch() as batch:
+        with storage.Batch():
             for bucket_name in self.case_buckets_to_delete:
-                storage.Bucket(bucket_name, connection=batch).delete()
+                storage.Bucket(bucket_name).delete()
 
     def test_create_bucket(self):
         new_bucket_name = 'a-new-bucket'