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)
