Exemplo n.º 1
0
    def test_get_multi_diff_datasets_w_prefix(self):
        from gcloud.datastore.key import Key

        DATASET_ID1 = 'e~DATASET'
        DATASET_ID2 = 's~DATASET-ALT'

        key1 = Key('KIND', 1234, dataset_id=DATASET_ID1)
        key2 = Key('KIND', 1234, dataset_id=DATASET_ID2)

        creds = object()
        client = self._makeOne(credentials=creds)

        with self.assertRaises(ValueError):
            client.get_multi([key1, key2])
Exemplo n.º 2
0
    def test_get_multi_diff_projects_w_prefix(self):
        from gcloud.datastore.key import Key

        PROJECT1 = 'e~PROJECT'
        PROJECT2 = 's~PROJECT-ALT'

        key1 = Key('KIND', 1234, project=PROJECT1)
        key2 = Key('KIND', 1234, project=PROJECT2)

        creds = object()
        client = self._makeOne(credentials=creds)

        with self.assertRaises(ValueError):
            client.get_multi([key1, key2])
Exemplo n.º 3
0
    def test_get_multi_diff_projects_w_prefix(self):
        from gcloud.datastore.key import Key

        PROJECT1 = 'e~PROJECT'
        PROJECT2 = 's~PROJECT-ALT'

        key1 = Key('KIND', 1234, project=PROJECT1)
        key2 = Key('KIND', 1234, project=PROJECT2)

        creds = object()
        client = self._makeOne(credentials=creds)

        with self.assertRaises(ValueError):
            client.get_multi([key1, key2])
Exemplo n.º 4
0
    def test_get_multi_hit_multiple_keys_different_dataset(self):
        from gcloud.datastore.key import Key

        DATASET_ID1 = 'DATASET'
        DATASET_ID2 = 'DATASET-ALT'

        # Make sure our IDs are actually different.
        self.assertNotEqual(DATASET_ID1, DATASET_ID2)

        key1 = Key('KIND', 1234, dataset_id=DATASET_ID1)
        key2 = Key('KIND', 1234, dataset_id=DATASET_ID2)
        client = self._makeOne(connection=object())

        with self.assertRaises(ValueError):
            client.get_multi([key1, key2])
Exemplo n.º 5
0
    def test_get_multi_hit_w_transaction(self):
        from gcloud.datastore.key import Key

        TXN_ID = "123"
        KIND = "Kind"
        ID = 1234
        PATH = [{"kind": KIND, "id": ID}]

        # Make a found entity pb to be returned from mock backend.
        entity_pb = _make_entity_pb(self.PROJECT, KIND, ID, "foo", "Foo")

        # Make a connection to return the entity pb.
        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result([entity_pb])

        key = Key(KIND, ID, project=self.PROJECT)
        txn = client.transaction()
        txn._id = TXN_ID
        result, = client.get_multi([key], transaction=txn)
        new_key = result.key

        # Check the returned value is as expected.
        self.assertFalse(new_key is key)
        self.assertEqual(new_key.project, self.PROJECT)
        self.assertEqual(new_key.path, PATH)
        self.assertEqual(list(result), ["foo"])
        self.assertEqual(result["foo"], "Foo")

        cw = client.connection._lookup_cw
        self.assertEqual(len(cw), 1)
        _, _, _, transaction_id = cw[0]
        self.assertEqual(transaction_id, TXN_ID)
Exemplo n.º 6
0
    def test_get_multi_hit(self):
        from gcloud.datastore.key import Key
        from gcloud.datastore.test_connection import _Connection

        KIND = 'Kind'
        ID = 1234
        PATH = [{'kind': KIND, 'id': ID}]

        # Make a found entity pb to be returned from mock backend.
        entity_pb = _make_entity_pb(self.DATASET_ID, KIND, ID, 'foo', 'Foo')

        # Make a connection to return the entity pb.
        connection = _Connection(entity_pb)
        client = self._makeOne(connection=connection)

        key = Key(KIND, ID, dataset_id=self.DATASET_ID)
        result, = client.get_multi([key])
        new_key = result.key

        # Check the returned value is as expected.
        self.assertFalse(new_key is key)
        self.assertEqual(new_key.dataset_id, self.DATASET_ID)
        self.assertEqual(new_key.path, PATH)
        self.assertEqual(list(result), ['foo'])
        self.assertEqual(result['foo'], 'Foo')
