def test_create_grpc_error(self):
from google.api_core.exceptions import GoogleAPICallError
from google.api_core.exceptions import Unknown
client = _Client()
api = client.database_admin_api = self._make_database_admin_api()
api.create_backup.side_effect = Unknown("testing")
instance = _Instance(self.INSTANCE_NAME, client=client)
timestamp = self._make_timestamp()
backup = self._make_one(self.BACKUP_ID,
instance,
database=self.DATABASE_NAME,
expire_time=timestamp)
from google.cloud._helpers import _datetime_to_pb_timestamp
backup_pb = {
"database": self.DATABASE_NAME,
"expire_time": _datetime_to_pb_timestamp(timestamp),
}
with self.assertRaises(GoogleAPICallError):
backup.create()
api.create_backup.assert_called_once_with(
parent=self.INSTANCE_NAME,
backup_id=self.BACKUP_ID,
backup=backup_pb,
metadata=[("google-cloud-resource-prefix", backup.name)],
)
def test_update_expire_time_grpc_error(self):
from google.api_core.exceptions import Unknown
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.cloud.bigtable_admin_v2.types import table
from google.protobuf import field_mask_pb2
client = _Client()
api = client._table_admin_client = self._make_table_admin_client()
api.update_backup.side_effect = Unknown("testing")
instance = _Instance(self.INSTANCE_NAME, client=client)
backup = self._make_one(self.BACKUP_ID,
instance,
cluster_id=self.CLUSTER_ID)
expire_time = self._make_timestamp()
with self.assertRaises(Unknown):
backup.update_expire_time(expire_time)
backup_update = table.Backup(
name=self.BACKUP_NAME,
expire_time=_datetime_to_pb_timestamp(expire_time),
)
update_mask = field_mask_pb2.FieldMask(paths=["expire_time"])
api.update_backup.assert_called_once_with(request={
"backup": backup_update,
"update_mask": update_mask
})
def test_create_grpc_error(self):
from google.api_core.exceptions import GoogleAPICallError
from google.api_core.exceptions import Unknown
from google.cloud.spanner_admin_database_v1 import Backup
from google.cloud.spanner_admin_database_v1 import CreateBackupRequest
client = _Client()
api = client.database_admin_api = self._make_database_admin_api()
api.create_backup.side_effect = Unknown("testing")
instance = _Instance(self.INSTANCE_NAME, client=client)
timestamp = self._make_timestamp()
backup = self._make_one(
self.BACKUP_ID, instance, database=self.DATABASE_NAME, expire_time=timestamp
)
backup_pb = Backup(
database=self.DATABASE_NAME,
expire_time=timestamp,
)
with self.assertRaises(GoogleAPICallError):
backup.create()
request = CreateBackupRequest(
parent=self.INSTANCE_NAME,
backup_id=self.BACKUP_ID,
backup=backup_pb,
)
api.create_backup.assert_called_once_with(
request=request,
metadata=[("google-cloud-resource-prefix", backup.name)],
)
def test_create_grpc_error(self):
from google.api_core.exceptions import GoogleAPICallError
from google.api_core.exceptions import Unknown
from google.cloud._helpers import _datetime_to_pb_timestamp
from google.cloud.bigtable_admin_v2.types import table
client = _Client()
api = client.table_admin_client = self._make_table_admin_client()
api.create_backup.side_effect = Unknown("testing")
timestamp = self._make_timestamp()
backup = self._make_one(
self.BACKUP_ID,
_Instance(self.INSTANCE_NAME, client=client),
table_id=self.TABLE_ID,
expire_time=timestamp,
)
backup_pb = table.Backup(
source_table=self.TABLE_NAME,
expire_time=_datetime_to_pb_timestamp(timestamp),
)
with self.assertRaises(GoogleAPICallError):
backup.create(self.CLUSTER_ID)
api.create_backup.assert_called_once_with(
request={
"parent": self.CLUSTER_NAME,
"backup_id": self.BACKUP_ID,
"backup": backup_pb,
}
)
def test_backup_restore_w_grpc_error():
from google.api_core.exceptions import GoogleAPICallError
from google.api_core.exceptions import Unknown
client = _Client()
api = client.table_admin_client = _make_table_admin_client()
api.restore_table.side_effect = Unknown("testing")
timestamp = _make_timestamp()
backup = _make_backup(
BACKUP_ID,
_Instance(INSTANCE_NAME, client=client),
cluster_id=CLUSTER_ID,
table_id=TABLE_NAME,
expire_time=timestamp,
)
with pytest.raises(GoogleAPICallError):
backup.restore(TABLE_ID)
api.restore_table.assert_called_once_with(request={
"parent": INSTANCE_NAME,
"table_id": TABLE_ID,
"backup": BACKUP_NAME
})
def test_restore_grpc_error(self):
from google.api_core.exceptions import GoogleAPICallError
from google.api_core.exceptions import Unknown
client = _Client()
api = client.table_admin_client = self._make_table_admin_client()
api.restore_table.side_effect = Unknown("testing")
timestamp = self._make_timestamp()
backup = self._make_one(
self.BACKUP_ID,
_Instance(self.INSTANCE_NAME, client=client),
cluster_id=self.CLUSTER_ID,
table_id=self.TABLE_NAME,
expire_time=timestamp,
)
with self.assertRaises(GoogleAPICallError):
backup.restore(self.TABLE_ID)
api.restore_table.assert_called_once_with(
request={
"parent": self.INSTANCE_NAME,
"table_id": self.TABLE_ID,
"backup": self.BACKUP_NAME,
}
)
def drop_database(self, database, metadata=None):
from google.api_core.exceptions import NotFound, Unknown
self._dropped_database = database, metadata
if self._rpc_error:
raise Unknown('error')
if self._database_not_found:
raise NotFound('not found')
return self._drop_database_response
def get_instance(self, name, metadata=None):
from google.api_core.exceptions import NotFound, Unknown
self._got_instance = (name, metadata)
if self._rpc_error:
raise Unknown('error')
if self._instance_not_found:
raise NotFound('error')
return self._get_instance_response
def create_instance(self, parent, instance_id, instance, metadata=None):
from google.api_core.exceptions import AlreadyExists, Unknown
self._created_instance = (parent, instance_id, instance, metadata)
if self._rpc_error:
raise Unknown("error")
if self._create_instance_conflict:
raise AlreadyExists("conflict")
return self._create_instance_response
def update_instance(self, instance, field_mask, metadata=None):
from google.api_core.exceptions import NotFound, Unknown
self._updated_instance = (instance, field_mask, metadata)
if self._rpc_error:
raise Unknown("error")
if self._instance_not_found:
raise NotFound("error")
return self._update_instance_response
def delete_instance(self, name, metadata=None):
from google.api_core.exceptions import NotFound, Unknown
self._deleted_instance = name, metadata
if self._rpc_error:
raise Unknown("error")
if self._instance_not_found:
raise NotFound("error")
return self._delete_instance_response
def test_create_error(self):
from google.api_core.exceptions import Unknown
gax_api = _SpannerApi(_rpc_error=Unknown('error'))
database = _Database(self.DATABASE_NAME)
database.spanner_api = gax_api
session = self._make_one(database)
with self.assertRaises(Unknown):
session.create()
def test_create_error(self):
from google.api_core.exceptions import Unknown
gax_api = self._make_spanner_api()
gax_api.create_session.side_effect = Unknown("error")
database = self._make_database()
database.spanner_api = gax_api
session = self._make_one(database)
with self.assertRaises(Unknown):
session.create()
def update_database_ddl(self, database, statements, operation_id,
metadata=None):
from google.api_core.exceptions import NotFound, Unknown
self._updated_database_ddl = (
database, statements, operation_id, metadata)
if self._rpc_error:
raise Unknown('error')
if self._database_not_found:
raise NotFound('not found')
return self._update_database_ddl_response
def test_exists_error(self):
from google.api_core.exceptions import Unknown
gax_api = _SpannerApi(_rpc_error=Unknown('error'))
database = _Database(self.DATABASE_NAME)
database.spanner_api = gax_api
session = self._make_one(database)
session._session_id = self.SESSION_ID
with self.assertRaises(Unknown):
session.exists()
def test_delete_grpc_error(self):
from google.api_core.exceptions import Unknown
client = _Client()
api = client.table_admin_client = self._make_table_admin_client()
api.delete_backup.side_effect = Unknown("testing")
instance = _Instance(self.INSTANCE_NAME, client=client)
backup = self._make_one(self.BACKUP_ID, instance, cluster_id=self.CLUSTER_ID)
with self.assertRaises(Unknown):
backup.delete()
api.delete_backup.assert_called_once_with(request={"name": self.BACKUP_NAME})
def create_database(self, parent, create_statement, extra_statements=None,
metadata=None):
from google.api_core.exceptions import AlreadyExists, NotFound, Unknown
self._created_database = (
parent, create_statement, extra_statements, metadata)
if self._rpc_error:
raise Unknown('error')
if self._create_database_conflict:
raise AlreadyExists('conflict')
if self._database_not_found:
raise NotFound('not found')
return self._create_database_response
def commit(self,
session,
mutations,
transaction_id='',
single_use_transaction=None,
metadata=None):
from google.api_core.exceptions import Unknown
assert transaction_id == ''
self._committed = (session, mutations, single_use_transaction,
metadata)
if self._rpc_error:
raise Unknown('error')
return self._commit_response
def test_backup_exists_w_grpc_error():
from google.api_core.exceptions import Unknown
client = _Client()
api = client.table_admin_client = _make_table_admin_client()
api.get_backup.side_effect = Unknown("testing")
instance = _Instance(INSTANCE_NAME, client=client)
backup = _make_backup(BACKUP_ID, instance, cluster_id=CLUSTER_ID)
with pytest.raises(Unknown):
backup.exists()
request = {"name": BACKUP_NAME}
api.get_backup.assert_called_once_with(request)
def test_reload_grpc_error(self):
from google.api_core.exceptions import Unknown
client = _Client()
api = client.database_admin_api = self._make_database_admin_api()
api.get_backup.side_effect = Unknown("testing")
instance = _Instance(self.INSTANCE_NAME, client=client)
backup = self._make_one(self.BACKUP_ID, instance)
with self.assertRaises(Unknown):
backup.reload()
api.get_backup.assert_called_once_with(
self.BACKUP_NAME,
metadata=[("google-cloud-resource-prefix", backup.name)])
def test_exists_grpc_error(self):
from google.api_core.exceptions import Unknown
client = _Client()
api = client._table_admin_client = self._make_table_admin_client()
api.get_backup.side_effect = Unknown("testing")
instance = _Instance(self.INSTANCE_NAME, client=client)
backup = self._make_one(self.BACKUP_ID,
instance,
cluster_id=self.CLUSTER_ID)
with self.assertRaises(Unknown):
backup.exists()
api.get_backup(self.BACKUP_NAME)
def commit(
self,
request=None,
metadata=None,
):
from google.api_core.exceptions import Unknown
assert request.transaction_id == b""
self._committed = (
request.session,
request.mutations,
request.single_use_transaction,
metadata,
)
if self._rpc_error:
raise Unknown("error")
return self._commit_response
def test_run_in_transaction_w_commit_error(self):
from google.api_core.exceptions import Unknown
from google.cloud.spanner_v1.transaction import Transaction
TABLE_NAME = "citizens"
COLUMNS = ["email", "first_name", "last_name", "age"]
VALUES = [
["*****@*****.**", "Phred", "Phlyntstone", 32],
["*****@*****.**", "Bharney", "Rhubble", 31],
]
TRANSACTION_ID = b"FACEDACE"
gax_api = self._make_spanner_api()
gax_api.commit.side_effect = Unknown("error")
database = self._make_database()
database.spanner_api = gax_api
session = self._make_one(database)
session._session_id = self.SESSION_ID
begun_txn = session._transaction = Transaction(session)
begun_txn._transaction_id = TRANSACTION_ID
assert session._transaction._transaction_id
called_with = []
def unit_of_work(txn, *args, **kw):
called_with.append((txn, args, kw))
txn.insert(TABLE_NAME, COLUMNS, VALUES)
with self.assertRaises(Unknown):
session.run_in_transaction(unit_of_work)
self.assertIsNone(session._transaction)
self.assertEqual(len(called_with), 1)
txn, args, kw = called_with[0]
self.assertIs(txn, begun_txn)
self.assertEqual(txn.committed, None)
self.assertEqual(args, ())
self.assertEqual(kw, {})
gax_api.begin_transaction.assert_not_called()
gax_api.commit.assert_called_once_with(
self.SESSION_NAME,
mutations=txn._mutations,
transaction_id=TRANSACTION_ID,
metadata=[("google-cloud-resource-prefix", database.name)],
)
def test_create_error(self):
from google.api_core.exceptions import Unknown
gax_api = self._make_spanner_api()
gax_api.create_session.side_effect = Unknown("error")
database = self._make_database()
database.spanner_api = gax_api
session = self._make_one(database)
with self.assertRaises(Unknown):
session.create()
self.assertSpanAttributes(
"CloudSpanner.CreateSession",
status=StatusCanonicalCode.UNKNOWN,
attributes=TestSession.BASE_ATTRIBUTES,
)
def test_delete_error(self):
from google.api_core.exceptions import Unknown
gax_api = self._make_spanner_api()
gax_api.delete_session.side_effect = Unknown("testing")
database = self._make_database()
database.spanner_api = gax_api
session = self._make_one(database)
session._session_id = self.SESSION_ID
with self.assertRaises(Unknown):
session.delete()
gax_api.delete_session.assert_called_once_with(
self.SESSION_NAME,
metadata=[("google-cloud-resource-prefix", database.name)],
)
def commit(self,
session,
mutations,
transaction_id='',
single_use_transaction=None,
metadata=None):
from google.api_core.exceptions import Unknown, Aborted
assert single_use_transaction is None
self._committed = (session, mutations, transaction_id, metadata)
if self._commit_error:
raise Unknown('error')
if self._commit_abort_count > 0:
self._commit_abort_count -= 1
raise _make_rpc_error(Aborted,
trailing_metadata=self._trailing_metadata())
return self._commit_response
def test_update_expire_time_grpc_error(self):
from google.api_core.exceptions import Unknown
from google.cloud.spanner_admin_database_v1 import Backup
client = _Client()
api = client.database_admin_api = self._make_database_admin_api()
api.update_backup.side_effect = Unknown("testing")
instance = _Instance(self.INSTANCE_NAME, client=client)
backup = self._make_one(self.BACKUP_ID, instance)
expire_time = self._make_timestamp()
with self.assertRaises(Unknown):
backup.update_expire_time(expire_time)
backup_update = Backup(name=self.BACKUP_NAME, expire_time=expire_time,)
update_mask = {"paths": ["expire_time"]}
api.update_backup.assert_called_once_with(
backup=backup_update,
update_mask=update_mask,
metadata=[("google-cloud-resource-prefix", backup.name)],
)
def test_delete_error(self):
from google.api_core.exceptions import Unknown
gax_api = self._make_spanner_api()
gax_api.delete_session.side_effect = Unknown("testing")
database = self._make_database()
database.spanner_api = gax_api
session = self._make_one(database)
session._session_id = self.SESSION_ID
with self.assertRaises(Unknown):
session.delete()
gax_api.delete_session.assert_called_once_with(
self.SESSION_NAME,
metadata=[("google-cloud-resource-prefix", database.name)],
)
self.assertSpanAttributes(
"CloudSpanner.DeleteSession",
status=StatusCanonicalCode.UNKNOWN,
attributes=TestSession.BASE_ATTRIBUTES,
)
def test_ping_error(self):
from google.api_core.exceptions import Unknown
from google.cloud.spanner_v1 import ExecuteSqlRequest
gax_api = self._make_spanner_api()
gax_api.execute_sql.side_effect = Unknown("testing")
database = self._make_database()
database.spanner_api = gax_api
session = self._make_one(database)
session._session_id = self.SESSION_ID
with self.assertRaises(Unknown):
session.ping()
request = ExecuteSqlRequest(
session=self.SESSION_NAME,
sql="SELECT 1",
)
gax_api.execute_sql.assert_called_once_with(
request=request,
metadata=[("google-cloud-resource-prefix", database.name)],
)
def test__execute_insert_heterogenous_error(self):
from google.cloud.spanner_dbapi import _helpers
from google.api_core.exceptions import Unknown
sql = "sql"
params = (sql, None)
with mock.patch(
"google.cloud.spanner_dbapi._helpers.sql_pyformat_args_to_spanner",
return_value=params,
) as mock_pyformat:
with mock.patch(
"google.cloud.spanner_dbapi._helpers.get_param_types",
return_value=None) as mock_param_types:
transaction = mock.MagicMock()
transaction.execute_update = mock_update = mock.MagicMock(
side_effect=Unknown("Unknown"))
with self.assertRaises(Unknown):
_helpers._execute_insert_heterogenous(
transaction, (params, ))
mock_pyformat.assert_called_once_with(params[0], params[1])
mock_param_types.assert_called_once_with(None)
mock_update.assert_called_once_with(sql, None, None)
