Updating unit tests for GAPIC commit in datastore.

Author: dhermes

datastore/unit_tests/test__gax.py

@@ -34,6 +34,14 @@ def _fake_method(exc, result=None):
         else:
             raise exc
 
+    @staticmethod
+    def _make_rendezvous(status_code, details):
+        from grpc._channel import _RPCState
+        from google.cloud.exceptions import GrpcRendezvous
+
+        exc_state = _RPCState((), None, None, status_code, details)
+        return GrpcRendezvous(exc_state, None, None, None)
+
     def test_success(self):
         expected = object()
         with self._call_fut():
@@ -42,39 +50,30 @@ def test_success(self):
 
     def test_failure_aborted(self):
         from grpc import StatusCode
-        from grpc._channel import _RPCState
         from google.cloud.exceptions import Conflict
-        from google.cloud.exceptions import GrpcRendezvous
 
         details = 'Bad things.'
-        exc_state = _RPCState((), None, None, StatusCode.ABORTED, details)
-        exc = GrpcRendezvous(exc_state, None, None, None)
+        exc = self._make_rendezvous(StatusCode.ABORTED, details)
         with self.assertRaises(Conflict):
             with self._call_fut():
                 self._fake_method(exc)
 
     def test_failure_invalid_argument(self):
         from grpc import StatusCode
-        from grpc._channel import _RPCState
         from google.cloud.exceptions import BadRequest
-        from google.cloud.exceptions import GrpcRendezvous
 
         details = ('Cannot have inequality filters on multiple '
                    'properties: [created, priority]')
-        exc_state = _RPCState((), None, None,
-                              StatusCode.INVALID_ARGUMENT, details)
-        exc = GrpcRendezvous(exc_state, None, None, None)
+        exc = self._make_rendezvous(StatusCode.INVALID_ARGUMENT, details)
         with self.assertRaises(BadRequest):
             with self._call_fut():
                 self._fake_method(exc)
 
     def test_failure_cancelled(self):
-        from grpc import StatusCode
-        from grpc._channel import _RPCState
         from google.cloud.exceptions import GrpcRendezvous
+        from grpc import StatusCode
 
-        exc_state = _RPCState((), None, None, StatusCode.CANCELLED, None)
-        exc = GrpcRendezvous(exc_state, None, None, None)
+        exc = self._make_rendezvous(StatusCode.CANCELLED, None)
         with self.assertRaises(GrpcRendezvous):
             with self._call_fut():
                 self._fake_method(exc)
@@ -85,6 +84,33 @@ def test_commit_failure_non_grpc_err(self):
             with self._call_fut():
                 self._fake_method(exc)
 
+    def test_gax_error(self):
+        from google.gax.errors import GaxError
+        from grpc import StatusCode
+        from google.cloud.exceptions import Forbidden
+
+        # First, create low-level GrpcRendezvous exception.
+        details = 'Some error details.'
+        cause = self._make_rendezvous(StatusCode.PERMISSION_DENIED, details)
+        # Then put it into a high-level GaxError.
+        msg = 'GAX Error content.'
+        exc = GaxError(msg, cause=cause)
+
+        with self.assertRaises(Forbidden):
+            with self._call_fut():
+                self._fake_method(exc)
+
+    def test_gax_error_not_mapped(self):
+        from google.gax.errors import GaxError
+        from grpc import StatusCode
+
+        cause = self._make_rendezvous(StatusCode.CANCELLED, None)
+        exc = GaxError(None, cause=cause)
+
+        with self.assertRaises(GaxError):
+            with self._call_fut():
+                self._fake_method(exc)
+
 
 class Test_DatastoreAPIOverGRPC(unittest.TestCase):
 
@@ -228,45 +254,38 @@ def test_begin_transaction(self):
             stub.method_calls,
             [(request_pb, 'BeginTransaction')])
 
-    def test_commit_success(self):
-        return_val = object()
-        stub = _GRPCStub(return_val)
-        datastore_api, _ = self._make_one(stub=stub)
 
-        request_pb = mock.Mock(project_id=None, spec=['project_id'])
-        project = 'PROJECT'
-        result = datastore_api.commit(project, request_pb)
-        self.assertIs(result, return_val)
-        self.assertEqual(request_pb.project_id, project)
-        self.assertEqual(stub.method_calls,
-                         [(request_pb, 'Commit')])
+@unittest.skipUnless(_HAVE_GRPC, 'No gRPC')
+class TestGAPICDatastoreAPI(unittest.TestCase):
 