Exemplo n.º 7
0
    def test_get_multi_hit_multiple_keys_same_dataset(self):
        from gcloud.datastore.key import Key
        from gcloud.datastore.test_connection import _Connection

        KIND = 'Kind'
        ID1 = 1234
        ID2 = 2345

        # Make a found entity pb to be returned from mock backend.
        entity_pb1 = _make_entity_pb(self.DATASET_ID, KIND, ID1)
        entity_pb2 = _make_entity_pb(self.DATASET_ID, KIND, ID2)

        # Make a connection to return the entity pbs.
        connection = _Connection(entity_pb1, entity_pb2)
        client = self._makeOne(connection=connection)

        key1 = Key(KIND, ID1, dataset_id=self.DATASET_ID)
        key2 = Key(KIND, ID2, dataset_id=self.DATASET_ID)
        retrieved1, retrieved2 = client.get_multi([key1, key2])

        # Check values match.
        self.assertEqual(retrieved1.key.path, key1.path)
        self.assertEqual(dict(retrieved1), {})
        self.assertEqual(retrieved2.key.path, key2.path)
        self.assertEqual(dict(retrieved2), {})
Exemplo n.º 8
0
    def test_get_multi_diff_prefixes(self):
        from gcloud.datastore.key import Key

        PROJECT1 = 'PROJECT'
        PROJECT2 = 'e~PROJECT'
        PROJECT3 = 's~PROJECT'
        KIND = 'Kind'
        ID1 = 1234
        ID2 = 2345
        ID3 = 3456

        # Make found entity pbs to be returned from mock backend.
        entity_pb1 = _make_entity_pb(PROJECT1, KIND, ID1)
        entity_pb2 = _make_entity_pb(PROJECT2, KIND, ID2)
        entity_pb3 = _make_entity_pb(PROJECT3, KIND, ID3)

        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result([entity_pb1,
                                              entity_pb2,
                                              entity_pb3])

        key1 = Key(KIND, ID1, project=PROJECT1)
        key2 = Key(KIND, ID2, project=PROJECT2)
        key3 = Key(KIND, ID3, project=PROJECT3)

        retrieved_all = client.get_multi([key1, key2, key3])
        retrieved1, retrieved2, retrieved3 = retrieved_all

        # Check values & keys match.
        self.assertEqual(retrieved1.key.path, key1.path)
        self.assertEqual(retrieved2.key.path, key2.path)
        self.assertEqual(retrieved3.key.path, key3.path)
Exemplo n.º 9
0
    def test_get_multi_hit(self):
        from gcloud.datastore.key import Key

        KIND = 'Kind'
        ID = 1234
        PATH = [{'kind': KIND, 'id': ID}]

        # Make a found entity pb to be returned from mock backend.
        entity_pb = _make_entity_pb(self.PROJECT, KIND, ID, 'foo', 'Foo')

        # Make a connection to return the entity pb.
        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result([entity_pb])

        key = Key(KIND, ID, project=self.PROJECT)
        result, = client.get_multi([key])
        new_key = result.key

        # Check the returned value is as expected.
        self.assertFalse(new_key is key)
        self.assertEqual(new_key.project, self.PROJECT)
        self.assertEqual(new_key.path, PATH)
        self.assertEqual(list(result), ['foo'])
        self.assertEqual(result['foo'], 'Foo')
Exemplo n.º 10
0
    def test_get_multi_miss_w_missing(self):
        from gcloud.datastore._generated import entity_pb2
        from gcloud.datastore.key import Key

        KIND = 'Kind'
        ID = 1234

        # Make a missing entity pb to be returned from mock backend.
        missed = entity_pb2.Entity()
        missed.key.partition_id.dataset_id = self.PROJECT
        path_element = missed.key.path_element.add()
        path_element.kind = KIND
        path_element.id = ID

        creds = object()
        client = self._makeOne(credentials=creds)
        # Set missing entity on mock connection.
        client.connection._add_lookup_result(missing=[missed])

        key = Key(KIND, ID, project=self.PROJECT)
        missing = []
        entities = client.get_multi([key], missing=missing)
        self.assertEqual(entities, [])
        self.assertEqual([missed.key.to_protobuf() for missed in missing],
                         [key.to_protobuf()])
