async def test___call__success_first_attempt(self):
to_wrap = AsyncMock(return_value=mock.sentinel.result, spec=[])
wrapped = self._make_one(to_wrap)
txn_id = b"whole-enchilada"
transaction = _make_transaction(txn_id)
result = await wrapped(transaction, "a", b="c")
self.assertIs(result, mock.sentinel.result)
self.assertIsNone(transaction._id)
self.assertEqual(wrapped.current_id, txn_id)
self.assertEqual(wrapped.retry_id, txn_id)
# Verify mocks.
to_wrap.assert_called_once_with(transaction, "a", b="c")
firestore_api = transaction._client._firestore_api
firestore_api.begin_transaction.assert_called_once_with(
request={"database": transaction._client._database_string, "options": None},
metadata=transaction._client._rpc_metadata,
)
firestore_api.rollback.assert_not_called()
firestore_api.commit.assert_called_once_with(
request={
"database": transaction._client._database_string,
"writes": [],
"transaction": txn_id,
},
metadata=transaction._client._rpc_metadata,
)
async def test__pre_commit_failure(self):
exc = RuntimeError("Nope not today.")
to_wrap = AsyncMock(side_effect=exc, spec=[])
wrapped = self._make_one(to_wrap)
txn_id = b"gotta-fail"
transaction = _make_transaction(txn_id)
with self.assertRaises(RuntimeError) as exc_info:
await wrapped._pre_commit(transaction, 10, 20)
self.assertIs(exc_info.exception, exc)
self.assertIsNone(transaction._id)
self.assertEqual(wrapped.current_id, txn_id)
self.assertEqual(wrapped.retry_id, txn_id)
# Verify mocks.
to_wrap.assert_called_once_with(transaction, 10, 20)
firestore_api = transaction._client._firestore_api
firestore_api.begin_transaction.assert_called_once_with(
request={
"database": transaction._client._database_string,
"options": None,
},
metadata=transaction._client._rpc_metadata,
)
firestore_api.rollback.assert_called_once_with(
request={
"database": transaction._client._database_string,
"transaction": txn_id,
},
metadata=transaction._client._rpc_metadata,
)
firestore_api.commit.assert_not_called()
async def test__pre_commit_retry_id_already_set_success(self):
from google.cloud.firestore_v1.types import common
to_wrap = AsyncMock(return_value=mock.sentinel.result, spec=[])
wrapped = self._make_one(to_wrap)
txn_id1 = b"already-set"
wrapped.retry_id = txn_id1
txn_id2 = b"ok-here-too"
transaction = _make_transaction(txn_id2)
result = await wrapped._pre_commit(transaction)
self.assertIs(result, mock.sentinel.result)
self.assertEqual(transaction._id, txn_id2)
self.assertEqual(wrapped.current_id, txn_id2)
self.assertEqual(wrapped.retry_id, txn_id1)
# Verify mocks.
to_wrap.assert_called_once_with(transaction)
firestore_api = transaction._client._firestore_api
options_ = common.TransactionOptions(
read_write=common.TransactionOptions.ReadWrite(retry_transaction=txn_id1)
)
firestore_api.begin_transaction.assert_called_once_with(
request={
"database": transaction._client._database_string,
"options": options_,
},
metadata=transaction._client._rpc_metadata,
)
firestore_api.rollback.assert_not_called()
firestore_api.commit.assert_not_called()
async def test__pre_commit_success(self):
to_wrap = AsyncMock(return_value=mock.sentinel.result, spec=[])
wrapped = self._make_one(to_wrap)
txn_id = b"totes-began"
transaction = _make_transaction(txn_id)
result = await wrapped._pre_commit(transaction, "pos", key="word")
self.assertIs(result, mock.sentinel.result)
self.assertEqual(transaction._id, txn_id)
self.assertEqual(wrapped.current_id, txn_id)
self.assertEqual(wrapped.retry_id, txn_id)
# Verify mocks.
to_wrap.assert_called_once_with(transaction, "pos", key="word")
firestore_api = transaction._client._firestore_api
firestore_api.begin_transaction.assert_called_once_with(
request={
"database": transaction._client._database_string,
"options": None,
},
metadata=transaction._client._rpc_metadata,
)
firestore_api.rollback.assert_not_called()
firestore_api.commit.assert_not_called()
async def test_asynctransactional__pre_commit_failure():
exc = RuntimeError("Nope not today.")
to_wrap = AsyncMock(side_effect=exc, spec=[])
wrapped = _make_async_transactional(to_wrap)
txn_id = b"gotta-fail"
transaction = _make_transaction(txn_id)
with pytest.raises(RuntimeError) as exc_info:
await wrapped._pre_commit(transaction, 10, 20)
assert exc_info.value is exc
assert transaction._id is None
assert wrapped.current_id == txn_id
assert wrapped.retry_id == txn_id
# Verify mocks.
to_wrap.assert_called_once_with(transaction, 10, 20)
firestore_api = transaction._client._firestore_api
firestore_api.begin_transaction.assert_called_once_with(
request={"database": transaction._client._database_string, "options": None},
metadata=transaction._client._rpc_metadata,
)
firestore_api.rollback.assert_called_once_with(
request={
"database": transaction._client._database_string,
"transaction": txn_id,
},
metadata=transaction._client._rpc_metadata,
)
firestore_api.commit.assert_not_called()
async def test___call__failure(self):
from google.api_core import exceptions
from google.cloud.firestore_v1.async_transaction import (
_EXCEED_ATTEMPTS_TEMPLATE,
)
to_wrap = AsyncMock(return_value=mock.sentinel.result, spec=[])
wrapped = self._make_one(to_wrap)
txn_id = b"only-one-shot"
transaction = _make_transaction(txn_id, max_attempts=1)
# Actually force the ``commit`` to fail.
exc = exceptions.Aborted("Contention just once.")
firestore_api = transaction._client._firestore_api
firestore_api.commit.side_effect = exc
# Call the __call__-able ``wrapped``.
with self.assertRaises(ValueError) as exc_info:
await wrapped(transaction, "here", there=1.5)
err_msg = _EXCEED_ATTEMPTS_TEMPLATE.format(transaction._max_attempts)
self.assertEqual(exc_info.exception.args, (err_msg,))
self.assertIsNone(transaction._id)
self.assertEqual(wrapped.current_id, txn_id)
self.assertEqual(wrapped.retry_id, txn_id)
# Verify mocks.
to_wrap.assert_called_once_with(transaction, "here", there=1.5)
firestore_api.begin_transaction.assert_called_once_with(
request={
"database": transaction._client._database_string,
"options": None,
},
metadata=transaction._client._rpc_metadata,
)
firestore_api.rollback.assert_called_once_with(
request={
"database": transaction._client._database_string,
"transaction": txn_id,
},
metadata=transaction._client._rpc_metadata,
)
firestore_api.commit.assert_called_once_with(
request={
"database": transaction._client._database_string,
"writes": [],
"transaction": txn_id,
},
metadata=transaction._client._rpc_metadata,
)
async def test__pre_commit_failure_with_rollback_failure(self):
from google.api_core import exceptions
exc1 = ValueError("I will not be only failure.")
to_wrap = AsyncMock(side_effect=exc1, spec=[])
wrapped = self._make_one(to_wrap)
txn_id = b"both-will-fail"
transaction = _make_transaction(txn_id)
# Actually force the ``rollback`` to fail as well.
exc2 = exceptions.InternalServerError("Rollback blues.")
firestore_api = transaction._client._firestore_api
firestore_api.rollback.side_effect = exc2
# Try to ``_pre_commit``
with self.assertRaises(exceptions.InternalServerError) as exc_info:
await wrapped._pre_commit(transaction, a="b", c="zebra")
self.assertIs(exc_info.exception, exc2)
self.assertIsNone(transaction._id)
self.assertEqual(wrapped.current_id, txn_id)
self.assertEqual(wrapped.retry_id, txn_id)
# Verify mocks.
to_wrap.assert_called_once_with(transaction, a="b", c="zebra")
firestore_api.begin_transaction.assert_called_once_with(
request={
"database": transaction._client._database_string,
"options": None,
},
metadata=transaction._client._rpc_metadata,
)
firestore_api.rollback.assert_called_once_with(
request={
"database": transaction._client._database_string,
"transaction": txn_id,
},
metadata=transaction._client._rpc_metadata,
)
firestore_api.commit.assert_not_called()
