866 lines
31 KiB
Python
866 lines
31 KiB
Python
# Copyright 2015 Google Inc. All rights reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
|
|
import datetime
|
|
import unittest2
|
|
|
|
|
|
class TestOperation(unittest2.TestCase):
|
|
|
|
OP_TYPE = 'fake-op'
|
|
OP_ID = 8915
|
|
BEGIN = datetime.datetime(2015, 10, 22, 1, 1)
|
|
LOCATION_ID = 'loc-id'
|
|
|
|
def _getTargetClass(self):
|
|
from gcloud.bigtable.instance import Operation
|
|
return Operation
|
|
|
|
def _makeOne(self, *args, **kwargs):
|
|
return self._getTargetClass()(*args, **kwargs)
|
|
|
|
def _constructor_test_helper(self, instance=None):
|
|
operation = self._makeOne(
|
|
self.OP_TYPE, self.OP_ID, self.BEGIN, self.LOCATION_ID,
|
|
instance=instance)
|
|
|
|
self.assertEqual(operation.op_type, self.OP_TYPE)
|
|
self.assertEqual(operation.op_id, self.OP_ID)
|
|
self.assertEqual(operation.begin, self.BEGIN)
|
|
self.assertEqual(operation.location_id, self.LOCATION_ID)
|
|
self.assertEqual(operation._instance, instance)
|
|
self.assertFalse(operation._complete)
|
|
|
|
def test_constructor_defaults(self):
|
|
self._constructor_test_helper()
|
|
|
|
def test_constructor_explicit_instance(self):
|
|
instance = object()
|
|
self._constructor_test_helper(instance=instance)
|
|
|
|
def test___eq__(self):
|
|
instance = object()
|
|
operation1 = self._makeOne(
|
|
self.OP_TYPE, self.OP_ID, self.BEGIN, self.LOCATION_ID,
|
|
instance=instance)
|
|
operation2 = self._makeOne(
|
|
self.OP_TYPE, self.OP_ID, self.BEGIN, self.LOCATION_ID,
|
|
instance=instance)
|
|
self.assertEqual(operation1, operation2)
|
|
|
|
def test___eq__type_differ(self):
|
|
operation1 = self._makeOne('foo', 123, None, self.LOCATION_ID)
|
|
operation2 = object()
|
|
self.assertNotEqual(operation1, operation2)
|
|
|
|
def test___ne__same_value(self):
|
|
instance = object()
|
|
operation1 = self._makeOne(
|
|
self.OP_TYPE, self.OP_ID, self.BEGIN, self.LOCATION_ID,
|
|
instance=instance)
|
|
operation2 = self._makeOne(
|
|
self.OP_TYPE, self.OP_ID, self.BEGIN, self.LOCATION_ID,
|
|
instance=instance)
|
|
comparison_val = (operation1 != operation2)
|
|
self.assertFalse(comparison_val)
|
|
|
|
def test___ne__(self):
|
|
operation1 = self._makeOne('foo', 123, None, self.LOCATION_ID)
|
|
operation2 = self._makeOne('bar', 456, None, self.LOCATION_ID)
|
|
self.assertNotEqual(operation1, operation2)
|
|
|
|
def test_finished_without_operation(self):
|
|
operation = self._makeOne(None, None, None, None)
|
|
operation._complete = True
|
|
with self.assertRaises(ValueError):
|
|
operation.finished()
|
|
|
|
def _finished_helper(self, done):
|
|
from google.longrunning import operations_pb2
|
|
from gcloud.bigtable._testing import _FakeStub
|
|
from gcloud.bigtable.instance import Instance
|
|
|
|
PROJECT = 'PROJECT'
|
|
INSTANCE_ID = 'instance-id'
|
|
TIMEOUT_SECONDS = 1
|
|
|
|
client = _Client(PROJECT, timeout_seconds=TIMEOUT_SECONDS)
|
|
instance = Instance(INSTANCE_ID, client, self.LOCATION_ID)
|
|
operation = self._makeOne(
|
|
self.OP_TYPE, self.OP_ID, self.BEGIN, self.LOCATION_ID,
|
|
instance=instance)
|
|
|
|
# Create request_pb
|
|
op_name = ('operations/projects/' + PROJECT +
|
|
'/instances/' + INSTANCE_ID +
|
|
'/locations/' + self.LOCATION_ID +
|
|
'/operations/%d' % (self.OP_ID,))
|
|
request_pb = operations_pb2.GetOperationRequest(name=op_name)
|
|
|
|
# Create response_pb
|
|
response_pb = operations_pb2.Operation(done=done)
|
|
|
|
# Patch the stub used by the API method.
|
|
client._operations_stub = stub = _FakeStub(response_pb)
|
|
|
|
# Create expected_result.
|
|
expected_result = done
|
|
|
|
# Perform the method and check the result.
|
|
result = operation.finished()
|
|
|
|
self.assertEqual(result, expected_result)
|
|
self.assertEqual(stub.method_calls, [(
|
|
'GetOperation',
|
|
(request_pb, TIMEOUT_SECONDS),
|
|
{},
|
|
)])
|
|
|
|
if done:
|
|
self.assertTrue(operation._complete)
|
|
else:
|
|
self.assertFalse(operation._complete)
|
|
|
|
def test_finished(self):
|
|
self._finished_helper(done=True)
|
|
|
|
def test_finished_not_done(self):
|
|
self._finished_helper(done=False)
|
|
|
|
|
|
class TestInstance(unittest2.TestCase):
|
|
|
|
PROJECT = 'project'
|
|
INSTANCE_ID = 'instance-id'
|
|
INSTANCE_NAME = 'projects/' + PROJECT + '/instances/' + INSTANCE_ID
|
|
LOCATION_ID = 'locname'
|
|
LOCATION = 'projects/' + PROJECT + '/locations/' + LOCATION_ID
|
|
DISPLAY_NAME = 'display_name'
|
|
OP_ID = 8915
|
|
OP_NAME = ('operations/projects/%s/instances/%soperations/%d' %
|
|
(PROJECT, INSTANCE_ID, OP_ID))
|
|
TABLE_ID = 'table_id'
|
|
TABLE_NAME = INSTANCE_NAME + '/tables/' + TABLE_ID
|
|
TIMEOUT_SECONDS = 1
|
|
|
|
def _getTargetClass(self):
|
|
from gcloud.bigtable.instance import Instance
|
|
return Instance
|
|
|
|
def _makeOne(self, *args, **kwargs):
|
|
return self._getTargetClass()(*args, **kwargs)
|
|
|
|
def test_constructor_defaults(self):
|
|
from gcloud.bigtable.cluster import DEFAULT_SERVE_NODES
|
|
|
|
client = object()
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
self.assertEqual(instance.instance_id, self.INSTANCE_ID)
|
|
self.assertEqual(instance.display_name, self.INSTANCE_ID)
|
|
self.assertTrue(instance._client is client)
|
|
self.assertEqual(instance._cluster_location_id, self.LOCATION_ID)
|
|
self.assertEqual(instance._cluster_serve_nodes, DEFAULT_SERVE_NODES)
|
|
|
|
def test_constructor_non_default(self):
|
|
display_name = 'display_name'
|
|
client = object()
|
|
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID,
|
|
display_name=display_name)
|
|
self.assertEqual(instance.instance_id, self.INSTANCE_ID)
|
|
self.assertEqual(instance.display_name, display_name)
|
|
self.assertTrue(instance._client is client)
|
|
|
|
def test_copy(self):
|
|
display_name = 'display_name'
|
|
|
|
client = _Client(self.PROJECT)
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID,
|
|
display_name=display_name)
|
|
new_instance = instance.copy()
|
|
|
|
# Make sure the client copy succeeded.
|
|
self.assertFalse(new_instance._client is client)
|
|
self.assertEqual(new_instance._client, client)
|
|
# Make sure the client got copied to a new instance.
|
|
self.assertFalse(instance is new_instance)
|
|
self.assertEqual(instance, new_instance)
|
|
|
|
def test_table_factory(self):
|
|
from gcloud.bigtable.table import Table
|
|
|
|
instance = self._makeOne(self.INSTANCE_ID, None, self.LOCATION_ID)
|
|
|
|
table = instance.table(self.TABLE_ID)
|
|
self.assertTrue(isinstance(table, Table))
|
|
self.assertEqual(table.table_id, self.TABLE_ID)
|
|
self.assertEqual(table._instance, instance)
|
|
|
|
def test__update_from_pb_success(self):
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as data_v2_pb2)
|
|
|
|
display_name = 'display_name'
|
|
instance_pb = data_v2_pb2.Instance(
|
|
display_name=display_name,
|
|
)
|
|
|
|
instance = self._makeOne(None, None, None, None)
|
|
self.assertEqual(instance.display_name, None)
|
|
instance._update_from_pb(instance_pb)
|
|
self.assertEqual(instance.display_name, display_name)
|
|
|
|
def test__update_from_pb_no_display_name(self):
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as data_v2_pb2)
|
|
|
|
instance_pb = data_v2_pb2.Instance()
|
|
instance = self._makeOne(None, None, None, None)
|
|
self.assertEqual(instance.display_name, None)
|
|
with self.assertRaises(ValueError):
|
|
instance._update_from_pb(instance_pb)
|
|
self.assertEqual(instance.display_name, None)
|
|
|
|
def test_from_pb_success(self):
|
|
from gcloud.bigtable.instance import _EXISTING_INSTANCE_LOCATION_ID
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as data_v2_pb2)
|
|
|
|
client = _Client(project=self.PROJECT)
|
|
|
|
instance_pb = data_v2_pb2.Instance(
|
|
name=self.INSTANCE_NAME,
|
|
display_name=self.INSTANCE_ID,
|
|
)
|
|
|
|
klass = self._getTargetClass()
|
|
instance = klass.from_pb(instance_pb, client)
|
|
self.assertTrue(isinstance(instance, klass))
|
|
self.assertEqual(instance._client, client)
|
|
self.assertEqual(instance.instance_id, self.INSTANCE_ID)
|
|
self.assertEqual(instance._cluster_location_id,
|
|
_EXISTING_INSTANCE_LOCATION_ID)
|
|
|
|
def test_from_pb_bad_instance_name(self):
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as data_v2_pb2)
|
|
|
|
instance_name = 'INCORRECT_FORMAT'
|
|
instance_pb = data_v2_pb2.Instance(name=instance_name)
|
|
|
|
klass = self._getTargetClass()
|
|
with self.assertRaises(ValueError):
|
|
klass.from_pb(instance_pb, None)
|
|
|
|
def test_from_pb_project_mistmatch(self):
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as data_v2_pb2)
|
|
|
|
ALT_PROJECT = 'ALT_PROJECT'
|
|
client = _Client(project=ALT_PROJECT)
|
|
|
|
self.assertNotEqual(self.PROJECT, ALT_PROJECT)
|
|
|
|
instance_pb = data_v2_pb2.Instance(name=self.INSTANCE_NAME)
|
|
|
|
klass = self._getTargetClass()
|
|
with self.assertRaises(ValueError):
|
|
klass.from_pb(instance_pb, client)
|
|
|
|
def test_name_property(self):
|
|
client = _Client(project=self.PROJECT)
|
|
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
self.assertEqual(instance.name, self.INSTANCE_NAME)
|
|
|
|
def test___eq__(self):
|
|
client = object()
|
|
instance1 = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
instance2 = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
self.assertEqual(instance1, instance2)
|
|
|
|
def test___eq__type_differ(self):
|
|
client = object()
|
|
instance1 = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
instance2 = object()
|
|
self.assertNotEqual(instance1, instance2)
|
|
|
|
def test___ne__same_value(self):
|
|
client = object()
|
|
instance1 = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
instance2 = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
comparison_val = (instance1 != instance2)
|
|
self.assertFalse(comparison_val)
|
|
|
|
def test___ne__(self):
|
|
instance1 = self._makeOne('instance_id1', 'client1', self.LOCATION_ID)
|
|
instance2 = self._makeOne('instance_id2', 'client2', self.LOCATION_ID)
|
|
self.assertNotEqual(instance1, instance2)
|
|
|
|
def test_reload(self):
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as data_v2_pb2)
|
|
from gcloud.bigtable._generated_v2 import (
|
|
bigtable_instance_admin_pb2 as messages_v2_pb)
|
|
from gcloud.bigtable._testing import _FakeStub
|
|
|
|
client = _Client(self.PROJECT, timeout_seconds=self.TIMEOUT_SECONDS)
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
|
|
# Create request_pb
|
|
request_pb = messages_v2_pb.GetInstanceRequest(
|
|
name=self.INSTANCE_NAME)
|
|
|
|
# Create response_pb
|
|
DISPLAY_NAME = u'hey-hi-hello'
|
|
response_pb = data_v2_pb2.Instance(
|
|
display_name=DISPLAY_NAME,
|
|
)
|
|
|
|
# Patch the stub used by the API method.
|
|
client._instance_stub = stub = _FakeStub(response_pb)
|
|
|
|
# Create expected_result.
|
|
expected_result = None # reload() has no return value.
|
|
|
|
# Check Instance optional config values before.
|
|
self.assertEqual(instance.display_name, self.INSTANCE_ID)
|
|
|
|
# Perform the method and check the result.
|
|
result = instance.reload()
|
|
self.assertEqual(result, expected_result)
|
|
self.assertEqual(stub.method_calls, [(
|
|
'GetInstance',
|
|
(request_pb, self.TIMEOUT_SECONDS),
|
|
{},
|
|
)])
|
|
|
|
# Check Instance optional config values before.
|
|
self.assertEqual(instance.display_name, DISPLAY_NAME)
|
|
|
|
def test_create(self):
|
|
from google.longrunning import operations_pb2
|
|
from gcloud._testing import _Monkey
|
|
from gcloud.bigtable._testing import _FakeStub
|
|
from gcloud.bigtable import instance as MUT
|
|
|
|
client = _Client(self.PROJECT, timeout_seconds=self.TIMEOUT_SECONDS)
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
|
|
# Create request_pb. Just a mock since we monkey patch
|
|
# _prepare_create_request
|
|
request_pb = object()
|
|
|
|
# Create response_pb
|
|
OP_BEGIN = object()
|
|
response_pb = operations_pb2.Operation(name=self.OP_NAME)
|
|
|
|
# Patch the stub used by the API method.
|
|
client._instance_stub = stub = _FakeStub(response_pb)
|
|
|
|
# Create expected_result.
|
|
expected_result = MUT.Operation('create', self.OP_ID, OP_BEGIN,
|
|
self.LOCATION_ID, instance=instance)
|
|
|
|
# Create the mocks.
|
|
prep_create_called = []
|
|
|
|
def mock_prep_create_req(instance):
|
|
prep_create_called.append(instance)
|
|
return request_pb
|
|
|
|
process_operation_called = []
|
|
|
|
def mock_process_operation(operation_pb):
|
|
process_operation_called.append(operation_pb)
|
|
return self.OP_ID, self.LOCATION_ID, OP_BEGIN
|
|
|
|
# Perform the method and check the result.
|
|
with _Monkey(MUT,
|
|
_prepare_create_request=mock_prep_create_req,
|
|
_process_operation=mock_process_operation):
|
|
result = instance.create()
|
|
|
|
self.assertEqual(result, expected_result)
|
|
self.assertEqual(stub.method_calls, [(
|
|
'CreateInstance',
|
|
(request_pb, self.TIMEOUT_SECONDS),
|
|
{},
|
|
)])
|
|
self.assertEqual(prep_create_called, [instance])
|
|
self.assertEqual(process_operation_called, [response_pb])
|
|
|
|
def test_create_w_explicit_serve_nodes(self):
|
|
from google.longrunning import operations_pb2
|
|
from gcloud._testing import _Monkey
|
|
from gcloud.bigtable._testing import _FakeStub
|
|
from gcloud.bigtable import instance as MUT
|
|
|
|
SERVE_NODES = 5
|
|
|
|
client = _Client(self.PROJECT, timeout_seconds=self.TIMEOUT_SECONDS)
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID,
|
|
serve_nodes=SERVE_NODES)
|
|
|
|
# Create request_pb. Just a mock since we monkey patch
|
|
# _prepare_create_request
|
|
request_pb = object()
|
|
|
|
# Create response_pb
|
|
OP_BEGIN = object()
|
|
response_pb = operations_pb2.Operation(name=self.OP_NAME)
|
|
|
|
# Patch the stub used by the API method.
|
|
client._instance_stub = stub = _FakeStub(response_pb)
|
|
|
|
# Create expected_result.
|
|
expected_result = MUT.Operation('create', self.OP_ID, OP_BEGIN,
|
|
self.LOCATION_ID, instance=instance)
|
|
|
|
# Create the mocks.
|
|
prep_create_called = []
|
|
|
|
def mock_prep_create_req(instance):
|
|
prep_create_called.append(instance)
|
|
return request_pb
|
|
|
|
process_operation_called = []
|
|
|
|
def mock_process_operation(operation_pb):
|
|
process_operation_called.append(operation_pb)
|
|
return self.OP_ID, self.LOCATION_ID, OP_BEGIN
|
|
|
|
# Perform the method and check the result.
|
|
with _Monkey(MUT,
|
|
_prepare_create_request=mock_prep_create_req,
|
|
_process_operation=mock_process_operation):
|
|
result = instance.create()
|
|
|
|
self.assertEqual(result, expected_result)
|
|
self.assertEqual(stub.method_calls, [(
|
|
'CreateInstance',
|
|
(request_pb, self.TIMEOUT_SECONDS),
|
|
{},
|
|
)])
|
|
self.assertEqual(prep_create_called, [instance])
|
|
self.assertEqual(process_operation_called, [response_pb])
|
|
|
|
def test_update(self):
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as data_v2_pb2)
|
|
from gcloud.bigtable._testing import _FakeStub
|
|
|
|
client = _Client(self.PROJECT, timeout_seconds=self.TIMEOUT_SECONDS)
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID,
|
|
display_name=self.DISPLAY_NAME)
|
|
|
|
# Create request_pb
|
|
request_pb = data_v2_pb2.Instance(
|
|
name=self.INSTANCE_NAME,
|
|
display_name=self.DISPLAY_NAME,
|
|
)
|
|
|
|
# Create response_pb
|
|
response_pb = data_v2_pb2.Instance()
|
|
|
|
# Patch the stub used by the API method.
|
|
client._instance_stub = stub = _FakeStub(response_pb)
|
|
|
|
# Create expected_result.
|
|
expected_result = None
|
|
|
|
# Perform the method and check the result.
|
|
result = instance.update()
|
|
|
|
self.assertEqual(result, expected_result)
|
|
self.assertEqual(stub.method_calls, [(
|
|
'UpdateInstance',
|
|
(request_pb, self.TIMEOUT_SECONDS),
|
|
{},
|
|
)])
|
|
|
|
def test_delete(self):
|
|
from google.protobuf import empty_pb2
|
|
from gcloud.bigtable._generated_v2 import (
|
|
bigtable_instance_admin_pb2 as messages_v2_pb)
|
|
from gcloud.bigtable._testing import _FakeStub
|
|
|
|
client = _Client(self.PROJECT, timeout_seconds=self.TIMEOUT_SECONDS)
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
|
|
# Create request_pb
|
|
request_pb = messages_v2_pb.DeleteInstanceRequest(
|
|
name=self.INSTANCE_NAME)
|
|
|
|
# Create response_pb
|
|
response_pb = empty_pb2.Empty()
|
|
|
|
# Patch the stub used by the API method.
|
|
client._instance_stub = stub = _FakeStub(response_pb)
|
|
|
|
# Create expected_result.
|
|
expected_result = None # delete() has no return value.
|
|
|
|
# Perform the method and check the result.
|
|
result = instance.delete()
|
|
|
|
self.assertEqual(result, expected_result)
|
|
self.assertEqual(stub.method_calls, [(
|
|
'DeleteInstance',
|
|
(request_pb, self.TIMEOUT_SECONDS),
|
|
{},
|
|
)])
|
|
|
|
def test_list_clusters(self):
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as instance_v2_pb2)
|
|
from gcloud.bigtable._generated_v2 import (
|
|
bigtable_instance_admin_pb2 as messages_v2_pb2)
|
|
from gcloud.bigtable._testing import _FakeStub
|
|
|
|
FAILED_LOCATION = 'FAILED'
|
|
FAILED_LOCATIONS = [FAILED_LOCATION]
|
|
CLUSTER_ID1 = 'cluster-id1'
|
|
CLUSTER_ID2 = 'cluster-id2'
|
|
SERVE_NODES = 4
|
|
|
|
client = _Client(self.PROJECT, timeout_seconds=self.TIMEOUT_SECONDS)
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
|
|
CLUSTER_NAME1 = (instance.name + '/clusters/' + CLUSTER_ID1)
|
|
CLUSTER_NAME2 = (instance.name + '/clusters/' + CLUSTER_ID2)
|
|
# Create request_pb
|
|
request_pb = messages_v2_pb2.ListClustersRequest(
|
|
parent=instance.name,
|
|
)
|
|
|
|
# Create response_pb
|
|
response_pb = messages_v2_pb2.ListClustersResponse(
|
|
failed_locations=[FAILED_LOCATION],
|
|
clusters=[
|
|
instance_v2_pb2.Cluster(
|
|
name=CLUSTER_NAME1,
|
|
serve_nodes=SERVE_NODES,
|
|
),
|
|
instance_v2_pb2.Cluster(
|
|
name=CLUSTER_NAME2,
|
|
serve_nodes=SERVE_NODES,
|
|
),
|
|
],
|
|
)
|
|
|
|
# Patch the stub used by the API method.
|
|
client._instance_stub = stub = _FakeStub(response_pb)
|
|
|
|
# Create expected_result.
|
|
clusters = [
|
|
instance.cluster(CLUSTER_ID1),
|
|
instance.cluster(CLUSTER_ID2),
|
|
]
|
|
expected_result = (clusters, FAILED_LOCATIONS)
|
|
|
|
# Perform the method and check the result.
|
|
result = instance.list_clusters()
|
|
self.assertEqual(result, expected_result)
|
|
self.assertEqual(stub.method_calls, [(
|
|
'ListClusters',
|
|
(request_pb, self.TIMEOUT_SECONDS),
|
|
{},
|
|
)])
|
|
|
|
def _list_tables_helper(self, table_name=None):
|
|
from gcloud.bigtable._generated_v2 import (
|
|
table_pb2 as table_data_v2_pb2)
|
|
from gcloud.bigtable._generated_v2 import (
|
|
bigtable_table_admin_pb2 as table_messages_v1_pb2)
|
|
from gcloud.bigtable._testing import _FakeStub
|
|
|
|
client = _Client(self.PROJECT, timeout_seconds=self.TIMEOUT_SECONDS)
|
|
instance = self._makeOne(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
|
|
# Create request_
|
|
request_pb = table_messages_v1_pb2.ListTablesRequest(
|
|
parent=self.INSTANCE_NAME)
|
|
|
|
# Create response_pb
|
|
if table_name is None:
|
|
table_name = self.TABLE_NAME
|
|
|
|
response_pb = table_messages_v1_pb2.ListTablesResponse(
|
|
tables=[
|
|
table_data_v2_pb2.Table(name=table_name),
|
|
],
|
|
)
|
|
|
|
# Patch the stub used by the API method.
|
|
client._table_stub = stub = _FakeStub(response_pb)
|
|
|
|
# Create expected_result.
|
|
expected_table = instance.table(self.TABLE_ID)
|
|
expected_result = [expected_table]
|
|
|
|
# Perform the method and check the result.
|
|
result = instance.list_tables()
|
|
|
|
self.assertEqual(result, expected_result)
|
|
self.assertEqual(stub.method_calls, [(
|
|
'ListTables',
|
|
(request_pb, self.TIMEOUT_SECONDS),
|
|
{},
|
|
)])
|
|
|
|
def test_list_tables(self):
|
|
self._list_tables_helper()
|
|
|
|
def test_list_tables_failure_bad_split(self):
|
|
with self.assertRaises(ValueError):
|
|
self._list_tables_helper(table_name='wrong-format')
|
|
|
|
def test_list_tables_failure_name_bad_before(self):
|
|
BAD_TABLE_NAME = ('nonempty-section-before' +
|
|
'projects/' + self.PROJECT +
|
|
'/instances/' + self.INSTANCE_ID +
|
|
'/tables/' + self.TABLE_ID)
|
|
with self.assertRaises(ValueError):
|
|
self._list_tables_helper(table_name=BAD_TABLE_NAME)
|
|
|
|
|
|
class Test__prepare_create_request(unittest2.TestCase):
|
|
PROJECT = 'PROJECT'
|
|
PARENT = 'projects/' + PROJECT
|
|
LOCATION_ID = 'locname'
|
|
LOCATION_NAME = 'projects/' + PROJECT + '/locations/' + LOCATION_ID
|
|
INSTANCE_ID = 'instance-id'
|
|
INSTANCE_NAME = PARENT + '/instances/' + INSTANCE_ID
|
|
CLUSTER_NAME = INSTANCE_NAME + '/clusters/' + INSTANCE_ID
|
|
|
|
def _callFUT(self, instance, **kw):
|
|
from gcloud.bigtable.instance import _prepare_create_request
|
|
return _prepare_create_request(instance, **kw)
|
|
|
|
def test_w_defaults(self):
|
|
from gcloud.bigtable.cluster import DEFAULT_SERVE_NODES
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as data_v2_pb2)
|
|
from gcloud.bigtable._generated_v2 import (
|
|
bigtable_instance_admin_pb2 as messages_v2_pb)
|
|
from gcloud.bigtable.instance import Instance
|
|
|
|
client = _Client(self.PROJECT)
|
|
|
|
instance = Instance(self.INSTANCE_ID, client, self.LOCATION_ID)
|
|
request_pb = self._callFUT(instance)
|
|
self.assertTrue(isinstance(request_pb,
|
|
messages_v2_pb.CreateInstanceRequest))
|
|
self.assertEqual(request_pb.instance_id, self.INSTANCE_ID)
|
|
self.assertEqual(request_pb.parent, self.PARENT)
|
|
self.assertTrue(isinstance(request_pb.instance, data_v2_pb2.Instance))
|
|
self.assertEqual(request_pb.instance.name, u'')
|
|
self.assertEqual(request_pb.instance.display_name, self.INSTANCE_ID)
|
|
|
|
# An instance must also define a same-named cluster
|
|
cluster = request_pb.clusters[self.INSTANCE_ID]
|
|
self.assertTrue(isinstance(cluster, data_v2_pb2.Cluster))
|
|
self.assertEqual(cluster.name, self.CLUSTER_NAME)
|
|
self.assertEqual(cluster.location, self.LOCATION_NAME)
|
|
self.assertEqual(cluster.serve_nodes, DEFAULT_SERVE_NODES)
|
|
|
|
def test_w_explicit_serve_nodes(self):
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as data_v2_pb2)
|
|
from gcloud.bigtable._generated_v2 import (
|
|
bigtable_instance_admin_pb2 as messages_v2_pb)
|
|
from gcloud.bigtable.instance import Instance
|
|
DISPLAY_NAME = u'DISPLAY_NAME'
|
|
SERVE_NODES = 5
|
|
client = _Client(self.PROJECT)
|
|
instance = Instance(self.INSTANCE_ID, client, self.LOCATION_ID,
|
|
display_name=DISPLAY_NAME,
|
|
serve_nodes=SERVE_NODES)
|
|
|
|
request_pb = self._callFUT(instance)
|
|
|
|
self.assertTrue(isinstance(request_pb,
|
|
messages_v2_pb.CreateInstanceRequest))
|
|
self.assertEqual(request_pb.instance_id, self.INSTANCE_ID)
|
|
self.assertEqual(request_pb.parent,
|
|
'projects/' + self.PROJECT)
|
|
self.assertTrue(isinstance(request_pb.instance, data_v2_pb2.Instance))
|
|
self.assertEqual(request_pb.instance.display_name, DISPLAY_NAME)
|
|
# An instance must also define a same-named cluster
|
|
cluster = request_pb.clusters[self.INSTANCE_ID]
|
|
self.assertTrue(isinstance(cluster, data_v2_pb2.Cluster))
|
|
self.assertEqual(cluster.location, self.LOCATION_NAME)
|
|
self.assertEqual(cluster.serve_nodes, SERVE_NODES)
|
|
|
|
|
|
class Test__parse_pb_any_to_native(unittest2.TestCase):
|
|
|
|
def _callFUT(self, any_val, expected_type=None):
|
|
from gcloud.bigtable.instance import _parse_pb_any_to_native
|
|
return _parse_pb_any_to_native(any_val, expected_type=expected_type)
|
|
|
|
def test_with_known_type_url(self):
|
|
from google.protobuf import any_pb2
|
|
from gcloud._testing import _Monkey
|
|
from gcloud.bigtable._generated_v2 import (
|
|
data_pb2 as data_v2_pb2)
|
|
from gcloud.bigtable import instance as MUT
|
|
|
|
TYPE_URL = 'type.googleapis.com/' + data_v2_pb2._CELL.full_name
|
|
fake_type_url_map = {TYPE_URL: data_v2_pb2.Cell}
|
|
|
|
cell = data_v2_pb2.Cell(
|
|
timestamp_micros=0,
|
|
value=b'foobar',
|
|
)
|
|
any_val = any_pb2.Any(
|
|
type_url=TYPE_URL,
|
|
value=cell.SerializeToString(),
|
|
)
|
|
with _Monkey(MUT, _TYPE_URL_MAP=fake_type_url_map):
|
|
result = self._callFUT(any_val)
|
|
|
|
self.assertEqual(result, cell)
|
|
|
|
def test_with_create_instance_metadata(self):
|
|
from google.protobuf import any_pb2
|
|
from google.protobuf.timestamp_pb2 import Timestamp
|
|
from gcloud.bigtable._generated_v2 import (
|
|
instance_pb2 as data_v2_pb2)
|
|
from gcloud.bigtable._generated_v2 import (
|
|
bigtable_instance_admin_pb2 as messages_v2_pb)
|
|
|
|
TYPE_URL = ('type.googleapis.com/' +
|
|
messages_v2_pb._CREATEINSTANCEMETADATA.full_name)
|
|
metadata = messages_v2_pb.CreateInstanceMetadata(
|
|
request_time=Timestamp(seconds=1, nanos=1234),
|
|
finish_time=Timestamp(seconds=10, nanos=891011),
|
|
original_request=messages_v2_pb.CreateInstanceRequest(
|
|
parent='foo',
|
|
instance_id='bar',
|
|
instance=data_v2_pb2.Instance(
|
|
display_name='quux',
|
|
),
|
|
),
|
|
)
|
|
|
|
any_val = any_pb2.Any(
|
|
type_url=TYPE_URL,
|
|
value=metadata.SerializeToString(),
|
|
)
|
|
result = self._callFUT(any_val)
|
|
self.assertEqual(result, metadata)
|
|
|
|
def test_unknown_type_url(self):
|
|
from google.protobuf import any_pb2
|
|
from gcloud._testing import _Monkey
|
|
from gcloud.bigtable import instance as MUT
|
|
|
|
fake_type_url_map = {}
|
|
any_val = any_pb2.Any()
|
|
with _Monkey(MUT, _TYPE_URL_MAP=fake_type_url_map):
|
|
with self.assertRaises(KeyError):
|
|
self._callFUT(any_val)
|
|
|
|
def test_disagreeing_type_url(self):
|
|
from google.protobuf import any_pb2
|
|
from gcloud._testing import _Monkey
|
|
from gcloud.bigtable import instance as MUT
|
|
|
|
TYPE_URL1 = 'foo'
|
|
TYPE_URL2 = 'bar'
|
|
fake_type_url_map = {TYPE_URL1: None}
|
|
any_val = any_pb2.Any(type_url=TYPE_URL2)
|
|
with _Monkey(MUT, _TYPE_URL_MAP=fake_type_url_map):
|
|
with self.assertRaises(ValueError):
|
|
self._callFUT(any_val, expected_type=TYPE_URL1)
|
|
|
|
|
|
class Test__process_operation(unittest2.TestCase):
|
|
|
|
def _callFUT(self, operation_pb):
|
|
from gcloud.bigtable.instance import _process_operation
|
|
return _process_operation(operation_pb)
|
|
|
|
def test_it(self):
|
|
from google.longrunning import operations_pb2
|
|
from gcloud._testing import _Monkey
|
|
from gcloud.bigtable._generated_v2 import (
|
|
bigtable_instance_admin_pb2 as messages_v2_pb)
|
|
from gcloud.bigtable import instance as MUT
|
|
|
|
PROJECT = 'PROJECT'
|
|
INSTANCE_ID = 'instance-id'
|
|
LOCATION_ID = 'location'
|
|
OP_ID = 234
|
|
OPERATION_NAME = (
|
|
'operations/projects/%s/instances/%s/locations/%s/operations/%d' %
|
|
(PROJECT, INSTANCE_ID, LOCATION_ID, OP_ID))
|
|
|
|
current_op = operations_pb2.Operation(name=OPERATION_NAME)
|
|
|
|
# Create mocks.
|
|
request_metadata = messages_v2_pb.CreateInstanceMetadata()
|
|
parse_pb_any_called = []
|
|
|
|
def mock_parse_pb_any_to_native(any_val, expected_type=None):
|
|
parse_pb_any_called.append((any_val, expected_type))
|
|
return request_metadata
|
|
|
|
expected_operation_begin = object()
|
|
ts_to_dt_called = []
|
|
|
|
def mock_pb_timestamp_to_datetime(timestamp):
|
|
ts_to_dt_called.append(timestamp)
|
|
return expected_operation_begin
|
|
|
|
# Exectute method with mocks in place.
|
|
with _Monkey(MUT, _parse_pb_any_to_native=mock_parse_pb_any_to_native,
|
|
_pb_timestamp_to_datetime=mock_pb_timestamp_to_datetime):
|
|
op_id, loc_id, op_begin = self._callFUT(current_op)
|
|
|
|
# Check outputs.
|
|
self.assertEqual(op_id, OP_ID)
|
|
self.assertTrue(op_begin is expected_operation_begin)
|
|
self.assertEqual(loc_id, LOCATION_ID)
|
|
|
|
# Check mocks were used correctly.
|
|
self.assertEqual(parse_pb_any_called, [(current_op.metadata, None)])
|
|
self.assertEqual(ts_to_dt_called, [request_metadata.request_time])
|
|
|
|
def test_op_name_parsing_failure(self):
|
|
from google.longrunning import operations_pb2
|
|
|
|
operation_pb = operations_pb2.Operation(name='invalid')
|
|
with self.assertRaises(ValueError):
|
|
self._callFUT(operation_pb)
|
|
|
|
|
|
class _Client(object):
|
|
|
|
def __init__(self, project, timeout_seconds=None):
|
|
self.project = project
|
|
self.project_name = 'projects/' + self.project
|
|
self.timeout_seconds = timeout_seconds
|
|
|
|
def copy(self):
|
|
from copy import deepcopy
|
|
return deepcopy(self)
|
|
|
|
def __eq__(self, other):
|
|
return (other.project == self.project and
|
|
other.project_name == self.project_name and
|
|
other.timeout_seconds == self.timeout_seconds)
|