Exemplo n.º 11
0
    def test_get_multi_hit_multiple_keys_same_project(self):
        from gcloud.datastore.key import Key

        KIND = "Kind"
        ID1 = 1234
        ID2 = 2345

        # Make a found entity pb to be returned from mock backend.
        entity_pb1 = _make_entity_pb(self.PROJECT, KIND, ID1)
        entity_pb2 = _make_entity_pb(self.PROJECT, KIND, ID2)

        # Make a connection to return the entity pbs.
        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result([entity_pb1, entity_pb2])

        key1 = Key(KIND, ID1, project=self.PROJECT)
        key2 = Key(KIND, ID2, project=self.PROJECT)
        retrieved1, retrieved2 = client.get_multi([key1, key2])

        # Check values match.
        self.assertEqual(retrieved1.key.path, key1.path)
        self.assertEqual(dict(retrieved1), {})
        self.assertEqual(retrieved2.key.path, key2.path)
        self.assertEqual(dict(retrieved2), {})
Exemplo n.º 12
0
    def test_get_multi_diff_prefixes(self):
        from gcloud.datastore.key import Key

        PROJECT1 = 'PROJECT'
        PROJECT2 = 'e~PROJECT'
        PROJECT3 = 's~PROJECT'
        KIND = 'Kind'
        ID1 = 1234
        ID2 = 2345
        ID3 = 3456

        # Make found entity pbs to be returned from mock backend.
        entity_pb1 = _make_entity_pb(PROJECT1, KIND, ID1)
        entity_pb2 = _make_entity_pb(PROJECT2, KIND, ID2)
        entity_pb3 = _make_entity_pb(PROJECT3, KIND, ID3)

        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result(
            [entity_pb1, entity_pb2, entity_pb3])

        key1 = Key(KIND, ID1, project=PROJECT1)
        key2 = Key(KIND, ID2, project=PROJECT2)
        key3 = Key(KIND, ID3, project=PROJECT3)

        retrieved_all = client.get_multi([key1, key2, key3])
        retrieved1, retrieved2, retrieved3 = retrieved_all

        # Check values & keys match.
        self.assertEqual(retrieved1.key.path, key1.path)
        self.assertEqual(retrieved2.key.path, key2.path)
        self.assertEqual(retrieved3.key.path, key3.path)
Exemplo n.º 13
0
    def test_get_multi_hit(self):
        from gcloud.datastore.key import Key

        KIND = 'Kind'
        ID = 1234
        PATH = [{'kind': KIND, 'id': ID}]

        # Make a found entity pb to be returned from mock backend.
        entity_pb = _make_entity_pb(self.PROJECT, KIND, ID, 'foo', 'Foo')

        # Make a connection to return the entity pb.
        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result([entity_pb])

        key = Key(KIND, ID, project=self.PROJECT)
        result, = client.get_multi([key])
        new_key = result.key

        # Check the returned value is as expected.
        self.assertFalse(new_key is key)
        self.assertEqual(new_key.project, self.PROJECT)
        self.assertEqual(new_key.path, PATH)
        self.assertEqual(list(result), ['foo'])
        self.assertEqual(result['foo'], 'Foo')
Exemplo n.º 14
0
    def test_get_multi_max_loops(self):
        from gcloud._testing import _Monkey
        from gcloud.datastore import client as _MUT
        from gcloud.datastore.key import Key
        from gcloud.datastore.test_connection import _Connection

        KIND = 'Kind'
        ID = 1234

        # Make a found entity pb to be returned from mock backend.
        entity_pb = _make_entity_pb(self.DATASET_ID, KIND, ID, 'foo', 'Foo')

        # Make a connection to return the entity pb.
        connection = _Connection(entity_pb)
        client = self._makeOne(connection=connection)

        key = Key(KIND, ID, dataset_id=self.DATASET_ID)
        deferred = []
        missing = []
        with _Monkey(_MUT, _MAX_LOOPS=-1):
            result = client.get_multi([key], missing=missing,
                                      deferred=deferred)

        # Make sure we have no results, even though the connection has been
        # set up as in `test_hit` to return a single result.
        self.assertEqual(result, [])
        self.assertEqual(missing, [])
        self.assertEqual(deferred, [])
