From f15405923cd57fc4b68a71e4d2ddfc090407fef6 Mon Sep 17 00:00:00 2001 From: Thomas Schultz Date: Fri, 17 Feb 2017 08:42:49 -0500 Subject: [PATCH 1/6] Spanner unittest formatting. --- spanner/unit_tests/test__helpers.py | 49 +++++++- spanner/unit_tests/test_batch.py | 45 ++++--- spanner/unit_tests/test_client.py | 35 ++++-- spanner/unit_tests/test_database.py | 157 ++++++++++++++++--------- spanner/unit_tests/test_instance.py | 118 +++++++++++-------- spanner/unit_tests/test_keyset.py | 51 ++++---- spanner/unit_tests/test_pool.py | 142 ++++++++++++---------- spanner/unit_tests/test_session.py | 92 +++++++++------ spanner/unit_tests/test_snapshot.py | 42 ++++--- spanner/unit_tests/test_streamed.py | 98 ++++++++------- spanner/unit_tests/test_transaction.py | 62 ++++++---- 11 files changed, 562 insertions(+), 329 deletions(-) diff --git a/spanner/unit_tests/test__helpers.py b/spanner/unit_tests/test__helpers.py index 2b432d446ab0..9e33924fc14d 100644 --- a/spanner/unit_tests/test__helpers.py +++ b/spanner/unit_tests/test__helpers.py @@ -20,6 +20,7 @@ class TestTimestampWithNanoseconds(unittest.TestCase): def _get_target_class(self): from google.cloud.spanner._helpers import TimestampWithNanoseconds + return TimestampWithNanoseconds def _make_one(self, *args, **kw): @@ -82,6 +83,7 @@ def test_from_rfc3339_w_invalid(self): def test_from_rfc3339_wo_fraction(self): from google.cloud._helpers import UTC + klass = self._get_target_class() STAMP = '2016-12-20T21:13:47Z' expected = self._make_one(2016, 12, 20, 21, 13, 47, tzinfo=UTC) @@ -90,6 +92,7 @@ def test_from_rfc3339_wo_fraction(self): def test_from_rfc3339_w_partial_precision(self): from google.cloud._helpers import UTC + klass = self._get_target_class() STAMP = '2016-12-20T21:13:47.1Z' expected = self._make_one(2016, 12, 20, 21, 13, 47, @@ -99,6 +102,7 @@ def test_from_rfc3339_w_partial_precision(self): def test_from_rfc3339_w_full_precision(self): from google.cloud._helpers import UTC + klass = self._get_target_class() STAMP = '2016-12-20T21:13:47.123456789Z' expected = self._make_one(2016, 12, 20, 21, 13, 47, @@ -111,6 +115,7 @@ class Test_make_value_pb(unittest.TestCase): def _callFUT(self, *args, **kw): from google.cloud.spanner._helpers import _make_value_pb + return _make_value_pb(*args, **kw) def test_w_None(self): @@ -119,6 +124,7 @@ def test_w_None(self): def test_w_bytes(self): from google.protobuf.struct_pb2 import Value + BYTES = b'BYTES' expected = Value(string_value=BYTES) value_pb = self._callFUT(BYTES) @@ -132,6 +138,7 @@ def test_w_invalid_bytes(self): def test_w_explicit_unicode(self): from google.protobuf.struct_pb2 import Value + TEXT = u'TEXT' value_pb = self._callFUT(TEXT) self.assertIsInstance(value_pb, Value) @@ -140,6 +147,7 @@ def test_w_explicit_unicode(self): def test_w_list(self): from google.protobuf.struct_pb2 import Value from google.protobuf.struct_pb2 import ListValue + value_pb = self._callFUT([u'a', u'b', u'c']) self.assertIsInstance(value_pb, Value) self.assertIsInstance(value_pb.list_value, ListValue) @@ -149,6 +157,7 @@ def test_w_list(self): def test_w_bool(self): from google.protobuf.struct_pb2 import Value + value_pb = self._callFUT(True) self.assertIsInstance(value_pb, Value) self.assertEqual(value_pb.bool_value, True) @@ -156,6 +165,7 @@ def test_w_bool(self): def test_w_int(self): import six from google.protobuf.struct_pb2 import Value + for int_type in six.integer_types: # include 'long' on Python 2 value_pb = self._callFUT(int_type(42)) self.assertIsInstance(value_pb, Value) @@ -163,24 +173,28 @@ def test_w_int(self): def test_w_float(self): from google.protobuf.struct_pb2 import Value + value_pb = self._callFUT(3.14159) self.assertIsInstance(value_pb, Value) self.assertEqual(value_pb.number_value, 3.14159) def test_w_float_nan(self): from google.protobuf.struct_pb2 import Value + value_pb = self._callFUT(float('nan')) self.assertIsInstance(value_pb, Value) self.assertEqual(value_pb.string_value, 'NaN') def test_w_float_neg_inf(self): from google.protobuf.struct_pb2 import Value + value_pb = self._callFUT(float('-inf')) self.assertIsInstance(value_pb, Value) self.assertEqual(value_pb.string_value, '-inf') def test_w_float_pos_inf(self): from google.protobuf.struct_pb2 import Value + value_pb = self._callFUT(float('inf')) self.assertIsInstance(value_pb, Value) self.assertEqual(value_pb.string_value, 'inf') @@ -188,6 +202,7 @@ def test_w_float_pos_inf(self): def test_w_date(self): import datetime from google.protobuf.struct_pb2 import Value + today = datetime.date.today() value_pb = self._callFUT(today) self.assertIsInstance(value_pb, Value) @@ -197,6 +212,7 @@ def test_w_timestamp_w_nanos(self): from google.protobuf.struct_pb2 import Value from google.cloud._helpers import UTC from google.cloud.spanner._helpers import TimestampWithNanoseconds + when = TimestampWithNanoseconds( 2016, 12, 20, 21, 13, 47, nanosecond=123456789, tzinfo=UTC) value_pb = self._callFUT(when) @@ -207,6 +223,7 @@ def test_w_datetime(self): import datetime from google.protobuf.struct_pb2 import Value from google.cloud._helpers import UTC, _datetime_to_rfc3339 + now = datetime.datetime.utcnow().replace(tzinfo=UTC) value_pb = self._callFUT(now) self.assertIsInstance(value_pb, Value) @@ -221,16 +238,19 @@ class Test_make_list_value_pb(unittest.TestCase): def _callFUT(self, *args, **kw): from google.cloud.spanner._helpers import _make_list_value_pb + return _make_list_value_pb(*args, **kw) def test_empty(self): from google.protobuf.struct_pb2 import ListValue + result = self._callFUT(values=[]) self.assertIsInstance(result, ListValue) self.assertEqual(len(result.values), 0) def test_w_single_value(self): from google.protobuf.struct_pb2 import ListValue + VALUE = u'value' result = self._callFUT(values=[VALUE]) self.assertIsInstance(result, ListValue) @@ -239,6 +259,7 @@ def test_w_single_value(self): def test_w_multiple_values(self): from google.protobuf.struct_pb2 import ListValue + VALUE_1 = u'value' VALUE_2 = 42 result = self._callFUT(values=[VALUE_1, VALUE_2]) @@ -252,6 +273,7 @@ class Test_make_list_value_pbs(unittest.TestCase): def _callFUT(self, *args, **kw): from google.cloud.spanner._helpers import _make_list_value_pbs + return _make_list_value_pbs(*args, **kw) def test_empty(self): @@ -260,6 +282,7 @@ def test_empty(self): def test_w_single_values(self): from google.protobuf.struct_pb2 import ListValue + values = [[0], [1]] result = self._callFUT(values=values) self.assertEqual(len(result), len(values)) @@ -270,6 +293,7 @@ def test_w_single_values(self): def test_w_multiple_values(self): from google.protobuf.struct_pb2 import ListValue + values = [[0, u'A'], [1, u'B']] result = self._callFUT(values=values) self.assertEqual(len(result), len(values)) @@ -284,11 +308,13 @@ class Test_parse_value_pb(unittest.TestCase): def _callFUT(self, *args, **kw): from google.cloud.spanner._helpers import _parse_value_pb + return _parse_value_pb(*args, **kw) def test_w_null(self): from google.protobuf.struct_pb2 import Value, NULL_VALUE from google.cloud.proto.spanner.v1.type_pb2 import Type, STRING + field_type = Type(code=STRING) value_pb = Value(null_value=NULL_VALUE) @@ -297,6 +323,7 @@ def test_w_null(self): def test_w_string(self): from google.protobuf.struct_pb2 import Value from google.cloud.proto.spanner.v1.type_pb2 import Type, STRING + VALUE = u'Value' field_type = Type(code=STRING) value_pb = Value(string_value=VALUE) @@ -306,6 +333,7 @@ def test_w_string(self): def test_w_bytes(self): from google.protobuf.struct_pb2 import Value from google.cloud.proto.spanner.v1.type_pb2 import Type, BYTES + VALUE = b'Value' field_type = Type(code=BYTES) value_pb = Value(string_value=VALUE) @@ -315,6 +343,7 @@ def test_w_bytes(self): def test_w_bool(self): from google.protobuf.struct_pb2 import Value from google.cloud.proto.spanner.v1.type_pb2 import Type, BOOL + VALUE = True field_type = Type(code=BOOL) value_pb = Value(bool_value=VALUE) @@ -324,6 +353,7 @@ def test_w_bool(self): def test_w_int(self): from google.protobuf.struct_pb2 import Value from google.cloud.proto.spanner.v1.type_pb2 import Type, INT64 + VALUE = 12345 field_type = Type(code=INT64) value_pb = Value(string_value=str(VALUE)) @@ -333,6 +363,7 @@ def test_w_int(self): def test_w_float(self): from google.protobuf.struct_pb2 import Value from google.cloud.proto.spanner.v1.type_pb2 import Type, FLOAT64 + VALUE = 3.14159 field_type = Type(code=FLOAT64) value_pb = Value(number_value=VALUE) @@ -343,6 +374,7 @@ def test_w_date(self): import datetime from google.protobuf.struct_pb2 import Value from google.cloud.proto.spanner.v1.type_pb2 import Type, DATE + VALUE = datetime.date.today() field_type = Type(code=DATE) value_pb = Value(string_value=VALUE.isoformat()) @@ -354,6 +386,7 @@ def test_w_timestamp_wo_nanos(self): from google.cloud.proto.spanner.v1.type_pb2 import Type, TIMESTAMP from google.cloud._helpers import UTC, _datetime_to_rfc3339 from google.cloud.spanner._helpers import TimestampWithNanoseconds + VALUE = TimestampWithNanoseconds( 2016, 12, 20, 21, 13, 47, microsecond=123456, tzinfo=UTC) field_type = Type(code=TIMESTAMP) @@ -368,6 +401,7 @@ def test_w_timestamp_w_nanos(self): from google.cloud.proto.spanner.v1.type_pb2 import Type, TIMESTAMP from google.cloud._helpers import UTC, _datetime_to_rfc3339 from google.cloud.spanner._helpers import TimestampWithNanoseconds + VALUE = TimestampWithNanoseconds( 2016, 12, 20, 21, 13, 47, nanosecond=123456789, tzinfo=UTC) field_type = Type(code=TIMESTAMP) @@ -380,6 +414,7 @@ def test_w_timestamp_w_nanos(self): def test_w_array_empty(self): from google.protobuf.struct_pb2 import Value from google.cloud.proto.spanner.v1.type_pb2 import Type, ARRAY, INT64 + field_type = Type(code=ARRAY, array_element_type=Type(code=INT64)) value_pb = Value() @@ -388,6 +423,7 @@ def test_w_array_empty(self): def test_w_array_non_empty(self): from google.protobuf.struct_pb2 import Value, ListValue from google.cloud.proto.spanner.v1.type_pb2 import Type, ARRAY, INT64 + field_type = Type(code=ARRAY, array_element_type=Type(code=INT64)) VALUES = [32, 19, 5] values_pb = ListValue( @@ -402,6 +438,7 @@ def test_w_struct(self): from google.cloud.proto.spanner.v1.type_pb2 import ( STRUCT, STRING, INT64) from google.cloud.spanner._helpers import _make_list_value_pb + VALUES = [u'phred', 32] struct_type_pb = StructType(fields=[ StructType.Field(name='name', type=Type(code=STRING)), @@ -417,6 +454,7 @@ def test_w_unknown_type(self): from google.cloud.proto.spanner.v1.type_pb2 import Type from google.cloud.proto.spanner.v1.type_pb2 import ( TYPE_CODE_UNSPECIFIED) + field_type = Type(code=TYPE_CODE_UNSPECIFIED) value_pb = Value(string_value='Borked') @@ -428,11 +466,13 @@ class Test_parse_list_value_pbs(unittest.TestCase): def _callFUT(self, *args, **kw): from google.cloud.spanner._helpers import _parse_list_value_pbs + return _parse_list_value_pbs(*args, **kw) def test_empty(self): from google.cloud.proto.spanner.v1.type_pb2 import Type, StructType from google.cloud.proto.spanner.v1.type_pb2 import STRING, INT64 + struct_type_pb = StructType(fields=[ StructType.Field(name='name', type=Type(code=STRING)), StructType.Field(name='age', type=Type(code=INT64)), @@ -444,6 +484,7 @@ def test_non_empty(self): from google.cloud.proto.spanner.v1.type_pb2 import Type, StructType from google.cloud.proto.spanner.v1.type_pb2 import STRING, INT64 from google.cloud.spanner._helpers import _make_list_value_pbs + VALUES = [ [u'phred', 32], [u'bharney', 31], @@ -462,14 +503,15 @@ class Test_SessionWrapper(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner._helpers import _SessionWrapper + return _SessionWrapper - def _makeOne(self, session): + def _make_one(self, session): return self._getTargetClass()(session) def test_ctor(self): session = object() - base = self._makeOne(session) + base = self._make_one(session) self.assertTrue(base._session is session) @@ -477,10 +519,12 @@ class Test_options_with_prefix(unittest.TestCase): def _call_fut(self, *args, **kw): from google.cloud.spanner._helpers import _options_with_prefix + return _options_with_prefix(*args, **kw) def test_wo_kwargs(self): from google.gax import CallOptions + PREFIX = 'prefix' options = self._call_fut(PREFIX) self.assertIsInstance(options, CallOptions) @@ -489,6 +533,7 @@ def test_wo_kwargs(self): def test_w_kwargs(self): from google.gax import CallOptions + PREFIX = 'prefix' TOKEN = 'token' options = self._call_fut('prefix', page_token=TOKEN) diff --git a/spanner/unit_tests/test_batch.py b/spanner/unit_tests/test_batch.py index 5ac6aa3fcaec..ad4cbc872a1e 100644 --- a/spanner/unit_tests/test_batch.py +++ b/spanner/unit_tests/test_batch.py @@ -36,7 +36,7 @@ class _BaseTest(unittest.TestCase): SESSION_ID = 'session-id' SESSION_NAME = DATABASE_NAME + '/sessions/' + SESSION_ID - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) @@ -44,11 +44,13 @@ class Test_BatchBase(_BaseTest): def _getTargetClass(self): from google.cloud.spanner.batch import _BatchBase + return _BatchBase def _compare_values(self, result, source): from google.protobuf.struct_pb2 import ListValue from google.protobuf.struct_pb2 import Value + for found, expected in zip(result, source): self.assertIsInstance(found, ListValue) self.assertEqual(len(found.values), len(expected)) @@ -62,20 +64,21 @@ def _compare_values(self, result, source): def test_ctor(self): session = _Session() - base = self._makeOne(session) + base = self._make_one(session) self.assertTrue(base._session is session) self.assertEqual(len(base._mutations), 0) def test__check_state_virtual(self): session = _Session() - base = self._makeOne(session) + base = self._make_one(session) with self.assertRaises(NotImplementedError): base._check_state() def test_insert(self): from google.cloud.proto.spanner.v1.mutation_pb2 import Mutation + session = _Session() - base = self._makeOne(session) + base = self._make_one(session) base.insert(TABLE_NAME, columns=COLUMNS, values=VALUES) @@ -90,8 +93,9 @@ def test_insert(self): def test_update(self): from google.cloud.proto.spanner.v1.mutation_pb2 import Mutation + session = _Session() - base = self._makeOne(session) + base = self._make_one(session) base.update(TABLE_NAME, columns=COLUMNS, values=VALUES) @@ -106,8 +110,9 @@ def test_update(self): def test_insert_or_update(self): from google.cloud.proto.spanner.v1.mutation_pb2 import Mutation + session = _Session() - base = self._makeOne(session) + base = self._make_one(session) base.insert_or_update(TABLE_NAME, columns=COLUMNS, values=VALUES) @@ -122,8 +127,9 @@ def test_insert_or_update(self): def test_replace(self): from google.cloud.proto.spanner.v1.mutation_pb2 import Mutation + session = _Session() - base = self._makeOne(session) + base = self._make_one(session) base.replace(TABLE_NAME, columns=COLUMNS, values=VALUES) @@ -139,10 +145,11 @@ def test_replace(self): def test_delete(self): from google.cloud.proto.spanner.v1.mutation_pb2 import Mutation from google.cloud.spanner.keyset import KeySet + keys = [[0], [1], [2]] keyset = KeySet(keys=keys) session = _Session() - base = self._makeOne(session) + base = self._make_one(session) base.delete(TABLE_NAME, keyset=keyset) @@ -164,20 +171,22 @@ class TestBatch(_BaseTest): def _getTargetClass(self): from google.cloud.spanner.batch import Batch + return Batch def test_ctor(self): session = _Session() - batch = self._makeOne(session) + batch = self._make_one(session) self.assertTrue(batch._session is session) def test_commit_already_committed(self): from google.cloud.spanner.keyset import KeySet + keys = [[0], [1], [2]] keyset = KeySet(keys=keys) database = _Database() session = _Session(database) - batch = self._makeOne(session) + batch = self._make_one(session) batch.committed = object() batch.delete(TABLE_NAME, keyset=keyset) @@ -191,13 +200,14 @@ def test_commit_grpc_error(self): from google.cloud.proto.spanner.v1.mutation_pb2 import ( Mutation as MutationPB) from google.cloud.spanner.keyset import KeySet + keys = [[0], [1], [2]] keyset = KeySet(keys=keys) database = _Database() api = database.spanner_api = _FauxSpannerAPI( _random_gax_error=True) session = _Session(database) - batch = self._makeOne(session) + batch = self._make_one(session) batch.delete(TABLE_NAME, keyset=keyset) with self.assertRaises(GaxError): @@ -229,6 +239,7 @@ def test_commit_ok(self): TransactionOptions) from google.cloud._helpers import UTC from google.cloud._helpers import _datetime_to_pb_timestamp + now = datetime.datetime.utcnow().replace(tzinfo=UTC) now_pb = _datetime_to_pb_timestamp(now) response = CommitResponse(commit_timestamp=now_pb) @@ -236,7 +247,7 @@ def test_commit_ok(self): api = database.spanner_api = _FauxSpannerAPI( _commit_response=response) session = _Session(database) - batch = self._makeOne(session) + batch = self._make_one(session) batch.insert(TABLE_NAME, COLUMNS, VALUES) committed = batch.commit() @@ -255,11 +266,12 @@ def test_commit_ok(self): def test_context_mgr_already_committed(self): import datetime from google.cloud._helpers import UTC + now = datetime.datetime.utcnow().replace(tzinfo=UTC) database = _Database() api = database.spanner_api = _FauxSpannerAPI() session = _Session(database) - batch = self._makeOne(session) + batch = self._make_one(session) batch.committed = now with self.assertRaises(ValueError): @@ -275,6 +287,7 @@ def test_context_mgr_success(self): TransactionOptions) from google.cloud._helpers import UTC from google.cloud._helpers import _datetime_to_pb_timestamp + now = datetime.datetime.utcnow().replace(tzinfo=UTC) now_pb = _datetime_to_pb_timestamp(now) response = CommitResponse(commit_timestamp=now_pb) @@ -282,7 +295,7 @@ def test_context_mgr_success(self): api = database.spanner_api = _FauxSpannerAPI( _commit_response=response) session = _Session(database) - batch = self._makeOne(session) + batch = self._make_one(session) with batch: batch.insert(TABLE_NAME, COLUMNS, VALUES) @@ -302,6 +315,7 @@ def test_context_mgr_failure(self): from google.cloud.proto.spanner.v1.spanner_pb2 import CommitResponse from google.cloud._helpers import UTC from google.cloud._helpers import _datetime_to_pb_timestamp + now = datetime.datetime.utcnow().replace(tzinfo=UTC) now_pb = _datetime_to_pb_timestamp(now) response = CommitResponse(commit_timestamp=now_pb) @@ -309,7 +323,7 @@ def test_context_mgr_failure(self): api = database.spanner_api = _FauxSpannerAPI( _commit_response=response) session = _Session(database) - batch = self._makeOne(session) + batch = self._make_one(session) class _BailOut(Exception): pass @@ -344,6 +358,7 @@ class _FauxSpannerAPI(_GAXBaseAPI): def commit(self, session, mutations, transaction_id='', single_use_transaction=None, options=None): from google.gax.errors import GaxError + assert transaction_id == '' self._committed = (session, mutations, single_use_transaction, options) if self._random_gax_error: diff --git a/spanner/unit_tests/test_client.py b/spanner/unit_tests/test_client.py index 9a30a0e6efdf..14c968f12bda 100644 --- a/spanner/unit_tests/test_client.py +++ b/spanner/unit_tests/test_client.py @@ -42,9 +42,10 @@ class TestClient(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.client import Client + return Client - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def _constructor_test_helper(self, expected_scopes, creds, @@ -53,7 +54,7 @@ def _constructor_test_helper(self, expected_scopes, creds, from google.cloud.spanner import client as MUT user_agent = user_agent or MUT.DEFAULT_USER_AGENT - client = self._makeOne(project=self.PROJECT, credentials=creds, + client = self._make_one(project=self.PROJECT, credentials=creds, user_agent=user_agent) expected_creds = expected_creds or creds.with_scopes.return_value @@ -108,8 +109,9 @@ def test_constructor_credentials_wo_create_scoped(self): def test_instance_admin_api(self): from google.cloud._testing import _Monkey from google.cloud.spanner import client as MUT + creds = _make_credentials() - client = self._makeOne(project=self.PROJECT, credentials=creds) + client = self._make_one(project=self.PROJECT, credentials=creds) class _Client(object): pass @@ -124,8 +126,9 @@ class _Client(object): def test_database_admin_api(self): from google.cloud._testing import _Monkey from google.cloud.spanner import client as MUT + creds = _make_credentials() - client = self._makeOne(project=self.PROJECT, credentials=creds) + client = self._make_one(project=self.PROJECT, credentials=creds) class _Client(object): pass @@ -139,7 +142,7 @@ class _Client(object): def test_copy(self): credentials = _Credentials('value') - client = self._makeOne( + client = self._make_one( project=self.PROJECT, credentials=credentials, user_agent=self.USER_AGENT) @@ -151,12 +154,12 @@ def test_copy(self): def test_credentials_property(self): credentials = _Credentials() - client = self._makeOne(project=self.PROJECT, credentials=credentials) + client = self._make_one(project=self.PROJECT, credentials=credentials) self.assertTrue(client.credentials is credentials) def test_project_name_property(self): credentials = _Credentials() - client = self._makeOne(project=self.PROJECT, credentials=credentials) + client = self._make_one(project=self.PROJECT, credentials=credentials) project_name = 'projects/' + self.PROJECT self.assertEqual(client.project_name, project_name) @@ -164,8 +167,9 @@ def test_list_instance_configs_wo_paging(self): from google.cloud._testing import _GAXPageIterator from google.gax import INITIAL_PAGE from google.cloud.spanner.client import InstanceConfig + credentials = _Credentials() - client = self._makeOne(project=self.PROJECT, credentials=credentials) + client = self._make_one(project=self.PROJECT, credentials=credentials) client.connection = object() api = client._instance_admin_api = _FauxInstanceAdminAPI() config = _InstanceConfigPB(name=self.CONFIGURATION_NAME, @@ -194,11 +198,12 @@ def test_list_instance_configs_w_paging(self): import six from google.cloud._testing import _GAXPageIterator from google.cloud.spanner.client import InstanceConfig + SIZE = 15 TOKEN_RETURNED = 'TOKEN_RETURNED' TOKEN_PASSED = 'TOKEN_PASSED' credentials = _Credentials() - client = self._makeOne(project=self.PROJECT, credentials=credentials) + client = self._make_one(project=self.PROJECT, credentials=credentials) client.connection = object() api = client._instance_admin_api = _FauxInstanceAdminAPI() config = _InstanceConfigPB(name=self.CONFIGURATION_NAME, @@ -229,8 +234,9 @@ def test_list_instance_configs_w_paging(self): def test_instance_factory_defaults(self): from google.cloud.spanner.instance import DEFAULT_NODE_COUNT from google.cloud.spanner.instance import Instance + credentials = _Credentials() - client = self._makeOne(project=self.PROJECT, credentials=credentials) + client = self._make_one(project=self.PROJECT, credentials=credentials) instance = client.instance(self.INSTANCE_ID) @@ -243,8 +249,9 @@ def test_instance_factory_defaults(self): def test_instance_factory_explicit(self): from google.cloud.spanner.instance import Instance + credentials = _Credentials() - client = self._makeOne(project=self.PROJECT, credentials=credentials) + client = self._make_one(project=self.PROJECT, credentials=credentials) instance = client.instance(self.INSTANCE_ID, self.CONFIGURATION_NAME, display_name=self.DISPLAY_NAME, @@ -261,8 +268,9 @@ def test_list_instances_wo_paging(self): from google.cloud._testing import _GAXPageIterator from google.gax import INITIAL_PAGE from google.cloud.spanner.instance import Instance + credentials = _Credentials() - client = self._makeOne(project=self.PROJECT, credentials=credentials) + client = self._make_one(project=self.PROJECT, credentials=credentials) client.connection = object() api = client._instance_admin_api = _FauxInstanceAdminAPI() instance = _InstancePB(name=self.INSTANCE_NAME, @@ -296,11 +304,12 @@ def test_list_instances_w_paging(self): import six from google.cloud._testing import _GAXPageIterator from google.cloud.spanner.instance import Instance + SIZE = 15 TOKEN_RETURNED = 'TOKEN_RETURNED' TOKEN_PASSED = 'TOKEN_PASSED' credentials = _Credentials() - client = self._makeOne(project=self.PROJECT, credentials=credentials) + client = self._make_one(project=self.PROJECT, credentials=credentials) client.connection = object() api = client._instance_admin_api = _FauxInstanceAdminAPI() instance = _InstancePB(name=self.INSTANCE_NAME, diff --git a/spanner/unit_tests/test_database.py b/spanner/unit_tests/test_database.py index 89e571ee59cb..9d36e6635509 100644 --- a/spanner/unit_tests/test_database.py +++ b/spanner/unit_tests/test_database.py @@ -31,7 +31,7 @@ class _BaseTest(unittest.TestCase): SESSION_ID = 'session_id' SESSION_NAME = DATABASE_NAME + '/sessions/' + SESSION_ID - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) @@ -39,13 +39,15 @@ class TestDatabase(_BaseTest): def _getTargetClass(self): from google.cloud.spanner.database import Database + return Database def test_ctor_defaults(self): from google.cloud.spanner.pool import BurstyPool + instance = _Instance(self.INSTANCE_NAME) - database = self._makeOne(self.DATABASE_ID, instance) + database = self._make_one(self.DATABASE_ID, instance) self.assertEqual(database.database_id, self.DATABASE_ID) self.assertTrue(database._instance is instance) @@ -57,7 +59,7 @@ def test_ctor_defaults(self): def test_ctor_w_explicit_pool(self): instance = _Instance(self.INSTANCE_NAME) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) self.assertEqual(database.database_id, self.DATABASE_ID) self.assertTrue(database._instance is instance) self.assertEqual(list(database.ddl_statements), []) @@ -67,22 +69,23 @@ def test_ctor_w_explicit_pool(self): def test_ctor_w_ddl_statements_non_string(self): with self.assertRaises(ValueError): - self._makeOne( + self._make_one( self.DATABASE_ID, instance=object(), ddl_statements=[object()]) def test_ctor_w_ddl_statements_w_create_database(self): with self.assertRaises(ValueError): - self._makeOne( + self._make_one( self.DATABASE_ID, instance=object(), ddl_statements=['CREATE DATABASE foo']) def test_ctor_w_ddl_statements_ok(self): from google.cloud.spanner._fixtures import DDL_STATEMENTS + instance = _Instance(self.INSTANCE_NAME) pool = _Pool() - database = self._makeOne( + database = self._make_one( self.DATABASE_ID, instance, ddl_statements=DDL_STATEMENTS, pool=pool) self.assertEqual(database.database_id, self.DATABASE_ID) @@ -92,6 +95,7 @@ def test_ctor_w_ddl_statements_ok(self): def test_from_pb_bad_database_name(self): from google.cloud.proto.spanner.admin.database.v1 import ( spanner_database_admin_pb2 as admin_v1_pb2) + database_name = 'INCORRECT_FORMAT' database_pb = admin_v1_pb2.Database(name=database_name) klass = self._getTargetClass() @@ -102,6 +106,7 @@ def test_from_pb_bad_database_name(self): def test_from_pb_project_mistmatch(self): from google.cloud.proto.spanner.admin.database.v1 import ( spanner_database_admin_pb2 as admin_v1_pb2) + ALT_PROJECT = 'ALT_PROJECT' client = _Client(project=ALT_PROJECT) instance = _Instance(self.INSTANCE_NAME, client) @@ -114,6 +119,7 @@ def test_from_pb_project_mistmatch(self): def test_from_pb_instance_mistmatch(self): from google.cloud.proto.spanner.admin.database.v1 import ( spanner_database_admin_pb2 as admin_v1_pb2) + ALT_INSTANCE = '/projects/%s/instances/ALT-INSTANCE' % ( self.PROJECT_ID,) client = _Client() @@ -127,6 +133,7 @@ def test_from_pb_instance_mistmatch(self): def test_from_pb_success_w_explicit_pool(self): from google.cloud.proto.spanner.admin.database.v1 import ( spanner_database_admin_pb2 as admin_v1_pb2) + client = _Client() instance = _Instance(self.INSTANCE_NAME, client) database_pb = admin_v1_pb2.Database(name=self.DATABASE_NAME) @@ -144,6 +151,7 @@ def test_from_pb_success_w_hyphen_w_default_pool(self): from google.cloud.proto.spanner.admin.database.v1 import ( spanner_database_admin_pb2 as admin_v1_pb2) from google.cloud.spanner.pool import BurstyPool + DATABASE_ID_HYPHEN = 'database-id' DATABASE_NAME_HYPHEN = ( self.INSTANCE_NAME + '/databases/' + DATABASE_ID_HYPHEN) @@ -164,17 +172,18 @@ def test_from_pb_success_w_hyphen_w_default_pool(self): def test_name_property(self): instance = _Instance(self.INSTANCE_NAME) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) expected_name = self.DATABASE_NAME self.assertEqual(database.name, expected_name) def test_spanner_api_property(self): from google.cloud._testing import _Monkey from google.cloud.spanner import database as MUT + client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) _client = object() _clients = [_client] @@ -192,38 +201,39 @@ def _mock_spanner_client(): def test___eq__(self): instance = _Instance(self.INSTANCE_NAME) pool1, pool2 = _Pool(), _Pool() - database1 = self._makeOne(self.DATABASE_ID, instance, pool=pool1) - database2 = self._makeOne(self.DATABASE_ID, instance, pool=pool2) + database1 = self._make_one(self.DATABASE_ID, instance, pool=pool1) + database2 = self._make_one(self.DATABASE_ID, instance, pool=pool2) self.assertEqual(database1, database2) def test___eq__type_differ(self): pool = _Pool() - database1 = self._makeOne(self.DATABASE_ID, None, pool=pool) + database1 = self._make_one(self.DATABASE_ID, None, pool=pool) database2 = object() self.assertNotEqual(database1, database2) def test___ne__same_value(self): instance = _Instance(self.INSTANCE_NAME) pool1, pool2 = _Pool(), _Pool() - database1 = self._makeOne(self.DATABASE_ID, instance, pool=pool1) - database2 = self._makeOne(self.DATABASE_ID, instance, pool=pool2) + database1 = self._make_one(self.DATABASE_ID, instance, pool=pool1) + database2 = self._make_one(self.DATABASE_ID, instance, pool=pool2) comparison_val = (database1 != database2) self.assertFalse(comparison_val) def test___ne__(self): pool1, pool2 = _Pool(), _Pool() - database1 = self._makeOne('database_id1', 'instance1', pool=pool1) - database2 = self._makeOne('database_id2', 'instance2', pool=pool2) + database1 = self._make_one('database_id1', 'instance1', pool=pool1) + database2 = self._make_one('database_id2', 'instance2', pool=pool2) self.assertNotEqual(database1, database2) def test_create_grpc_error(self): from google.gax.errors import GaxError + client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _random_gax_error=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) with self.assertRaises(GaxError): database.create() @@ -238,14 +248,15 @@ def test_create_grpc_error(self): [('google-cloud-resource-prefix', database.name)]) def test_create_already_exists(self): - DATABASE_ID_HYPHEN = 'database-id' from google.cloud.exceptions import Conflict + + DATABASE_ID_HYPHEN = 'database-id' client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _create_database_conflict=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(DATABASE_ID_HYPHEN, instance, pool=pool) + database = self._make_one(DATABASE_ID_HYPHEN, instance, pool=pool) with self.assertRaises(Conflict): database.create() @@ -268,7 +279,7 @@ def test_create_instance_not_found(self): _database_not_found=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(DATABASE_ID_HYPHEN, instance, pool=pool) + database = self._make_one(DATABASE_ID_HYPHEN, instance, pool=pool) with self.assertRaises(NotFound): database.create() @@ -284,13 +295,14 @@ def test_create_instance_not_found(self): def test_create_success(self): from google.cloud.spanner._fixtures import DDL_STATEMENTS + op_future = _FauxOperationFuture() client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _create_database_response=op_future) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne( + database = self._make_one( self.DATABASE_ID, instance, ddl_statements=DDL_STATEMENTS, pool=pool) @@ -311,12 +323,13 @@ def test_create_success(self): def test_exists_grpc_error(self): from google.gax.errors import GaxError + client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _random_gax_error=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) with self.assertRaises(GaxError): database.exists() @@ -332,7 +345,7 @@ def test_exists_not_found(self): _database_not_found=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) self.assertFalse(database.exists()) @@ -345,6 +358,7 @@ def test_exists_success(self): from google.cloud.proto.spanner.admin.database.v1 import ( spanner_database_admin_pb2 as admin_v1_pb2) from google.cloud.spanner._fixtures import DDL_STATEMENTS + client = _Client() ddl_pb = admin_v1_pb2.GetDatabaseDdlResponse( statements=DDL_STATEMENTS) @@ -352,7 +366,7 @@ def test_exists_success(self): _get_database_ddl_response=ddl_pb) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) self.assertTrue(database.exists()) @@ -363,12 +377,13 @@ def test_exists_success(self): def test_reload_grpc_error(self): from google.gax.errors import GaxError + client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _random_gax_error=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) with self.assertRaises(GaxError): database.reload() @@ -380,12 +395,13 @@ def test_reload_grpc_error(self): def test_reload_not_found(self): from google.cloud.exceptions import NotFound + client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _database_not_found=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) with self.assertRaises(NotFound): database.reload() @@ -399,6 +415,7 @@ def test_reload_success(self): from google.cloud.proto.spanner.admin.database.v1 import ( spanner_database_admin_pb2 as admin_v1_pb2) from google.cloud.spanner._fixtures import DDL_STATEMENTS + client = _Client() ddl_pb = admin_v1_pb2.GetDatabaseDdlResponse( statements=DDL_STATEMENTS) @@ -406,7 +423,7 @@ def test_reload_success(self): _get_database_ddl_response=ddl_pb) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) database.reload() @@ -420,12 +437,13 @@ def test_reload_success(self): def test_update_ddl_grpc_error(self): from google.gax.errors import GaxError from google.cloud.spanner._fixtures import DDL_STATEMENTS + client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _random_gax_error=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) with self.assertRaises(GaxError): database.update_ddl(DDL_STATEMENTS) @@ -440,12 +458,13 @@ def test_update_ddl_grpc_error(self): def test_update_ddl_not_found(self): from google.cloud.exceptions import NotFound from google.cloud.spanner._fixtures import DDL_STATEMENTS + client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _database_not_found=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) with self.assertRaises(NotFound): database.update_ddl(DDL_STATEMENTS) @@ -459,13 +478,14 @@ def test_update_ddl_not_found(self): def test_update_ddl(self): from google.cloud.spanner._fixtures import DDL_STATEMENTS + op_future = _FauxOperationFuture() client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _update_database_ddl_response=op_future) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) future = database.update_ddl(DDL_STATEMENTS) @@ -482,12 +502,13 @@ def test_update_ddl(self): def test_drop_grpc_error(self): from google.gax.errors import GaxError + client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _random_gax_error=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) with self.assertRaises(GaxError): database.drop() @@ -499,12 +520,13 @@ def test_drop_grpc_error(self): def test_drop_not_found(self): from google.cloud.exceptions import NotFound + client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _database_not_found=True) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) with self.assertRaises(NotFound): database.drop() @@ -516,12 +538,13 @@ def test_drop_not_found(self): def test_drop_success(self): from google.protobuf.empty_pb2 import Empty + client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _drop_database_response=Empty()) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) database.drop() @@ -532,10 +555,11 @@ def test_drop_success(self): def test_session_factory(self): from google.cloud.spanner.session import Session + client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) session = database.session() @@ -551,7 +575,7 @@ def test_execute_sql_defaults(self): session = _Session() pool.put(session) session._execute_result = [] - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) rows = list(database.execute_sql(QUERY)) @@ -560,6 +584,7 @@ def test_execute_sql_defaults(self): def test_run_in_transaction_wo_args(self): import datetime + NOW = datetime.datetime.now() client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) @@ -567,7 +592,7 @@ def test_run_in_transaction_wo_args(self): session = _Session() pool.put(session) session._committed = NOW - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) _unit_of_work = object() @@ -578,6 +603,7 @@ def test_run_in_transaction_wo_args(self): def test_run_in_transaction_w_args(self): import datetime + SINCE = datetime.datetime(2017, 1, 1) UNTIL = datetime.datetime(2018, 1, 1) NOW = datetime.datetime.now() @@ -587,7 +613,7 @@ def test_run_in_transaction_w_args(self): session = _Session() pool.put(session) session._committed = NOW - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) _unit_of_work = object() @@ -600,6 +626,7 @@ def test_run_in_transaction_w_args(self): def test_read(self): from google.cloud.spanner.keyset import KeySet + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] KEYS = ['bharney@example.com', 'phred@example.com'] @@ -612,7 +639,7 @@ def test_read(self): pool = _Pool() session = _Session() pool.put(session) - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) rows = list(database.read( TABLE_NAME, COLUMNS, KEYSET, INDEX, LIMIT, TOKEN)) @@ -631,12 +658,13 @@ def test_read(self): def test_batch(self): from google.cloud.spanner.database import BatchCheckout + client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() session = _Session() pool.put(session) - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) checkout = database.batch() self.assertIsInstance(checkout, BatchCheckout) @@ -644,12 +672,13 @@ def test_batch(self): def test_snapshot_defaults(self): from google.cloud.spanner.database import SnapshotCheckout + client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() session = _Session() pool.put(session) - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) checkout = database.snapshot() self.assertIsInstance(checkout, SnapshotCheckout) @@ -663,13 +692,14 @@ def test_snapshot_w_read_timestamp(self): import datetime from google.cloud._helpers import UTC from google.cloud.spanner.database import SnapshotCheckout + now = datetime.datetime.utcnow().replace(tzinfo=UTC) client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() session = _Session() pool.put(session) - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) checkout = database.snapshot(read_timestamp=now) @@ -684,13 +714,14 @@ def test_snapshot_w_min_read_timestamp(self): import datetime from google.cloud._helpers import UTC from google.cloud.spanner.database import SnapshotCheckout + now = datetime.datetime.utcnow().replace(tzinfo=UTC) client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() session = _Session() pool.put(session) - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) checkout = database.snapshot(min_read_timestamp=now) @@ -704,13 +735,14 @@ def test_snapshot_w_min_read_timestamp(self): def test_snapshot_w_max_staleness(self): import datetime from google.cloud.spanner.database import SnapshotCheckout + staleness = datetime.timedelta(seconds=1, microseconds=234567) client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() session = _Session() pool.put(session) - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) checkout = database.snapshot(max_staleness=staleness) @@ -724,13 +756,14 @@ def test_snapshot_w_max_staleness(self): def test_snapshot_w_exact_staleness(self): import datetime from google.cloud.spanner.database import SnapshotCheckout + staleness = datetime.timedelta(seconds=1, microseconds=234567) client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() session = _Session() pool.put(session) - database = self._makeOne(self.DATABASE_ID, instance, pool=pool) + database = self._make_one(self.DATABASE_ID, instance, pool=pool) checkout = database.snapshot(exact_staleness=staleness) @@ -746,11 +779,12 @@ class TestBatchCheckout(_BaseTest): def _getTargetClass(self): from google.cloud.spanner.database import BatchCheckout + return BatchCheckout def test_ctor(self): database = _Database(self.DATABASE_NAME) - checkout = self._makeOne(database) + checkout = self._make_one(database) self.assertTrue(checkout._database is database) def test_context_mgr_success(self): @@ -761,6 +795,7 @@ def test_context_mgr_success(self): from google.cloud._helpers import UTC from google.cloud._helpers import _datetime_to_pb_timestamp from google.cloud.spanner.batch import Batch + now = datetime.datetime.utcnow().replace(tzinfo=UTC) now_pb = _datetime_to_pb_timestamp(now) response = CommitResponse(commit_timestamp=now_pb) @@ -770,7 +805,7 @@ def test_context_mgr_success(self): pool = database._pool = _Pool() session = _Session(database) pool.put(session) - checkout = self._makeOne(database) + checkout = self._make_one(database) with checkout as batch: self.assertIsNone(pool._session) @@ -790,11 +825,12 @@ def test_context_mgr_success(self): def test_context_mgr_failure(self): from google.cloud.spanner.batch import Batch + database = _Database(self.DATABASE_NAME) pool = database._pool = _Pool() session = _Session(database) pool.put(session) - checkout = self._makeOne(database) + checkout = self._make_one(database) class Testing(Exception): pass @@ -814,16 +850,18 @@ class TestSnapshotCheckout(_BaseTest): def _getTargetClass(self): from google.cloud.spanner.database import SnapshotCheckout + return SnapshotCheckout def test_ctor_defaults(self): from google.cloud.spanner.snapshot import Snapshot + database = _Database(self.DATABASE_NAME) session = _Session(database) pool = database._pool = _Pool() pool.put(session) - checkout = self._makeOne(database) + checkout = self._make_one(database) self.assertTrue(checkout._database is database) self.assertIsNone(checkout._read_timestamp) self.assertIsNone(checkout._min_read_timestamp) @@ -842,13 +880,14 @@ def test_ctor_w_read_timestamp(self): import datetime from google.cloud._helpers import UTC from google.cloud.spanner.snapshot import Snapshot + now = datetime.datetime.utcnow().replace(tzinfo=UTC) database = _Database(self.DATABASE_NAME) session = _Session(database) pool = database._pool = _Pool() pool.put(session) - checkout = self._makeOne(database, read_timestamp=now) + checkout = self._make_one(database, read_timestamp=now) self.assertTrue(checkout._database is database) self.assertEqual(checkout._read_timestamp, now) self.assertIsNone(checkout._min_read_timestamp) @@ -868,13 +907,14 @@ def test_ctor_w_min_read_timestamp(self): import datetime from google.cloud._helpers import UTC from google.cloud.spanner.snapshot import Snapshot + now = datetime.datetime.utcnow().replace(tzinfo=UTC) database = _Database(self.DATABASE_NAME) session = _Session(database) pool = database._pool = _Pool() pool.put(session) - checkout = self._makeOne(database, min_read_timestamp=now) + checkout = self._make_one(database, min_read_timestamp=now) self.assertTrue(checkout._database is database) self.assertIsNone(checkout._read_timestamp) self.assertEqual(checkout._min_read_timestamp, now) @@ -893,13 +933,14 @@ def test_ctor_w_min_read_timestamp(self): def test_ctor_w_max_staleness(self): import datetime from google.cloud.spanner.snapshot import Snapshot + staleness = datetime.timedelta(seconds=1, microseconds=234567) database = _Database(self.DATABASE_NAME) session = _Session(database) pool = database._pool = _Pool() pool.put(session) - checkout = self._makeOne(database, max_staleness=staleness) + checkout = self._make_one(database, max_staleness=staleness) self.assertTrue(checkout._database is database) self.assertIsNone(checkout._read_timestamp) self.assertIsNone(checkout._min_read_timestamp) @@ -918,13 +959,14 @@ def test_ctor_w_max_staleness(self): def test_ctor_w_exact_staleness(self): import datetime from google.cloud.spanner.snapshot import Snapshot + staleness = datetime.timedelta(seconds=1, microseconds=234567) database = _Database(self.DATABASE_NAME) session = _Session(database) pool = database._pool = _Pool() pool.put(session) - checkout = self._makeOne(database, exact_staleness=staleness) + checkout = self._make_one(database, exact_staleness=staleness) self.assertIs(checkout._database, database) self.assertIsNone(checkout._read_timestamp) @@ -943,11 +985,12 @@ def test_ctor_w_exact_staleness(self): def test_context_mgr_failure(self): from google.cloud.spanner.snapshot import Snapshot + database = _Database(self.DATABASE_NAME) pool = database._pool = _Pool() session = _Session(database) pool.put(session) - checkout = self._makeOne(database) + checkout = self._make_one(database) class Testing(Exception): pass @@ -1068,14 +1111,13 @@ class _FauxDatabaseAdminAPI(_GAXBaseAPI): def _make_grpc_already_exists(self): from grpc.beta.interfaces import StatusCode + return self._make_grpc_error(StatusCode.ALREADY_EXISTS) - def create_database(self, - parent, - create_statement, - extra_statements=None, + def create_database(self, parent, create_statement, extra_statements=None, options=None): from google.gax.errors import GaxError + self._created_database = ( parent, create_statement, extra_statements, options) if self._random_gax_error: @@ -1088,6 +1130,7 @@ def create_database(self, def get_database_ddl(self, database, options=None): from google.gax.errors import GaxError + self._got_database_ddl = database, options if self._random_gax_error: raise GaxError('error') @@ -1097,6 +1140,7 @@ def get_database_ddl(self, database, options=None): def drop_database(self, database, options=None): from google.gax.errors import GaxError + self._dropped_database = database, options if self._random_gax_error: raise GaxError('error') @@ -1107,6 +1151,7 @@ def drop_database(self, database, options=None): def update_database_ddl(self, database, statements, operation_id, options=None): from google.gax.errors import GaxError + self._updated_database_ddl = ( database, statements, operation_id, options) if self._random_gax_error: diff --git a/spanner/unit_tests/test_instance.py b/spanner/unit_tests/test_instance.py index be275a49d023..bd6cc19442fb 100644 --- a/spanner/unit_tests/test_instance.py +++ b/spanner/unit_tests/test_instance.py @@ -38,15 +38,17 @@ class TestInstance(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.instance import Instance + return Instance - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_constructor_defaults(self): from google.cloud.spanner.instance import DEFAULT_NODE_COUNT + client = object() - instance = self._makeOne(self.INSTANCE_ID, client) + instance = self._make_one(self.INSTANCE_ID, client) self.assertEqual(instance.instance_id, self.INSTANCE_ID) self.assertTrue(instance._client is client) self.assertTrue(instance.configuration_name is None) @@ -57,10 +59,10 @@ def test_constructor_non_default(self): DISPLAY_NAME = 'display_name' client = object() - instance = self._makeOne(self.INSTANCE_ID, client, - configuration_name=self.CONFIG_NAME, - node_count=self.NODE_COUNT, - display_name=DISPLAY_NAME) + instance = self._make_one(self.INSTANCE_ID, client, + configuration_name=self.CONFIG_NAME, + node_count=self.NODE_COUNT, + display_name=DISPLAY_NAME) self.assertEqual(instance.instance_id, self.INSTANCE_ID) self.assertTrue(instance._client is client) self.assertEqual(instance.configuration_name, self.CONFIG_NAME) @@ -71,8 +73,8 @@ def test_copy(self): DISPLAY_NAME = 'display_name' client = _Client(self.PROJECT) - instance = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME, - display_name=DISPLAY_NAME) + instance = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME, + display_name=DISPLAY_NAME) new_instance = instance.copy() # Make sure the client copy succeeded. @@ -91,7 +93,7 @@ def test__update_from_pb_success(self): display_name=display_name, ) - instance = self._makeOne(None, None, None, None) + instance = self._make_one(None, None, None, None) self.assertEqual(instance.display_name, None) instance._update_from_pb(instance_pb) self.assertEqual(instance.display_name, display_name) @@ -101,7 +103,7 @@ def test__update_from_pb_no_display_name(self): spanner_instance_admin_pb2 as admin_v1_pb2) instance_pb = admin_v1_pb2.Instance() - instance = self._makeOne(None, None, None, None) + instance = self._make_one(None, None, None, None) self.assertEqual(instance.display_name, None) with self.assertRaises(ValueError): instance._update_from_pb(instance_pb) @@ -155,40 +157,41 @@ def test_from_pb_success(self): def test_name_property(self): client = _Client(project=self.PROJECT) - instance = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) self.assertEqual(instance.name, self.INSTANCE_NAME) def test___eq__(self): client = object() - instance1 = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) - instance2 = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance1 = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance2 = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) self.assertEqual(instance1, instance2) def test___eq__type_differ(self): client = object() - instance1 = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance1 = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) instance2 = object() self.assertNotEqual(instance1, instance2) def test___ne__same_value(self): client = object() - instance1 = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) - instance2 = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance1 = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance2 = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) comparison_val = (instance1 != instance2) self.assertFalse(comparison_val) def test___ne__(self): - instance1 = self._makeOne('instance_id1', 'client1', self.CONFIG_NAME) - instance2 = self._makeOne('instance_id2', 'client2', self.CONFIG_NAME) + instance1 = self._make_one('instance_id1', 'client1', self.CONFIG_NAME) + instance2 = self._make_one('instance_id2', 'client2', self.CONFIG_NAME) self.assertNotEqual(instance1, instance2) def test_create_grpc_error(self): from google.gax.errors import GaxError + client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _random_gax_error=True) - instance = self._makeOne(self.INSTANCE_ID, client, - configuration_name=self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, + configuration_name=self.CONFIG_NAME) with self.assertRaises(GaxError): instance.create() @@ -205,11 +208,12 @@ def test_create_grpc_error(self): def test_create_already_exists(self): from google.cloud.exceptions import Conflict + client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _create_instance_conflict=True) - instance = self._makeOne(self.INSTANCE_ID, client, - configuration_name=self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, + configuration_name=self.CONFIG_NAME) with self.assertRaises(Conflict): instance.create() @@ -229,10 +233,10 @@ def test_create_success(self): client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _create_instance_response=op_future) - instance = self._makeOne(self.INSTANCE_ID, client, - configuration_name=self.CONFIG_NAME, - display_name=self.DISPLAY_NAME, - node_count=self.NODE_COUNT) + instance = self._make_one(self.INSTANCE_ID, client, + configuration_name=self.CONFIG_NAME, + display_name=self.DISPLAY_NAME, + node_count=self.NODE_COUNT) future = instance.create() @@ -252,10 +256,11 @@ def test_create_success(self): def test_exists_instance_grpc_error(self): from google.gax.errors import GaxError + client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _random_gax_error=True) - instance = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) with self.assertRaises(GaxError): instance.exists() @@ -270,7 +275,7 @@ def test_exists_instance_not_found(self): api = client.instance_admin_api = _FauxInstanceAdminAPI( _instance_not_found=True) api._instance_not_found = True - instance = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) self.assertFalse(instance.exists()) @@ -282,6 +287,7 @@ def test_exists_instance_not_found(self): def test_exists_success(self): from google.cloud.proto.spanner.admin.instance.v1 import ( spanner_instance_admin_pb2 as admin_v1_pb2) + client = _Client(self.PROJECT) instance_pb = admin_v1_pb2.Instance( name=self.INSTANCE_NAME, @@ -291,7 +297,7 @@ def test_exists_success(self): ) api = client.instance_admin_api = _FauxInstanceAdminAPI( _get_instance_response=instance_pb) - instance = self._makeOne(self.INSTANCE_ID, client) + instance = self._make_one(self.INSTANCE_ID, client) self.assertTrue(instance.exists()) @@ -302,10 +308,11 @@ def test_exists_success(self): def test_reload_instance_grpc_error(self): from google.gax.errors import GaxError + client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _random_gax_error=True) - instance = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) with self.assertRaises(GaxError): instance.reload() @@ -317,11 +324,12 @@ def test_reload_instance_grpc_error(self): def test_reload_instance_not_found(self): from google.cloud.exceptions import NotFound + client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _instance_not_found=True) api._instance_not_found = True - instance = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) with self.assertRaises(NotFound): instance.reload() @@ -334,6 +342,7 @@ def test_reload_instance_not_found(self): def test_reload_success(self): from google.cloud.proto.spanner.admin.instance.v1 import ( spanner_instance_admin_pb2 as admin_v1_pb2) + client = _Client(self.PROJECT) instance_pb = admin_v1_pb2.Instance( name=self.INSTANCE_NAME, @@ -343,7 +352,7 @@ def test_reload_success(self): ) api = client.instance_admin_api = _FauxInstanceAdminAPI( _get_instance_response=instance_pb) - instance = self._makeOne(self.INSTANCE_ID, client) + instance = self._make_one(self.INSTANCE_ID, client) instance.reload() @@ -359,11 +368,12 @@ def test_reload_success(self): def test_update_grpc_error(self): from google.gax.errors import GaxError from google.cloud.spanner.instance import DEFAULT_NODE_COUNT + client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _random_gax_error=True) - instance = self._makeOne(self.INSTANCE_ID, client, - configuration_name=self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, + configuration_name=self.CONFIG_NAME) with self.assertRaises(GaxError): instance.update() @@ -381,11 +391,12 @@ def test_update_grpc_error(self): def test_update_not_found(self): from google.cloud.exceptions import NotFound from google.cloud.spanner.instance import DEFAULT_NODE_COUNT + client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _instance_not_found=True) - instance = self._makeOne(self.INSTANCE_ID, client, - configuration_name=self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, + configuration_name=self.CONFIG_NAME) with self.assertRaises(NotFound): instance.update() @@ -405,10 +416,10 @@ def test_update_success(self): client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _update_instance_response=op_future) - instance = self._makeOne(self.INSTANCE_ID, client, - configuration_name=self.CONFIG_NAME, - node_count=self.NODE_COUNT, - display_name=self.DISPLAY_NAME) + instance = self._make_one(self.INSTANCE_ID, client, + configuration_name=self.CONFIG_NAME, + node_count=self.NODE_COUNT, + display_name=self.DISPLAY_NAME) future = instance.update() @@ -428,10 +439,11 @@ def test_update_success(self): def test_delete_grpc_error(self): from google.gax.errors import GaxError + client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _random_gax_error=True) - instance = self._makeOne(self.INSTANCE_ID, client) + instance = self._make_one(self.INSTANCE_ID, client) with self.assertRaises(GaxError): instance.delete() @@ -443,10 +455,11 @@ def test_delete_grpc_error(self): def test_delete_not_found(self): from google.cloud.exceptions import NotFound + client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _instance_not_found=True) - instance = self._makeOne(self.INSTANCE_ID, client) + instance = self._make_one(self.INSTANCE_ID, client) with self.assertRaises(NotFound): instance.delete() @@ -458,10 +471,11 @@ def test_delete_not_found(self): def test_delete_success(self): from google.protobuf.empty_pb2 import Empty + client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _delete_instance_response=Empty()) - instance = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) instance.delete() @@ -473,8 +487,9 @@ def test_delete_success(self): def test_database_factory_defaults(self): from google.cloud.spanner.database import Database from google.cloud.spanner.pool import BurstyPool + client = _Client(self.PROJECT) - instance = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) DATABASE_ID = 'database-id' database = instance.database(DATABASE_ID) @@ -490,8 +505,9 @@ def test_database_factory_defaults(self): def test_database_factory_explicit(self): from google.cloud.spanner._fixtures import DDL_STATEMENTS from google.cloud.spanner.database import Database + client = _Client(self.PROJECT) - instance = self._makeOne(self.INSTANCE_ID, client, self.CONFIG_NAME) + instance = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) DATABASE_ID = 'database-id' pool = _Pool() @@ -509,13 +525,14 @@ def test_list_databases_wo_paging(self): from google.cloud._testing import _GAXPageIterator from google.gax import INITIAL_PAGE from google.cloud.spanner.database import Database + NEXT_TOKEN = 'TOKEN' database_pb = _DatabasePB(name=self.DATABASE_NAME) response = _GAXPageIterator([database_pb], page_token=NEXT_TOKEN) client = _Client(self.PROJECT) api = client.database_admin_api = _FauxDatabaseAdminAPI() api._list_databases_response = response - instance = self._makeOne(self.INSTANCE_ID, client) + instance = self._make_one(self.INSTANCE_ID, client) iterator = instance.list_databases() next_token = iterator.next_page_token @@ -537,6 +554,7 @@ def test_list_databases_wo_paging(self): def test_list_databases_w_paging(self): from google.cloud._testing import _GAXPageIterator from google.cloud.spanner.database import Database + SIZE = 15 TOKEN = 'TOKEN' database_pb = _DatabasePB(name=self.DATABASE_NAME) @@ -544,7 +562,7 @@ def test_list_databases_w_paging(self): client = _Client(self.PROJECT) api = client.database_admin_api = _FauxDatabaseAdminAPI() api._list_databases_response = response - instance = self._makeOne(self.INSTANCE_ID, client) + instance = self._make_one(self.INSTANCE_ID, client) iterator = instance.list_databases( page_size=SIZE, page_token=TOKEN) @@ -574,6 +592,7 @@ def __init__(self, project, timeout_seconds=None): def copy(self): from copy import deepcopy + return deepcopy(self) def __eq__(self, other): @@ -595,10 +614,12 @@ class _FauxInstanceAdminAPI(_GAXBaseAPI): def _make_grpc_already_exists(self): from grpc.beta.interfaces import StatusCode + return self._make_grpc_error(StatusCode.ALREADY_EXISTS) def create_instance(self, parent, instance_id, instance, options=None): from google.gax.errors import GaxError + self._created_instance = (parent, instance_id, instance, options) if self._random_gax_error: raise GaxError('error') @@ -608,6 +629,7 @@ def create_instance(self, parent, instance_id, instance, options=None): def get_instance(self, name, options=None): from google.gax.errors import GaxError + self._got_instance = (name, options) if self._random_gax_error: raise GaxError('error') @@ -617,6 +639,7 @@ def get_instance(self, name, options=None): def update_instance(self, instance, field_mask, options=None): from google.gax.errors import GaxError + self._updated_instance = (instance, field_mask, options) if self._random_gax_error: raise GaxError('error') @@ -626,6 +649,7 @@ def update_instance(self, instance, field_mask, options=None): def delete_instance(self, name, options=None): from google.gax.errors import GaxError + self._deleted_instance = name, options if self._random_gax_error: raise GaxError('error') diff --git a/spanner/unit_tests/test_keyset.py b/spanner/unit_tests/test_keyset.py index 7da6dfd9fc85..6ee0670c5828 100644 --- a/spanner/unit_tests/test_keyset.py +++ b/spanner/unit_tests/test_keyset.py @@ -20,30 +20,31 @@ class TestKeyRange(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.keyset import KeyRange + return KeyRange - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_ctor_no_start_no_end(self): with self.assertRaises(ValueError): - self._makeOne() + self._make_one() def test_ctor_w_start_open_and_start_closed(self): KEY_1 = [u'key_1'] KEY_2 = [u'key_2'] with self.assertRaises(ValueError): - self._makeOne(start_open=KEY_1, start_closed=KEY_2) + self._make_one(start_open=KEY_1, start_closed=KEY_2) def test_ctor_w_end_open_and_end_closed(self): KEY_1 = [u'key_1'] KEY_2 = [u'key_2'] with self.assertRaises(ValueError): - self._makeOne(end_open=KEY_1, end_closed=KEY_2) + self._make_one(end_open=KEY_1, end_closed=KEY_2) def test_ctor_w_only_start_open(self): KEY_1 = [u'key_1'] - krange = self._makeOne(start_open=KEY_1) + krange = self._make_one(start_open=KEY_1) self.assertEqual(krange.start_open, KEY_1) self.assertEqual(krange.start_closed, None) self.assertEqual(krange.end_open, None) @@ -51,7 +52,7 @@ def test_ctor_w_only_start_open(self): def test_ctor_w_only_start_closed(self): KEY_1 = [u'key_1'] - krange = self._makeOne(start_closed=KEY_1) + krange = self._make_one(start_closed=KEY_1) self.assertEqual(krange.start_open, None) self.assertEqual(krange.start_closed, KEY_1) self.assertEqual(krange.end_open, None) @@ -59,7 +60,7 @@ def test_ctor_w_only_start_closed(self): def test_ctor_w_only_end_open(self): KEY_1 = [u'key_1'] - krange = self._makeOne(end_open=KEY_1) + krange = self._make_one(end_open=KEY_1) self.assertEqual(krange.start_open, None) self.assertEqual(krange.start_closed, None) self.assertEqual(krange.end_open, KEY_1) @@ -67,7 +68,7 @@ def test_ctor_w_only_end_open(self): def test_ctor_w_only_end_closed(self): KEY_1 = [u'key_1'] - krange = self._makeOne(end_closed=KEY_1) + krange = self._make_one(end_closed=KEY_1) self.assertEqual(krange.start_open, None) self.assertEqual(krange.start_closed, None) self.assertEqual(krange.end_open, None) @@ -76,7 +77,7 @@ def test_ctor_w_only_end_closed(self): def test_ctor_w_start_open_and_end_closed(self): KEY_1 = [u'key_1'] KEY_2 = [u'key_2'] - krange = self._makeOne(start_open=KEY_1, end_closed=KEY_2) + krange = self._make_one(start_open=KEY_1, end_closed=KEY_2) self.assertEqual(krange.start_open, KEY_1) self.assertEqual(krange.start_closed, None) self.assertEqual(krange.end_open, None) @@ -85,7 +86,7 @@ def test_ctor_w_start_open_and_end_closed(self): def test_ctor_w_start_closed_and_end_open(self): KEY_1 = [u'key_1'] KEY_2 = [u'key_2'] - krange = self._makeOne(start_closed=KEY_1, end_open=KEY_2) + krange = self._make_one(start_closed=KEY_1, end_open=KEY_2) self.assertEqual(krange.start_open, None) self.assertEqual(krange.start_closed, KEY_1) self.assertEqual(krange.end_open, KEY_2) @@ -93,9 +94,10 @@ def test_ctor_w_start_closed_and_end_open(self): def test_to_pb_w_start_closed_and_end_open(self): from google.cloud.proto.spanner.v1.keys_pb2 import KeyRange + KEY_1 = [u'key_1'] KEY_2 = [u'key_2'] - krange = self._makeOne(start_closed=KEY_1, end_open=KEY_2) + krange = self._make_one(start_closed=KEY_1, end_open=KEY_2) krange_pb = krange.to_pb() self.assertIsInstance(krange_pb, KeyRange) self.assertEqual(len(krange_pb.start_closed), 1) @@ -106,9 +108,10 @@ def test_to_pb_w_start_closed_and_end_open(self): def test_to_pb_w_start_open_and_end_closed(self): from google.cloud.proto.spanner.v1.keys_pb2 import KeyRange + KEY_1 = [u'key_1'] KEY_2 = [u'key_2'] - krange = self._makeOne(start_open=KEY_1, end_closed=KEY_2) + krange = self._make_one(start_open=KEY_1, end_closed=KEY_2) krange_pb = krange.to_pb() self.assertIsInstance(krange_pb, KeyRange) self.assertEqual(len(krange_pb.start_open), 1) @@ -121,13 +124,14 @@ class TestKeySet(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.keyset import KeySet + return KeySet - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_ctor_w_all(self): - keyset = self._makeOne(all_=True) + keyset = self._make_one(all_=True) self.assertTrue(keyset.all_) self.assertEqual(keyset.keys, []) @@ -136,7 +140,7 @@ def test_ctor_w_all(self): def test_ctor_w_keys(self): KEYS = [[u'key1'], [u'key2']] - keyset = self._makeOne(keys=KEYS) + keyset = self._make_one(keys=KEYS) self.assertFalse(keyset.all_) self.assertEqual(keyset.keys, KEYS) @@ -144,10 +148,11 @@ def test_ctor_w_keys(self): def test_ctor_w_ranges(self): from google.cloud.spanner.keyset import KeyRange + range_1 = KeyRange(start_closed=[u'key1'], end_open=[u'key3']) range_2 = KeyRange(start_open=[u'key5'], end_closed=[u'key6']) - keyset = self._makeOne(ranges=[range_1, range_2]) + keyset = self._make_one(ranges=[range_1, range_2]) self.assertFalse(keyset.all_) self.assertEqual(keyset.keys, []) @@ -156,19 +161,21 @@ def test_ctor_w_ranges(self): def test_ctor_w_all_and_keys(self): with self.assertRaises(ValueError): - self._makeOne(all_=True, keys=[['key1'], ['key2']]) + self._make_one(all_=True, keys=[['key1'], ['key2']]) def test_ctor_w_all_and_ranges(self): from google.cloud.spanner.keyset import KeyRange + range_1 = KeyRange(start_closed=[u'key1'], end_open=[u'key3']) range_2 = KeyRange(start_open=[u'key5'], end_closed=[u'key6']) with self.assertRaises(ValueError): - self._makeOne(all_=True, ranges=[range_1, range_2]) + self._make_one(all_=True, ranges=[range_1, range_2]) def test_to_pb_w_all(self): from google.cloud.proto.spanner.v1.keys_pb2 import KeySet - keyset = self._makeOne(all_=True) + + keyset = self._make_one(all_=True) result = keyset.to_pb() @@ -179,8 +186,9 @@ def test_to_pb_w_all(self): def test_to_pb_w_only_keys(self): from google.cloud.proto.spanner.v1.keys_pb2 import KeySet + KEYS = [[u'key1'], [u'key2']] - keyset = self._makeOne(keys=KEYS) + keyset = self._make_one(keys=KEYS) result = keyset.to_pb() @@ -197,6 +205,7 @@ def test_to_pb_w_only_keys(self): def test_to_pb_w_only_ranges(self): from google.cloud.proto.spanner.v1.keys_pb2 import KeySet from google.cloud.spanner.keyset import KeyRange + KEY_1 = u'KEY_1' KEY_2 = u'KEY_2' KEY_3 = u'KEY_3' @@ -205,7 +214,7 @@ def test_to_pb_w_only_ranges(self): KeyRange(start_open=KEY_1, end_closed=KEY_2), KeyRange(start_closed=KEY_3, end_open=KEY_4), ] - keyset = self._makeOne(ranges=RANGES) + keyset = self._make_one(ranges=RANGES) result = keyset.to_pb() diff --git a/spanner/unit_tests/test_pool.py b/spanner/unit_tests/test_pool.py index e0a06852c031..f017fbc84e6b 100644 --- a/spanner/unit_tests/test_pool.py +++ b/spanner/unit_tests/test_pool.py @@ -20,40 +20,42 @@ class TestAbstractSessionPool(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.pool import AbstractSessionPool + return AbstractSessionPool - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_ctor_defaults(self): - pool = self._makeOne() + pool = self._make_one() self.assertIsNone(pool._database) def test_bind_abstract(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') with self.assertRaises(NotImplementedError): pool.bind(database) def test_get_abstract(self): - pool = self._makeOne() + pool = self._make_one() with self.assertRaises(NotImplementedError): pool.get() def test_put_abstract(self): - pool = self._makeOne() + pool = self._make_one() session = object() with self.assertRaises(NotImplementedError): pool.put(session) def test_clear_abstract(self): - pool = self._makeOne() + pool = self._make_one() with self.assertRaises(NotImplementedError): pool.clear() def test_session_wo_kwargs(self): from google.cloud.spanner.pool import SessionCheckout - pool = self._makeOne() + + pool = self._make_one() checkout = pool.session() self.assertIsInstance(checkout, SessionCheckout) self.assertIs(checkout._pool, pool) @@ -62,7 +64,8 @@ def test_session_wo_kwargs(self): def test_session_w_kwargs(self): from google.cloud.spanner.pool import SessionCheckout - pool = self._makeOne() + + pool = self._make_one() checkout = pool.session(foo='bar') self.assertIsInstance(checkout, SessionCheckout) self.assertIs(checkout._pool, pool) @@ -74,27 +77,28 @@ class TestFixedSizePool(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.pool import FixedSizePool + return FixedSizePool - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_ctor_defaults(self): - pool = self._makeOne() + pool = self._make_one() self.assertIsNone(pool._database) self.assertEqual(pool.size, 10) self.assertEqual(pool.default_timeout, 10) self.assertTrue(pool._sessions.empty()) def test_ctor_explicit(self): - pool = self._makeOne(size=4, default_timeout=30) + pool = self._make_one(size=4, default_timeout=30) self.assertIsNone(pool._database) self.assertEqual(pool.size, 4) self.assertEqual(pool.default_timeout, 30) self.assertTrue(pool._sessions.empty()) def test_bind(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') SESSIONS = [_Session(database)] * 10 database._sessions.extend(SESSIONS) @@ -110,7 +114,7 @@ def test_bind(self): self.assertTrue(session._created) def test_get_non_expired(self): - pool = self._makeOne(size=4) + pool = self._make_one(size=4) database = _Database('name') SESSIONS = [_Session(database)] * 4 database._sessions.extend(SESSIONS) @@ -123,7 +127,7 @@ def test_get_non_expired(self): self.assertFalse(pool._sessions.full()) def test_get_expired(self): - pool = self._makeOne(size=4) + pool = self._make_one(size=4) database = _Database('name') SESSIONS = [_Session(database)] * 5 SESSIONS[0]._exists = False @@ -139,7 +143,8 @@ def test_get_expired(self): def test_get_empty_default_timeout(self): from six.moves.queue import Empty - pool = self._makeOne(size=1) + + pool = self._make_one(size=1) queue = pool._sessions = _Queue() with self.assertRaises(Empty): @@ -149,7 +154,8 @@ def test_get_empty_default_timeout(self): def test_get_empty_explicit_timeout(self): from six.moves.queue import Empty - pool = self._makeOne(size=1, default_timeout=0.1) + + pool = self._make_one(size=1, default_timeout=0.1) queue = pool._sessions = _Queue() with self.assertRaises(Empty): @@ -159,7 +165,8 @@ def test_get_empty_explicit_timeout(self): def test_put_full(self): from six.moves.queue import Full - pool = self._makeOne(size=4) + + pool = self._make_one(size=4) database = _Database('name') SESSIONS = [_Session(database)] * 4 database._sessions.extend(SESSIONS) @@ -171,7 +178,7 @@ def test_put_full(self): self.assertTrue(pool._sessions.full()) def test_put_non_full(self): - pool = self._makeOne(size=4) + pool = self._make_one(size=4) database = _Database('name') SESSIONS = [_Session(database)] * 4 database._sessions.extend(SESSIONS) @@ -183,7 +190,7 @@ def test_put_non_full(self): self.assertTrue(pool._sessions.full()) def test_clear(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') SESSIONS = [_Session(database)] * 10 database._sessions.extend(SESSIONS) @@ -203,25 +210,26 @@ class TestBurstyPool(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.pool import BurstyPool + return BurstyPool - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_ctor_defaults(self): - pool = self._makeOne() + pool = self._make_one() self.assertIsNone(pool._database) self.assertEqual(pool.target_size, 10) self.assertTrue(pool._sessions.empty()) def test_ctor_explicit(self): - pool = self._makeOne(target_size=4) + pool = self._make_one(target_size=4) self.assertIsNone(pool._database) self.assertEqual(pool.target_size, 4) self.assertTrue(pool._sessions.empty()) def test_get_empty(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') database._sessions.append(_Session(database)) pool.bind(database) @@ -234,7 +242,7 @@ def test_get_empty(self): self.assertTrue(pool._sessions.empty()) def test_get_non_empty_session_exists(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') previous = _Session(database) pool.bind(database) @@ -248,7 +256,7 @@ def test_get_non_empty_session_exists(self): self.assertTrue(pool._sessions.empty()) def test_get_non_empty_session_expired(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') previous = _Session(database, exists=False) newborn = _Session(database) @@ -265,7 +273,7 @@ def test_get_non_empty_session_expired(self): self.assertTrue(pool._sessions.empty()) def test_put_empty(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') pool.bind(database) session = _Session(database) @@ -275,7 +283,7 @@ def test_put_empty(self): self.assertFalse(pool._sessions.empty()) def test_put_full(self): - pool = self._makeOne(target_size=1) + pool = self._make_one(target_size=1) database = _Database('name') pool.bind(database) older = _Session(database) @@ -289,7 +297,7 @@ def test_put_full(self): self.assertIs(pool.get(), older) def test_put_full_expired(self): - pool = self._makeOne(target_size=1) + pool = self._make_one(target_size=1) database = _Database('name') pool.bind(database) older = _Session(database) @@ -303,7 +311,7 @@ def test_put_full_expired(self): self.assertIs(pool.get(), older) def test_clear(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') pool.bind(database) previous = _Session(database) @@ -318,13 +326,14 @@ class TestPingingPool(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.pool import PingingPool + return PingingPool - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_ctor_defaults(self): - pool = self._makeOne() + pool = self._make_one() self.assertIsNone(pool._database) self.assertEqual(pool.size, 10) self.assertEqual(pool.default_timeout, 10) @@ -332,7 +341,7 @@ def test_ctor_defaults(self): self.assertTrue(pool._sessions.empty()) def test_ctor_explicit(self): - pool = self._makeOne(size=4, default_timeout=30, ping_interval=1800) + pool = self._make_one(size=4, default_timeout=30, ping_interval=1800) self.assertIsNone(pool._database) self.assertEqual(pool.size, 4) self.assertEqual(pool.default_timeout, 30) @@ -340,7 +349,7 @@ def test_ctor_explicit(self): self.assertTrue(pool._sessions.empty()) def test_bind(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') SESSIONS = [_Session(database)] * 10 database._sessions.extend(SESSIONS) @@ -357,7 +366,7 @@ def test_bind(self): self.assertTrue(session._created) def test_get_hit_no_ping(self): - pool = self._makeOne(size=4) + pool = self._make_one(size=4) database = _Database('name') SESSIONS = [_Session(database)] * 4 database._sessions.extend(SESSIONS) @@ -373,7 +382,8 @@ def test_get_hit_w_ping(self): import datetime from google.cloud._testing import _Monkey from google.cloud.spanner import pool as MUT - pool = self._makeOne(size=4) + + pool = self._make_one(size=4) database = _Database('name') SESSIONS = [_Session(database)] * 4 database._sessions.extend(SESSIONS) @@ -394,7 +404,8 @@ def test_get_hit_w_ping_expired(self): import datetime from google.cloud._testing import _Monkey from google.cloud.spanner import pool as MUT - pool = self._makeOne(size=4) + + pool = self._make_one(size=4) database = _Database('name') SESSIONS = [_Session(database)] * 5 SESSIONS[0]._exists = False @@ -415,7 +426,8 @@ def test_get_hit_w_ping_expired(self): def test_get_empty_default_timeout(self): from six.moves.queue import Empty - pool = self._makeOne(size=1) + + pool = self._make_one(size=1) queue = pool._sessions = _Queue() with self.assertRaises(Empty): @@ -425,7 +437,8 @@ def test_get_empty_default_timeout(self): def test_get_empty_explicit_timeout(self): from six.moves.queue import Empty - pool = self._makeOne(size=1, default_timeout=0.1) + + pool = self._make_one(size=1, default_timeout=0.1) queue = pool._sessions = _Queue() with self.assertRaises(Empty): @@ -435,7 +448,8 @@ def test_get_empty_explicit_timeout(self): def test_put_full(self): from six.moves.queue import Full - pool = self._makeOne(size=4) + + pool = self._make_one(size=4) database = _Database('name') SESSIONS = [_Session(database)] * 4 database._sessions.extend(SESSIONS) @@ -450,7 +464,8 @@ def test_put_non_full(self): import datetime from google.cloud._testing import _Monkey from google.cloud.spanner import pool as MUT - pool = self._makeOne(size=1) + + pool = self._make_one(size=1) queue = pool._sessions = _Queue() now = datetime.datetime.utcnow() @@ -466,7 +481,7 @@ def test_put_non_full(self): self.assertIs(queued, session) def test_clear(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') SESSIONS = [_Session(database)] * 10 database._sessions.extend(SESSIONS) @@ -482,11 +497,11 @@ def test_clear(self): self.assertTrue(session._deleted) def test_ping_empty(self): - pool = self._makeOne(size=1) + pool = self._make_one(size=1) pool.ping() # Does not raise 'Empty' def test_ping_oldest_fresh(self): - pool = self._makeOne(size=1) + pool = self._make_one(size=1) database = _Database('name') SESSIONS = [_Session(database)] * 1 database._sessions.extend(SESSIONS) @@ -500,7 +515,8 @@ def test_ping_oldest_stale_but_exists(self): import datetime from google.cloud._testing import _Monkey from google.cloud.spanner import pool as MUT - pool = self._makeOne(size=1) + + pool = self._make_one(size=1) database = _Database('name') SESSIONS = [_Session(database)] * 1 database._sessions.extend(SESSIONS) @@ -516,7 +532,8 @@ def test_ping_oldest_stale_and_not_exists(self): import datetime from google.cloud._testing import _Monkey from google.cloud.spanner import pool as MUT - pool = self._makeOne(size=1) + + pool = self._make_one(size=1) database = _Database('name') SESSIONS = [_Session(database)] * 2 SESSIONS[0]._exists = False @@ -535,13 +552,14 @@ class TestTransactionPingingPool(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.pool import TransactionPingingPool + return TransactionPingingPool - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_ctor_defaults(self): - pool = self._makeOne() + pool = self._make_one() self.assertIsNone(pool._database) self.assertEqual(pool.size, 10) self.assertEqual(pool.default_timeout, 10) @@ -550,7 +568,7 @@ def test_ctor_defaults(self): self.assertTrue(pool._pending_sessions.empty()) def test_ctor_explicit(self): - pool = self._makeOne(size=4, default_timeout=30, ping_interval=1800) + pool = self._make_one(size=4, default_timeout=30, ping_interval=1800) self.assertIsNone(pool._database) self.assertEqual(pool.size, 4) self.assertEqual(pool.default_timeout, 30) @@ -559,7 +577,7 @@ def test_ctor_explicit(self): self.assertTrue(pool._pending_sessions.empty()) def test_bind(self): - pool = self._makeOne() + pool = self._make_one() database = _Database('name') SESSIONS = [_Session(database) for _ in range(10)] database._sessions.extend(SESSIONS) @@ -581,7 +599,8 @@ def test_bind(self): def test_put_full(self): from six.moves.queue import Full - pool = self._makeOne(size=4) + + pool = self._make_one(size=4) database = _Database('name') SESSIONS = [_Session(database) for _ in range(4)] database._sessions.extend(SESSIONS) @@ -593,7 +612,7 @@ def test_put_full(self): self.assertTrue(pool._sessions.full()) def test_put_non_full_w_active_txn(self): - pool = self._makeOne(size=1) + pool = self._make_one(size=1) queue = pool._sessions = _Queue() pending = pool._pending_sessions = _Queue() database = _Database('name') @@ -610,7 +629,7 @@ def test_put_non_full_w_active_txn(self): self.assertFalse(txn._begun) def test_put_non_full_w_committed_txn(self): - pool = self._makeOne(size=1) + pool = self._make_one(size=1) queue = pool._sessions = _Queue() pending = pool._pending_sessions = _Queue() database = _Database('name') @@ -628,7 +647,7 @@ def test_put_non_full_w_committed_txn(self): self.assertFalse(session._transaction._begun) def test_put_non_full(self): - pool = self._makeOne(size=1) + pool = self._make_one(size=1) queue = pool._sessions = _Queue() pending = pool._pending_sessions = _Queue() database = _Database('name') @@ -643,11 +662,11 @@ def test_put_non_full(self): self.assertFalse(pending.empty()) def test_begin_pending_transactions_empty(self): - pool = self._makeOne(size=1) + pool = self._make_one(size=1) pool.begin_pending_transactions() # no raise def test_begin_pending_transactions_non_empty(self): - pool = self._makeOne(size=1) + pool = self._make_one(size=1) pool._sessions = _Queue() database = _Database('name') @@ -670,21 +689,22 @@ class TestSessionCheckout(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.pool import SessionCheckout + return SessionCheckout - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_ctor_wo_kwargs(self): pool = _Pool() - checkout = self._makeOne(pool) + checkout = self._make_one(pool) self.assertIs(checkout._pool, pool) self.assertIsNone(checkout._session) self.assertEqual(checkout._kwargs, {}) def test_ctor_w_kwargs(self): pool = _Pool() - checkout = self._makeOne(pool, foo='bar') + checkout = self._make_one(pool, foo='bar') self.assertIs(checkout._pool, pool) self.assertIsNone(checkout._session) self.assertEqual(checkout._kwargs, {'foo': 'bar'}) @@ -692,7 +712,7 @@ def test_ctor_w_kwargs(self): def test_context_manager_wo_kwargs(self): session = object() pool = _Pool(session) - checkout = self._makeOne(pool) + checkout = self._make_one(pool) self.assertEqual(len(pool._items), 1) self.assertIs(pool._items[0], session) @@ -708,7 +728,7 @@ def test_context_manager_wo_kwargs(self): def test_context_manager_w_kwargs(self): session = object() pool = _Pool(session) - checkout = self._makeOne(pool, foo='bar') + checkout = self._make_one(pool, foo='bar') self.assertEqual(len(pool._items), 1) self.assertIs(pool._items[0], session) @@ -756,6 +776,7 @@ def exists(self): def delete(self): from google.cloud.exceptions import NotFound + self._deleted = True if not self._exists: raise NotFound("unknown session") @@ -790,6 +811,7 @@ def full(self): def get(self, **kwargs): from six.moves.queue import Empty + self._got = kwargs try: return self._items.pop() diff --git a/spanner/unit_tests/test_session.py b/spanner/unit_tests/test_session.py index 0c1f500e12e6..c7257adca15f 100644 --- a/spanner/unit_tests/test_session.py +++ b/spanner/unit_tests/test_session.py @@ -30,32 +30,33 @@ class TestSession(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.session import Session + return Session - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_constructor(self): database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) self.assertTrue(session.session_id is None) self.assertTrue(session._database is database) def test_name_property_wo_session_id(self): database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) with self.assertRaises(ValueError): _ = session.name def test_name_property_w_session_id(self): database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) session._session_id = self.SESSION_ID self.assertEqual(session.name, self.SESSION_NAME) def test_create_w_session_id(self): database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) session._session_id = self.SESSION_ID with self.assertRaises(ValueError): session.create() @@ -65,7 +66,7 @@ def test_create_ok(self): gax_api = _SpannerApi(_create_session_response=session_pb) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session.create() @@ -78,10 +79,11 @@ def test_create_ok(self): def test_create_error(self): from google.gax.errors import GaxError + gax_api = _SpannerApi(_random_gax_error=True) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) with self.assertRaises(GaxError): session.create() @@ -93,7 +95,7 @@ def test_create_error(self): def test_exists_wo_session_id(self): database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) self.assertFalse(session.exists()) def test_exists_hit(self): @@ -101,7 +103,7 @@ def test_exists_hit(self): gax_api = _SpannerApi(_get_session_response=session_pb) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = self.SESSION_ID self.assertTrue(session.exists()) @@ -115,7 +117,7 @@ def test_exists_miss(self): gax_api = _SpannerApi() database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = self.SESSION_ID self.assertFalse(session.exists()) @@ -127,10 +129,11 @@ def test_exists_miss(self): def test_exists_error(self): from google.gax.errors import GaxError + gax_api = _SpannerApi(_random_gax_error=True) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = self.SESSION_ID with self.assertRaises(GaxError): @@ -143,7 +146,7 @@ def test_exists_error(self): def test_delete_wo_session_id(self): database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) with self.assertRaises(ValueError): session.delete() @@ -151,7 +154,7 @@ def test_delete_hit(self): gax_api = _SpannerApi(_delete_session_ok=True) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = self.SESSION_ID session.delete() @@ -163,10 +166,11 @@ def test_delete_hit(self): def test_delete_miss(self): from google.cloud.exceptions import NotFound + gax_api = _SpannerApi(_delete_session_ok=False) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = self.SESSION_ID with self.assertRaises(NotFound): @@ -179,10 +183,11 @@ def test_delete_miss(self): def test_delete_error(self): from google.gax.errors import GaxError + gax_api = _SpannerApi(_random_gax_error=True) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = self.SESSION_ID with self.assertRaises(GaxError): @@ -195,15 +200,16 @@ def test_delete_error(self): def test_snapshot_not_created(self): database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) with self.assertRaises(ValueError): session.snapshot() def test_snapshot_created(self): from google.cloud.spanner.snapshot import Snapshot + database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' # emulate 'session.create()' snapshot = session.snapshot() @@ -214,12 +220,13 @@ def test_snapshot_created(self): def test_read_not_created(self): from google.cloud.spanner.keyset import KeySet + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] KEYS = ['bharney@example.com', 'phred@example.com'] KEYSET = KeySet(keys=KEYS) database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) with self.assertRaises(ValueError): session.read(TABLE_NAME, COLUMNS, KEYSET) @@ -228,6 +235,7 @@ def test_read(self): from google.cloud.spanner import session as MUT from google.cloud._testing import _Monkey from google.cloud.spanner.keyset import KeySet + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] KEYS = ['bharney@example.com', 'phred@example.com'] @@ -236,7 +244,7 @@ def test_read(self): LIMIT = 20 TOKEN = b'DEADBEEF' database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' _read_with = [] @@ -274,7 +282,7 @@ def read(self, table, columns, keyset, index='', limit=0, def test_execute_sql_not_created(self): SQL = 'SELECT first_name, age FROM citizens' database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) with self.assertRaises(ValueError): session.execute_sql(SQL) @@ -282,10 +290,11 @@ def test_execute_sql_not_created(self): def test_execute_sql_defaults(self): from google.cloud.spanner import session as MUT from google.cloud._testing import _Monkey + SQL = 'SELECT first_name, age FROM citizens' TOKEN = b'DEADBEEF' database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' _executed_sql_with = [] @@ -320,15 +329,16 @@ def execute_sql( def test_batch_not_created(self): database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) with self.assertRaises(ValueError): session.batch() def test_batch_created(self): from google.cloud.spanner.batch import Batch + database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' batch = session.batch() @@ -338,15 +348,16 @@ def test_batch_created(self): def test_transaction_not_created(self): database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) with self.assertRaises(ValueError): session.transaction() def test_transaction_created(self): from google.cloud.spanner.transaction import Transaction + database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' transaction = session.transaction() @@ -357,7 +368,7 @@ def test_transaction_created(self): def test_transaction_w_existing_txn(self): database = _Database(self.DATABASE_NAME) - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' existing = session.transaction() @@ -369,6 +380,7 @@ def test_transaction_w_existing_txn(self): def test_retry_transaction_w_commit_error_txn_already_begun(self): from google.gax.errors import GaxError from google.cloud.spanner.transaction import Transaction + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] VALUES = [ @@ -380,7 +392,7 @@ def test_retry_transaction_w_commit_error_txn_already_begun(self): ) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' begun_txn = session._transaction = Transaction(session) begun_txn._id = b'FACEDACE' @@ -405,6 +417,7 @@ def test_run_in_transaction_callback_raises_abort(self): from google.cloud.proto.spanner.v1.transaction_pb2 import ( Transaction as TransactionPB) from google.cloud.spanner.transaction import Transaction + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] VALUES = [ @@ -419,7 +432,7 @@ def test_run_in_transaction_callback_raises_abort(self): ) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' called_with = [] @@ -451,6 +464,7 @@ def test_run_in_transaction_w_args_w_kwargs_wo_abort(self): from google.cloud._helpers import UTC from google.cloud._helpers import _datetime_to_pb_timestamp from google.cloud.spanner.transaction import Transaction + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] VALUES = [ @@ -468,7 +482,7 @@ def test_run_in_transaction_w_args_w_kwargs_wo_abort(self): ) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' called_with = [] @@ -496,6 +510,7 @@ def test_run_in_transaction_w_abort_no_retry_metadata(self): from google.cloud._helpers import UTC from google.cloud._helpers import _datetime_to_pb_timestamp from google.cloud.spanner.transaction import Transaction + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] VALUES = [ @@ -514,7 +529,7 @@ def test_run_in_transaction_w_abort_no_retry_metadata(self): ) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' called_with = [] @@ -547,6 +562,7 @@ def test_run_in_transaction_w_abort_w_retry_metadata(self): from google.cloud.spanner.transaction import Transaction from google.cloud.spanner import session as MUT from google.cloud._testing import _Monkey + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] VALUES = [ @@ -569,7 +585,7 @@ def test_run_in_transaction_w_abort_w_retry_metadata(self): ) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' called_with = [] @@ -609,6 +625,7 @@ def test_run_in_transaction_w_callback_raises_abort_wo_metadata(self): from google.cloud.spanner.transaction import Transaction from google.cloud.spanner import session as MUT from google.cloud._testing import _Monkey + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] VALUES = [ @@ -630,7 +647,7 @@ def test_run_in_transaction_w_callback_raises_abort_wo_metadata(self): ) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' called_with = [] @@ -675,6 +692,7 @@ def test_run_in_transaction_w_abort_w_retry_metadata_deadline(self): from google.cloud.spanner.transaction import Transaction from google.cloud.spanner import session as MUT from google.cloud._testing import _Monkey + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] VALUES = [ @@ -697,7 +715,7 @@ def test_run_in_transaction_w_abort_w_retry_metadata_deadline(self): ) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' called_with = [] @@ -729,6 +747,7 @@ def test_run_in_transaction_w_timeout(self): Transaction as TransactionPB) from grpc import StatusCode from google.cloud.spanner.transaction import Transaction + TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] VALUES = [ @@ -743,7 +762,7 @@ def test_run_in_transaction_w_timeout(self): ) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api - session = self._makeOne(database) + session = self._make_one(database) session._session_id = 'DEADBEEF' called_with = [] @@ -780,6 +799,7 @@ class _SpannerApi(_GAXBaseAPI): def create_session(self, database, options=None): from google.gax.errors import GaxError + self._create_session_called_with = database, options if self._random_gax_error: raise GaxError('error') @@ -787,6 +807,7 @@ def create_session(self, database, options=None): def get_session(self, name, options=None): from google.gax.errors import GaxError + self._get_session_called_with = name, options if self._random_gax_error: raise GaxError('error') @@ -797,6 +818,7 @@ def get_session(self, name, options=None): def delete_session(self, name, options=None): from google.gax.errors import GaxError + self._delete_session_called_with = name, options if self._random_gax_error: raise GaxError('error') @@ -811,6 +833,7 @@ def _trailing_metadata(self): from google.protobuf.duration_pb2 import Duration from google.rpc.error_details_pb2 import RetryInfo from grpc._common import cygrpc_metadata + if self._commit_abort_retry_nanos is None: return cygrpc_metadata(()) retry_info = RetryInfo( @@ -824,6 +847,7 @@ def commit(self, session, mutations, transaction_id='', single_use_transaction=None, options=None): from grpc import StatusCode from google.gax.errors import GaxError + assert single_use_transaction is None self._committed = (session, mutations, transaction_id, options) if self._commit_error: diff --git a/spanner/unit_tests/test_snapshot.py b/spanner/unit_tests/test_snapshot.py index 3e8fe26583ef..cf1abce94f45 100644 --- a/spanner/unit_tests/test_snapshot.py +++ b/spanner/unit_tests/test_snapshot.py @@ -43,9 +43,10 @@ class Test_SnapshotBase(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.snapshot import _SnapshotBase + return _SnapshotBase - def _makeOne(self, session): + def _make_one(self, session): return self._getTargetClass()(session) def _makeDerived(self, session): @@ -55,6 +56,7 @@ class _Derived(self._getTargetClass()): def _make_txn_selector(self): from google.cloud.proto.spanner.v1.transaction_pb2 import ( TransactionOptions, TransactionSelector) + options = TransactionOptions( read_only=TransactionOptions.ReadOnly(strong=True)) return TransactionSelector(single_use=options) @@ -63,12 +65,12 @@ def _make_txn_selector(self): def test_ctor(self): session = _Session() - base = self._makeOne(session) + base = self._make_one(session) self.assertTrue(base._session is session) def test__make_txn_selector_virtual(self): session = _Session() - base = self._makeOne(session) + base = self._make_one(session) with self.assertRaises(NotImplementedError): base._make_txn_selector() @@ -77,6 +79,7 @@ def test_read_grpc_error(self): TransactionSelector) from google.gax.errors import GaxError from google.cloud.spanner.keyset import KeySet + KEYSET = KeySet(all_=True) database = _Database() api = database.spanner_api = _FauxSpannerAPI( @@ -112,6 +115,7 @@ def test_read_normal(self): from google.cloud.proto.spanner.v1.type_pb2 import STRING, INT64 from google.cloud.spanner.keyset import KeySet from google.cloud.spanner._helpers import _make_value_pb + VALUES = [ [u'bharney', 31], [u'phred', 32], @@ -172,6 +176,7 @@ def test_execute_sql_grpc_error(self): from google.cloud.proto.spanner.v1.transaction_pb2 import ( TransactionSelector) from google.gax.errors import GaxError + database = _Database() api = database.spanner_api = _FauxSpannerAPI( _random_gax_error=True) @@ -212,6 +217,7 @@ def test_execute_sql_normal(self): from google.cloud.proto.spanner.v1.type_pb2 import Type, StructType from google.cloud.proto.spanner.v1.type_pb2 import STRING, INT64 from google.cloud.spanner._helpers import _make_value_pb + VALUES = [ [u'bharney', u'rhubbyl', 31], [u'phred', u'phlyntstone', 32], @@ -297,21 +303,23 @@ def _getTargetClass(self): from google.cloud.spanner.snapshot import Snapshot return Snapshot - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def _makeTimestamp(self): import datetime from google.cloud._helpers import UTC + return datetime.datetime.utcnow().replace(tzinfo=UTC) def _makeDuration(self, seconds=1, microseconds=0): import datetime + return datetime.timedelta(seconds=seconds, microseconds=microseconds) def test_ctor_defaults(self): session = _Session() - snapshot = self._makeOne(session) + snapshot = self._make_one(session) self.assertTrue(snapshot._session is session) self.assertTrue(snapshot._strong) self.assertIsNone(snapshot._read_timestamp) @@ -325,13 +333,13 @@ def test_ctor_w_multiple_options(self): session = _Session() with self.assertRaises(ValueError): - self._makeOne( + self._make_one( session, read_timestamp=timestamp, max_staleness=duration) def test_ctor_w_read_timestamp(self): timestamp = self._makeTimestamp() session = _Session() - snapshot = self._makeOne(session, read_timestamp=timestamp) + snapshot = self._make_one(session, read_timestamp=timestamp) self.assertTrue(snapshot._session is session) self.assertFalse(snapshot._strong) self.assertEqual(snapshot._read_timestamp, timestamp) @@ -342,7 +350,7 @@ def test_ctor_w_read_timestamp(self): def test_ctor_w_min_read_timestamp(self): timestamp = self._makeTimestamp() session = _Session() - snapshot = self._makeOne(session, min_read_timestamp=timestamp) + snapshot = self._make_one(session, min_read_timestamp=timestamp) self.assertTrue(snapshot._session is session) self.assertFalse(snapshot._strong) self.assertIsNone(snapshot._read_timestamp) @@ -353,7 +361,7 @@ def test_ctor_w_min_read_timestamp(self): def test_ctor_w_max_staleness(self): duration = self._makeDuration() session = _Session() - snapshot = self._makeOne(session, max_staleness=duration) + snapshot = self._make_one(session, max_staleness=duration) self.assertTrue(snapshot._session is session) self.assertFalse(snapshot._strong) self.assertIsNone(snapshot._read_timestamp) @@ -364,7 +372,7 @@ def test_ctor_w_max_staleness(self): def test_ctor_w_exact_staleness(self): duration = self._makeDuration() session = _Session() - snapshot = self._makeOne(session, exact_staleness=duration) + snapshot = self._make_one(session, exact_staleness=duration) self.assertTrue(snapshot._session is session) self.assertFalse(snapshot._strong) self.assertIsNone(snapshot._read_timestamp) @@ -374,16 +382,17 @@ def test_ctor_w_exact_staleness(self): def test__make_txn_selector_strong(self): session = _Session() - snapshot = self._makeOne(session) + snapshot = self._make_one(session) selector = snapshot._make_txn_selector() options = selector.single_use self.assertTrue(options.read_only.strong) def test__make_txn_selector_w_read_timestamp(self): from google.cloud._helpers import _pb_timestamp_to_datetime + timestamp = self._makeTimestamp() session = _Session() - snapshot = self._makeOne(session, read_timestamp=timestamp) + snapshot = self._make_one(session, read_timestamp=timestamp) selector = snapshot._make_txn_selector() options = selector.single_use self.assertEqual( @@ -392,9 +401,10 @@ def test__make_txn_selector_w_read_timestamp(self): def test__make_txn_selector_w_min_read_timestamp(self): from google.cloud._helpers import _pb_timestamp_to_datetime + timestamp = self._makeTimestamp() session = _Session() - snapshot = self._makeOne(session, min_read_timestamp=timestamp) + snapshot = self._make_one(session, min_read_timestamp=timestamp) selector = snapshot._make_txn_selector() options = selector.single_use self.assertEqual( @@ -404,7 +414,7 @@ def test__make_txn_selector_w_min_read_timestamp(self): def test__make_txn_selector_w_max_staleness(self): duration = self._makeDuration(seconds=3, microseconds=123456) session = _Session() - snapshot = self._makeOne(session, max_staleness=duration) + snapshot = self._make_one(session, max_staleness=duration) selector = snapshot._make_txn_selector() options = selector.single_use self.assertEqual(options.read_only.max_staleness.seconds, 3) @@ -413,7 +423,7 @@ def test__make_txn_selector_w_max_staleness(self): def test__make_txn_selector_w_exact_staleness(self): duration = self._makeDuration(seconds=3, microseconds=123456) session = _Session() - snapshot = self._makeOne(session, exact_staleness=duration) + snapshot = self._make_one(session, exact_staleness=duration) selector = snapshot._make_txn_selector() options = selector.single_use self.assertEqual(options.read_only.exact_staleness.seconds, 3) @@ -440,6 +450,7 @@ def streaming_read(self, session, table, columns, key_set, transaction=None, index='', limit=0, resume_token='', options=None): from google.gax.errors import GaxError + self._streaming_read_with = ( session, table, columns, key_set, transaction, index, limit, resume_token, options) @@ -452,6 +463,7 @@ def execute_streaming_sql(self, session, sql, transaction=None, params=None, param_types=None, resume_token='', query_mode=None, options=None): from google.gax.errors import GaxError + self._executed_streaming_sql_with = ( session, sql, transaction, params, param_types, resume_token, query_mode, options) diff --git a/spanner/unit_tests/test_streamed.py b/spanner/unit_tests/test_streamed.py index 115eda9b96f0..674d34e2a03c 100644 --- a/spanner/unit_tests/test_streamed.py +++ b/spanner/unit_tests/test_streamed.py @@ -20,14 +20,15 @@ class TestStreamedResultSet(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.streamed import StreamedResultSet + return StreamedResultSet - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_ctor_defaults(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) self.assertIs(streamed._response_iterator, iterator) self.assertEqual(streamed.rows, []) self.assertIsNone(streamed.metadata) @@ -36,7 +37,7 @@ def test_ctor_defaults(self): def test_fields_unset(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) with self.assertRaises(AttributeError): _ = streamed.fields @@ -44,12 +45,14 @@ def test_fields_unset(self): def _makeScalarField(name, type_): from google.cloud.proto.spanner.v1.type_pb2 import StructType from google.cloud.proto.spanner.v1.type_pb2 import Type + return StructType.Field(name=name, type=Type(code=type_)) @staticmethod def _makeArrayField(name, element_type_code=None, element_type=None): from google.cloud.proto.spanner.v1.type_pb2 import StructType from google.cloud.proto.spanner.v1.type_pb2 import Type + if element_type is None: element_type = Type(code=element_type_code) array_type = Type( @@ -60,6 +63,7 @@ def _makeArrayField(name, element_type_code=None, element_type=None): def _makeStructType(struct_type_fields): from google.cloud.proto.spanner.v1.type_pb2 import StructType from google.cloud.proto.spanner.v1.type_pb2 import Type + fields = [ StructType.Field(name=key, type=Type(code=value)) for key, value in struct_type_fields @@ -70,6 +74,7 @@ def _makeStructType(struct_type_fields): @staticmethod def _makeValue(value): from google.cloud.spanner._helpers import _make_value_pb + return _make_value_pb(value) @staticmethod @@ -77,13 +82,14 @@ def _makeListValue(values=(), value_pbs=None): from google.protobuf.struct_pb2 import ListValue from google.protobuf.struct_pb2 import Value from google.cloud.spanner._helpers import _make_list_value_pb + if value_pbs is not None: return Value(list_value=ListValue(values=value_pbs)) return Value(list_value=_make_list_value_pb(values)) def test_properties_set(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('full_name', 'STRING'), self._makeScalarField('age', 'INT64'), @@ -96,8 +102,9 @@ def test_properties_set(self): def test__merge_chunk_bool(self): from google.cloud.spanner.streamed import Unmergeable + iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('registered_voter', 'BOOL'), ] @@ -110,7 +117,7 @@ def test__merge_chunk_bool(self): def test__merge_chunk_int64(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('age', 'INT64'), ] @@ -124,7 +131,7 @@ def test__merge_chunk_int64(self): def test__merge_chunk_float64_nan_string(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('weight', 'FLOAT64'), ] @@ -137,7 +144,7 @@ def test__merge_chunk_float64_nan_string(self): def test__merge_chunk_float64_w_empty(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('weight', 'FLOAT64'), ] @@ -150,8 +157,9 @@ def test__merge_chunk_float64_w_empty(self): def test__merge_chunk_float64_w_float64(self): from google.cloud.spanner.streamed import Unmergeable + iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('weight', 'FLOAT64'), ] @@ -164,7 +172,7 @@ def test__merge_chunk_float64_w_float64(self): def test__merge_chunk_string(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('name', 'STRING'), ] @@ -179,7 +187,7 @@ def test__merge_chunk_string(self): def test__merge_chunk_array_of_bool(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeArrayField('name', element_type_code='BOOL'), ] @@ -195,7 +203,7 @@ def test__merge_chunk_array_of_bool(self): def test__merge_chunk_array_of_int(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeArrayField('name', element_type_code='INT64'), ] @@ -211,12 +219,13 @@ def test__merge_chunk_array_of_int(self): def test__merge_chunk_array_of_float(self): import math + PI = math.pi EULER = math.e SQRT_2 = math.sqrt(2.0) LOG_10 = math.log(10) iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeArrayField('name', element_type_code='FLOAT64'), ] @@ -232,7 +241,7 @@ def test__merge_chunk_array_of_float(self): def test__merge_chunk_array_of_string(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeArrayField('name', element_type_code='STRING'), ] @@ -248,7 +257,7 @@ def test__merge_chunk_array_of_string(self): def test__merge_chunk_array_of_string_with_null(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeArrayField('name', element_type_code='STRING'), ] @@ -265,11 +274,12 @@ def test__merge_chunk_array_of_string_with_null(self): def test__merge_chunk_array_of_array_of_int(self): from google.cloud.proto.spanner.v1.type_pb2 import StructType from google.cloud.proto.spanner.v1.type_pb2 import Type + subarray_type = Type( code='ARRAY', array_element_type=Type(code='INT64')) array_type = Type(code='ARRAY', array_element_type=subarray_type) iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ StructType.Field(name='loloi', type=array_type) ] @@ -296,11 +306,12 @@ def test__merge_chunk_array_of_array_of_int(self): def test__merge_chunk_array_of_array_of_string(self): from google.cloud.proto.spanner.v1.type_pb2 import StructType from google.cloud.proto.spanner.v1.type_pb2 import Type + subarray_type = Type( code='ARRAY', array_element_type=Type(code='STRING')) array_type = Type(code='ARRAY', array_element_type=subarray_type) iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ StructType.Field(name='lolos', type=array_type) ] @@ -326,7 +337,7 @@ def test__merge_chunk_array_of_array_of_string(self): def test__merge_chunk_array_of_struct(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) struct_type = self._makeStructType([ ('name', 'STRING'), ('age', 'INT64'), @@ -349,7 +360,7 @@ def test__merge_chunk_array_of_struct(self): def test__merge_chunk_array_of_struct_unmergeable(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) struct_type = self._makeStructType([ ('name', 'STRING'), ('registered', 'BOOL'), @@ -373,7 +384,7 @@ def test__merge_chunk_array_of_struct_unmergeable(self): def test_merge_values_empty_and_empty(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('full_name', 'STRING'), self._makeScalarField('age', 'INT64'), @@ -387,7 +398,7 @@ def test_merge_values_empty_and_empty(self): def test_merge_values_empty_and_partial(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('full_name', 'STRING'), self._makeScalarField('age', 'INT64'), @@ -403,7 +414,7 @@ def test_merge_values_empty_and_partial(self): def test_merge_values_empty_and_filled(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('full_name', 'STRING'), self._makeScalarField('age', 'INT64'), @@ -419,7 +430,7 @@ def test_merge_values_empty_and_filled(self): def test_merge_values_empty_and_filled_plus(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('full_name', 'STRING'), self._makeScalarField('age', 'INT64'), @@ -439,7 +450,7 @@ def test_merge_values_empty_and_filled_plus(self): def test_merge_values_partial_and_empty(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('full_name', 'STRING'), self._makeScalarField('age', 'INT64'), @@ -456,7 +467,7 @@ def test_merge_values_partial_and_empty(self): def test_merge_values_partial_and_partial(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('full_name', 'STRING'), self._makeScalarField('age', 'INT64'), @@ -473,7 +484,7 @@ def test_merge_values_partial_and_partial(self): def test_merge_values_partial_and_filled(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('full_name', 'STRING'), self._makeScalarField('age', 'INT64'), @@ -492,7 +503,7 @@ def test_merge_values_partial_and_filled(self): def test_merge_values_partial_and_filled_plus(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) FIELDS = [ self._makeScalarField('full_name', 'STRING'), self._makeScalarField('age', 'INT64'), @@ -516,7 +527,7 @@ def test_merge_values_partial_and_filled_plus(self): def test_consume_next_empty(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) with self.assertRaises(StopIteration): streamed.consume_next() @@ -531,7 +542,7 @@ def test_consume_next_first_set_partial(self): VALUES = [self._makeValue(bare) for bare in BARE] result_set = _PartialResultSetPB(VALUES, metadata=metadata) iterator = _MockCancellableIterator(result_set) - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) streamed.consume_next() self.assertEqual(streamed.rows, []) self.assertEqual(streamed._current_row, BARE) @@ -549,7 +560,7 @@ def test_consume_next_w_partial_result(self): ] result_set = _PartialResultSetPB(VALUES, chunked_value=True) iterator = _MockCancellableIterator(result_set) - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) streamed._metadata = _ResultSetMetadataPB(FIELDS) streamed.consume_next() self.assertEqual(streamed.rows, []) @@ -571,7 +582,7 @@ def test_consume_next_w_pending_chunk(self): VALUES = [self._makeValue(bare) for bare in BARE] result_set = _PartialResultSetPB(VALUES) iterator = _MockCancellableIterator(result_set) - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) streamed._metadata = _ResultSetMetadataPB(FIELDS) streamed._pending_chunk = self._makeValue(u'Phred ') streamed.consume_next() @@ -599,7 +610,7 @@ def test_consume_next_last_set(self): VALUES = [self._makeValue(bare) for bare in BARE] result_set = _PartialResultSetPB(VALUES, stats=stats) iterator = _MockCancellableIterator(result_set) - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) streamed._metadata = metadata streamed.consume_next() self.assertEqual(streamed.rows, [BARE]) @@ -609,7 +620,7 @@ def test_consume_next_last_set(self): def test_consume_all_empty(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) streamed.consume_all() def test_consume_all_one_result_set_partial(self): @@ -623,7 +634,7 @@ def test_consume_all_one_result_set_partial(self): VALUES = [self._makeValue(bare) for bare in BARE] result_set = _PartialResultSetPB(VALUES, metadata=metadata) iterator = _MockCancellableIterator(result_set) - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) streamed.consume_all() self.assertEqual(streamed.rows, []) self.assertEqual(streamed._current_row, BARE) @@ -645,7 +656,7 @@ def test_consume_all_multiple_result_sets_filled(self): result_set1 = _PartialResultSetPB(VALUES[:4], metadata=metadata) result_set2 = _PartialResultSetPB(VALUES[4:]) iterator = _MockCancellableIterator(result_set1, result_set2) - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) streamed.consume_all() self.assertEqual(streamed.rows, [ [BARE[0], BARE[1], BARE[2]], @@ -657,7 +668,7 @@ def test_consume_all_multiple_result_sets_filled(self): def test___iter___empty(self): iterator = _MockCancellableIterator() - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) found = list(streamed) self.assertEqual(found, []) @@ -672,7 +683,7 @@ def test___iter___one_result_set_partial(self): VALUES = [self._makeValue(bare) for bare in BARE] result_set = _PartialResultSetPB(VALUES, metadata=metadata) iterator = _MockCancellableIterator(result_set) - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) found = list(streamed) self.assertEqual(found, []) self.assertEqual(streamed.rows, []) @@ -695,7 +706,7 @@ def test___iter___multiple_result_sets_filled(self): result_set1 = _PartialResultSetPB(VALUES[:4], metadata=metadata) result_set2 = _PartialResultSetPB(VALUES[4:]) iterator = _MockCancellableIterator(result_set1, result_set2) - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) found = list(streamed) self.assertEqual(found, [ [BARE[0], BARE[1], BARE[2]], @@ -726,7 +737,7 @@ def test___iter___w_existing_rows_read(self): result_set1 = _PartialResultSetPB(VALUES[:4], metadata=metadata) result_set2 = _PartialResultSetPB(VALUES[4:]) iterator = _MockCancellableIterator(result_set1, result_set2) - streamed = self._makeOne(iterator) + streamed = self._make_one(iterator) streamed._rows[:] = ALREADY found = list(streamed) self.assertEqual(found, ALREADY + [ @@ -757,6 +768,7 @@ class _ResultSetMetadataPB(object): def __init__(self, fields): from google.cloud.proto.spanner.v1.type_pb2 import StructType + self.row_type = StructType(fields=fields) @@ -765,6 +777,7 @@ class _ResultSetStatsPB(object): def __init__(self, query_plan=None, **query_stats): from google.protobuf.struct_pb2 import Struct from google.cloud.spanner._helpers import _make_value_pb + self.query_plan = query_plan self.query_stats = Struct(fields={ key: _make_value_pb(value) for key, value in query_stats.items()}) @@ -791,13 +804,15 @@ class TestStreamedResultSet_JSON_acceptance_tests(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.streamed import StreamedResultSet + return StreamedResultSet - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def _load_json_test(self, test_name): import os + if self.__class__._json_tests is None: dirname = os.path.dirname(__file__) filename = os.path.join( @@ -813,7 +828,7 @@ def _load_json_test(self, test_name): def _match_results(self, testcase_name, assert_equality=None): partial_result_sets, expected = self._load_json_test(testcase_name) iterator = _MockCancellableIterator(*partial_result_sets) - partial = self._makeOne(iterator) + partial = self._make_one(iterator) partial.consume_all() if assert_equality is not None: assert_equality(partial.rows, expected) @@ -927,6 +942,7 @@ def _normalize_float(cell): def _normalize_results(rows_data, fields): """Helper for _parse_streaming_read_acceptance_tests""" from google.cloud.proto.spanner.v1 import type_pb2 + normalized = [] for row_data in rows_data: row = [] diff --git a/spanner/unit_tests/test_transaction.py b/spanner/unit_tests/test_transaction.py index 265c0d8a6967..bdb8d20b8f01 100644 --- a/spanner/unit_tests/test_transaction.py +++ b/spanner/unit_tests/test_transaction.py @@ -39,14 +39,15 @@ class TestTransaction(unittest.TestCase): def _getTargetClass(self): from google.cloud.spanner.transaction import Transaction + return Transaction - def _makeOne(self, *args, **kwargs): + def _make_one(self, *args, **kwargs): return self._getTargetClass()(*args, **kwargs) def test_ctor_defaults(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) self.assertTrue(transaction._session is session) self.assertIsNone(transaction._id) self.assertIsNone(transaction.committed) @@ -54,13 +55,13 @@ def test_ctor_defaults(self): def test__check_state_not_begun(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) with self.assertRaises(ValueError): transaction._check_state() def test__check_state_already_committed(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = b'DEADBEEF' transaction.committed = object() with self.assertRaises(ValueError): @@ -68,7 +69,7 @@ def test__check_state_already_committed(self): def test__check_state_already_rolled_back(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = b'DEADBEEF' transaction._rolled_back = True with self.assertRaises(ValueError): @@ -76,45 +77,46 @@ def test__check_state_already_rolled_back(self): def test__check_state_ok(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = b'DEADBEEF' transaction._check_state() # does not raise def test__make_txn_selector(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID selector = transaction._make_txn_selector() self.assertEqual(selector.id, self.TRANSACTION_ID) def test_begin_already_begun(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID with self.assertRaises(ValueError): transaction.begin() def test_begin_already_rolled_back(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._rolled_back = True with self.assertRaises(ValueError): transaction.begin() def test_begin_already_committed(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction.committed = object() with self.assertRaises(ValueError): transaction.begin() def test_begin_w_gax_error(self): from google.gax.errors import GaxError + database = _Database() api = database.spanner_api = _FauxSpannerAPI( _random_gax_error=True) session = _Session(database) - transaction = self._makeOne(session) + transaction = self._make_one(session) with self.assertRaises(GaxError): transaction.begin() @@ -128,12 +130,13 @@ def test_begin_w_gax_error(self): def test_begin_ok(self): from google.cloud.proto.spanner.v1.transaction_pb2 import ( Transaction as TransactionPB) + transaction_pb = TransactionPB(id=self.TRANSACTION_ID) database = _Database() api = database.spanner_api = _FauxSpannerAPI( _begin_transaction_response=transaction_pb) session = _Session(database) - transaction = self._makeOne(session) + transaction = self._make_one(session) txn_id = transaction.begin() @@ -148,13 +151,13 @@ def test_begin_ok(self): def test_rollback_not_begun(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) with self.assertRaises(ValueError): transaction.rollback() def test_rollback_already_committed(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID transaction.committed = object() with self.assertRaises(ValueError): @@ -162,7 +165,7 @@ def test_rollback_already_committed(self): def test_rollback_already_rolled_back(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID transaction._rolled_back = True with self.assertRaises(ValueError): @@ -170,11 +173,12 @@ def test_rollback_already_rolled_back(self): def test_rollback_w_gax_error(self): from google.gax.errors import GaxError + database = _Database() api = database.spanner_api = _FauxSpannerAPI( _random_gax_error=True) session = _Session(database) - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID transaction.insert(TABLE_NAME, COLUMNS, VALUES) @@ -191,12 +195,13 @@ def test_rollback_w_gax_error(self): def test_rollback_ok(self): from google.protobuf.empty_pb2 import Empty + empty_pb = Empty() database = _Database() api = database.spanner_api = _FauxSpannerAPI( _rollback_response=empty_pb) session = _Session(database) - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID transaction.replace(TABLE_NAME, COLUMNS, VALUES) @@ -212,13 +217,13 @@ def test_rollback_ok(self): def test_commit_not_begun(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) with self.assertRaises(ValueError): transaction.commit() def test_commit_already_committed(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID transaction.committed = object() with self.assertRaises(ValueError): @@ -226,7 +231,7 @@ def test_commit_already_committed(self): def test_commit_already_rolled_back(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID transaction._rolled_back = True with self.assertRaises(ValueError): @@ -234,18 +239,19 @@ def test_commit_already_rolled_back(self): def test_commit_no_mutations(self): session = _Session() - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID with self.assertRaises(ValueError): transaction.commit() def test_commit_w_gax_error(self): from google.gax.errors import GaxError + database = _Database() api = database.spanner_api = _FauxSpannerAPI( _random_gax_error=True) session = _Session(database) - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID transaction.replace(TABLE_NAME, COLUMNS, VALUES) @@ -267,6 +273,7 @@ def test_commit_ok(self): from google.cloud.spanner.keyset import KeySet from google.cloud._helpers import UTC from google.cloud._helpers import _datetime_to_pb_timestamp + now = datetime.datetime.utcnow().replace(tzinfo=UTC) now_pb = _datetime_to_pb_timestamp(now) keys = [[0], [1], [2]] @@ -276,7 +283,7 @@ def test_commit_ok(self): api = database.spanner_api = _FauxSpannerAPI( _commit_response=response) session = _Session(database) - transaction = self._makeOne(session) + transaction = self._make_one(session) transaction._id = self.TRANSACTION_ID transaction.delete(TABLE_NAME, keyset) @@ -298,6 +305,7 @@ def test_context_mgr_success(self): Transaction as TransactionPB) from google.cloud._helpers import UTC from google.cloud._helpers import _datetime_to_pb_timestamp + transaction_pb = TransactionPB(id=self.TRANSACTION_ID) database = _Database() now = datetime.datetime.utcnow().replace(tzinfo=UTC) @@ -308,7 +316,7 @@ def test_context_mgr_success(self): _begin_transaction_response=transaction_pb, _commit_response=response) session = _Session(database) - transaction = self._makeOne(session) + transaction = self._make_one(session) with transaction: transaction.insert(TABLE_NAME, COLUMNS, VALUES) @@ -327,13 +335,14 @@ def test_context_mgr_failure(self): empty_pb = Empty() from google.cloud.proto.spanner.v1.transaction_pb2 import ( Transaction as TransactionPB) + transaction_pb = TransactionPB(id=self.TRANSACTION_ID) database = _Database() api = database.spanner_api = _FauxSpannerAPI( _begin_transaction_response=transaction_pb, _rollback_response=empty_pb) session = _Session(database) - transaction = self._makeOne(session) + transaction = self._make_one(session) with self.assertRaises(Exception): with transaction: @@ -370,6 +379,7 @@ class _FauxSpannerAPI(_GAXBaseAPI): def begin_transaction(self, session, options_, options=None): from google.gax.errors import GaxError + self._begun = (session, options_, options) if self._random_gax_error: raise GaxError('error') @@ -377,6 +387,7 @@ def begin_transaction(self, session, options_, options=None): def rollback(self, session, transaction_id, options=None): from google.gax.errors import GaxError + self._rolled_back = (session, transaction_id, options) if self._random_gax_error: raise GaxError('error') @@ -385,6 +396,7 @@ def rollback(self, session, transaction_id, options=None): def commit(self, session, mutations, transaction_id='', single_use_transaction=None, options=None): from google.gax.errors import GaxError + assert single_use_transaction is None self._committed = (session, mutations, transaction_id, options) if self._random_gax_error: From 11a2e359e9568959204d608feaad3c078093f7c3 Mon Sep 17 00:00:00 2001 From: Thomas Schultz Date: Fri, 17 Feb 2017 08:43:08 -0500 Subject: [PATCH 2/6] BigQuery formatting. --- bigquery/unit_tests/test__helpers.py | 1 + bigquery/unit_tests/test_table.py | 1 + 2 files changed, 2 insertions(+) diff --git a/bigquery/unit_tests/test__helpers.py b/bigquery/unit_tests/test__helpers.py index e42d8207b471..d989da592ba1 100644 --- a/bigquery/unit_tests/test__helpers.py +++ b/bigquery/unit_tests/test__helpers.py @@ -556,6 +556,7 @@ def test_w_non_bytes(self): def test_w_bytes(self): import base64 + source = b'source' expected = base64.encodestring(source) self.assertEqual(self._call_fut(source), expected) diff --git a/bigquery/unit_tests/test_table.py b/bigquery/unit_tests/test_table.py index 09fd37730199..6a496ba69e95 100644 --- a/bigquery/unit_tests/test_table.py +++ b/bigquery/unit_tests/test_table.py @@ -1536,6 +1536,7 @@ def test_upload_from_file_multipart_w_400(self): from google.cloud._testing import _NamedTemporaryFile from google.cloud._helpers import UTC from google.cloud.exceptions import BadRequest + WHEN_TS = 1437767599.006 WHEN = datetime.datetime.utcfromtimestamp(WHEN_TS).replace( tzinfo=UTC) From 2a8c6b297ca27e9e091b1a4dfc997b127a65ad20 Mon Sep 17 00:00:00 2001 From: Thomas Schultz Date: Fri, 17 Feb 2017 08:43:25 -0500 Subject: [PATCH 3/6] Core formatting. --- core/unit_tests/test__helpers.py | 1 + 1 file changed, 1 insertion(+) diff --git a/core/unit_tests/test__helpers.py b/core/unit_tests/test__helpers.py index ced80e92278f..fcd47f7535bc 100644 --- a/core/unit_tests/test__helpers.py +++ b/core/unit_tests/test__helpers.py @@ -669,6 +669,7 @@ class Test__name_from_project_path(unittest.TestCase): def _call_fut(self, path, project, template): from google.cloud._helpers import _name_from_project_path + return _name_from_project_path(path, project, template) def test_w_invalid_path_length(self): From 83d54b8381115a85d8e2b6a5d90df728830b4f39 Mon Sep 17 00:00:00 2001 From: Thomas Schultz Date: Fri, 17 Feb 2017 08:43:40 -0500 Subject: [PATCH 4/6] Error Reporting formatting. --- error_reporting/unit_tests/test__gax.py | 2 ++ error_reporting/unit_tests/test__logging.py | 2 ++ error_reporting/unit_tests/test_client.py | 5 ++--- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/error_reporting/unit_tests/test__gax.py b/error_reporting/unit_tests/test__gax.py index af0c4247dae4..4eada07c79bf 100644 --- a/error_reporting/unit_tests/test__gax.py +++ b/error_reporting/unit_tests/test__gax.py @@ -21,6 +21,7 @@ class Test_make_report_error_api(unittest.TestCase): def test_make_report_error_api(self): from google.cloud.error_reporting._gax import make_report_error_api + client = mock.Mock() client.project = mock.Mock() report_error_client = make_report_error_api(client) @@ -33,6 +34,7 @@ class Test_ErrorReportingGaxApi(unittest.TestCase): def _call_fut(self, gax_api, project): from google.cloud.error_reporting._gax import _ErrorReportingGaxApi + return _ErrorReportingGaxApi(gax_api, project) def test_constructor(self): diff --git a/error_reporting/unit_tests/test__logging.py b/error_reporting/unit_tests/test__logging.py index 99371906eedc..2a96d0162117 100644 --- a/error_reporting/unit_tests/test__logging.py +++ b/error_reporting/unit_tests/test__logging.py @@ -19,6 +19,7 @@ def _make_credentials(): import google.auth.credentials + return mock.Mock(spec=google.auth.credentials.Credentials) @@ -31,6 +32,7 @@ class Test_ErrorReportingLoggingAPI(unittest.TestCase): def _call_fut(self, project, credentials): from google.cloud.error_reporting._logging import ( _ErrorReportingLoggingAPI) + return _ErrorReportingLoggingAPI(project, credentials) def test_constructor(self): diff --git a/error_reporting/unit_tests/test_client.py b/error_reporting/unit_tests/test_client.py index 09b9065f59f9..95723189df8c 100644 --- a/error_reporting/unit_tests/test_client.py +++ b/error_reporting/unit_tests/test_client.py @@ -107,9 +107,8 @@ def test_report_exception_wo_gax(self): self.assertIsNotNone(target.report_errors_api) @mock.patch('google.cloud.error_reporting.client.make_report_error_api') - def test_report_exception_with_service_version_in_constructor( - self, - make_client): + def test_report_exception_with_service_version_in_constructor(self, + make_client): CREDENTIALS = _make_credentials() SERVICE = "notdefault" VERSION = "notdefaultversion" From 5acf5e8c2357d627db10d366e8407d81dd9c4b4f Mon Sep 17 00:00:00 2001 From: Thomas Schultz Date: Fri, 17 Feb 2017 08:43:51 -0500 Subject: [PATCH 5/6] Logging formatting. --- logging/unit_tests/handlers/test_handlers.py | 2 ++ .../unit_tests/handlers/transports/test_background_thread.py | 2 ++ logging/unit_tests/handlers/transports/test_base.py | 1 + logging/unit_tests/handlers/transports/test_sync.py | 1 + logging/unit_tests/test__gax.py | 1 + 5 files changed, 7 insertions(+) diff --git a/logging/unit_tests/handlers/test_handlers.py b/logging/unit_tests/handlers/test_handlers.py index 234b2991df45..26d3e6352024 100644 --- a/logging/unit_tests/handlers/test_handlers.py +++ b/logging/unit_tests/handlers/test_handlers.py @@ -23,6 +23,7 @@ class TestCloudLoggingHandler(unittest.TestCase): @staticmethod def _get_target_class(): from google.cloud.logging.handlers.handlers import CloudLoggingHandler + return CloudLoggingHandler def _make_one(self, *args, **kw): @@ -49,6 +50,7 @@ class TestSetupLogging(unittest.TestCase): def _call_fut(self, handler, excludes=None): from google.cloud.logging.handlers.handlers import setup_logging + if excludes: return setup_logging(handler, excluded_loggers=excludes) else: diff --git a/logging/unit_tests/handlers/transports/test_background_thread.py b/logging/unit_tests/handlers/transports/test_background_thread.py index aa0cae2f2669..454f1d873de5 100644 --- a/logging/unit_tests/handlers/transports/test_background_thread.py +++ b/logging/unit_tests/handlers/transports/test_background_thread.py @@ -25,6 +25,7 @@ class TestBackgroundThreadHandler(unittest.TestCase): def _get_target_class(): from google.cloud.logging.handlers.transports import ( BackgroundThreadTransport) + return BackgroundThreadTransport def _make_one(self, *args, **kw): @@ -62,6 +63,7 @@ class TestWorker(unittest.TestCase): @staticmethod def _get_target_class(): from google.cloud.logging.handlers.transports import background_thread + return background_thread._Worker def _make_one(self, *args, **kw): diff --git a/logging/unit_tests/handlers/transports/test_base.py b/logging/unit_tests/handlers/transports/test_base.py index 0fd673fc2a1b..2844f64fbf5a 100644 --- a/logging/unit_tests/handlers/transports/test_base.py +++ b/logging/unit_tests/handlers/transports/test_base.py @@ -22,6 +22,7 @@ class TestBaseHandler(unittest.TestCase): @staticmethod def _get_target_class(): from google.cloud.logging.handlers.transports import Transport + return Transport def _make_one(self, *args, **kw): diff --git a/logging/unit_tests/handlers/transports/test_sync.py b/logging/unit_tests/handlers/transports/test_sync.py index 6650eb8a9d2e..562a7175380b 100644 --- a/logging/unit_tests/handlers/transports/test_sync.py +++ b/logging/unit_tests/handlers/transports/test_sync.py @@ -23,6 +23,7 @@ class TestSyncHandler(unittest.TestCase): @staticmethod def _get_target_class(): from google.cloud.logging.handlers.transports import SyncTransport + return SyncTransport def _make_one(self, *args, **kw): diff --git a/logging/unit_tests/test__gax.py b/logging/unit_tests/test__gax.py index 4d150535db22..852166861417 100644 --- a/logging/unit_tests/test__gax.py +++ b/logging/unit_tests/test__gax.py @@ -53,6 +53,7 @@ class Test_LoggingAPI(_Base, unittest.TestCase): @staticmethod def _get_target_class(): from google.cloud.logging._gax import _LoggingAPI + return _LoggingAPI def test_ctor(self): From d675b067594b0db525672676267ef64f2169d8a7 Mon Sep 17 00:00:00 2001 From: Thomas Schultz Date: Fri, 17 Feb 2017 13:07:00 -0500 Subject: [PATCH 6/6] Fix lint issue with method signature. --- error_reporting/unit_tests/test_client.py | 4 ++-- spanner/unit_tests/test_client.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/error_reporting/unit_tests/test_client.py b/error_reporting/unit_tests/test_client.py index 95723189df8c..60b5f4df61d2 100644 --- a/error_reporting/unit_tests/test_client.py +++ b/error_reporting/unit_tests/test_client.py @@ -107,8 +107,8 @@ def test_report_exception_wo_gax(self): self.assertIsNotNone(target.report_errors_api) @mock.patch('google.cloud.error_reporting.client.make_report_error_api') - def test_report_exception_with_service_version_in_constructor(self, - make_client): + def test_report_exception_with_service_version_in_constructor( + self, make_client): CREDENTIALS = _make_credentials() SERVICE = "notdefault" VERSION = "notdefaultversion" diff --git a/spanner/unit_tests/test_client.py b/spanner/unit_tests/test_client.py index 14c968f12bda..9383471f7fdb 100644 --- a/spanner/unit_tests/test_client.py +++ b/spanner/unit_tests/test_client.py @@ -55,7 +55,7 @@ def _constructor_test_helper(self, expected_scopes, creds, user_agent = user_agent or MUT.DEFAULT_USER_AGENT client = self._make_one(project=self.PROJECT, credentials=creds, - user_agent=user_agent) + user_agent=user_agent) expected_creds = expected_creds or creds.with_scopes.return_value self.assertIs(client._credentials, expected_creds)