def test_it(self):
        from google.cloud.datastore_v1.proto import datastore_pb2
        from google.cloud.datastore_v1.proto import entity_pb2

        index_updates = 1337
        keys = [
            entity_pb2.Key(path=[
                entity_pb2.Key.PathElement(
                    kind='Foo',
                    id=1234,
                ),
            ], ),
            entity_pb2.Key(path=[
                entity_pb2.Key.PathElement(
                    kind='Bar',
                    name='baz',
                ),
            ], ),
        ]
        response = datastore_pb2.CommitResponse(
            mutation_results=[
                datastore_pb2.MutationResult(key=key) for key in keys
            ],
            index_updates=index_updates,
        )
        result = self._call_fut(response)
        self.assertEqual(result, (index_updates, keys))
示例#2
0
    def test_commit_w_transaction(self):
        from google.cloud.datastore_v1.proto import datastore_pb2
        from google.cloud.datastore.helpers import _new_value_pb

        project = 'PROJECT'
        key_pb = _make_key_pb(project)
        rsp_pb = datastore_pb2.CommitResponse()
        req_pb = datastore_pb2.CommitRequest()
        mutation = req_pb.mutations.add()
        insert = mutation.upsert
        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 = _make_requests_session(
            [_make_response(content=rsp_pb.SerializeToString())])
        client = mock.Mock(
            _http=http, _base_url='test.invalid', spec=['_http', '_base_url'])

        # 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')

        # Check the result and verify the callers.
        self.assertEqual(result, rsp_pb)

        uri = _build_expected_url(client._base_url, project, 'commit')
        request = _verify_protobuf_call(http, uri, rq_class())
        self.assertEqual(request.transaction, b'xact')
        self.assertEqual(list(request.mutations), [mutation])
        self.assertEqual(request.mode, rq_class.TRANSACTIONAL)
示例#3
0
    def test_commit(self):
        # Setup Expected Response
        index_updates = 1425228195
        expected_response = {'index_updates': index_updates}
        expected_response = datastore_pb2.CommitResponse(**expected_response)

        # Mock the API response
        channel = ChannelStub(responses=[expected_response])
        client = datastore_v1.DatastoreClient(channel=channel)

        # Setup Request
        project_id = 'projectId-1969970175'
        mode = enums.CommitRequest.Mode.MODE_UNSPECIFIED
        mutations = []

        response = client.commit(project_id, mode, mutations)
        assert expected_response == response

        assert len(channel.requests) == 1
        expected_request = datastore_pb2.CommitRequest(project_id=project_id,
                                                       mode=mode,
                                                       mutations=mutations)
        actual_request = channel.requests[0][1]
        assert expected_request == actual_request
def _make_commit_response(*new_key_ids):
    from google.cloud.datastore_v1.proto import datastore_pb2

    mutation_results = [_make_mutation(key_id) for key_id in new_key_ids]
    return datastore_pb2.CommitResponse(mutation_results=mutation_results)
def _make_commit_response(*keys):
    from google.cloud.datastore_v1.proto import datastore_pb2

    mutation_results = [
        datastore_pb2.MutationResult(key=key) for key in keys]
    return datastore_pb2.CommitResponse(mutation_results=mutation_results)