-    def test_rollback(self):
-        return_val = object()
-        stub = _GRPCStub(return_val)
-        datastore_api, _ = self._make_one(stub=stub)
+    @staticmethod
+    def _get_target_class():
+        from google.cloud.datastore._gax import GAPICDatastoreAPI
 
-        request_pb = mock.Mock(project_id=None, spec=['project_id'])
-        project = 'PROJECT'
-        result = datastore_api.rollback(project, request_pb)
-        self.assertIs(result, return_val)
-        self.assertEqual(request_pb.project_id, project)
-        self.assertEqual(stub.method_calls,
-                         [(request_pb, 'Rollback')])
+        return GAPICDatastoreAPI
 
-    def test_allocate_ids(self):
-        return_val = object()
-        stub = _GRPCStub(return_val)
-        datastore_api, _ = self._make_one(stub=stub)
+    def _make_one(self, *args, **kwargs):
+        return self._get_target_class()(*args, **kwargs)
 
-        request_pb = mock.Mock(project_id=None, spec=['project_id'])
-        project = 'PROJECT'
-        result = datastore_api.allocate_ids(project, request_pb)
-        self.assertIs(result, return_val)
-        self.assertEqual(request_pb.project_id, project)
-        self.assertEqual(
-            stub.method_calls,
-            [(request_pb, 'AllocateIds')])
+    def test_commit(self):
+        from google.cloud.gapic.datastore.v1 import datastore_client
+
+        patch1 = mock.patch.object(
+            datastore_client.DatastoreClient, '__init__',
+            return_value=None)
+        patch2 = mock.patch.object(datastore_client.DatastoreClient, 'commit')
+        patch3 = mock.patch(
+            'google.cloud.datastore._gax._grpc_catch_rendezvous')
+
+        with patch1 as mock_constructor:
+            ds_api = self._make_one()
+            mock_constructor.assert_called_once_with()
+            with patch2 as mock_commit:
+                with patch3 as mock_catch_rendezvous:
+                    mock_catch_rendezvous.assert_not_called()
+                    ds_api.commit(1, 2, a=3)
+                    mock_commit.assert_called_once_with(1, 2, a=3)
+                    mock_catch_rendezvous.assert_called_once_with()
 
 
 @unittest.skipUnless(_HAVE_GRPC, 'No gRPC')
@@ -278,12 +297,12 @@ def _call_fut(self, client):
         return make_datastore_api(client)
 
     @mock.patch(
-        'google.cloud.gapic.datastore.v1.datastore_client.DatastoreClient',
-        SERVICE_ADDRESS='datastore.mock.mock',
+        'google.cloud.datastore._gax.GAPICDatastoreAPI',
         return_value=mock.sentinel.ds_client)
     @mock.patch('google.cloud.datastore._gax.make_secure_channel',
                 return_value=mock.sentinel.channel)
     def test_it(self, make_chan, mock_klass):
+        from google.cloud.gapic.datastore.v1 import datastore_client
         from google.cloud._http import DEFAULT_USER_AGENT
         from google.cloud.datastore import __version__
 
@@ -294,7 +313,7 @@ def test_it(self, make_chan, mock_klass):
 
         make_chan.assert_called_once_with(
             mock.sentinel.credentials, DEFAULT_USER_AGENT,
-            mock_klass.SERVICE_ADDRESS)
+            datastore_client.DatastoreClient.SERVICE_ADDRESS)
         mock_klass.assert_called_once_with(
             channel=mock.sentinel.channel, lib_name='gccl',
             lib_version=__version__)
@@ -322,12 +341,3 @@ def RunQuery(self, request_pb):
 
     def BeginTransaction(self, request_pb):
         return self._method(request_pb, 'BeginTransaction')
-
-    def Commit(self, request_pb):
-        return self._method(request_pb, 'Commit')
-
-    def Rollback(self, request_pb):
-        return self._method(request_pb, 'Rollback')
-
-    def AllocateIds(self, request_pb):
-        return self._method(request_pb, 'AllocateIds')

datastore/unit_tests/test__http.py

