def test___call__(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable.client import Client
from gcloud_bigtable.client import DATA_SCOPE
from gcloud_bigtable.client import DEFAULT_USER_AGENT
access_token_expected = 'FOOBARBAZ'
class _ReturnVal(object):
access_token = access_token_expected
scoped_creds = _MockWithAttachedMethods(_ReturnVal)
credentials = _MockWithAttachedMethods(scoped_creds)
project_id = 'PROJECT_ID'
client = Client(credentials, project_id=project_id)
transformer = self._makeOne(client)
result = transformer(None)
self.assertEqual(
result,
[
('Authorization', 'Bearer ' + access_token_expected),
('User-agent', DEFAULT_USER_AGENT),
])
self.assertEqual(credentials._called, [
('create_scoped', ([DATA_SCOPE],), {}),
])
self.assertEqual(scoped_creds._called, [('get_access_token', (), {})])
def test_from_service_account_p12(self):
from gcloud_bigtable._testing import _MockCalled
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import client as MUT
klass = self._getTargetClass()
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
signed_creds = _MockCalled(credentials)
private_key = 'PRIVATE_KEY'
mock_get_contents = _MockCalled(private_key)
client_email = 'CLIENT_EMAIL'
private_key_path = 'PRIVATE_KEY_PATH'
with _Monkey(MUT, SignedJwtAssertionCredentials=signed_creds,
_get_contents=mock_get_contents):
client = klass.from_service_account_p12(
client_email, private_key_path, project_id=PROJECT_ID)
self.assertEqual(client.project_id, PROJECT_ID)
self.assertTrue(client._credentials is scoped_creds)
expected_scopes = [MUT.DATA_SCOPE]
self.assertEqual(credentials._called, [
('create_scoped', (expected_scopes,), {}),
])
# SignedJwtAssertionCredentials() called with only kwargs
signed_creds_kw = {
'private_key': private_key,
'service_account_name': client_email,
}
signed_creds.check_called(self, [()], [signed_creds_kw])
# Load private key (via _get_contents) from the key path.
mock_get_contents.check_called(self, [(private_key_path,)])
def test_from_service_account_json(self):
from gcloud_bigtable._testing import _MockCalled
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import client as MUT
klass = self._getTargetClass()
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
get_adc = _MockCalled(credentials)
json_credentials_path = 'JSON_CREDENTIALS_PATH'
with _Monkey(MUT,
_get_application_default_credential_from_file=get_adc):
client = klass.from_service_account_json(
json_credentials_path, project_id=PROJECT_ID)
self.assertEqual(client.project_id, PROJECT_ID)
self.assertTrue(client._credentials is scoped_creds)
expected_scopes = [MUT.DATA_SCOPE]
self.assertEqual(credentials._called, [
('create_scoped', (expected_scopes,), {}),
])
# _get_application_default_credential_from_file only has pos. args.
get_adc.check_called(self, [(json_credentials_path,)])
def test_table_stub_getter(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID, admin=True)
client._table_stub = object()
self.assertTrue(client.table_stub is client._table_stub)
def test_table_stub_unset_failure(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID, admin=True)
with self.assertRaises(ValueError):
getattr(client, 'table_stub')
def _constructor_test_helper(self, expected_scopes, project_id=None,
read_only=False, admin=False,
user_agent=None):
from gcloud_bigtable._testing import _MockCalled
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import client as MUT
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
determined_project_id = object()
mock_determine_project_id = _MockCalled(determined_project_id)
with _Monkey(MUT, _determine_project_id=mock_determine_project_id):
client = self._makeOne(credentials, project_id=project_id,
read_only=read_only, admin=admin,
user_agent=user_agent)
self.assertTrue(client._credentials is scoped_creds)
self.assertEqual(credentials._called, [
('create_scoped', (expected_scopes,), {}),
])
self.assertTrue(client._project_id is determined_project_id)
self.assertEqual(client.timeout_seconds, MUT.DEFAULT_TIMEOUT_SECONDS)
self.assertEqual(client.user_agent, user_agent)
mock_determine_project_id.check_called(self, [(project_id,)])
def test_it(self):
from gcloud_bigtable._testing import _MockCalled
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import _helpers as MUT
mock_result = object()
custom_factory = _MockCalled(mock_result)
transformed = object()
transformer = _MockCalled(transformed)
host = 'HOST'
port = 1025
certs = 'FOOBAR'
client = _MockWithAttachedMethods()
with _Monkey(MUT, get_certs=lambda: certs,
MetadataTransformer=transformer):
result = self._callFUT(client, custom_factory, host, port)
self.assertTrue(result is mock_result)
custom_factory.check_called(
self,
[(host, port)],
[{
'metadata_transformer': transformed,
'secure': True,
'root_certificates': certs,
}],
)
transformer.check_called(self, [(client,)])
self.assertEqual(client._called, [])
def test__make_table_stub(self):
from gcloud_bigtable._testing import _MockCalled
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import client as MUT
from gcloud_bigtable.client import TABLE_ADMIN_HOST
from gcloud_bigtable.client import TABLE_ADMIN_PORT
from gcloud_bigtable.client import TABLE_STUB_FACTORY
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID)
expected_result = object()
mock_make_stub = _MockCalled(expected_result)
with _Monkey(MUT, make_stub=mock_make_stub):
result = client._make_table_stub()
self.assertTrue(result is expected_result)
make_stub_args = [
(
client,
TABLE_STUB_FACTORY,
TABLE_ADMIN_HOST,
TABLE_ADMIN_PORT,
),
]
mock_make_stub.check_called(self, make_stub_args)
def _start_method_helper(self, admin):
from gcloud_bigtable._testing import _MockCalled
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import client as MUT
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID, admin=admin)
stub = _FakeStub()
mock_make_stub = _MockCalled(stub)
with _Monkey(MUT, make_stub=mock_make_stub):
client.start()
self.assertTrue(client._data_stub is stub)
if admin:
self.assertTrue(client._cluster_stub is stub)
self.assertTrue(client._operations_stub is stub)
self.assertTrue(client._table_stub is stub)
self.assertEqual(stub._entered, 4)
else:
self.assertTrue(client._cluster_stub is None)
self.assertTrue(client._operations_stub is None)
self.assertTrue(client._table_stub is None)
self.assertEqual(stub._entered, 1)
self.assertEqual(stub._exited, [])
def _stop_method_helper(self, admin):
from gcloud_bigtable._testing import _MockWithAttachedMethods
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID, admin=admin)
stub1 = _FakeStub()
stub2 = _FakeStub()
client._data_stub = stub1
client._cluster_stub = stub2
client._operations_stub = stub2
client._table_stub = stub2
client.stop()
self.assertTrue(client._data_stub is None)
self.assertTrue(client._cluster_stub is None)
self.assertTrue(client._operations_stub is None)
self.assertTrue(client._table_stub is None)
self.assertEqual(stub1._entered, 0)
self.assertEqual(stub2._entered, 0)
exc_none_triple = (None, None, None)
self.assertEqual(stub1._exited, [exc_none_triple])
if admin:
self.assertEqual(stub2._exited, [exc_none_triple] * 3)
else:
self.assertEqual(stub2._exited, [])
def test_project_id_getter(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID)
self.assertEqual(client.project_id, PROJECT_ID)
def test_copy(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
class Credentials(object):
def __init__(self, value):
self.value = value
def __eq__(self, other):
return self.value == other.value
scoped_creds = Credentials('value')
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID)
# Put some fake stubs in place so that we can verify they
# don't get copied.
client._data_stub = object()
client._cluster_stub = object()
client._operations_stub = object()
client._table_stub = object()
new_client = client.copy()
self.assertEqual(new_client._admin, client._admin)
self.assertEqual(new_client._credentials, client._credentials)
# Make sure credentials (a non-simple type) gets copied
# to a new instance.
self.assertFalse(new_client._credentials is client._credentials)
self.assertEqual(new_client._project_id, client._project_id)
self.assertEqual(new_client.user_agent, client.user_agent)
self.assertEqual(new_client.timeout_seconds, client.timeout_seconds)
# Make sure stubs are not preserved.
self.assertEqual(new_client._data_stub, None)
self.assertEqual(new_client._cluster_stub, None)
self.assertEqual(new_client._operations_stub, None)
self.assertEqual(new_client._table_stub, None)
def _helper(self, status, raise_socket_err=False):
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import client as MUT
fake_project_id = object()
response = self._make_http_connection_response(
status, fake_project_id, raise_socket_err=raise_socket_err)
# The connection does the bulk of the work.
mock_connection = _MockWithAttachedMethods(None, response, None)
# The http_client module holds the connection constructor.
mock_http_client = _MockWithAttachedMethods(mock_connection)
# We need to put the client in place of it's location in six.
mock_six = self._make_fake_six_module(mock_http_client)
with _Monkey(MUT, six=mock_six):
result = self._callFUT()
if status == 200 and not raise_socket_err:
self.assertEqual(result, fake_project_id)
else:
self.assertEqual(result, None)
self.assertEqual(mock_connection._called, [
(
'request',
('GET', '/computeMetadata/v1/project/project-id'),
{'headers': {'Metadata-Flavor': 'Google'}},
),
(
'getresponse',
(),
{},
),
(
'close',
(),
{},
),
])
self.assertEqual(mock_http_client._called, [
(
'HTTPConnection',
('169.254.169.254',),
{'timeout': 0.1},
),
])
def test_project_name_property(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
project_name = 'projects/' + PROJECT_ID
client = self._makeOne(credentials, project_id=PROJECT_ID)
self.assertEqual(client.project_name, project_name)
def test_project_id_getter(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable.client import Client
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = Client(credentials, project_id=PROJECT_ID)
cluster = self._makeOne(ZONE, CLUSTER_ID, client)
self.assertEqual(cluster.project_id, PROJECT_ID)
def test_name_property(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable.client import Client
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = Client(credentials, project_id=PROJECT_ID)
cluster = self._makeOne(ZONE, CLUSTER_ID, client)
cluster_name = "projects/" + PROJECT_ID + "/zones/" + ZONE + "/clusters/" + CLUSTER_ID
self.assertEqual(cluster.name, cluster_name)
def test_is_started(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID)
self.assertFalse(client.is_started())
client._data_stub = object()
self.assertTrue(client.is_started())
client._data_stub = None
self.assertFalse(client.is_started())
def test_start_while_started(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID)
client._data_stub = data_stub = object()
self.assertTrue(client.is_started())
client.start()
# Make sure the stub did not change.
self.assertEqual(client._data_stub, data_stub)
def test_constructor_default(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import client as MUT
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
mock_creds_class = _MockWithAttachedMethods(credentials)
with _Monkey(MUT, GoogleCredentials=mock_creds_class):
client = self._makeOne(project_id=PROJECT_ID)
self.assertEqual(client.project_id, PROJECT_ID)
self.assertTrue(client._credentials is scoped_creds)
self.assertEqual(client.user_agent, MUT.DEFAULT_USER_AGENT)
self.assertEqual(mock_creds_class._called,
[('get_application_default', (), {})])
expected_scopes = [MUT.DATA_SCOPE]
self.assertEqual(credentials._called, [
('create_scoped', (expected_scopes,), {}),
])
def test_with_app_engine(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import client as MUT
fake_project_id = object()
mock_app_identity = _MockWithAttachedMethods(fake_project_id)
with _Monkey(MUT, app_identity=mock_app_identity):
result = self._callFUT()
self.assertTrue(result is fake_project_id)
self.assertEqual(mock_app_identity._called,
[('get_application_id', (), {})])
def test_it(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import client as MUT
fake_project_id = object()
mock_os = _MockWithAttachedMethods(fake_project_id)
with _Monkey(MUT, os=mock_os):
result = self._callFUT()
self.assertTrue(result is fake_project_id)
self.assertEqual(mock_os._called,
[('getenv', (MUT.PROJECT_ENV_VAR,), {})])
def test_cluster_factory(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable.cluster import Cluster
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID)
zone = 'zone'
cluster_id = 'cluster-id'
cluster = client.cluster(zone, cluster_id)
self.assertTrue(isinstance(cluster, Cluster))
self.assertTrue(cluster.client is client)
self.assertEqual(cluster.zone, zone)
self.assertEqual(cluster.cluster_id, cluster_id)
def test_stop_while_stopped(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID)
self.assertFalse(client.is_started())
# This is a bit hacky. We set the cluster stub protected value
# since it isn't used in is_started() and make sure that stop
# doesn't reset this value to None.
client._cluster_stub = cluster_stub = object()
client.stop()
# Make sure the cluster stub did not change.
self.assertEqual(client._cluster_stub, cluster_stub)
def test_constructor(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable.client import Client
from gcloud_bigtable.client import DATA_SCOPE
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
project_id = 'PROJECT_ID'
user_agent = 'USER_AGENT'
client = Client(credentials, project_id=project_id,
user_agent=user_agent)
transformer = self._makeOne(client)
self.assertTrue(transformer._credentials is scoped_creds)
self.assertEqual(transformer._user_agent, user_agent)
self.assertEqual(credentials._called, [
('create_scoped', ([DATA_SCOPE],), {}),
])
def test_from_pb_success(self):
from gcloud_bigtable._generated import bigtable_cluster_data_pb2 as data_pb2
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable.client import Client
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = Client(credentials, project_id=PROJECT_ID)
cluster_name = "projects/" + PROJECT_ID + "/zones/" + ZONE + "/clusters/" + CLUSTER_ID
cluster_pb = data_pb2.Cluster(name=cluster_name, display_name=CLUSTER_ID, serve_nodes=3)
klass = self._getTargetClass()
cluster = klass.from_pb(cluster_pb, client)
self.assertTrue(isinstance(cluster, klass))
self.assertEqual(cluster.client, client)
self.assertEqual(cluster.zone, ZONE)
self.assertEqual(cluster.cluster_id, CLUSTER_ID)
def test_from_pb_project_id_mistmatch(self):
from gcloud_bigtable._generated import bigtable_cluster_data_pb2 as data_pb2
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable.client import Client
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
alt_project_id = "ALT_PROJECT_ID"
client = Client(credentials, project_id=alt_project_id)
self.assertNotEqual(PROJECT_ID, alt_project_id)
cluster_name = "projects/" + PROJECT_ID + "/zones/" + ZONE + "/clusters/" + CLUSTER_ID
cluster_pb = data_pb2.Cluster(name=cluster_name)
klass = self._getTargetClass()
with self.assertRaises(ValueError):
klass.from_pb(cluster_pb, client)
def _list_zones_helper(self, zone_status):
from gcloud_bigtable._generated import (
bigtable_cluster_data_pb2 as data_pb2)
from gcloud_bigtable._generated import (
bigtable_cluster_service_messages_pb2 as messages_pb2)
from gcloud_bigtable._grpc_mocks import StubMock
from gcloud_bigtable._testing import _MockWithAttachedMethods
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID, admin=True)
# Create request_pb
request_pb = messages_pb2.ListZonesRequest(
name='projects/' + PROJECT_ID,
)
# Create response_pb
zone1 = 'foo'
zone2 = 'bar'
response_pb = messages_pb2.ListZonesResponse(
zones=[
data_pb2.Zone(display_name=zone1, status=zone_status),
data_pb2.Zone(display_name=zone2, status=zone_status),
],
)
# Patch the stub used by the API method.
client._cluster_stub = stub = StubMock(response_pb)
# Create expected_result.
expected_result = [zone1, zone2]
# Perform the method and check the result.
timeout_seconds = 281330
result = client.list_zones(timeout_seconds=timeout_seconds)
self.assertEqual(result, expected_result)
self.assertEqual(stub.method_calls, [(
'ListZones',
(request_pb, timeout_seconds),
{},
)])
def test_copy_partial_failure(self):
from gcloud_bigtable._testing import _MockWithAttachedMethods
from gcloud_bigtable._testing import _Monkey
from gcloud_bigtable import client as MUT
captured_stubs = {}
def always_fail(client_to_copy):
captured_stubs['data_stub'] = client_to_copy._data_stub
captured_stubs['cluster_stub'] = client_to_copy._cluster_stub
captured_stubs['operations_stub'] = client_to_copy._operations_stub
captured_stubs['table_stub'] = client_to_copy._table_stub
raise ValueError('cannot copy', client_to_copy)
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID)
client._data_stub = data_stub = object()
client._cluster_stub = cluster_stub = object()
client._operations_stub = operations_stub = object()
client._table_stub = table_stub = object()
with _Monkey(MUT.copy, deepcopy=always_fail):
with self.assertRaises(ValueError):
client.copy()
# Make sure none of the stubs were present in the deepcopy().
self.assertEqual(captured_stubs, {
'data_stub': None,
'cluster_stub': None,
'operations_stub': None,
'table_stub': None,
})
# Make sure **all** the stubs were restored after the failure.
self.assertEqual(client._data_stub, data_stub)
self.assertEqual(client._cluster_stub, cluster_stub)
self.assertEqual(client._operations_stub, operations_stub)
self.assertEqual(client._table_stub, table_stub)
def test_list_clusters(self):
from gcloud_bigtable._generated import (
bigtable_cluster_data_pb2 as data_pb2)
from gcloud_bigtable._generated import (
bigtable_cluster_service_messages_pb2 as messages_pb2)
from gcloud_bigtable._grpc_mocks import StubMock
from gcloud_bigtable._testing import _MockWithAttachedMethods
scoped_creds = object()
credentials = _MockWithAttachedMethods(scoped_creds)
client = self._makeOne(credentials, project_id=PROJECT_ID, admin=True)
# Create request_pb
request_pb = messages_pb2.ListClustersRequest(
name='projects/' + PROJECT_ID,
)
# Create response_pb
zone = 'foo'
failed_zone = 'bar'
cluster_id1 = 'cluster-id1'
cluster_id2 = 'cluster-id2'
cluster_name1 = ('projects/' + PROJECT_ID + '/zones/' + zone +
'/clusters/' + cluster_id1)
cluster_name2 = ('projects/' + PROJECT_ID + '/zones/' + zone +
'/clusters/' + cluster_id2)
response_pb = messages_pb2.ListClustersResponse(
failed_zones=[
data_pb2.Zone(display_name=failed_zone),
],
clusters=[
data_pb2.Cluster(
name=cluster_name1,
display_name=cluster_name1,
serve_nodes=3,
),
data_pb2.Cluster(
name=cluster_name2,
display_name=cluster_name2,
serve_nodes=3,
),
],
)
# Patch the stub used by the API method.
client._cluster_stub = stub = StubMock(response_pb)
# Create expected_result.
failed_zones = [failed_zone]
clusters = [
client.cluster(zone, cluster_id1),
client.cluster(zone, cluster_id2),
]
expected_result = (clusters, failed_zones)
# Perform the method and check the result.
timeout_seconds = 8004
result = client.list_clusters(timeout_seconds=timeout_seconds)
self.assertEqual(result, expected_result)
self.assertEqual(stub.method_calls, [(
'ListClusters',
(request_pb, timeout_seconds),
{},
)])