From 38427df4848d82ce7c976c6be8a9782d1112c1c2 Mon Sep 17 00:00:00 2001 From: Danny Hermes Date: Sat, 31 Jan 2015 15:05:57 -0800 Subject: [PATCH] Using a default bucket instead of bucket name in storage. This is in preparation for using the default bucket in the Blob constructor. --- gcloud/storage/__init__.py | 38 ++++++++----- gcloud/storage/_implicit_environ.py | 4 +- gcloud/storage/test___init__.py | 85 ++++++++++++++++++----------- 3 files changed, 78 insertions(+), 49 deletions(-) diff --git a/gcloud/storage/__init__.py b/gcloud/storage/__init__.py index c0a07d56b8ee..24305c05795f 100644 --- a/gcloud/storage/__init__.py +++ b/gcloud/storage/__init__.py @@ -41,6 +41,7 @@ from gcloud import credentials from gcloud.storage import _implicit_environ +from gcloud.storage.bucket import Bucket from gcloud.storage.connection import Connection @@ -52,23 +53,30 @@ _PROJECT_ENV_VAR_NAME = 'GCLOUD_PROJECT' -def set_default_bucket_name(bucket_name=None): - """Set default bucket name either explicitly or implicitly as fall-back. +def set_default_bucket(bucket=None): + """Set default bucket either explicitly or implicitly as fall-back. In implicit case, currently only supports enviroment variable but will support App Engine, Compute Engine and other environments in the future. + In the implicit case, relies on an implicit connection in addition to the + implicit bucket name. + Local environment variable used is: - GCLOUD_BUCKET_NAME - :type bucket_name: string - :param bucket_name: Optional. The bucket name to use as default. + :type bucket: :class:`gcloud.storage.bucket.Bucket` + :param bucket: Optional. The bucket to use as default. """ - if bucket_name is None: + if bucket is None: bucket_name = os.getenv(_BUCKET_ENV_VAR_NAME) + connection = _implicit_environ.CONNECTION - if bucket_name is not None: - _implicit_environ.BUCKET_NAME = bucket_name + if bucket_name is not None and connection is not None: + bucket = Bucket(connection=connection, name=bucket_name) + + if bucket is not None: + _implicit_environ.BUCKET = bucket def set_default_project(project=None): @@ -96,7 +104,7 @@ def set_default_connection(project=None, connection=None): :type project: string :param project: Optional. The name of the project to connect to. - :type connection: :class:`gcloud.datastore.connection.Connection` + :type connection: :class:`gcloud.storage.connection.Connection` :param connection: A connection provided to be the default. """ if project is None: @@ -106,25 +114,27 @@ def set_default_connection(project=None, connection=None): _implicit_environ.CONNECTION = connection -def set_defaults(bucket_name=None, project=None, connection=None): +def set_defaults(bucket=None, project=None, connection=None): """Set defaults either explicitly or implicitly as fall-back. Uses the arguments to call the individual default methods. - :type bucket_name: string - :param bucket_name: Optional. The bucket name to use as default. + :type bucket: :class:`gcloud.storage.bucket.Bucket` + :param bucket: Optional. The bucket to use as default. :type project: string :param project: Optional. The name of the project to connect to. - :type connection: :class:`gcloud.datastore.connection.Connection` - :param connection: A connection provided to be the default. + :type connection: :class:`gcloud.storage.connection.Connection` + :param connection: Optional. A connection provided to be the default. """ - set_default_bucket_name(bucket_name=bucket_name) # NOTE: `set_default_project` is called before `set_default_connection` # since `set_default_connection` falls back to implicit project. set_default_project(project=project) set_default_connection(project=project, connection=connection) + # NOTE: `set_default_bucket` is called after `set_default_connection` + # since `set_default_bucket` falls back to implicit connection. + set_default_bucket(bucket=bucket) def get_connection(project): diff --git a/gcloud/storage/_implicit_environ.py b/gcloud/storage/_implicit_environ.py index 75ce5b8b1f11..69d0a8e3207a 100644 --- a/gcloud/storage/_implicit_environ.py +++ b/gcloud/storage/_implicit_environ.py @@ -22,8 +22,8 @@ PROJECT = None """Module global to allow persistent implied project from enviroment.""" -BUCKET_NAME = None -"""Module global to allow persistent implied bucket name from enviroment.""" +BUCKET = None +"""Module global to allow persistent implied bucket from enviroment.""" CONNECTION = None """Module global to allow persistent implied connection from enviroment.""" diff --git a/gcloud/storage/test___init__.py b/gcloud/storage/test___init__.py index 60e2e5ba68dd..c68d5b76a462 100644 --- a/gcloud/storage/test___init__.py +++ b/gcloud/storage/test___init__.py @@ -71,68 +71,87 @@ def get_connection(*args, **kw): self.assertEqual(connection._called_with, BUCKET) -class Test_set_default_bucket_name(unittest2.TestCase): +class Test_set_default_bucket(unittest2.TestCase): def setUp(self): from gcloud.storage import _implicit_environ - self._replaced_bucket_name = _implicit_environ.BUCKET_NAME - _implicit_environ.BUCKET_NAME = None + self._replaced_bucket = _implicit_environ.BUCKET + _implicit_environ.BUCKET = None def tearDown(self): from gcloud.storage import _implicit_environ - _implicit_environ.BUCKET_NAME = self._replaced_bucket_name + _implicit_environ.BUCKET = self._replaced_bucket - def _callFUT(self, bucket_name=None): - from gcloud.storage import set_default_bucket_name - return set_default_bucket_name(bucket_name=bucket_name) + def _callFUT(self, bucket=None): + from gcloud.storage import set_default_bucket + return set_default_bucket(bucket=bucket) - def _monkey(self, implicit_bucket_name): + def _monkey(self, implicit_bucket_name, connection=None): + from contextlib import nested import os - from gcloud.storage import _BUCKET_ENV_VAR_NAME + from gcloud._testing import _Monkey + from gcloud.storage import _BUCKET_ENV_VAR_NAME + from gcloud.storage import _implicit_environ + environ = {_BUCKET_ENV_VAR_NAME: implicit_bucket_name} - return _Monkey(os, getenv=environ.get) + return nested(_Monkey(os, getenv=environ.get), + _Monkey(_implicit_environ, CONNECTION=connection)) def test_no_env_var_set(self): from gcloud.storage import _implicit_environ with self._monkey(None): self._callFUT() - self.assertEqual(_implicit_environ.BUCKET_NAME, None) + self.assertEqual(_implicit_environ.BUCKET, None) def test_set_from_env_var(self): from gcloud.storage import _implicit_environ IMPLICIT_BUCKET_NAME = 'IMPLICIT' - with self._monkey(IMPLICIT_BUCKET_NAME): + CONNECTION = object() + with self._monkey(IMPLICIT_BUCKET_NAME, connection=CONNECTION): self._callFUT() - self.assertEqual(_implicit_environ.BUCKET_NAME, IMPLICIT_BUCKET_NAME) + + self.assertEqual(_implicit_environ.BUCKET.name, IMPLICIT_BUCKET_NAME) + self.assertEqual(_implicit_environ.BUCKET.connection, CONNECTION) def test_set_explicit_w_env_var_set(self): from gcloud.storage import _implicit_environ - EXPLICIT_BUCKET_NAME = 'EXPLICIT' + EXPLICIT_BUCKET = object() with self._monkey(None): - self._callFUT(EXPLICIT_BUCKET_NAME) - self.assertEqual(_implicit_environ.BUCKET_NAME, EXPLICIT_BUCKET_NAME) + self._callFUT(EXPLICIT_BUCKET) + self.assertEqual(_implicit_environ.BUCKET, EXPLICIT_BUCKET) def test_set_explicit_no_env_var_set(self): from gcloud.storage import _implicit_environ IMPLICIT_BUCKET_NAME = 'IMPLICIT' - EXPLICIT_BUCKET_NAME = 'EXPLICIT' - with self._monkey(IMPLICIT_BUCKET_NAME): - self._callFUT(EXPLICIT_BUCKET_NAME) - self.assertEqual(_implicit_environ.BUCKET_NAME, EXPLICIT_BUCKET_NAME) + CONNECTION = object() + EXPLICIT_BUCKET = object() + with self._monkey(IMPLICIT_BUCKET_NAME, connection=CONNECTION): + self._callFUT(EXPLICIT_BUCKET) + self.assertEqual(_implicit_environ.BUCKET, EXPLICIT_BUCKET) def test_set_explicit_None_wo_env_var_set(self): from gcloud.storage import _implicit_environ - with self._monkey(None): + CONNECTION = object() + with self._monkey(None, connection=CONNECTION): + self._callFUT(None) + self.assertEqual(_implicit_environ.BUCKET, None) + + def test_set_explicit_None_wo_connection_set(self): + from gcloud.storage import _implicit_environ + IMPLICIT_BUCKET_NAME = 'IMPLICIT' + with self._monkey(IMPLICIT_BUCKET_NAME, connection=None): self._callFUT(None) - self.assertEqual(_implicit_environ.BUCKET_NAME, None) + self.assertEqual(_implicit_environ.BUCKET, None) def test_set_explicit_None_w_env_var_set(self): from gcloud.storage import _implicit_environ IMPLICIT_BUCKET_NAME = 'IMPLICIT' - with self._monkey(IMPLICIT_BUCKET_NAME): + CONNECTION = object() + with self._monkey(IMPLICIT_BUCKET_NAME, connection=CONNECTION): self._callFUT(None) - self.assertEqual(_implicit_environ.BUCKET_NAME, IMPLICIT_BUCKET_NAME) + self.assertEqual(_implicit_environ.BUCKET.name, IMPLICIT_BUCKET_NAME) + self.assertEqual(_implicit_environ.BUCKET.connection, CONNECTION) class Test_set_default_project(unittest2.TestCase): @@ -299,23 +318,23 @@ def mock_get_connection(*args, **kwargs): class Test_set_defaults(unittest2.TestCase): - def _callFUT(self, bucket_name=None, project=None, connection=None): + def _callFUT(self, bucket=None, project=None, connection=None): from gcloud.storage import set_defaults - return set_defaults(bucket_name=bucket_name, project=project, + return set_defaults(bucket=bucket, project=project, connection=connection) def test_it(self): from gcloud._testing import _Monkey from gcloud import storage - BUCKET_NAME = object() + BUCKET = object() PROJECT = object() CONNECTION = object() - SET_BUCKET_NAME_CALLED = [] + SET_BUCKET_CALLED = [] - def call_set_bucket_name(bucket_name=None): - SET_BUCKET_NAME_CALLED.append(bucket_name) + def call_set_bucket(bucket=None): + SET_BUCKET_CALLED.append(bucket) SET_PROJECT_CALLED = [] @@ -327,12 +346,12 @@ def call_set_project(project=None): def call_set_connection(project=None, connection=None): SET_CONNECTION_CALLED.append((project, connection)) - with _Monkey(storage, set_default_bucket_name=call_set_bucket_name, + with _Monkey(storage, set_default_bucket=call_set_bucket, set_default_connection=call_set_connection, set_default_project=call_set_project): - self._callFUT(bucket_name=BUCKET_NAME, project=PROJECT, + self._callFUT(bucket=BUCKET, project=PROJECT, connection=CONNECTION) - self.assertEqual(SET_BUCKET_NAME_CALLED, [BUCKET_NAME]) self.assertEqual(SET_PROJECT_CALLED, [PROJECT]) self.assertEqual(SET_CONNECTION_CALLED, [(PROJECT, CONNECTION)]) + self.assertEqual(SET_BUCKET_CALLED, [BUCKET])