Exemplo n.º 15
0
    def test_get_multi_hit_multiple_keys_same_project(self):
        from gcloud.datastore.key import Key

        KIND = 'Kind'
        ID1 = 1234
        ID2 = 2345

        # Make a found entity pb to be returned from mock backend.
        entity_pb1 = _make_entity_pb(self.PROJECT, KIND, ID1)
        entity_pb2 = _make_entity_pb(self.PROJECT, KIND, ID2)

        # Make a connection to return the entity pbs.
        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result([entity_pb1, entity_pb2])

        key1 = Key(KIND, ID1, project=self.PROJECT)
        key2 = Key(KIND, ID2, project=self.PROJECT)
        retrieved1, retrieved2 = client.get_multi([key1, key2])

        # Check values match.
        self.assertEqual(retrieved1.key.path, key1.path)
        self.assertEqual(dict(retrieved1), {})
        self.assertEqual(retrieved2.key.path, key2.path)
        self.assertEqual(dict(retrieved2), {})
Exemplo n.º 16
0
    def test_get_multi_miss_w_missing(self):
        from gcloud.datastore._generated import entity_pb2
        from gcloud.datastore.key import Key

        KIND = 'Kind'
        ID = 1234

        # Make a missing entity pb to be returned from mock backend.
        missed = entity_pb2.Entity()
        missed.key.partition_id.dataset_id = self.PROJECT
        path_element = missed.key.path_element.add()
        path_element.kind = KIND
        path_element.id = ID

        creds = object()
        client = self._makeOne(credentials=creds)
        # Set missing entity on mock connection.
        client.connection._add_lookup_result(missing=[missed])

        key = Key(KIND, ID, project=self.PROJECT)
        missing = []
        entities = client.get_multi([key], missing=missing)
        self.assertEqual(entities, [])
        self.assertEqual([missed.key.to_protobuf() for missed in missing],
                         [key.to_protobuf()])
Exemplo n.º 17
0
    def test_get_multi_max_loops(self):
        from gcloud._testing import _Monkey
        from gcloud.datastore import client as _MUT
        from gcloud.datastore.key import Key

        KIND = 'Kind'
        ID = 1234

        # Make a found entity pb to be returned from mock backend.
        entity_pb = _make_entity_pb(self.PROJECT, KIND, ID, 'foo', 'Foo')

        # Make a connection to return the entity pb.
        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result([entity_pb])

        key = Key(KIND, ID, project=self.PROJECT)
        deferred = []
        missing = []
        with _Monkey(_MUT, _MAX_LOOPS=-1):
            result = client.get_multi([key],
                                      missing=missing,
                                      deferred=deferred)

        # Make sure we have no results, even though the connection has been
        # set up as in `test_hit` to return a single result.
        self.assertEqual(result, [])
        self.assertEqual(missing, [])
        self.assertEqual(deferred, [])
Exemplo n.º 18
0
    def test_get_multi_miss_w_missing(self):
        from gcloud.datastore import _datastore_v1_pb2 as datastore_pb
        from gcloud.datastore.key import Key
        from gcloud.datastore.test_connection import _Connection

        KIND = 'Kind'
        ID = 1234

        # Make a missing entity pb to be returned from mock backend.
        missed = datastore_pb.Entity()
        missed.key.partition_id.dataset_id = self.DATASET_ID
        path_element = missed.key.path_element.add()
        path_element.kind = KIND
        path_element.id = ID

        # Set missing entity on mock connection.
        connection = _Connection()
        connection._missing = [missed]
        client = self._makeOne(connection=connection)

        key = Key(KIND, ID, dataset_id=self.DATASET_ID)
        missing = []
        entities = client.get_multi([key], missing=missing)
        self.assertEqual(entities, [])
        self.assertEqual([missed.key.to_protobuf() for missed in missing],
                         [key.to_protobuf()])
