Exemplo n.º 1
0
    def test_lookup_single_key_empty_response_w_transaction(self):
        from google.cloud.datastore_v1.types import datastore as datastore_pb2

        project = "PROJECT"
        transaction = b"TRANSACTION"
        key_pb = _make_key_pb(project)
        rsp_pb = datastore_pb2.LookupResponse()
        read_options = datastore_pb2.ReadOptions(transaction=transaction)

        # Create mock HTTP and client with response.
        http = _make_requests_session(
            [_make_response(content=rsp_pb._pb.SerializeToString())])
        client_info = _make_client_info()
        client = mock.Mock(
            _http=http,
            _base_url="test.invalid",
            _client_info=client_info,
            spec=["_http", "_base_url", "_client_info"],
        )

        # Make request.
        ds_api = self._make_one(client)
        response = ds_api.lookup(project, [key_pb], read_options=read_options)

        # Check the result and verify the callers.
        self.assertEqual(response, rsp_pb._pb)
        uri = _build_expected_url(client._base_url, project, "lookup")
        self.assertEqual(len(response.found), 0)
        self.assertEqual(len(response.missing), 0)
        self.assertEqual(len(response.deferred), 0)

        request = _verify_protobuf_call(http, uri,
                                        datastore_pb2.LookupRequest())
        self.assertEqual(list(request.keys), [key_pb._pb])
        self.assertEqual(request.read_options, read_options._pb)
Exemplo n.º 2
0
    def test_lookup_multiple_keys_w_missing(self):
        from google.cloud.datastore_v1.types import datastore as datastore_pb2

        project = "PROJECT"
        key_pb1 = _make_key_pb(project)
        key_pb2 = _make_key_pb(project, id_=2345)
        rsp_pb = datastore_pb2.LookupResponse()
        er_1 = rsp_pb._pb.missing.add()
        er_1.entity.key.CopyFrom(key_pb1._pb)
        er_2 = rsp_pb._pb.missing.add()
        er_2.entity.key.CopyFrom(key_pb2._pb)
        read_options = datastore_pb2.ReadOptions()

        # Create mock HTTP and client with response.
        http = _make_requests_session(
            [_make_response(content=rsp_pb._pb.SerializeToString())])
        client_info = _make_client_info()
        client = mock.Mock(
            _http=http,
            _base_url="test.invalid",
            _client_info=client_info,
            spec=["_http", "_base_url", "_client_info"],
        )

        # Make request.
        ds_api = self._make_one(client)
        response = ds_api.lookup(project, [key_pb1, key_pb2],
                                 read_options=read_options)

        # Check the result and verify the callers.
        self.assertEqual(response, rsp_pb._pb)
        uri = _build_expected_url(client._base_url, project, "lookup")
        self.assertEqual(len(response.found), 0)
        self.assertEqual(len(response.deferred), 0)
        missing_keys = [result.entity.key for result in response.missing]
        self.assertEqual(missing_keys, [key_pb1._pb, key_pb2._pb])

        request = _verify_protobuf_call(http, uri,
                                        datastore_pb2.LookupRequest())
        self.assertEqual(list(request.keys), [key_pb1._pb, key_pb2._pb])
        self.assertEqual(request.read_options, read_options._pb)
Exemplo n.º 3
0
    def test_lookup_single_key_nonempty_response(self):
        from google.cloud.datastore_v1.types import datastore as datastore_pb2
        from google.cloud.datastore_v1.types import entity as entity_pb2

        project = "PROJECT"
        key_pb = _make_key_pb(project)
        rsp_pb = datastore_pb2.LookupResponse()
        entity = entity_pb2.Entity()
        entity.key._pb.CopyFrom(key_pb._pb)
        rsp_pb._pb.found.add(entity=entity._pb)
        read_options = datastore_pb2.ReadOptions()

        # Create mock HTTP and client with response.
        http = _make_requests_session(
            [_make_response(content=rsp_pb._pb.SerializeToString())])
        client_info = _make_client_info()
        client = mock.Mock(
            _http=http,
            _base_url="test.invalid",
            _client_info=client_info,
            spec=["_http", "_base_url", "_client_info"],
        )

        # Make request.
        ds_api = self._make_one(client)
        response = ds_api.lookup(project, [key_pb], read_options=read_options)

        # Check the result and verify the callers.
        self.assertEqual(response, rsp_pb._pb)
        uri = _build_expected_url(client._base_url, project, "lookup")
        self.assertEqual(len(response.found), 1)
        self.assertEqual(len(response.missing), 0)
        self.assertEqual(len(response.deferred), 0)
        found = response.found[0].entity
        self.assertEqual(found.key.path[0].kind, "Kind")
        self.assertEqual(found.key.path[0].id, 1234)

        request = _verify_protobuf_call(http, uri,
                                        datastore_pb2.LookupRequest())
        self.assertEqual(list(request.keys), [key_pb._pb])
        self.assertEqual(request.read_options, read_options._pb)
