refactor(storage): move 'create_bucket' implementation from 'Bucket' to 'Client'

storage/google/cloud/storage/bucket.py

@@ -437,6 +437,17 @@ def user_project(self):
         """
         return self._user_project
 
+    @property
+    def properties(self):
+        """Properties of the current bucket object.
+
+        Returns:
+            dict: Bucket properties transformed to dict.
+        """
+        properties = {key: self._properties[key] for key in self._changes}
+        properties["name"] = self.name
+        return properties
+
     def blob(
         self,
         blob_name,
@@ -577,28 +588,7 @@ def create(self, client=None, project=None, location=None):
             raise ValueError("Cannot create bucket with 'user_project' set.")
 
         client = self._require_client(client)
-
-        if project is None:
-            project = client.project
-
-        if project is None:
-            raise ValueError("Client project not set:  pass an explicit project.")
-
-        query_params = {"project": project}
-        properties = {key: self._properties[key] for key in self._changes}
-        properties["name"] = self.name
-
-        if location is not None:
-            properties["location"] = location
-
-        api_response = client._connection.api_request(
-            method="POST",
-            path="/b",
-            query_params=query_params,
-            data=properties,
-            _target_object=self,
-        )
-        self._set_properties(api_response)
+        client.create_bucket(self, project=project, location=location)
 
     def patch(self, client=None):
         """Sends all changed properties in a PATCH request.

storage/google/cloud/storage/client.py

@@ -298,7 +298,7 @@ def lookup_bucket(self, bucket_name):
         except NotFound:
             return None
 
-    def create_bucket(self, bucket_or_name, requester_pays=None, project=None):
+    def create_bucket(self, bucket_or_name, requester_pays=None, project=None, location=None):
         """API call: create a new bucket via a POST request.
 
         See
@@ -316,6 +316,10 @@ def create_bucket(self, bucket_or_name, requester_pays=None, project=None):
             project (str):
                 Optional. the project under which the bucket is to be created.
                 If not passed, uses the project set on the client.
+            location (str):
+                Optional. The location of the bucket. If not passed,
+                the default location, US, will be used. See
+                https://cloud.google.com/storage/docs/bucket-locations
 
         Returns:
             google.cloud.storage.bucket.Bucket
@@ -348,9 +352,30 @@ def create_bucket(self, bucket_or_name, requester_pays=None, project=None):
         """
         bucket = self._bucket_arg_to_bucket(bucket_or_name)
 
+        if project is None:
+            project = self.project
+
+        if project is None:
+            raise ValueError("Client project not set:  pass an explicit project.")
+
         if requester_pays is not None:
             bucket.requester_pays = requester_pays
-        bucket.create(client=self, project=project)
+
+        query_params = {"project": project}
+        properties = bucket.properties
+
+        if location is not None:
+            properties["location"] = location
+
+        api_response = self._connection.api_request(
+            method="POST",
+            path="/b",
+            query_params=query_params,
+            data=properties,
+            _target_object=bucket,
+        )
+
+        bucket._set_properties(api_response)
         return bucket
 
     def download_blob_to_file(self, blob_or_uri, file_obj, start=None, end=None):

storage/tests/unit/test_bucket.py

@@ -18,6 +18,15 @@
 import mock
 
 
+def _make_connection(*responses):
+    import google.cloud.storage._http
+
+    mock_connection = mock.create_autospec(google.cloud.storage._http.Connection)
+    mock_connection.user_agent = "testing 1.2.3"
+    mock_connection.api_request.side_effect = list(responses)
+    return mock_connection
+
+
 def _create_signing_credentials():
     import google.auth.credentials
 
@@ -535,66 +544,109 @@ def test_create_w_user_project(self):
             bucket.create()
 
     def test_create_w_missing_client_project(self):
+        from google.cloud.storage.client import Client
+
         BUCKET_NAME = "bucket-name"
-        connection = _Connection()
-        client = _Client(connection, project=None)
-        bucket = self._make_one(client, BUCKET_NAME)
+        connection = _make_connection()
+        client = Client(project=None)
 
-        with self.assertRaises(ValueError):
-            bucket.create()
+        with mock.patch(
+            'google.cloud.storage.client.Client._connection',
+            new_callable=mock.PropertyMock
+        ) as client_mock:
+            client_mock.return_value = connection
+
+            bucket = self._make_one(client, BUCKET_NAME)
+
+            with self.assertRaises(ValueError):
+                bucket.create()
 
     def test_create_w_explicit_project(self):
+        from google.cloud.storage.client import Client
+
         PROJECT = "PROJECT"
         BUCKET_NAME = "bucket-name"
         OTHER_PROJECT = "other-project-123"
         DATA = {"name": BUCKET_NAME}
