def test_no_batch_w_partial_key(self):
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
connection = _Connection()
entity = _Entity(foo=u'bar')
key = entity.key = _Key(_DATASET)
key._id = None
result = self._callFUT([entity], connection=connection,
dataset_id=_DATASET)
self.assertEqual(result, None)
self.assertEqual(len(connection._committed), 1)
dataset_id, mutation, transaction_id = connection._committed[0]
self.assertEqual(dataset_id, _DATASET)
inserts = list(mutation.insert_auto_id)
self.assertEqual(len(inserts), 1)
self.assertEqual(inserts[0].key, key.to_protobuf())
properties = list(inserts[0].property)
self.assertEqual(properties[0].name, 'foo')
self.assertEqual(properties[0].value.string_value, u'bar')
self.assertTrue(transaction_id is None)
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_implicit_connection_and_dataset_id(self):
from gcloud._testing import _Monkey
from gcloud.datastore import _implicit_environ
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
connection = _Connection()
key = _Key(_DATASET)
with _Monkey(_implicit_environ,
CONNECTION=connection,
DATASET_ID=_DATASET):
# Set up Batch on stack so we can check it is used.
with _NoCommitBatch(_DATASET, connection) as CURR_BATCH:
result = self._callFUT([key])
self.assertEqual(result, None)
self.assertEqual(len(CURR_BATCH.mutation.insert_auto_id), 0)
self.assertEqual(len(CURR_BATCH.mutation.upsert), 0)
deletes = list(CURR_BATCH.mutation.delete)
self.assertEqual(len(deletes), 1)
self.assertEqual(deletes[0], key._key)
self.assertEqual(len(connection._committed), 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')
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), {})
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, [])
def test_no_dataset_id(self):
from gcloud.datastore import _implicit_environ
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
connection = _Connection()
entity = _Entity(foo=u'bar')
entity.key = _Key(_DATASET)
self.assertEqual(_implicit_environ.get_default_connection(), None)
result = self._callFUT([entity], connection=connection)
self.assertEqual(result, None)
self.assertEqual(len(connection._committed), 1)
dataset_id, mutation, transaction_id = connection._committed[0]
self.assertEqual(dataset_id, _DATASET)
upserts = list(mutation.upsert)
self.assertEqual(len(upserts), 1)
self.assertEqual(upserts[0].key, entity.key.to_protobuf())
properties = list(upserts[0].property)
self.assertEqual(properties[0].name, 'foo')
self.assertEqual(properties[0].value.string_value, u'bar')
self.assertTrue(transaction_id is None)
def test_implicit_connection(self):
from gcloud.datastore._testing import _monkey_defaults
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
connection = _Connection()
entity = _Entity(foo=u'bar')
key = entity.key = _Key(_DATASET)
with _monkey_defaults(connection=connection):
# Set up Batch on stack so we can check it is used.
with _NoCommitBatch(_DATASET, connection) as CURR_BATCH:
result = self._callFUT(entity)
self.assertEqual(result, None)
self.assertEqual(len(CURR_BATCH.mutation.insert_auto_id), 0)
self.assertEqual(len(CURR_BATCH.mutation.upsert), 1)
upserts = list(CURR_BATCH.mutation.upsert)
self.assertEqual(len(upserts), 1)
self.assertEqual(upserts[0].key, key.to_protobuf())
properties = list(upserts[0].property)
self.assertEqual(properties[0].name, 'foo')
self.assertEqual(properties[0].value.string_value, u'bar')
self.assertEqual(len(CURR_BATCH.mutation.delete), 0)
def test_allocate_ids_with_completed_key(self):
from gcloud.datastore.test_batch import _Key
from gcloud.datastore.test_connection import _Connection
connection = _Connection()
client = self._makeOne(connection=connection)
COMPLETE_KEY = _Key(self.DATASET_ID)
self.assertRaises(ValueError, client.allocate_ids, COMPLETE_KEY, 2)
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, [])
def test_miss(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)
result = self._callFUT(key, connection=connection,
dataset_id=DATASET_ID)
self.assertTrue(result is None)
def test_miss(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,
dataset_id=DATASET_ID)
self.assertEqual(results, [])
def test_with_already_completed_key(self):
from gcloud.datastore._testing import _monkey_defaults
from gcloud.datastore.key import Key
from gcloud.datastore.test_connection import _Connection
CUSTOM_CONNECTION = _Connection()
with _monkey_defaults(connection=CUSTOM_CONNECTION,
dataset_id='DATASET'):
COMPLETE_KEY = Key('KIND', 1234)
self.assertRaises(ValueError, self._callFUT,
COMPLETE_KEY, 2)
def test_with_already_completed_key(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
CUSTOM_CONNECTION = _Connection()
with _Monkey(_implicit_environ, CONNECTION=CUSTOM_CONNECTION,
DATASET_ID='DATASET'):
COMPLETE_KEY = Key('KIND', 1234)
self.assertRaises(ValueError, self._callFUT,
COMPLETE_KEY, 2)
def test_w_implicit_connection(self):
from gcloud.datastore._testing import _monkey_defaults
from gcloud.datastore.key import Key
from gcloud.datastore.test_connection import _Connection
CUSTOM_CONNECTION = _Connection()
NUM_IDS = 2
with _monkey_defaults(connection=CUSTOM_CONNECTION,
dataset_id='DATASET'):
INCOMPLETE_KEY = Key('KIND')
result = self._callFUT(INCOMPLETE_KEY, NUM_IDS)
# Check the IDs returned.
self.assertEqual([key.id for key in result], list(range(NUM_IDS)))
def test_allocate_ids_w_partial_key(self):
from gcloud.datastore.test_batch import _Key
from gcloud.datastore.test_connection import _Connection
connection = _Connection()
client = self._makeOne(connection=connection)
NUM_IDS = 2
INCOMPLETE_KEY = _Key(self.DATASET_ID)
INCOMPLETE_KEY._id = None
result = client.allocate_ids(INCOMPLETE_KEY, NUM_IDS)
# Check the IDs returned.
self.assertEqual([key._id for key in result], list(range(NUM_IDS)))
def test_delete_multi_no_batch(self):
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Key
connection = _Connection()
client = self._makeOne(connection=connection)
key = _Key(self.DATASET_ID)
result = client.delete_multi([key])
self.assertEqual(result, None)
self.assertEqual(len(connection._committed), 1)
dataset_id, mutation, transaction_id = connection._committed[0]
self.assertEqual(dataset_id, self.DATASET_ID)
self.assertEqual(list(mutation.delete), [key.to_protobuf()])
self.assertTrue(transaction_id is None)
def test_w_explicit_connection(self):
from gcloud.datastore.key import Key
from gcloud.datastore.test_connection import _Connection
DATASET_ID = 'DATASET'
INCOMPLETE_KEY = Key('KIND', dataset_id=DATASET_ID)
CONNECTION = _Connection()
NUM_IDS = 2
result = self._callFUT(INCOMPLETE_KEY, NUM_IDS, connection=CONNECTION)
# Check the IDs returned match.
self.assertEqual([key.id for key in result], list(range(NUM_IDS)))
# Check connection is called correctly.
self.assertEqual(CONNECTION._called_dataset_id, DATASET_ID)
self.assertEqual(len(CONNECTION._called_key_pbs), NUM_IDS)
def test_no_batch(self):
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
connection = _Connection()
key = _Key(_DATASET)
result = self._callFUT(key, connection=connection,
dataset_id=_DATASET)
self.assertEqual(result, None)
self.assertEqual(len(connection._committed), 1)
dataset_id, mutation = connection._committed[0]
self.assertEqual(dataset_id, _DATASET)
self.assertEqual(list(mutation.delete), [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_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_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_delete_multi_w_existing_transaction(self):
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Key
connection = _Connection()
client = self._makeOne(connection=connection)
key = _Key(self.DATASET_ID)
with _NoCommitTransaction(client) as CURR_XACT:
result = client.delete_multi([key])
self.assertEqual(result, None)
self.assertEqual(len(CURR_XACT.mutation.insert_auto_id), 0)
self.assertEqual(len(CURR_XACT.mutation.upsert), 0)
deletes = list(CURR_XACT.mutation.delete)
self.assertEqual(len(deletes), 1)
self.assertEqual(deletes[0], key._key)
self.assertEqual(len(connection._committed), 0)
def test_wo_batch_w_key_different_than_default_dataset_id(self):
from gcloud.datastore._testing import _monkey_defaults
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DEFAULT_DATASET = 'DEFAULT'
_DATASET = 'DATASET'
connection = _Connection()
key = _Key(_DATASET)
with _monkey_defaults(connection=connection,
dataset_id=_DEFAULT_DATASET):
result = self._callFUT([key])
self.assertEqual(result, None)
self.assertEqual(len(connection._committed), 1)
dataset_id, mutation = connection._committed[0]
self.assertEqual(dataset_id, _DATASET)
self.assertEqual(list(mutation.delete), [key.to_protobuf()])
def test_no_dataset_id(self):
from gcloud.datastore import _implicit_environ
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
connection = _Connection()
key = _Key(_DATASET)
self.assertEqual(_implicit_environ.get_default_connection(), None)
result = self._callFUT([key], connection=connection)
self.assertEqual(result, None)
self.assertEqual(len(connection._committed), 1)
dataset_id, mutation, transaction_id = connection._committed[0]
self.assertEqual(dataset_id, _DATASET)
self.assertEqual(list(mutation.delete), [key.to_protobuf()])
self.assertTrue(transaction_id is None)
def test_w_existing_transaction(self):
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
connection = _Connection()
key = _Key(_DATASET)
# Set up Batch on stack so we can check it is used.
with _NoCommitTransaction(_DATASET, connection) as CURR_BATCH:
result = self._callFUT([key])
self.assertEqual(result, None)
self.assertEqual(len(CURR_BATCH.mutation.insert_auto_id), 0)
self.assertEqual(len(CURR_BATCH.mutation.upsert), 0)
deletes = list(CURR_BATCH.mutation.delete)
self.assertEqual(len(deletes), 1)
self.assertEqual(deletes[0], key._key)
self.assertEqual(len(connection._committed), 0)
def test_put_multi_existing_batch_w_completed_key(self):
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
connection = _Connection()
client = self._makeOne(connection=connection)
entity = _Entity(foo=u'bar')
key = entity.key = _Key(self.DATASET_ID)
with _NoCommitBatch(client) as CURR_BATCH:
result = client.put_multi([entity])
self.assertEqual(result, None)
self.assertEqual(len(CURR_BATCH.mutation.insert_auto_id), 0)
upserts = list(CURR_BATCH.mutation.upsert)
self.assertEqual(len(upserts), 1)
self.assertEqual(upserts[0].key, key.to_protobuf())
properties = list(upserts[0].property)
self.assertEqual(properties[0].name, 'foo')
self.assertEqual(properties[0].value.string_value, u'bar')
self.assertEqual(len(CURR_BATCH.mutation.delete), 0)
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_put_multi_no_batch_w_partial_key(self):
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
connection = _Connection()
client = self._makeOne(connection=connection)
entity = _Entity(foo=u'bar')
key = entity.key = _Key(self.DATASET_ID)
key._id = None
result = client.put_multi([entity])
self.assertTrue(result is None)
self.assertEqual(len(connection._committed), 1)
dataset_id, mutation, transaction_id = connection._committed[0]
self.assertEqual(dataset_id, self.DATASET_ID)
inserts = list(mutation.insert_auto_id)
self.assertEqual(len(inserts), 1)
self.assertEqual(inserts[0].key, key.to_protobuf())
properties = list(inserts[0].property)
self.assertEqual(properties[0].name, 'foo')
self.assertEqual(properties[0].value.string_value, u'bar')
self.assertTrue(transaction_id is None)
def test_no_batch_w_partial_key(self):
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
connection = _Connection()
entity = _Entity(foo=u'bar')
key = entity.key = _Key(_DATASET)
key._id = None
result = self._callFUT([entity], connection=connection,
dataset_id=_DATASET)
self.assertEqual(result, None)
self.assertEqual(len(connection._committed), 1)
dataset_id, mutation = connection._committed[0]
self.assertEqual(dataset_id, _DATASET)
inserts = list(mutation.insert_auto_id)
self.assertEqual(len(inserts), 1)
self.assertEqual(inserts[0].key, key.to_protobuf())
properties = list(inserts[0].property)
self.assertEqual(properties[0].name, 'foo')
self.assertEqual(properties[0].value.string_value, u'bar')
def test_existing_batch_w_completed_key(self):
from gcloud.datastore.test_batch import _Connection
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
connection = _Connection()
entity = _Entity(foo=u'bar')
key = entity.key = _Key(_DATASET)
# Set up Batch on stack so we can check it is used.
with _NoCommitBatch(_DATASET, connection) as CURR_BATCH:
result = self._callFUT([entity], connection=connection)
self.assertEqual(result, None)
self.assertEqual(len(CURR_BATCH.mutation.insert_auto_id), 0)
upserts = list(CURR_BATCH.mutation.upsert)
self.assertEqual(len(upserts), 1)
self.assertEqual(upserts[0].key, key.to_protobuf())
properties = list(upserts[0].property)
self.assertEqual(properties[0].name, 'foo')
self.assertEqual(properties[0].value.string_value, u'bar')
self.assertEqual(len(CURR_BATCH.mutation.delete), 0)
