Python key.Key类代码示例

    def test_key(self):
        from gcloud.datastore.key import Key

        key = Key('PATH', 1234, project='PROJECT')
        name, value = self._callFUT(key)
        self.assertEqual(name, 'key_value')
        self.assertEqual(value, key.to_protobuf())

    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()])

    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()])

 def test_key(self):
     from gcloud.datastore.dataset import Dataset
     from gcloud.datastore.key import Key
     _DATASET = 'DATASET'
     _KIND = 'KIND'
     _ID = 1234
     _PATH = [{'kind': _KIND, 'id': _ID}]
     key = Key(dataset=Dataset(_DATASET), path=_PATH)
     name, value = self._callFUT(key)
     self.assertEqual(name, 'key_value')
     self.assertEqual(value, key.to_protobuf())

    def test_from_key_wo_dataset(self):
        from gcloud.datastore.key import Key

        klass = self._getTargetClass()
        key = Key().kind(_KIND).id(_ID)
        entity = klass.from_key(key)
        self.assertTrue(entity.dataset() is None)
        self.assertEqual(entity.kind(), _KIND)
        key = entity.key()
        self.assertEqual(key.kind(), _KIND)
        self.assertEqual(key.id(), _ID)

    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)

    def test_from_key(self):
        from gcloud.datastore.dataset import Dataset
        from gcloud.datastore.key import Key

        klass = self._getTargetClass()
        dataset = Dataset(_DATASET_ID)
        key = Key(dataset=dataset).kind(_KIND).id(_ID)
        entity = klass.from_key(key)
        self.assertTrue(entity.dataset() is dataset)
        self.assertEqual(entity.kind(), _KIND)
        key = entity.key()
        self.assertEqual(key.kind(), _KIND)
        self.assertEqual(key.id(), _ID)

    def test_ancestor(self):
        from gcloud.datastore.key import Key
        from gcloud.datastore._generated import query_pb2

        ancestor = Key('Ancestor', 123, project='PROJECT')
        pb = self._callFUT(_Query(ancestor=ancestor))
        cfilter = pb.filter.composite_filter
        self.assertEqual(cfilter.op, query_pb2.CompositeFilter.AND)
        self.assertEqual(len(cfilter.filters), 1)
        pfilter = cfilter.filters[0].property_filter
        self.assertEqual(pfilter.property.name, '__key__')
        ancestor_pb = ancestor.to_protobuf()
        self.assertEqual(pfilter.value.key_value, ancestor_pb)

 def test_ancestor(self):
     from gcloud.datastore import _datastore_v1_pb2 as datastore_pb
     from gcloud.datastore.key import Key
     from gcloud.datastore.helpers import _prepare_key_for_request
     ancestor = Key('Ancestor', 123, dataset_id='DATASET')
     pb = self._callFUT(_Query(ancestor=ancestor))
     cfilter = pb.filter.composite_filter
     self.assertEqual(cfilter.operator, datastore_pb.CompositeFilter.AND)
     self.assertEqual(len(cfilter.filter), 1)
     pfilter = cfilter.filter[0].property_filter
     self.assertEqual(pfilter.property.name, '__key__')
     ancestor_pb = _prepare_key_for_request(ancestor.to_protobuf())
     self.assertEqual(pfilter.value.key_value, ancestor_pb)

    def test_key(self):
        from gcloud.datastore.dataset import Dataset
        from gcloud.datastore.key import Key

        _DATASET = 'DATASET'
        _KIND = 'KIND'
        _ID = 1234
        _PATH = [{'kind': _KIND, 'id': _ID}]
        pb = self._makePB()
        key = Key(dataset=Dataset(_DATASET), path=_PATH)
        self._callFUT(pb, key)
        value = pb.key_value
        self.assertEqual(value, key.to_protobuf())

    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()])

    def test_entity_w_key(self):
        from gcloud.datastore.entity import Entity
        from gcloud.datastore.key import Key

        pb = self._makePB()
        key = Key(path=[{'kind': 'KIND', 'id': 123}])
        entity = Entity().key(key)
        entity['foo'] = 'Foo'
        self._callFUT(pb, entity)
        value = pb.entity_value
        self.assertEqual(value.key, key.to_protobuf())
        props = list(value.property)
        self.assertEqual(len(props), 1)
        self.assertEqual(props[0].name, 'foo')
        self.assertEqual(props[0].value.string_value, 'Foo')

 def test_get_entities_miss_w_deferred(self):
     from gcloud.datastore.key import Key
     DATASET_ID = 'DATASET'
     KIND = 'Kind'
     ID = 1234
     PATH = [{'kind': KIND, 'id': ID}]
     connection = _Connection()
     dataset = self._makeOne(DATASET_ID, connection)
     key = Key(path=PATH, dataset_id=DATASET_ID)
     connection._deferred = [key.to_protobuf()]
     deferred = []
     entities = dataset.get_entities([key], deferred=deferred)
     self.assertEqual(entities, [])
     self.assertEqual([def_key.to_protobuf() for def_key in deferred],
                      [key.to_protobuf()])

 def test_ancester_wo_existing_ancestor_query_w_list(self):
     from gcloud.datastore.key import Key
     _KIND = 'KIND'
     _ID = 123
     key = Key(path=[{'kind': _KIND, 'id': _ID}])
     query = self._makeOne()
     after = query.ancestor([_KIND, _ID])
     self.assertFalse(after is query)
     self.assertTrue(isinstance(after, self._getTargetClass()))
     q_pb = after.to_protobuf()
     self.assertEqual(q_pb.filter.composite_filter.operator, 1) # AND
     f_pb, = list(q_pb.filter.composite_filter.filter)
     p_pb = f_pb.property_filter
     self.assertEqual(p_pb.property.name, '__key__')
     self.assertEqual(p_pb.value.key_value, key.to_protobuf())

    def save(self):
        """Save the entity in the Cloud Datastore.

        :rtype: :class:`gcloud.datastore.entity.Entity`
        :returns: The entity with a possibly updated Key.
        """
        # pylint: disable=maybe-no-member
        key_pb = self.dataset().connection().save_entity(
            dataset_id=self.dataset().id(),
            key_pb=self.key().to_protobuf(), properties=dict(self))
        # pylint: enable=maybe-no-member

        # If we are in a transaction and the current entity needs an
        # automatically assigned ID, tell the transaction where to put that.
        transaction = self.dataset().connection().transaction()
        # pylint: disable=maybe-no-member
        if transaction and self.key().is_partial():
            transaction.add_auto_id_entity(self)
        # pylint: enable=maybe-no-member

        if isinstance(key_pb, datastore_pb.Key):
            updated_key = Key.from_protobuf(key_pb)
            # Update the path (which may have been altered).
            # pylint: disable=maybe-no-member
            key = self.key().path(updated_key.path())
            # pylint: enable=maybe-no-member
            self.key(key)

        return self