@@ -662,6 +662,23 @@ def test_begin_transaction(self):
         # The RPC-over-HTTP request does not set the project in the request.
         self.assertEqual(request.project_id, u'')
 
+
+class TestHTTPDatastoreAPI(unittest.TestCase):
+
+    @staticmethod
+    def _get_target_class():
+        from google.cloud.datastore._http import HTTPDatastoreAPI
+
+        return HTTPDatastoreAPI
+
+    def _make_one(self, *args, **kwargs):
+        return self._get_target_class()(*args, **kwargs)
+
+    def test_constructor(self):
+        client = object()
+        ds_api = self._make_one(client)
+        self.assertIs(ds_api.client, client)
+
     def test_commit_wo_transaction(self):
         from google.cloud.proto.datastore.v1 import datastore_pb2
         from google.cloud.datastore.helpers import _new_value_pb
@@ -675,19 +692,23 @@ def test_commit_wo_transaction(self):
         insert.key.CopyFrom(key_pb)
         value_pb = _new_value_pb(insert, 'foo')
         value_pb.string_value = u'Foo'
+
+        # Create mock HTTP and client with response.
         http = Http({'status': '200'}, rsp_pb.SerializeToString())
         client = mock.Mock(
             _http=http, _base_url='test.invalid', spec=['_http', '_base_url'])
-        conn = self._make_one(client)
-        uri = _build_expected_url(conn.api_base_url, project, 'commit')
 
-        result = conn.commit(project, req_pb, None)
-        self.assertEqual(result, rsp_pb)
+        # Make request.
+        rq_class = datastore_pb2.CommitRequest
+        ds_api = self._make_one(client)
+        mode = rq_class.NON_TRANSACTIONAL
+        result = ds_api.commit(project, mode, [mutation])
 
-        # Verify the caller.
+        # Check the result and verify the callers.
+        self.assertEqual(result, rsp_pb)
+        uri = _build_expected_url(client._base_url, project, 'commit')
         cw = http._called_with
         _verify_protobuf_call(self, cw, uri)
-        rq_class = datastore_pb2.CommitRequest
         request = rq_class()
         request.ParseFromString(cw['body'])
         self.assertEqual(request.transaction, b'')
@@ -707,42 +728,29 @@ def test_commit_w_transaction(self):
         insert.key.CopyFrom(key_pb)
         value_pb = _new_value_pb(insert, 'foo')
         value_pb.string_value = u'Foo'
+
+        # Create mock HTTP and client with response.
         http = Http({'status': '200'}, rsp_pb.SerializeToString())
         client = mock.Mock(
             _http=http, _base_url='test.invalid', spec=['_http', '_base_url'])
-        conn = self._make_one(client)
-        uri = _build_expected_url(conn.api_base_url, project, 'commit')
 
-        result = conn.commit(project, req_pb, b'xact')
-        self.assertEqual(result, rsp_pb)
+        # Make request.
+        rq_class = datastore_pb2.CommitRequest
+        ds_api = self._make_one(client)
+        mode = rq_class.TRANSACTIONAL
+        result = ds_api.commit(project, mode, [mutation], transaction=b'xact')
 
-        # Verify the caller.
+        # Check the result and verify the callers.
+        self.assertEqual(result, rsp_pb)
+        uri = _build_expected_url(client._base_url, project, 'commit')
         cw = http._called_with
         _verify_protobuf_call(self, cw, uri)
-        rq_class = datastore_pb2.CommitRequest
         request = rq_class()
         request.ParseFromString(cw['body'])
         self.assertEqual(request.transaction, b'xact')
         self.assertEqual(list(request.mutations), [mutation])
         self.assertEqual(request.mode, rq_class.TRANSACTIONAL)
 
-
-class TestHTTPDatastoreAPI(unittest.TestCase):
-
-    @staticmethod
-    def _get_target_class():
-        from google.cloud.datastore._http import HTTPDatastoreAPI
-
-        return HTTPDatastoreAPI
-
-    def _make_one(self, *args, **kwargs):
-        return self._get_target_class()(*args, **kwargs)
-
-    def test_constructor(self):
-        client = object()
-        ds_api = self._make_one(client)
-        self.assertIs(ds_api.client, client)
-
     def test_rollback_ok(self):
         from google.cloud.proto.datastore.v1 import datastore_pb2