def test_ctor_w_implicit_inputs(self): from google.cloud._testing import _Monkey from google.cloud.datastore import client as _MUT from google.cloud import client as _base_client OTHER = 'other' creds = object() default_called = [] def fallback_mock(project): default_called.append(project) return project or OTHER klass = self._getTargetClass() with _Monkey(_MUT, _determine_default_project=fallback_mock): with _Monkey(_base_client, get_credentials=lambda: creds): client = klass() self.assertEqual(client.project, OTHER) self.assertIsNone(client.namespace) self.assertIsInstance(client.connection, _MockConnection) self.assertIs(client.connection.credentials, creds) self.assertIsNone(client.connection.http) self.assertIsNone(client.current_batch) self.assertIsNone(client.current_transaction) self.assertEqual(default_called, [None])
def test_gae(self): from google.cloud import _helpers as MUT from google.cloud._testing import _Monkey with _Monkey(os, name='not-nt'): with _Monkey(MUT, _USER_ROOT=None): result = self._callFUT() self.assertIsNone(result)
def test_it(self): from google.cloud import _helpers as MUT from google.cloud._testing import _Monkey appdata_dir = 'a' environ = {'APPDATA': appdata_dir} config_file = 'b' with _Monkey(os, getenv=environ.get): with _Monkey(MUT, _GCLOUD_CONFIG_FILE=config_file): result = self._callFUT() expected = os.path.join(appdata_dir, config_file) self.assertEqual(result, expected)
def test_with_emulator(self): from google.longrunning import operations_grpc from google.cloud._testing import _Monkey from google.cloud.bigtable import client as MUT emulator_host = object() client = _Client(None, None, emulator_host=emulator_host) fake_stub = object() make_insecure_stub_args = [] def mock_make_insecure_stub(*args): make_insecure_stub_args.append(args) return fake_stub with _Monkey(MUT, make_insecure_stub=mock_make_insecure_stub): result = self._call_fut(client) self.assertIs(result, fake_stub) self.assertEqual(make_insecure_stub_args, [ ( operations_grpc.OperationsStub, emulator_host, ), ])
def test_speech_api_with_gax(self): from google.cloud._testing import _Monkey from google.cloud.speech import _gax creds = _make_credentials() client = self._make_one(credentials=creds, use_gax=True) client._connection = _Connection() client._connection.credentials = creds channel_args = [] channel_obj = object() def make_channel(*args): channel_args.append(args) return channel_obj def speech_api(channel=None): return _MockGAPICSpeechAPI(channel=channel) host = 'foo.apis.invalid' speech_api.SERVICE_ADDRESS = host with _Monkey(_gax, SpeechClient=speech_api, make_secure_channel=make_channel): client._speech_api = _gax.GAPICSpeechAPI(client) low_level = client.speech_api._gapic_api self.assertIsInstance(low_level, _MockGAPICSpeechAPI) self.assertIs(low_level._channel, channel_obj) expected = (creds, _gax.DEFAULT_USER_AGENT, low_level.SERVICE_ADDRESS) self.assertEqual(channel_args, [expected])
def test_get_multi_max_loops(self): from google.cloud._testing import _Monkey from google.cloud.datastore import client as _MUT from google.cloud.datastore.key import Key KIND = 'Kind' ID = 1234 # Make a found entity pb to be returned from mock backend. entity_pb = _make_entity_pb(self.PROJECT, KIND, ID, 'foo', 'Foo') # Make a connection to return the entity pb. creds = object() client = self._makeOne(credentials=creds) client.connection._add_lookup_result([entity_pb]) key = Key(KIND, ID, project=self.PROJECT) deferred = [] missing = [] with _Monkey(_MUT, _MAX_LOOPS=-1): result = client.get_multi([key], missing=missing, deferred=deferred) # Make sure we have no results, even though the connection has been # set up as in `test_hit` to return a single result. self.assertEqual(result, []) self.assertEqual(missing, []) self.assertEqual(deferred, [])
def test_it_with_stubs(self): from google.cloud._testing import _Monkey from google.cloud.storage import _helpers as MUT class _Buffer(object): def __init__(self, return_vals): self.return_vals = return_vals self._block_sizes = [] def read(self, block_size): self._block_sizes.append(block_size) return self.return_vals.pop() BASE64 = _Base64() DIGEST_VAL = object() BYTES_TO_SIGN = b'BYTES_TO_SIGN' BUFFER = _Buffer([b'', BYTES_TO_SIGN]) MD5 = _MD5(DIGEST_VAL) with _Monkey(MUT, base64=BASE64, md5=MD5): SIGNED_CONTENT = self._callFUT(BUFFER) self.assertEqual(BUFFER._block_sizes, [8192, 8192]) self.assertIs(SIGNED_CONTENT, DIGEST_VAL) self.assertEqual(BASE64._called_b64encode, [DIGEST_VAL]) self.assertEqual(MD5._called, [None]) self.assertEqual(MD5.hash_obj.num_digest_calls, 1) self.assertEqual(MD5.hash_obj._blocks, [BYTES_TO_SIGN])
def test_without_emulator(self): from google.cloud._testing import _Monkey from google.cloud.bigtable import client as MUT credentials = _make_credentials() user_agent = 'you-sir-age-int' client = _Client(credentials, user_agent) fake_stub = object() make_secure_stub_args = [] def mock_make_secure_stub(*args): make_secure_stub_args.append(args) return fake_stub with _Monkey(MUT, make_secure_stub=mock_make_secure_stub): result = self._call_fut(client) self.assertIs(result, fake_stub) self.assertEqual(make_secure_stub_args, [ ( client.credentials, client.user_agent, MUT.bigtable_pb2.BigtableStub, MUT.DATA_API_HOST, ), ])
def test_no_value(self): from google.cloud._testing import _Monkey environ = {} with _Monkey(os, getenv=environ.get): project = self._callFUT() self.assertIsNone(project)
def test_no_value(self): from google.cloud._testing import _Monkey from google.cloud import _helpers with _Monkey(_helpers, app_identity=None): dataset_id = self._callFUT() self.assertIsNone(dataset_id)
def test_w_loggable_body_w_http(self): from google.cloud._testing import _Monkey from google.cloud.streaming import http_wrapper as MUT class _Connection(object): debuglevel = 0 def set_debuglevel(self, value): self.debuglevel = value request = _Request(loggable_body=object()) LEVEL = 1 _httplib2 = _Dummy(debuglevel=0) update_me = _Connection() skip_me = _Connection() connections = {'update:me': update_me, 'skip_me': skip_me} _http = _Dummy(connections=connections) with _Monkey(MUT, httplib2=_httplib2): with self._make_one(request, LEVEL, _http): self.assertEqual(_httplib2.debuglevel, LEVEL) self.assertEqual(update_me.debuglevel, LEVEL) self.assertEqual(skip_me.debuglevel, 0) self.assertEqual(_httplib2.debuglevel, 0) self.assertEqual(update_me.debuglevel, 0) self.assertEqual(skip_me.debuglevel, 0)
def test_w_exceptions_lt_max_retries(self): from google.cloud.streaming.exceptions import RetryAfterError from google.cloud.streaming import http_wrapper as MUT from google.cloud._testing import _Monkey HTTP, RESPONSE = object(), object() REQUEST = _Request() _created, _checked = [], [] _counter = [None] * 4 def _wo_exception(*args, **kw): _created.append((args, kw)) if _counter: _counter.pop() raise RetryAfterError(RESPONSE, '', REQUEST.url, 0.1) return RESPONSE with _Monkey(MUT, _make_api_request_no_retry=_wo_exception, _check_response=_checked.append): response = self._call_fut(HTTP, REQUEST, retries=5) self.assertIs(response, RESPONSE) self.assertEqual(len(_created), 5) expected_kw = {'redirections': MUT._REDIRECTIONS} for attempt in _created: self.assertEqual(attempt, ((HTTP, REQUEST), expected_kw)) self.assertEqual(_checked, []) # not called by '_wo_exception'
def test_without_emulator(self): from google.cloud._testing import _Monkey from google.cloud.bigtable import client as MUT credentials = _Credentials() user_agent = "you-sir-age-int" client = _Client(credentials, user_agent) fake_stub = object() make_secure_stub_args = [] def mock_make_secure_stub(*args): make_secure_stub_args.append(args) return fake_stub with _Monkey(MUT, make_secure_stub=mock_make_secure_stub): result = self._callFUT(client) self.assertIs(result, fake_stub) self.assertEqual( make_secure_stub_args, [ ( client.credentials, client.user_agent, MUT.bigtable_instance_admin_pb2.BigtableInstanceAdminStub, MUT.INSTANCE_ADMIN_HOST, ) ], )
def test_bind_w_timestamp_race(self): import datetime from google.cloud._testing import _Monkey from google.cloud.spanner_v1 import pool as MUT NOW = datetime.datetime.utcnow() pool = self._make_one() database = _Database("name") SESSIONS = [_Session(database) for _ in range(10)] database._sessions.extend(SESSIONS) with _Monkey(MUT, _NOW=lambda: NOW): pool.bind(database) self.assertIs(pool._database, database) self.assertEqual(pool.size, 10) self.assertEqual(pool.default_timeout, 10) self.assertEqual(pool._delta.seconds, 3000) self.assertTrue(pool._sessions.full()) for session in SESSIONS: self.assertTrue(session._created) txn = session._transaction self.assertTrue(txn._begun) self.assertTrue(pool._pending_sessions.empty())
def test_publish_single_bytes_wo_attrs_w_add_timestamp_alt_client(self): import datetime from google.cloud.pubsub import topic as MUT from google.cloud._helpers import _RFC3339_MICROS from google.cloud._testing import _Monkey NOW = datetime.datetime.utcnow() def _utcnow(): return NOW PAYLOAD = 'This is the message text' MSGID = 'DEADBEEF' MESSAGE = { 'data': PAYLOAD, 'attributes': {'timestamp': NOW.strftime(_RFC3339_MICROS)}, } client1 = _Client(project=self.PROJECT) client2 = _Client(project=self.PROJECT) api = client2.publisher_api = _FauxPublisherAPI() api._topic_publish_response = [MSGID] topic = self._makeOne(self.TOPIC_NAME, client=client1, timestamp_messages=True) with _Monkey(MUT, _NOW=_utcnow): msgid = topic.publish(PAYLOAD, client=client2) self.assertEqual(msgid, MSGID) self.assertEqual(api._topic_published, (self.TOPIC_PATH, [MESSAGE]))
def test_without_emulator(self): from google.longrunning import operations_grpc from google.cloud._testing import _Monkey from google.cloud.bigtable import client as MUT credentials = _Credentials() user_agent = "you-sir-age-int" client = _Client(credentials, user_agent) fake_stub = object() make_secure_stub_args = [] def mock_make_secure_stub(*args): make_secure_stub_args.append(args) return fake_stub with _Monkey(MUT, make_secure_stub=mock_make_secure_stub): result = self._callFUT(client) self.assertIs(result, fake_stub) self.assertEqual( make_secure_stub_args, [(client.credentials, client.user_agent, operations_grpc.OperationsStub, MUT.OPERATIONS_API_HOST)], )
def _read_row_helper(self, chunks, expected_result): from google.cloud._testing import _Monkey from unit_tests._testing import _FakeStub from google.cloud.bigtable import table as MUT client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) table = self._makeOne(self.TABLE_ID, instance) # Create request_pb request_pb = object() # Returned by our mock. mock_created = [] def mock_create_row_request(table_name, row_key, filter_): mock_created.append((table_name, row_key, filter_)) return request_pb # Create response_iterator if chunks is None: response_iterator = iter(()) # no responses at all else: response_pb = _ReadRowsResponsePB(chunks=chunks) response_iterator = iter([response_pb]) # Patch the stub used by the API method. client._data_stub = stub = _FakeStub(response_iterator) # Perform the method and check the result. filter_obj = object() with _Monkey(MUT, _create_row_request=mock_create_row_request): result = table.read_row(self.ROW_KEY, filter_=filter_obj) self.assertEqual(result, expected_result) self.assertEqual(stub.method_calls, [("ReadRows", (request_pb,), {})]) self.assertEqual(mock_created, [(table.name, self.ROW_KEY, filter_obj)])
def test_from_dict(self): from google.protobuf.struct_pb2 import Struct from google.cloud._testing import _Monkey from google.cloud import operation as MUT type_url = 'type.googleapis.com/%s' % (Struct.DESCRIPTOR.full_name,) api_response = { 'name': self.OPERATION_NAME, 'metadata': { '@type': type_url, 'value': {'foo': 'Bar'}, }, } client = _Client() klass = self._get_target_class() with _Monkey(MUT, _TYPE_URL_MAP={type_url: Struct}): operation = klass.from_dict(api_response, client) self.assertEqual(operation.name, self.OPERATION_NAME) self.assertIs(operation.client, client) self.assertIsNone(operation.target) self.assertIsNone(operation.response) self.assertIsNone(operation.error) self.assertIsInstance(operation.metadata, Struct) self.assertEqual(len(operation.metadata.fields), 1) self.assertEqual( operation.metadata.fields['foo'].string_value, 'Bar') self.assertEqual(operation.caller_metadata, {}) self.assertFalse(operation._from_grpc)
def test_sync_recognize_content_with_optional_params_no_gax(self): from base64 import b64encode from google.cloud._helpers import _to_bytes from google.cloud._helpers import _bytes_to_unicode from google.cloud._testing import _Monkey from google.cloud.speech import client as MUT from google.cloud import speech from google.cloud.speech.sample import Sample from google.cloud.speech.transcript import Transcript from unit_tests._fixtures import SYNC_RECOGNIZE_RESPONSE _AUDIO_CONTENT = _to_bytes(self.AUDIO_CONTENT) _B64_AUDIO_CONTENT = _bytes_to_unicode(b64encode(_AUDIO_CONTENT)) RETURNED = SYNC_RECOGNIZE_RESPONSE REQUEST = { 'config': { 'encoding': 'FLAC', 'maxAlternatives': 2, 'sampleRate': 16000, 'speechContext': { 'phrases': [ 'hi', ] }, 'languageCode': 'EN', 'profanityFilter': True, }, 'audio': { 'content': _B64_AUDIO_CONTENT, } } credentials = _Credentials() client = self._makeOne(credentials=credentials, use_gax=False) client.connection = _Connection(RETURNED) encoding = speech.Encoding.FLAC sample = Sample(content=self.AUDIO_CONTENT, encoding=encoding, sample_rate=self.SAMPLE_RATE) with _Monkey(MUT, _USE_GAX=False): response = client.sync_recognize(sample, language_code='EN', max_alternatives=2, profanity_filter=True, speech_context=self.HINTS) self.assertEqual(len(client.connection._requested), 1) req = client.connection._requested[0] self.assertEqual(len(req), 3) self.assertEqual(req['data'], REQUEST) self.assertEqual(req['method'], 'POST') self.assertEqual(req['path'], 'speech:syncrecognize') alternative = SYNC_RECOGNIZE_RESPONSE['results'][0]['alternatives'][0] expected = Transcript.from_api_repr(alternative) self.assertEqual(len(response), 1) self.assertIsInstance(response[0], Transcript) self.assertEqual(response[0].transcript, expected.transcript) self.assertEqual(response[0].confidence, expected.confidence)
def test_emulator(self): from google.cloud._testing import _Monkey from google.cloud.pubsub import _gax as MUT channels = [] mock_result = object() insecure_args = [] mock_channel = object() def mock_subscriber_api(channel): channels.append(channel) return mock_result def mock_insecure_channel(host): insecure_args.append(host) return mock_channel host = 'CURR_HOST:1234' connection = _Connection(in_emulator=True, host=host) with _Monkey(MUT, SubscriberApi=mock_subscriber_api, insecure_channel=mock_insecure_channel): result = self._callFUT(connection) self.assertIs(result, mock_result) self.assertEqual(channels, [mock_channel]) self.assertEqual(insecure_args, [host])
def test_logging_api_w_gax(self): from google.cloud.logging import client as MUT from google.cloud._testing import _Monkey wrapped = object() _called_with = [] def _generated_api(*args, **kw): _called_with.append((args, kw)) return wrapped class _GaxLoggingAPI(object): def __init__(self, _wrapped): self._wrapped = _wrapped creds = _Credentials() client = self._makeOne(project=self.PROJECT, credentials=creds) with _Monkey(MUT, _USE_GAX=True, GeneratedLoggingAPI=_generated_api, GAXLoggingAPI=_GaxLoggingAPI): api = client.logging_api self.assertIsInstance(api, _GaxLoggingAPI) self.assertIs(api._wrapped, wrapped) # API instance is cached again = client.logging_api self.assertIs(again, api)
def test_ctor_defaults(self): from google.cloud._testing import _Monkey from google.cloud import client PROJECT = 'PROJECT' CREDENTIALS = _make_credentials() FUNC_CALLS = [] def mock_determine_proj(project): FUNC_CALLS.append((project, '_determine_default_project')) return PROJECT def mock_get_credentials(): FUNC_CALLS.append('get_credentials') return CREDENTIALS with _Monkey(client, get_credentials=mock_get_credentials, _determine_default_project=mock_determine_proj): client_obj = self._make_one() self.assertEqual(client_obj.project, PROJECT) self.assertIsInstance(client_obj._connection, _MockConnection) self.assertIs(client_obj._connection.credentials, CREDENTIALS) self.assertEqual( FUNC_CALLS, [(None, '_determine_default_project'), 'get_credentials'])
def test_it(self): from google.cloud._testing import _Monkey from google.cloud import _helpers as MUT result = object() channel_obj = object() channels = [] channel_args = [] def stub_class(channel): channels.append(channel) return result def mock_channel(*args, **kwargs): channel_args.append(args) channel_args.append(kwargs) return channel_obj credentials = object() user_agent = 'you-sir-age-int' host = 'localhost' extra_options = {'extra_options': ()} with _Monkey(MUT, make_secure_channel=mock_channel): stub = self._call_fut(credentials, user_agent, stub_class, host) self.assertIs(stub, result) self.assertEqual(channels, [channel_obj]) self.assertEqual(channel_args, [(credentials, user_agent, host), extra_options])
def test_without_emulator(self): from google.cloud._testing import _Monkey from google.cloud.bigtable import client as MUT credentials = _make_credentials() user_agent = 'you-sir-age-int' client = _Client(credentials, user_agent) fake_stub = object() make_secure_stub_args = [] def mock_make_secure_stub(*args, **kwargs): make_secure_stub_args.append(args) make_secure_stub_args.append(kwargs) return fake_stub with _Monkey(MUT, make_secure_stub=mock_make_secure_stub): result = self._call_fut(client) extra_options = {'extra_options': ( ('grpc.max_message_length', 104857600), ('grpc.max_receive_message_length', 104857600) )} self.assertIs(result, fake_stub) self.assertEqual(make_secure_stub_args, [ ( client.credentials, client.user_agent, MUT.bigtable_pb2.BigtableStub, MUT.DATA_API_HOST, ), extra_options, ])
def _helper(self, target, host, port=None): from google.cloud._testing import _Monkey from google.cloud import _helpers as MUT mock_result = object() stub_inputs = [] CHANNEL = object() class _GRPCModule(object): def insecure_channel(self, *args): self.insecure_channel_args = args return CHANNEL grpc_mod = _GRPCModule() def mock_stub_class(channel): stub_inputs.append(channel) return mock_result with _Monkey(MUT, grpc=grpc_mod): result = self._call_fut(mock_stub_class, host, port=port) self.assertIs(result, mock_result) self.assertEqual(stub_inputs, [CHANNEL]) self.assertEqual(grpc_mod.insecure_channel_args, (target,))
def test_from_pb_w_metadata_and_kwargs(self): from google.longrunning import operations_pb2 from google.protobuf.any_pb2 import Any from google.protobuf.struct_pb2 import Struct, Value from google.cloud import operation as MUT from google.cloud._testing import _Monkey TYPE_URI = 'type.googleapis.com/%s' % (Struct.DESCRIPTOR.full_name,) type_url_map = {TYPE_URI: Struct} client = _Client() meta = Struct(fields={'foo': Value(string_value=u'Bar')}) metadata_pb = Any(type_url=TYPE_URI, value=meta.SerializeToString()) operation_pb = operations_pb2.Operation( name=self.OPERATION_NAME, metadata=metadata_pb) klass = self._getTargetClass() with _Monkey(MUT, _TYPE_URL_MAP=type_url_map): operation = klass.from_pb(operation_pb, client, baz='qux') self.assertEqual(operation.name, self.OPERATION_NAME) self.assertIs(operation.client, client) pb_metadata = operation.pb_metadata self.assertIsInstance(pb_metadata, Struct) self.assertEqual(list(pb_metadata.fields), ['foo']) self.assertEqual(pb_metadata.fields['foo'].string_value, 'Bar') self.assertEqual(operation.metadata, {'baz': 'qux'})
def test_pages_iter_empty_then_another(self): import six from google.cloud._testing import _Monkey from google.cloud import iterator as MUT items_key = 'its-key' iterator = self._makeOne(None, None, None, items_key=items_key) # Fake the next page class. fake_page = MUT.Page(None, (), None) page_args = [] def dummy_response(): return {} def dummy_page_class(*args): page_args.append(args) return fake_page iterator._get_next_page_response = dummy_response pages_iter = iterator.pages with _Monkey(MUT, Page=dummy_page_class): page = six.next(pages_iter) self.assertIs(page, fake_page) self.assertEqual( page_args, [(iterator, (), iterator._item_to_value)])
def test_poll_http(self): from google.protobuf.struct_pb2 import Struct from google.cloud._testing import _Monkey from google.cloud import operation as MUT type_url = 'type.googleapis.com/%s' % (Struct.DESCRIPTOR.full_name,) name = '2302903294023' api_response = { 'name': name, 'done': True, 'metadata': { '@type': type_url, 'value': {'foo': 'Bar'}, }, } connection = _Connection(api_response) client = _Client(connection) operation = self._make_one(name, client) operation._from_grpc = False with _Monkey(MUT, _TYPE_URL_MAP={type_url: Struct}): self.assertTrue(operation.poll()) expected_path = 'operations/%s' % (name,) self.assertEqual(connection._requested, [{ 'method': 'GET', 'path': expected_path, }])
def test_publisher_api_w_gax(self): from google.cloud.pubsub import client as MUT from google.cloud._testing import _Monkey wrapped = object() _called_with = [] def _generated_api(*args, **kw): _called_with.append((args, kw)) return wrapped class _GaxPublisherAPI(object): def __init__(self, _wrapped, client): self._wrapped = _wrapped self._client = client creds = _Credentials() client = self._makeOne(project=self.PROJECT, credentials=creds) with _Monkey(MUT, _USE_GAX=True, make_gax_publisher_api=_generated_api, GAXPublisherAPI=_GaxPublisherAPI): api = client.publisher_api self.assertIsInstance(api, _GaxPublisherAPI) self.assertIs(api._wrapped, wrapped) self.assertIs(api._client, client) # API instance is cached again = client.publisher_api self.assertIs(again, api) args = (client.connection,) self.assertEqual(_called_with, [(args, {})])
def test_ctor_w_project_no_environ(self): from google.cloud._testing import _Monkey from google.cloud.datastore import client as _MUT # Some environments (e.g. AppVeyor CI) run in GCE, so # this test would fail artificially. with _Monkey(_MUT, _base_default_project=lambda project: None): self.assertRaises(EnvironmentError, self._makeOne, None)
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 = ['*****@*****.**', '*****@*****.**'] KEYSET = KeySet(keys=KEYS) INDEX = 'email-address-index' LIMIT = 20 TOKEN = b'DEADBEEF' database = _Database(self.DATABASE_NAME) session = self._makeOne(database) session._session_id = 'DEADBEEF' _read_with = [] expected = object() class _Snapshot(object): def __init__(self, session, **kwargs): self._session = session self._kwargs = kwargs.copy() def read(self, table, columns, keyset, index='', limit=0, resume_token=b''): _read_with.append( (table, columns, keyset, index, limit, resume_token)) return expected with _Monkey(MUT, Snapshot=_Snapshot): found = session.read(TABLE_NAME, COLUMNS, KEYSET, index=INDEX, limit=LIMIT, resume_token=TOKEN) self.assertIs(found, expected) self.assertEqual(len(_read_with), 1) (table, columns, key_set, index, limit, resume_token) = _read_with[0] self.assertEqual(table, TABLE_NAME) self.assertEqual(columns, COLUMNS) self.assertEqual(key_set, KEYSET) self.assertEqual(index, INDEX) self.assertEqual(limit, LIMIT) self.assertEqual(resume_token, TOKEN)
def test_commit_too_many_mutations(self): from google.cloud._testing import _Monkey from google.cloud.bigtable import row as MUT row_key = b'row_key' table = object() row = self._make_one(row_key, table) row._rule_pb_list = [1, 2, 3] num_mutations = len(row._rule_pb_list) with _Monkey(MUT, MAX_MUTATIONS=num_mutations - 1): with self.assertRaises(ValueError): row.commit()
def test_w_same_class(self): from google.cloud import operation as MUT from google.cloud._testing import _Monkey type_url = 'testing.google-cloud-python.com/testing' klass = object() type_url_map = {type_url: klass} with _Monkey(MUT, _TYPE_URL_MAP=type_url_map): self._call_fut(klass, type_url) self.assertEqual(type_url_map, {type_url: klass})
def test_constructor_implicit_credentials(self): from google.cloud._testing import _Monkey from google.cloud.spanner import client as MUT creds = _make_credentials() def mock_get_credentials(): return creds with _Monkey(MUT, get_credentials=mock_get_credentials): self._constructor_test_helper( None, None, expected_creds=creds.with_scopes.return_value)
def _generate_helper(self, response_type=None, response_disposition=None, generation=None): import base64 from six.moves.urllib.parse import parse_qs from six.moves.urllib.parse import urlsplit from google.cloud._testing import _Monkey from google.cloud import credentials as MUT ENDPOINT = 'http://api.example.com' RESOURCE = '/name/path' SIGNED = base64.b64encode(b'DEADBEEF') CREDENTIALS = _Credentials() def _get_signed_query_params(*args): credentials, expiration = args[:2] return { 'GoogleAccessId': credentials.service_account_email, 'Expires': str(expiration), 'Signature': SIGNED, } with _Monkey(MUT, _get_signed_query_params=_get_signed_query_params): url = self._callFUT(CREDENTIALS, RESOURCE, 1000, api_access_endpoint=ENDPOINT, response_type=response_type, response_disposition=response_disposition, generation=generation) scheme, netloc, path, qs, frag = urlsplit(url) self.assertEqual(scheme, 'http') self.assertEqual(netloc, 'api.example.com') self.assertEqual(path, RESOURCE) params = parse_qs(qs) # In Py3k, parse_qs gives us text values: self.assertEqual(params.pop('Signature'), [SIGNED.decode('ascii')]) self.assertEqual(params.pop('Expires'), ['1000']) self.assertEqual(params.pop('GoogleAccessId'), [CREDENTIALS.service_account_email]) if response_type is not None: self.assertEqual(params.pop('response-content-type'), [response_type]) if response_disposition is not None: self.assertEqual(params.pop('response-content-disposition'), [response_disposition]) if generation is not None: self.assertEqual(params.pop('generation'), [generation]) # Make sure we have checked them all. self.assertEqual(len(params), 0) self.assertEqual(frag, '')
def test_from_service_account_json(self): from google.cloud._testing import _Monkey from google.cloud import client KLASS = self._getTargetClass() MOCK_FILENAME = 'foo.path' mock_creds = _MockServiceAccountCredentials() with _Monkey(client, ServiceAccountCredentials=mock_creds): client_obj = KLASS.from_service_account_json(MOCK_FILENAME) self.assertIs(client_obj.connection.credentials, mock_creds._result) self.assertEqual(mock_creds.json_called, [MOCK_FILENAME])
def test_read_rows(self): from google.cloud._testing import _Monkey from tests.unit._testing import _FakeStub from google.cloud.bigtable.row_data import PartialRowsData from google.cloud.bigtable import table as MUT client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) table = self._make_one(self.TABLE_ID, instance) # Create request_pb request_pb = object() # Returned by our mock. mock_created = [] def mock_create_row_request(table_name, **kwargs): mock_created.append((table_name, kwargs)) return request_pb # Create response_iterator response_iterator = object() # Patch the stub used by the API method. client._data_stub = stub = _FakeStub(response_iterator) # Create expected_result. expected_result = PartialRowsData(response_iterator) # Perform the method and check the result. start_key = b'start-key' end_key = b'end-key' filter_obj = object() limit = 22 with _Monkey(MUT, _create_row_request=mock_create_row_request): result = table.read_rows(start_key=start_key, end_key=end_key, filter_=filter_obj, limit=limit) self.assertEqual(result, expected_result) self.assertEqual(stub.method_calls, [( 'ReadRows', (request_pb, ), {}, )]) created_kwargs = { 'start_key': start_key, 'end_key': end_key, 'filter_': filter_obj, 'limit': limit, 'end_inclusive': False, } self.assertEqual(mock_created, [(table.name, created_kwargs)])
def _constructor_test_helper(self, expected_scopes, creds, read_only=False, admin=False, user_agent=None, expected_creds=None): from google.cloud._testing import _Monkey from google.cloud.bigtable import client as MUT user_agent = user_agent or MUT.DEFAULT_USER_AGENT mock_make_data_stub = _MakeStubMock() mock_make_instance_stub = _MakeStubMock() mock_make_operations_stub = _MakeStubMock() mock_make_table_stub = _MakeStubMock() with _Monkey(MUT, _make_data_stub=mock_make_data_stub, _make_instance_stub=mock_make_instance_stub, _make_operations_stub=mock_make_operations_stub, _make_table_stub=mock_make_table_stub): client = self._make_one(project=self.PROJECT, credentials=creds, read_only=read_only, admin=admin, user_agent=user_agent) # Verify the mocks. self.assertEqual(mock_make_data_stub.calls, [client]) if admin: self.assertSequenceEqual(mock_make_instance_stub.calls, [client]) self.assertSequenceEqual(mock_make_operations_stub.calls, [client]) self.assertSequenceEqual(mock_make_table_stub.calls, [client]) else: self.assertSequenceEqual(mock_make_instance_stub.calls, []) self.assertSequenceEqual(mock_make_operations_stub.calls, []) self.assertSequenceEqual(mock_make_table_stub.calls, []) expected_creds = expected_creds or creds.with_scopes.return_value self.assertIs(client._credentials, expected_creds) if expected_scopes is not None: creds.with_scopes.assert_called_once_with(expected_scopes) self.assertEqual(client.project, self.PROJECT) self.assertEqual(client.user_agent, user_agent) # Check gRPC stubs (or mocks of them) are set self.assertIs(client._data_stub, mock_make_data_stub.result) if admin: self.assertIs(client._instance_stub_internal, mock_make_instance_stub.result) self.assertIs(client._operations_stub_internal, mock_make_operations_stub.result) self.assertIs(client._table_stub_internal, mock_make_table_stub.result) else: self.assertIsNone(client._instance_stub_internal) self.assertIsNone(client._operations_stub_internal) self.assertIsNone(client._table_stub_internal)
def test_windows(self): from google.cloud import _helpers as MUT from google.cloud._testing import _Monkey from google.cloud._testing import _NamedTemporaryFile project_id = 'test-project-id' with _NamedTemporaryFile() as temp: config_value = self.CONFIG_TEMPLATE % ( MUT._GCLOUD_CONFIG_SECTION, MUT._GCLOUD_CONFIG_KEY, project_id) with open(temp.name, 'w') as config_file: config_file.write(config_value) def mock_get_path(): return temp.name with _Monkey(os, name='nt'): with _Monkey(MUT, _get_windows_config_path=mock_get_path, _USER_ROOT=None): result = self._callFUT() self.assertEqual(result, project_id)
def test_it(self): from google.cloud import _helpers as MUT from google.cloud._testing import _Monkey user_root = 'a' config_file = 'b' with _Monkey(MUT, _USER_ROOT=user_root, _GCLOUD_CONFIG_FILE=config_file): result = self._callFUT() expected = os.path.join(user_root, '.config', config_file) self.assertEqual(result, expected)
def _payload_helper(self, key, class_name): from google.cloud._testing import _Monkey import google.cloud.logging._helpers as MUT resource = {key: 'yup'} client = object() loggers = {} mock_class = EntryMock() with _Monkey(MUT, **{class_name: mock_class}): result = self._call_fut(resource, client, loggers) self.assertIs(result, mock_class.sentinel) self.assertEqual(mock_class.called, (resource, client, loggers))
def _makeOneWithMockQueue(self, queue_return): from google.cloud._testing import _Monkey from google.cloud.happybase import pool as MUT # We are going to use a fake queue, so we don't want any connections # or instances to be created in the constructor. size = -1 instance = object() with _Monkey(MUT, _MIN_POOL_SIZE=size): pool = self._makeOne(size, instance=instance) pool._queue = _Queue(queue_return) return pool
def test_no_gax_ctor(self): from google.cloud._testing import _Monkey from google.cloud.logging import client as MUT from google.cloud.logging.connection import _LoggingAPI creds = _Credentials() with _Monkey(MUT, _USE_GAX=True): client = self._makeOne(project=self.PROJECT, credentials=creds, use_gax=False) api = client.logging_api self.assertIsInstance(api, _LoggingAPI)
def test_conditional_row_commit_too_many_mutations(): from google.cloud._testing import _Monkey from google.cloud.bigtable import row as MUT row_key = b"row_key" table = object() filter_ = object() row = _make_conditional_row(row_key, table, filter_=filter_) row._true_pb_mutations = [1, 2, 3] num_mutations = len(row._true_pb_mutations) with _Monkey(MUT, MAX_MUTATIONS=num_mutations - 1): with pytest.raises(ValueError): row.commit()
def test_w_timedelta_days(self): import datetime from google.cloud._testing import _Monkey from google.cloud import credentials as MUT dummy_utcnow = datetime.datetime(2004, 8, 19, 0, 0, 0, 0) utc_seconds = self._utc_seconds(dummy_utcnow) expiration_as_delta = datetime.timedelta(days=1) with _Monkey(MUT, _NOW=lambda: dummy_utcnow): result = self._call_fut(expiration_as_delta) self.assertEqual(result, utc_seconds + 86400)
def test_delete_table_disable(self): from google.cloud._testing import _Monkey from happybase import connection as MUT warned = [] def mock_warn(msg): warned.append(msg) with _Monkey(MUT, _WARN=mock_warn): self._delete_table_helper(disable=True) self.assertEqual(warned, [MUT._DISABLE_DELETE_MSG])
def test_w_conflict(self): from google.cloud import operation as MUT from google.cloud._testing import _Monkey type_url = 'testing.google-cloud-python.com/testing' klass, other = object(), object() type_url_map = {type_url: other} with _Monkey(MUT, _TYPE_URL_MAP=type_url_map): with self.assertRaises(ValueError): self._call_fut(klass, type_url) self.assertEqual(type_url_map, {type_url: other})
def test_batch(self): from google.cloud.datastore import client as MUT from google.cloud._testing import _Monkey creds = object() client = self._makeOne(credentials=creds) with _Monkey(MUT, Batch=_Dummy): batch = client.batch() self.assertIsInstance(batch, _Dummy) self.assertEqual(batch.args, (client,)) self.assertEqual(batch.kwargs, {})
def test_transaction_defaults(self): from google.cloud.datastore import client as MUT from google.cloud._testing import _Monkey creds = object() client = self._makeOne(credentials=creds) with _Monkey(MUT, Transaction=_Dummy): xact = client.transaction() self.assertIsInstance(xact, _Dummy) self.assertEqual(xact.args, (client,)) self.assertEqual(xact.kwargs, {})
def _make_oneWithMocks(self, *args, **kwargs): from google.cloud._testing import _Monkey from google.cloud.bigtable import client as MUT mock_make_data_stub = _MakeStubMock() mock_make_instance_stub = _MakeStubMock() mock_make_operations_stub = _MakeStubMock() mock_make_table_stub = _MakeStubMock() with _Monkey(MUT, _make_data_stub=mock_make_data_stub, _make_instance_stub=mock_make_instance_stub, _make_operations_stub=mock_make_operations_stub, _make_table_stub=mock_make_table_stub): return self._make_one(*args, **kwargs)
def test_run_in_transaction_w_abort_w_retry_metadata_deadline(self): import datetime from google.api_core.exceptions import Aborted from google.cloud.spanner_v1.proto.spanner_pb2 import CommitResponse from google.cloud.spanner_v1.proto.transaction_pb2 import ( Transaction as TransactionPB) from google.cloud._helpers import UTC from google.cloud._helpers import _datetime_to_pb_timestamp from google.cloud.spanner_v1 import session as MUT from google.cloud._testing import _Monkey TABLE_NAME = 'citizens' COLUMNS = ['email', 'first_name', 'last_name', 'age'] VALUES = [ ['*****@*****.**', 'Phred', 'Phlyntstone', 32], ['*****@*****.**', 'Bharney', 'Rhubble', 31], ] TRANSACTION_ID = b'FACEDACE' RETRY_SECONDS = 1 RETRY_NANOS = 3456 transaction_pb = TransactionPB(id=TRANSACTION_ID) now = datetime.datetime.utcnow().replace(tzinfo=UTC) now_pb = _datetime_to_pb_timestamp(now) response = CommitResponse(commit_timestamp=now_pb) gax_api = _SpannerApi( _begin_transaction_response=transaction_pb, _commit_abort_count=1, _commit_abort_retry_seconds=RETRY_SECONDS, _commit_abort_retry_nanos=RETRY_NANOS, _commit_response=response, ) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api session = self._make_one(database) session._session_id = 'DEADBEEF' called_with = [] def unit_of_work(txn, *args, **kw): called_with.append((txn, args, kw)) txn.insert(TABLE_NAME, COLUMNS, VALUES) time_module = _FauxTimeModule() time_module._times = [1, 1.5] with _Monkey(MUT, time=time_module): with self.assertRaises(Aborted): session.run_in_transaction(unit_of_work, 'abc', timeout_secs=1) self.assertIsNone(time_module._slept) self.assertEqual(len(called_with), 1)
def test_get_default_handler_container_engine(self): import os from google.cloud._testing import _Monkey from google.cloud.logging.client import _CONTAINER_ENGINE_ENV from google.cloud.logging.handlers import ContainerEngineHandler client = self._make_one(project=self.PROJECT, credentials=_make_credentials(), use_gax=False) with _Monkey(os, environ={_CONTAINER_ENGINE_ENV: 'True'}): handler = client.get_default_handler() self.assertIsInstance(handler, ContainerEngineHandler)
def test_custom_url_from_env(self): import os from google.cloud._testing import _Monkey from google.cloud.environment_vars import PUBSUB_EMULATOR HOST = 'localhost:8187' fake_environ = {PUBSUB_EMULATOR: HOST} with _Monkey(os, getenv=fake_environ.get): conn = self._makeOne() klass = self._getTargetClass() self.assertNotEqual(conn.api_base_url, klass.API_BASE_URL) self.assertEqual(conn.api_base_url, 'http://' + HOST)
def test_no_gax_ctor(self): from google.cloud._testing import _Monkey from google.cloud.pubsub.connection import _PublisherAPI from google.cloud.pubsub import client as MUT creds = _Credentials() with _Monkey(MUT, _USE_GAX=True): client = self._makeOne(project=self.PROJECT, credentials=creds, use_gax=False) self.assertFalse(client._use_gax) api = client.publisher_api self.assertIsInstance(api, _PublisherAPI)
def test_constructor_implicit_credentials(self): from google.cloud._testing import _Monkey from google.cloud.bigtable import client as MUT creds = _Credentials() expected_scopes = [MUT.DATA_SCOPE] def mock_get_credentials(): return creds with _Monkey(MUT, get_credentials=mock_get_credentials): self._constructor_test_helper(expected_scopes, None, expected_creds=creds)
def test_ctor_missing_project(self): from google.cloud._testing import _Monkey from google.cloud import client FUNC_CALLS = [] def mock_determine_proj(project): FUNC_CALLS.append((project, '_determine_default_project')) return None with _Monkey(client, _determine_default_project=mock_determine_proj): self.assertRaises(EnvironmentError, self._make_one) self.assertEqual(FUNC_CALLS, [(None, '_determine_default_project')])
def test_read_rows_non_idempotent_error_throws(self): from google.cloud._testing import _Monkey from tests.unit._testing import _CustomFakeStub from google.cloud.bigtable.row_data import PartialRowsData from google.cloud.bigtable import retry as MUT from google.cloud.bigtable.retry import ReadRowsIterator from google.gax import BackoffSettings from google.gax.errors import RetryError from grpc import StatusCode, RpcError import time client = _Client() instance = _Instance(self.INSTANCE_NAME, client=client) table = self._make_one(self.TABLE_ID, instance) # Create request_pb request_pb = object() # Returned by our mock. mock_created = [] def mock_create_row_request(table_name, **kwargs): mock_created.append((table_name, kwargs)) return request_pb # Create response iterator that raises a non-idempotent exception class MockNonIdempotentError(RpcError): def code(self): return StatusCode.RESOURCE_EXHAUSTED def _raise(): raise MockNonIdempotentError() # Patch the stub used by the API method. The stub should create a new # slow_iterator every time its queried. def make_raising_iterator(): return (_raise() for i in range(10)) client._data_stub = stub = _CustomFakeStub(make_raising_iterator) start_key = b'start-key' end_key = b'end-key' filter_obj = object() limit = 22 with _Monkey(MUT, _create_row_request=mock_create_row_request): # Verify that a RetryError is thrown on read. result = table.read_rows(start_key=start_key, end_key=end_key, filter_=filter_obj, limit=limit) with self.assertRaises(MockNonIdempotentError): result.consume_next()
def test_custom_url_from_env(self): import os from google.cloud._testing import _Monkey from google.cloud.connection import API_BASE_URL from google.cloud.environment_vars import GCD_HOST HOST = 'CURR_HOST' fake_environ = {GCD_HOST: HOST} with _Monkey(os, environ=fake_environ): conn = self._makeOne() self.assertNotEqual(conn.api_base_url, API_BASE_URL) self.assertEqual(conn.api_base_url, 'http://' + HOST)
def test_run_in_transaction_w_timeout(self): from google.cloud.spanner import session as MUT from google.cloud._testing import _Monkey from google.gax.errors import GaxError from google.gax.grpc import exc_to_code from google.cloud.proto.spanner.v1.transaction_pb2 import ( 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 = [ ['*****@*****.**', 'Phred', 'Phlyntstone', 32], ['*****@*****.**', 'Bharney', 'Rhubble', 31], ] TRANSACTION_ID = b'FACEDACE' transaction_pb = TransactionPB(id=TRANSACTION_ID) gax_api = _SpannerApi( _begin_transaction_response=transaction_pb, _commit_abort_count=1e6, ) database = _Database(self.DATABASE_NAME) database.spanner_api = gax_api session = self._make_one(database) session._session_id = 'DEADBEEF' called_with = [] def unit_of_work(txn, *args, **kw): called_with.append((txn, args, kw)) txn.insert(TABLE_NAME, COLUMNS, VALUES) time_module = _FauxTimeModule() time_module._times = [1, 1.5, 2.5] # retry once w/ timeout_secs=1 with _Monkey(MUT, time=time_module): with self.assertRaises(GaxError) as exc: session.run_in_transaction(unit_of_work, timeout_secs=1) self.assertEqual(exc_to_code(exc.exception.cause), StatusCode.ABORTED) self.assertEqual(time_module._slept, None) self.assertEqual(len(called_with), 2) for txn, args, kw in called_with: self.assertIsInstance(txn, Transaction) self.assertIsNone(txn.committed) self.assertEqual(args, ()) self.assertEqual(kw, {})
def test_w_request_returning_None(self): from google.cloud._testing import _Monkey from google.cloud.streaming import http_wrapper as MUT from google.cloud.streaming.exceptions import RequestError INFO = None CONTENT = None CONN_TYPE = object() _http = _Http((INFO, CONTENT)) _http.connections = {'http': CONN_TYPE} _httplib2 = _Dummy(debuglevel=1) _request = _Request() with _Monkey(MUT, httplib2=_httplib2): with self.assertRaises(RequestError): self._callFUT(_http, _request) self._verify_requested(_http, _request, connection_type=CONN_TYPE)