def test_begin_transaction(self):
from google.cloud.proto.datastore.v1 import datastore_pb2
project = 'PROJECT'
transaction = b'TRANSACTION'
rsp_pb = datastore_pb2.BeginTransactionResponse()
rsp_pb.transaction = transaction
# Create mock HTTP and client with response.
http = _make_requests_session(
[_make_response(content=rsp_pb.SerializeToString())])
client = mock.Mock(_http=http,
_base_url='test.invalid',
spec=['_http', '_base_url'])
# Make request.
ds_api = self._make_one(client)
response = ds_api.begin_transaction(project)
# Check the result and verify the callers.
self.assertEqual(response, rsp_pb)
uri = _build_expected_url(client._base_url, project,
'beginTransaction')
request = _verify_protobuf_call(
http, uri, datastore_pb2.BeginTransactionRequest())
# The RPC-over-HTTP request does not set the project in the request.
self.assertEqual(request.project_id, u'')
def test_begin_transaction(self):
from google.cloud.proto.datastore.v1 import datastore_pb2
project = 'PROJECT'
transaction = b'TRANSACTION'
rsp_pb = datastore_pb2.BeginTransactionResponse()
rsp_pb.transaction = transaction
# Create mock HTTP and client with response.
http = Http({'status': '200'}, rsp_pb.SerializeToString())
client = mock.Mock(_http=http, spec=['_http'])
# Make request.
conn = self._make_one(client)
response = conn.begin_transaction(project)
# Check the result and verify the callers.
self.assertEqual(response, rsp_pb)
uri = '/'.join([
conn.api_base_url,
conn.API_VERSION,
'projects',
project + ':beginTransaction',
])
cw = http._called_with
self._verify_protobuf_call(cw, uri, conn)
request = datastore_pb2.BeginTransactionRequest()
request.ParseFromString(cw['body'])
# The RPC-over-HTTP request does not set the project in the request.
self.assertEqual(request.project_id, u'')
def begin_transaction(self, project_id, options=None):
"""
Begins a new transaction.
Example:
>>> from google.cloud.gapic.datastore.v1 import datastore_client
>>> api = datastore_client.DatastoreClient()
>>> project_id = ''
>>> response = api.begin_transaction(project_id)
Args:
project_id (string): The ID of the project against which to make the request.
options (:class:`google.gax.CallOptions`): Overrides the default
settings for this call, e.g, timeout, retries etc.
Returns:
A :class:`google.cloud.proto.datastore.v1.datastore_pb2.BeginTransactionResponse` instance.
Raises:
:exc:`google.gax.errors.GaxError` if the RPC is aborted.
:exc:`ValueError` if the parameters are invalid.
"""
# Create the request object.
request = datastore_pb2.BeginTransactionRequest(project_id=project_id)
return self._begin_transaction(request, options)
def test_begin_transaction(self, mock_create_stub):
# Mock gRPC layer
grpc_stub = mock.Mock()
mock_create_stub.return_value = grpc_stub
client = datastore_client.DatastoreClient()
# Mock request
project_id = 'projectId-1969970175'
# Mock response
transaction = b'-34'
expected_response = datastore_pb2.BeginTransactionResponse(
transaction=transaction)
grpc_stub.BeginTransaction.return_value = expected_response
response = client.begin_transaction(project_id)
self.assertEqual(expected_response, response)
grpc_stub.BeginTransaction.assert_called_once()
args, kwargs = grpc_stub.BeginTransaction.call_args
self.assertEqual(len(args), 2)
self.assertEqual(len(kwargs), 1)
self.assertIn('metadata', kwargs)
actual_request = args[0]
expected_request = datastore_pb2.BeginTransactionRequest(
project_id=project_id)
self.assertEqual(expected_request, actual_request)
def begin_transaction(self, project):
"""Begin a transaction.
Maps the ``DatastoreService.BeginTransaction`` protobuf RPC.
:type project: str
:param project: The project to which the transaction applies.
:rtype: :class:`.datastore_pb2.BeginTransactionResponse`
:returns: The serialized transaction that was begun.
"""
request = _datastore_pb2.BeginTransactionRequest()
return self._datastore_api.begin_transaction(project, request)
def begin_transaction(self, project):
"""Perform a ``beginTransaction`` request.
:type project: str
:param project: The project to connect to. This is
usually your project name in the cloud console.
:rtype: :class:`.datastore_pb2.BeginTransactionResponse`
:returns: The returned protobuf response object.
"""
request_pb = _datastore_pb2.BeginTransactionRequest()
return _rpc(self.client._http, project, 'beginTransaction',
self.client._base_url,
request_pb, _datastore_pb2.BeginTransactionResponse)
def test_it(self):
from google.cloud.proto.datastore.v1 import datastore_pb2
http = object()
project = 'projectOK'
method = 'beginTransaction'
base_url = 'test.invalid'
request_pb = datastore_pb2.BeginTransactionRequest(project_id=project)
response_pb = datastore_pb2.BeginTransactionResponse(
transaction=b'7830rmc')
patch = mock.patch('google.cloud.datastore._http._request',
return_value=response_pb.SerializeToString())
with patch as mock_request:
result = self._call_fut(http, project, method, base_url,
request_pb,
datastore_pb2.BeginTransactionResponse)
self.assertEqual(result, response_pb)
mock_request.assert_called_once_with(
http, project, method, request_pb.SerializeToString(),
base_url)
