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)