-        connection = _Connection(DATA)
-        client = _Client(connection, project=PROJECT)
-        bucket = self._make_one(client, BUCKET_NAME)
-
-        bucket.create(project=OTHER_PROJECT)
-
-        kw, = connection._requested
-        self.assertEqual(kw["method"], "POST")
-        self.assertEqual(kw["path"], "/b")
-        self.assertEqual(kw["query_params"], {"project": OTHER_PROJECT})
-        self.assertEqual(kw["data"], DATA)
+        connection = _make_connection(DATA)
+        client = Client(project=PROJECT)
+        with mock.patch(
+            'google.cloud.storage.client.Client._connection',
+            new_callable=mock.PropertyMock
+        ) as client_mock:
+            client_mock.return_value = connection
+
+            bucket = self._make_one(client, BUCKET_NAME)
+            bucket.create(project=OTHER_PROJECT)
+            connection.api_request.assert_called_once_with(
+                method="POST",
+                path="/b",
+                query_params={"project": OTHER_PROJECT},
+                data=DATA,
+                _target_object=bucket
+            )
 
     def test_create_w_explicit_location(self):
+        from google.cloud.storage.client import Client
+
         PROJECT = "PROJECT"
         BUCKET_NAME = "bucket-name"
         LOCATION = "us-central1"
         DATA = {"location": LOCATION, "name": BUCKET_NAME}
-        connection = _Connection(
-            DATA, "{'location': 'us-central1', 'name': 'bucket-name'}"
+
+        connection = _make_connection(
+            DATA,
+            "{'location': 'us-central1', 'name': 'bucket-name'}"
         )
-        client = _Client(connection, project=PROJECT)
-        bucket = self._make_one(client, BUCKET_NAME)
 
-        bucket.create(location=LOCATION)
+        client = Client(project=PROJECT)
+        with mock.patch(
+            'google.cloud.storage.client.Client._connection',
+            new_callable=mock.PropertyMock
+        ) as client_mock:
+            client_mock.return_value = connection
 
-        kw, = connection._requested
-        self.assertEqual(kw["method"], "POST")
-        self.assertEqual(kw["path"], "/b")
-        self.assertEqual(kw["data"], DATA)
-        self.assertEqual(bucket.location, LOCATION)
+            bucket = self._make_one(client, BUCKET_NAME)
+
+            bucket.create(location=LOCATION)
+
+            connection.api_request.assert_called_once_with(
+                method="POST",
+                path="/b",
+                data=DATA,
+                _target_object=bucket,
+                query_params={'project': 'PROJECT'}
+            )
+            self.assertEqual(bucket.location, LOCATION)
 
     def test_create_hit(self):
+        from google.cloud.storage.client import Client
+
         PROJECT = "PROJECT"
         BUCKET_NAME = "bucket-name"
         DATA = {"name": BUCKET_NAME}
-        connection = _Connection(DATA)
-        client = _Client(connection, project=PROJECT)
-        bucket = self._make_one(client=client, name=BUCKET_NAME)
-        bucket.create()
+        connection = _make_connection(DATA)
+        client = Client(project=PROJECT)
+        with mock.patch(
+            'google.cloud.storage.client.Client._connection',
+            new_callable=mock.PropertyMock
+        ) as client_mock:
+            client_mock.return_value = connection
+
+            bucket = self._make_one(client=client, name=BUCKET_NAME)
+            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)
+            connection.api_request.assert_called_once_with(
+                method="POST",
+                path="/b",
+                query_params={"project": PROJECT},
+                data=DATA,
+                _target_object=bucket
+            )
 
     def test_create_w_extra_properties(self):
+        from google.cloud.storage.client import Client
+
         BUCKET_NAME = "bucket-name"
         PROJECT = "PROJECT"
         CORS = [
@@ -619,22 +671,31 @@ def test_create_w_extra_properties(self):
             "billing": {"requesterPays": True},
             "labels": LABELS,
         }
-        connection = _Connection(DATA)
-        client = _Client(connection, project=PROJECT)
-        bucket = self._make_one(client=client, name=BUCKET_NAME)
-        bucket.cors = CORS
-        bucket.lifecycle_rules = LIFECYCLE_RULES
-        bucket.storage_class = STORAGE_CLASS
-        bucket.versioning_enabled = True
-        bucket.requester_pays = True
-        bucket.labels = LABELS
-        bucket.create(location=LOCATION)
 
-        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)
+        connection = _make_connection(DATA)
+        client = Client(project=PROJECT)
+        with mock.patch(
+            'google.cloud.storage.client.Client._connection',
+            new_callable=mock.PropertyMock
+        ) as client_mock:
+            client_mock.return_value = connection
+
+            bucket = self._make_one(client=client, name=BUCKET_NAME)
+            bucket.cors = CORS
+            bucket.lifecycle_rules = LIFECYCLE_RULES
+            bucket.storage_class = STORAGE_CLASS
+            bucket.versioning_enabled = True
+            bucket.requester_pays = True
+            bucket.labels = LABELS
+            bucket.create(location=LOCATION)
+
+            connection.api_request.assert_called_once_with(
+                method="POST",
+                path="/b",
+                query_params={"project": PROJECT},
+                data=DATA,
+                _target_object=bucket
+            )
 
     def test_acl_property(self):
         from google.cloud.storage.acl import BucketACL