Exemplo n.º 19
0
    def test_get_multi_max_loops(self):
        from gcloud._testing import _Monkey
        from gcloud.datastore import client as _MUT
        from gcloud.datastore.key import Key

        KIND = "Kind"
        ID = 1234

        # Make a found entity pb to be returned from mock backend.
        entity_pb = _make_entity_pb(self.PROJECT, KIND, ID, "foo", "Foo")

        # Make a connection to return the entity pb.
        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result([entity_pb])

        key = Key(KIND, ID, project=self.PROJECT)
        deferred = []
        missing = []
        with _Monkey(_MUT, _MAX_LOOPS=-1):
            result = client.get_multi([key], missing=missing, deferred=deferred)

        # Make sure we have no results, even though the connection has been
        # set up as in `test_hit` to return a single result.
        self.assertEqual(result, [])
        self.assertEqual(missing, [])
        self.assertEqual(deferred, [])
Exemplo n.º 20
0
    def test_get_multi_hit_multiple_keys_different_project(self):
        from gcloud.datastore.key import Key

        PROJECT1 = 'PROJECT'
        PROJECT2 = 'PROJECT-ALT'

        # Make sure our IDs are actually different.
        self.assertNotEqual(PROJECT1, PROJECT2)

        key1 = Key('KIND', 1234, project=PROJECT1)
        key2 = Key('KIND', 1234, project=PROJECT2)

        creds = object()
        client = self._makeOne(credentials=creds)

        with self.assertRaises(ValueError):
            client.get_multi([key1, key2])
Exemplo n.º 21
0
    def test_get_multi_hit_multiple_keys_different_project(self):
        from gcloud.datastore.key import Key

        PROJECT1 = "PROJECT"
        PROJECT2 = "PROJECT-ALT"

        # Make sure our IDs are actually different.
        self.assertNotEqual(PROJECT1, PROJECT2)

        key1 = Key("KIND", 1234, project=PROJECT1)
        key2 = Key("KIND", 1234, project=PROJECT2)

        creds = object()
        client = self._makeOne(credentials=creds)

        with self.assertRaises(ValueError):
            client.get_multi([key1, key2])
Exemplo n.º 22
0
    def test_get_multi_miss(self):
        from gcloud.datastore.key import Key

        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result()
        key = Key("Kind", 1234, project=self.PROJECT)
        results = client.get_multi([key])
        self.assertEqual(results, [])
Exemplo n.º 23
0
    def test_get_multi_miss(self):
        from gcloud.datastore.key import Key

        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result()
        key = Key('Kind', 1234, project=self.PROJECT)
        results = client.get_multi([key])
        self.assertEqual(results, [])
Exemplo n.º 24
0
    def test_get_multi_miss(self):
        from gcloud.datastore.key import Key

        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result()
        key = Key('Kind', 1234, dataset_id=self.DATASET_ID)
        results = client.get_multi([key])
        self.assertEqual(results, [])
Exemplo n.º 25
0
    def test_get_multi_miss(self):
        from gcloud.datastore.key import Key
        from gcloud.datastore.test_connection import _Connection

        connection = _Connection()
        client = self._makeOne(connection=connection)
        key = Key('Kind', 1234, dataset_id=self.DATASET_ID)
        results = client.get_multi([key])
        self.assertEqual(results, [])
Exemplo n.º 26
0
    def test_get_multi_w_deferred_from_backend_but_not_passed(self):
        from gcloud.datastore._generated import entity_pb2
        from gcloud.datastore.entity import Entity
        from gcloud.datastore.key import Key

        key1 = Key("Kind", project=self.PROJECT)
        key1_pb = key1.to_protobuf()
        key2 = Key("Kind", 2345, project=self.PROJECT)
        key2_pb = key2.to_protobuf()

        entity1_pb = entity_pb2.Entity()
        entity1_pb.key.CopyFrom(key1_pb)
        entity2_pb = entity_pb2.Entity()
        entity2_pb.key.CopyFrom(key2_pb)

        creds = object()
        client = self._makeOne(credentials=creds)
        # mock up two separate requests
        client.connection._add_lookup_result([entity1_pb], deferred=[key2_pb])
        client.connection._add_lookup_result([entity2_pb])

        missing = []
        found = client.get_multi([key1, key2], missing=missing)
        self.assertEqual(len(found), 2)
        self.assertEqual(len(missing), 0)

        # Check the actual contents on the response.
        self.assertTrue(isinstance(found[0], Entity))
        self.assertEqual(found[0].key.path, key1.path)
        self.assertEqual(found[0].key.project, key1.project)

        self.assertTrue(isinstance(found[1], Entity))
        self.assertEqual(found[1].key.path, key2.path)
        self.assertEqual(found[1].key.project, key2.project)

        cw = client.connection._lookup_cw
        self.assertEqual(len(cw), 2)

        ds_id, k_pbs, eventual, tid = cw[0]
        self.assertEqual(ds_id, self.PROJECT)
        self.assertEqual(len(k_pbs), 2)
        self.assertEqual(key1_pb, k_pbs[0])
        self.assertEqual(key2_pb, k_pbs[1])
        self.assertFalse(eventual)
        self.assertTrue(tid is None)

        ds_id, k_pbs, eventual, tid = cw[1]
        self.assertEqual(ds_id, self.PROJECT)
        self.assertEqual(len(k_pbs), 1)
        self.assertEqual(key2_pb, k_pbs[0])
        self.assertFalse(eventual)
        self.assertTrue(tid is None)
