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_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_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_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_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()])
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_miss_w_deferred(self):
from gcloud.datastore.key import Key
from gcloud.datastore.test_connection import _Connection
DATASET_ID = 'DATASET'
key = Key('Kind', 1234, dataset_id=DATASET_ID)
# Set deferred entity on mock connection.
connection = _Connection()
connection._deferred = [key.to_protobuf()]
deferred = []
entities = self._callFUT([key], connection=connection,
deferred=deferred, dataset_id=DATASET_ID)
self.assertEqual(entities, [])
self.assertEqual([def_key.to_protobuf() for def_key in deferred],
[key.to_protobuf()])
def test_key(self):
from gcloud.datastore.key import Key
pb = self._makePB()
key = Key('KIND', 1234, project='PROJECT')
self._callFUT(pb, key)
value = pb.key_value
self.assertEqual(value, 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_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_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_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_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_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 test_miss_wo_dataset_id(self):
from gcloud.datastore.key import Key
from gcloud.datastore.test_connection import _Connection
DATASET_ID = 'DATASET'
connection = _Connection()
key = Key('Kind', 1234, dataset_id=DATASET_ID)
results = self._callFUT([key], connection=connection)
self.assertEqual(results, [])
expected = {
'dataset_id': DATASET_ID,
'key_pbs': [key.to_protobuf()],
'transaction_id': None,
'eventual': False,
}
self.assertEqual(connection._called_with, expected)
def test_filter_key(self):
from gcloud.datastore.key import Key
from gcloud.datastore._generated import query_pb2
key = Key('Kind', 123, project='PROJECT')
query = _Query(filters=[('__key__', '=', key)])
query.OPERATORS = {
'=': query_pb2.PropertyFilter.EQUAL,
}
pb = self._callFUT(query)
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__')
key_pb = key.to_protobuf()
self.assertEqual(pfilter.value.key_value, key_pb)
def test_filter_key(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
key = Key('Kind', 123, dataset_id='DATASET')
query = _Query(filters=[('__key__', '=', key)])
query.OPERATORS = {
'=': datastore_pb.PropertyFilter.EQUAL,
}
pb = self._callFUT(query)
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__')
key_pb = _prepare_key_for_request(key.to_protobuf())
self.assertEqual(pfilter.value.key_value, key_pb)
def test_filter_key(self):
from gcloud.datastore.key import Key
from gcloud.datastore._generated import query_pb2
key = Key('Kind', 123, project='PROJECT')
query = _Query(filters=[('__key__', '=', key)])
query.OPERATORS = {
'=': query_pb2.PropertyFilter.EQUAL,
}
pb = self._callFUT(query)
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__')
key_pb = key.to_protobuf()
self.assertEqual(pfilter.value.key_value, key_pb)
def test_filter_key(self):
from gcloud.datastore.key import Key
from gcloud.datastore.helpers import _prepare_key_for_request
from gcloud.datastore._generated import query_pb2
key = Key('Kind', 123, dataset_id='DATASET')
query = _Query(filters=[('__key__', '=', key)])
query.OPERATORS = {
'=': query_pb2.PropertyFilter.EQUAL,
}
pb = self._callFUT(query)
cfilter = pb.filter.composite_filter
self.assertEqual(cfilter.operator, query_pb2.CompositeFilter.AND)
self.assertEqual(len(cfilter.filter), 1)
pfilter = cfilter.filter[0].property_filter
self.assertEqual(pfilter.property.name, '__key__')
key_pb = _prepare_key_for_request(key.to_protobuf())
self.assertEqual(pfilter.value.key_value, key_pb)
def test_entity_w_key(self):
from gcloud.datastore.entity import Entity
from gcloud.datastore.helpers import _property_tuples
from gcloud.datastore.key import Key
name = 'foo'
value = u'Foo'
pb = self._makePB()
key = Key('KIND', 123, project='PROJECT')
entity = Entity(key=key)
entity[name] = value
self._callFUT(pb, entity)
entity_pb = pb.entity_value
self.assertEqual(entity_pb.key, key.to_protobuf())
prop_dict = dict(_property_tuples(entity_pb))
self.assertEqual(len(prop_dict), 1)
self.assertEqual(list(prop_dict.keys()), [name])
self.assertEqual(prop_dict[name].string_value, value)
def test_entity_w_key(self):
from gcloud.datastore.entity import Entity
from gcloud.datastore.helpers import _property_tuples
from gcloud.datastore.key import Key
name = 'foo'
value = u'Foo'
pb = self._makePB()
key = Key('KIND', 123, project='PROJECT')
entity = Entity(key=key)
entity[name] = value
self._callFUT(pb, entity)
entity_pb = pb.entity_value
self.assertEqual(entity_pb.key, key.to_protobuf())
prop_dict = dict(_property_tuples(entity_pb))
self.assertEqual(len(prop_dict), 1)
self.assertEqual(list(prop_dict.keys()), [name])
self.assertEqual(prop_dict[name].string_value, value)
def test_ancestor_wo_existing_ancestor_query_w_key_and_propfilter(self):
from gcloud.datastore.key import Key
_KIND = 'KIND'
_ID = 123
_NAME = u'NAME'
key = Key(path=[{'kind': _KIND, 'id': _ID}])
query = self._makeOne().filter('name', '=', _NAME)
after = query.ancestor(key)
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
n_pb, f_pb, = list(q_pb.filter.composite_filter.filter)
p_pb = n_pb.property_filter
self.assertEqual(p_pb.property.name, 'name')
self.assertEqual(p_pb.value.string_value, _NAME)
p_pb = f_pb.property_filter
self.assertEqual(p_pb.property.name, '__key__')
self.assertEqual(p_pb.value.key_value, key.to_protobuf())
def test_get_entities_miss_w_missing(self):
from gcloud.datastore.connection import datastore_pb
from gcloud.datastore.key import Key
DATASET_ID = 'DATASET'
KIND = 'Kind'
ID = 1234
PATH = [{'kind': KIND, 'id': ID}]
missed = datastore_pb.Entity()
missed.key.partition_id.dataset_id = DATASET_ID
path_element = missed.key.path_element.add()
path_element.kind = KIND
path_element.id = ID
connection = _Connection()
connection._missing = [missed]
dataset = self._makeOne(DATASET_ID, connection)
key = Key(path=PATH, dataset_id=DATASET_ID)
missing = []
entities = dataset.get_entities([key], missing=missing)
self.assertEqual(entities, [])
self.assertEqual([missed.key().to_protobuf() for missed in missing],
[key.to_protobuf()])
def test_get_entities_miss_w_missing(self):
from gcloud.datastore.connection import datastore_pb
from gcloud.datastore.key import Key
DATASET_ID = 'DATASET'
KIND = 'Kind'
ID = 1234
PATH = [{'kind': KIND, 'id': ID}]
missed = datastore_pb.Entity()
missed.key.partition_id.dataset_id = DATASET_ID
path_element = missed.key.path_element.add()
path_element.kind = KIND
path_element.id = ID
connection = _Connection()
connection._missing = [missed]
dataset = self._makeOne(DATASET_ID, connection)
key = Key(path=PATH, dataset_id=DATASET_ID)
missing = []
entities = dataset.get_entities([key], missing=missing)
self.assertEqual(entities, [])
self.assertEqual([missed.key().to_protobuf() for missed in missing],
[key.to_protobuf()])
def test_implicit_wo_transaction(self):
from gcloud.datastore import _implicit_environ
from gcloud.datastore.key import Key
from gcloud.datastore.test_connection import _Connection
from gcloud._testing import _Monkey
DATASET_ID = 'DATASET'
KIND = 'Kind'
ID = 1234
PATH = [{'kind': KIND, 'id': ID}]
# Make a found entity pb to be returned from mock backend.
entity_pb = self._make_entity_pb(DATASET_ID, KIND, ID,
'foo', 'Foo')
# Make a connection to return the entity pb.
CUSTOM_CONNECTION = _Connection(entity_pb)
key = Key(KIND, ID, dataset_id=DATASET_ID)
with _Monkey(_implicit_environ, CONNECTION=CUSTOM_CONNECTION,
DATASET_ID=DATASET_ID):
result, = self._callFUT([key])
expected_called_with = {
'dataset_id': DATASET_ID,
'key_pbs': [key.to_protobuf()],
'transaction_id': None,
'eventual': False,
}
self.assertEqual(CUSTOM_CONNECTION._called_with, expected_called_with)
new_key = result.key
# Check the returned value is as expected.
self.assertFalse(new_key is key)
self.assertEqual(new_key.dataset_id, DATASET_ID)
self.assertEqual(new_key.path, PATH)
self.assertEqual(list(result), ['foo'])
self.assertEqual(result['foo'], 'Foo')
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])