Exemplo n.º 4
0
    def _lookup_multiple_helper(
        self,
        found=0,
        missing=0,
        deferred=0,
        retry=None,
        timeout=None,
    ):
        from google.cloud.datastore_v1.types import datastore as datastore_pb2
        from google.cloud.datastore_v1.types import entity as entity_pb2

        project = "PROJECT"
        key_pb1 = _make_key_pb(project)
        key_pb2 = _make_key_pb(project, id_=2345)
        keys = [key_pb1, key_pb2]
        read_options = datastore_pb2.ReadOptions()

        rsp_pb = datastore_pb2.LookupResponse()

        found_keys = []
        for i_found in range(found):
            key = keys[i_found]
            found_keys.append(key._pb)
            entity = entity_pb2.Entity()
            entity.key._pb.CopyFrom(key._pb)
            rsp_pb._pb.found.add(entity=entity._pb)

        missing_keys = []
        for i_missing in range(missing):
            key = keys[i_missing]
            missing_keys.append(key._pb)
            entity = entity_pb2.Entity()
            entity.key._pb.CopyFrom(key._pb)
            rsp_pb._pb.missing.add(entity=entity._pb)

        deferred_keys = []
        for i_deferred in range(deferred):
            key = keys[i_deferred]
            deferred_keys.append(key._pb)
            rsp_pb._pb.deferred.append(key._pb)

        http = _make_requests_session(
            [_make_response(content=rsp_pb._pb.SerializeToString())])
        client_info = _make_client_info()
        client = mock.Mock(
            _http=http,
            _base_url="test.invalid",
            _client_info=client_info,
            spec=["_http", "_base_url", "_client_info"],
        )
        ds_api = self._make_one(client)
        request = {
            "project_id": project,
            "keys": keys,
            "read_options": read_options,
        }
        kwargs = _make_retry_timeout_kwargs(retry, timeout, http)

        response = ds_api.lookup(request=request, **kwargs)

        self.assertEqual(response, rsp_pb._pb)

        self.assertEqual([found.entity.key for found in response.found],
                         found_keys)
        self.assertEqual([missing.entity.key for missing in response.missing],
                         missing_keys)
        self.assertEqual(list(response.deferred), deferred_keys)

        uri = _build_expected_url(client._base_url, project, "lookup")
        request = _verify_protobuf_call(
            http,
            uri,
            datastore_pb2.LookupRequest(),
            retry=retry,
            timeout=timeout,
        )
        self.assertEqual(list(request.keys), [key_pb1._pb, key_pb2._pb])
        self.assertEqual(request.read_options, read_options._pb)
Exemplo n.º 5
0
    def _lookup_single_helper(
        self,
        read_consistency=None,
        transaction=None,
        empty=True,
        retry=None,
        timeout=None,
    ):
        from google.cloud.datastore_v1.types import datastore as datastore_pb2
        from google.cloud.datastore_v1.types import entity as entity_pb2

        project = "PROJECT"
        key_pb = _make_key_pb(project)

        options_kw = {}
        if read_consistency is not None:
            options_kw["read_consistency"] = read_consistency
        if transaction is not None:
            options_kw["transaction"] = transaction

        read_options = datastore_pb2.ReadOptions(**options_kw)

        rsp_pb = datastore_pb2.LookupResponse()

        if not empty:
            entity = entity_pb2.Entity()
            entity.key._pb.CopyFrom(key_pb._pb)
            rsp_pb._pb.found.add(entity=entity._pb)

        http = _make_requests_session(
            [_make_response(content=rsp_pb._pb.SerializeToString())])
        client_info = _make_client_info()
        client = mock.Mock(
            _http=http,
            _base_url="test.invalid",
            _client_info=client_info,
            spec=["_http", "_base_url", "_client_info"],
        )
        ds_api = self._make_one(client)
        request = {
            "project_id": project,
            "keys": [key_pb],
            "read_options": read_options,
        }
        kwargs = _make_retry_timeout_kwargs(retry, timeout, http)

        response = ds_api.lookup(request=request, **kwargs)

        self.assertEqual(response, rsp_pb._pb)

        if empty:
            self.assertEqual(len(response.found), 0)
        else:
            self.assertEqual(len(response.found), 1)

        self.assertEqual(len(response.missing), 0)
        self.assertEqual(len(response.deferred), 0)

        uri = _build_expected_url(client._base_url, project, "lookup")
        request = _verify_protobuf_call(
            http,
            uri,
            datastore_pb2.LookupRequest(),
            retry=retry,
            timeout=timeout,
        )

        if retry is not None:
            retry.assert_called_once_with(http.request)

        self.assertEqual(list(request.keys), [key_pb._pb])
        self.assertEqual(request.read_options, read_options._pb)