Exemplo n.º 27
0
    def test_get_multi_w_deferred_from_backend_but_not_passed(self):
        from gcloud.datastore._generated import entity_pb2
        from gcloud.datastore.entity import Entity
        from gcloud.datastore.key import Key

        key1 = Key('Kind', project=self.PROJECT)
        key1_pb = key1.to_protobuf()
        key2 = Key('Kind', 2345, project=self.PROJECT)
        key2_pb = key2.to_protobuf()

        entity1_pb = entity_pb2.Entity()
        entity1_pb.key.CopyFrom(key1_pb)
        entity2_pb = entity_pb2.Entity()
        entity2_pb.key.CopyFrom(key2_pb)

        creds = object()
        client = self._makeOne(credentials=creds)
        # mock up two separate requests
        client.connection._add_lookup_result([entity1_pb], deferred=[key2_pb])
        client.connection._add_lookup_result([entity2_pb])

        missing = []
        found = client.get_multi([key1, key2], missing=missing)
        self.assertEqual(len(found), 2)
        self.assertEqual(len(missing), 0)

        # Check the actual contents on the response.
        self.assertTrue(isinstance(found[0], Entity))
        self.assertEqual(found[0].key.path, key1.path)
        self.assertEqual(found[0].key.project, key1.project)

        self.assertTrue(isinstance(found[1], Entity))
        self.assertEqual(found[1].key.path, key2.path)
        self.assertEqual(found[1].key.project, key2.project)

        cw = client.connection._lookup_cw
        self.assertEqual(len(cw), 2)

        ds_id, k_pbs, eventual, tid = cw[0]
        self.assertEqual(ds_id, self.PROJECT)
        self.assertEqual(len(k_pbs), 2)
        self.assertEqual(key1_pb, k_pbs[0])
        self.assertEqual(key2_pb, k_pbs[1])
        self.assertFalse(eventual)
        self.assertTrue(tid is None)

        ds_id, k_pbs, eventual, tid = cw[1]
        self.assertEqual(ds_id, self.PROJECT)
        self.assertEqual(len(k_pbs), 1)
        self.assertEqual(key2_pb, k_pbs[0])
        self.assertFalse(eventual)
        self.assertTrue(tid is None)
Exemplo n.º 28
0
    def test_get_multi_miss_w_deferred(self):
        from gcloud.datastore.key import Key

        key = Key("Kind", 1234, project=self.PROJECT)

        # Set deferred entity on mock connection.
        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result(deferred=[key.to_protobuf()])

        deferred = []
        entities = client.get_multi([key], deferred=deferred)
        self.assertEqual(entities, [])
        self.assertEqual([def_key.to_protobuf() for def_key in deferred], [key.to_protobuf()])
Exemplo n.º 29
0
    def test_get_multi_miss_w_deferred(self):
        from gcloud.datastore.key import Key

        key = Key('Kind', 1234, project=self.PROJECT)

        # Set deferred entity on mock connection.
        creds = object()
        client = self._makeOne(credentials=creds)
        client.connection._add_lookup_result(deferred=[key.to_protobuf()])

        deferred = []
        entities = client.get_multi([key], deferred=deferred)
        self.assertEqual(entities, [])
        self.assertEqual([def_key.to_protobuf() for def_key in deferred],
                         [key.to_protobuf()])
Exemplo n.º 30
0
    def test_get_multi_miss_w_deferred(self):
        from gcloud.datastore.key import Key
        from gcloud.datastore.test_connection import _Connection

        key = Key('Kind', 1234, dataset_id=self.DATASET_ID)

        # Set deferred entity on mock connection.
        connection = _Connection()
        connection._deferred = [key.to_protobuf()]
        client = self._makeOne(connection=connection)

        deferred = []
        entities = client.get_multi([key], deferred=deferred)
        self.assertEqual(entities, [])
        self.assertEqual([def_key.to_protobuf() for def_key in deferred],
                         [key.to_protobuf()])
Exemplo n.º 31
0
 def test_get_multi_no_keys(self):
     creds = object()
     client = self._makeOne(credentials=creds)
     results = client.get_multi([])
     self.assertEqual(results, [])
Exemplo n.º 32
0
    def test_get_multi_w_deferred_from_backend_but_not_passed(self):
        from gcloud.datastore import _datastore_v1_pb2 as datastore_pb
        from gcloud.datastore.connection import Connection
        from gcloud.datastore.key import Key
        from gcloud.datastore import test_connection

        # Shortening name, import line above was too long.
        cmp_key_after_req = test_connection._compare_key_pb_after_request

        key1 = Key('Kind', dataset_id=self.DATASET_ID)
        key2 = Key('Kind', 2345, dataset_id=self.DATASET_ID)
        key_pb1 = key1.to_protobuf()
        key_pb2 = key2.to_protobuf()

        # Build mock first response.
        rsp_pb1 = datastore_pb.LookupResponse()
        entity1 = datastore_pb.Entity()
        entity1.key.CopyFrom(key_pb1)
        # Add the entity to the "found" part of the response.
        rsp_pb1.found.add(entity=entity1)
        # Add the second key to the "deferred" part of the response.
        rsp_pb1.deferred.add().CopyFrom(key_pb2)

        # Build mock second response.
        rsp_pb2 = datastore_pb.LookupResponse()
        # Add in entity that was deferred.
        entity2 = datastore_pb.Entity()
        entity2.key.CopyFrom(key_pb2)
        rsp_pb2.found.add(entity=entity2)

        connection = Connection()
        client = self._makeOne(connection=connection)
        # Add mock http object to connection with response from above.
        http = connection._http = _HttpMultiple(
            ({'status': '200'}, rsp_pb1.SerializeToString()),
            ({'status': '200'}, rsp_pb2.SerializeToString()),
        )

        missing = []
        found = client.get_multi([key1, key2], missing=missing)
        self.assertEqual(len(found), 2)
        self.assertEqual(len(missing), 0)

        # Check the actual contents on the response.
        self.assertEqual(found[0].key.path, key1.path)
        self.assertEqual(found[0].key.dataset_id, key1.dataset_id)
        self.assertEqual(found[1].key.path, key2.path)
        self.assertEqual(found[1].key.dataset_id, key2.dataset_id)

        # Check that our http object was called correctly.
        cw = http._called_with
        rq_class = datastore_pb.LookupRequest
        request = rq_class()
        self.assertEqual(len(cw), 2)

        # Make URI to check for requests.
        URI = '/'.join([
            connection.api_base_url,
            'datastore',
            connection.API_VERSION,
            'datasets',
            self.DATASET_ID,
            'lookup',
        ])

        # Make sure the first called with argument checks out.
        self._verifyProtobufCall(cw[0], URI, connection)
        request.ParseFromString(cw[0]['body'])
        keys = list(request.key)
        self.assertEqual(len(keys), 2)
        cmp_key_after_req(self, key_pb1, keys[0])
        cmp_key_after_req(self, key_pb2, keys[1])

        # Make sure the second called with argument checks out.
        self._verifyProtobufCall(cw[1], URI, connection)
        request.ParseFromString(cw[1]['body'])
        keys = list(request.key)
        self.assertEqual(len(keys), 1)
        cmp_key_after_req(self, key_pb2, keys[0])
Exemplo n.º 33
0
 def test_get_multi_no_keys(self):
     creds = object()
     client = self._makeOne(credentials=creds)
     results = client.get_multi([])
     self.assertEqual(results, [])
Exemplo n.º 34
0
 def test_get_multi_no_keys(self):
     connection = object()
     client = self._makeOne(connection=connection)
     results = client.get_multi([])
     self.assertEqual(results, [])