def test_id_implicit_set_passed_explicitly_w_keys(self):
from gcloud.datastore.test_batch import _Key
ID = 'DATASET'
IMPLICIT_ID = 'IMPLICIT'
OTHER = 'OTHER'
with self._monkey(IMPLICIT_ID):
self.assertEqual(self._callFUT(ID, first_key=_Key(OTHER)), ID)
def _make_key(self, dataset_id):
class _Key(object):
def __init__(self, dataset_id):
self.dataset_id = dataset_id
return _Key(dataset_id)
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_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_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_put_multi_no_batch_w_partial_key(self):
from gcloud.datastore.test_batch import _CommitResult
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
entity = _Entity(foo=u'bar')
key = entity.key = _Key(self.DATASET_ID)
key._id = None
creds = object()
client = self._makeOne(credentials=creds)
client.connection._commit.append(_CommitResult(key))
result = client.put_multi([entity])
self.assertTrue(result is None)
self.assertEqual(len(client.connection._commit_cw), 1)
dataset_id, mutation, transaction_id = client.connection._commit_cw[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_put_multi_no_batch_w_partial_key(self):
from gcloud.datastore.helpers import _property_tuples
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
from gcloud.datastore.test_batch import _KeyPB
entity = _Entity(foo=u'bar')
key = entity.key = _Key(self.DATASET_ID)
key._id = None
creds = object()
client = self._makeOne(credentials=creds)
client.connection._commit.append([_KeyPB(key)])
result = client.put_multi([entity])
self.assertTrue(result is None)
self.assertEqual(len(client.connection._commit_cw), 1)
(dataset_id,
commit_req, transaction_id) = client.connection._commit_cw[0]
self.assertEqual(dataset_id, self.DATASET_ID)
inserts = list(commit_req.mutation.insert_auto_id)
self.assertEqual(len(inserts), 1)
self.assertEqual(inserts[0].key, key.to_protobuf())
prop_list = list(_property_tuples(inserts[0]))
self.assertTrue(len(prop_list), 1)
name, value_pb = prop_list[0]
self.assertEqual(name, 'foo')
self.assertEqual(value_pb.string_value, u'bar')
self.assertTrue(transaction_id is None)
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 = 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')
def test_implicit_connection(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 _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(_implicit_environ, 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_put_multi_no_batch_w_partial_key(self):
from gcloud.datastore.test_batch import _CommitResult
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
entity = _Entity(foo=u'bar')
key = entity.key = _Key(self.DATASET_ID)
key._id = None
creds = object()
client = self._makeOne(credentials=creds)
client.connection._commit.append(_CommitResult(key))
result = client.put_multi([entity])
self.assertTrue(result is None)
self.assertEqual(len(client.connection._commit_cw), 1)
dataset_id, mutation, transaction_id = client.connection._commit_cw[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_implicit_unset_w_existing_transaction_w_keys(self):
from gcloud.datastore.test_batch import _Key
ID = 'DATASET'
OTHER = 'OTHER'
with self._monkey(None):
with _NoCommitTransaction(dataset_id=ID, connection=object()):
self.assertEqual(self._callFUT(first_key=_Key(OTHER)), ID)
def test_put_multi_no_batch_w_partial_key(self):
from gcloud.datastore.helpers import _property_tuples
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
from gcloud.datastore.test_batch import _KeyPB
entity = _Entity(foo=u'bar')
key = entity.key = _Key(self.PROJECT)
key._id = None
creds = object()
client = self._makeOne(credentials=creds)
client.connection._commit.append([_KeyPB(key)])
result = client.put_multi([entity])
self.assertTrue(result is None)
self.assertEqual(len(client.connection._commit_cw), 1)
(project, commit_req, transaction_id) = client.connection._commit_cw[0]
self.assertEqual(project, self.PROJECT)
inserts = list(commit_req.mutation.insert_auto_id)
self.assertEqual(len(inserts), 1)
self.assertEqual(inserts[0].key, key.to_protobuf())
prop_list = list(_property_tuples(inserts[0]))
self.assertTrue(len(prop_list), 1)
name, value_pb = prop_list[0]
self.assertEqual(name, 'foo')
self.assertEqual(value_pb.string_value, u'bar')
self.assertTrue(transaction_id is None)
def test_put_multi_no_batch_w_partial_key(self):
from gcloud.datastore.helpers import _property_tuples
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
from gcloud.datastore.test_batch import _KeyPB
from gcloud.datastore.test_batch import _mutated_pb
entity = _Entity(foo=u"bar")
key = entity.key = _Key(self.PROJECT)
key._id = None
creds = object()
client = self._makeOne(credentials=creds)
client.connection._commit.append([_KeyPB(key)])
result = client.put_multi([entity])
self.assertTrue(result is None)
self.assertEqual(len(client.connection._commit_cw), 1)
(project, commit_req, transaction_id) = client.connection._commit_cw[0]
self.assertEqual(project, self.PROJECT)
mutated_entity = _mutated_pb(self, commit_req.mutations, "insert")
self.assertEqual(mutated_entity.key, key.to_protobuf())
prop_list = list(_property_tuples(mutated_entity))
self.assertTrue(len(prop_list), 1)
name, value_pb = prop_list[0]
self.assertEqual(name, "foo")
self.assertEqual(value_pb.string_value, u"bar")
self.assertTrue(transaction_id is None)
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_unset_w_existing_transaction_w_keys(self):
from gcloud.datastore.test_batch import _Key
ID = 'DATASET'
OTHER = 'OTHER'
with self._monkey(None):
with _NoCommitTransaction(dataset_id=ID, connection=object()):
self.assertEqual(self._callFUT(first_key=_Key(OTHER)), ID)
def test_id_implicit_set_passed_explicitly_w_keys(self):
from gcloud.datastore.test_batch import _Key
ID = 'DATASET'
IMPLICIT_ID = 'IMPLICIT'
OTHER = 'OTHER'
with self._monkey(IMPLICIT_ID):
self.assertEqual(self._callFUT(ID, first_key=_Key(OTHER)), ID)
def test_allocate_ids_with_completed_key(self):
from gcloud.datastore.test_batch import _Key
creds = object()
client = self._makeOne(credentials=creds)
COMPLETE_KEY = _Key(self.PROJECT)
self.assertRaises(ValueError, client.allocate_ids, COMPLETE_KEY, 2)
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_allocate_ids_with_completed_key(self):
from gcloud.datastore.test_batch import _Key
creds = object()
client = self._makeOne(credentials=creds)
COMPLETE_KEY = _Key(self.PROJECT)
self.assertRaises(ValueError, client.allocate_ids, COMPLETE_KEY, 2)
def test_no_connection(self):
from gcloud.datastore import _implicit_environ
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
key = _Key(_DATASET)
self.assertEqual(_implicit_environ.get_default_connection(), None)
with self.assertRaises(EnvironmentError):
self._callFUT([key], dataset_id=_DATASET)
def test_no_connection(self):
from gcloud.datastore import _implicit_environ
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
key = _Key(_DATASET)
self.assertEqual(_implicit_environ.CONNECTION, None)
with self.assertRaises(ValueError):
self._callFUT([key])
def test_no_connection(self):
from gcloud.datastore import _implicit_environ
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
key = _Key(_DATASET)
self.assertEqual(_implicit_environ.get_default_connection(), None)
with self.assertRaises(EnvironmentError):
self._callFUT([key], dataset_id=_DATASET)
def test_no_connection(self):
from gcloud.datastore import _implicit_environ
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
# Build basic mocks needed to delete.
_DATASET = 'DATASET'
entity = _Entity(foo=u'bar')
entity.key = _Key(_DATASET)
self.assertEqual(_implicit_environ.CONNECTION, None)
with self.assertRaises(EnvironmentError):
self._callFUT([entity], dataset_id=_DATASET)
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_w_existing_transaction(self):
from gcloud.datastore.test_batch import _Key
from gcloud.datastore.test_batch import _mutated_pb
creds = object()
client = self._makeOne(credentials=creds)
key = _Key(self.PROJECT)
with _NoCommitTransaction(client) as CURR_XACT:
result = client.delete_multi([key])
self.assertEqual(result, None)
mutated_key = _mutated_pb(self, CURR_XACT.mutations, "delete")
self.assertEqual(mutated_key, key._key)
self.assertEqual(len(client.connection._commit_cw), 0)
def test_allocate_ids_w_partial_key(self):
from gcloud.datastore.test_batch import _Key
NUM_IDS = 2
INCOMPLETE_KEY = _Key(self.PROJECT)
INCOMPLETE_KEY._id = None
creds = object()
client = self._makeOne(credentials=creds)
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_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)
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_delete_multi_w_existing_transaction(self):
from gcloud.datastore.test_batch import _Key
from gcloud.datastore.test_batch import _mutated_pb
creds = object()
client = self._makeOne(credentials=creds)
key = _Key(self.PROJECT)
with _NoCommitTransaction(client) as CURR_XACT:
result = client.delete_multi([key])
self.assertEqual(result, None)
mutated_key = _mutated_pb(self, CURR_XACT.mutations, 'delete')
self.assertEqual(mutated_key, key._key)
self.assertEqual(len(client.connection._commit_cw), 0)
def test_delete_multi_w_existing_batch(self):
from gcloud.datastore.test_batch import _Key
from gcloud.datastore.test_batch import _mutated_pb
creds = object()
client = self._makeOne(credentials=creds)
key = _Key(self.DATASET_ID)
with _NoCommitBatch(client) as CURR_BATCH:
result = client.delete_multi([key])
self.assertEqual(result, None)
mutated_key = _mutated_pb(self, CURR_BATCH.mutations, 'delete')
self.assertEqual(mutated_key, key._key)
self.assertEqual(len(client.connection._commit_cw), 0)
def test_allocate_ids_w_partial_key(self):
from gcloud.datastore.test_batch import _Key
NUM_IDS = 2
INCOMPLETE_KEY = _Key(self.PROJECT)
INCOMPLETE_KEY._id = None
creds = object()
client = self._makeOne(credentials=creds)
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_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_delete_multi_no_batch(self):
from gcloud.datastore.test_batch import _Key
key = _Key(self.PROJECT)
creds = object()
client = self._makeOne(credentials=creds)
client.connection._commit.append([])
result = client.delete_multi([key])
self.assertEqual(result, None)
self.assertEqual(len(client.connection._commit_cw), 1)
(project, commit_req, transaction_id) = client.connection._commit_cw[0]
self.assertEqual(project, self.PROJECT)
self.assertEqual(list(commit_req.mutation.delete), [key.to_protobuf()])
self.assertTrue(transaction_id is None)
def test_delete_multi_no_batch(self):
from gcloud.datastore.test_batch import _CommitResult
from gcloud.datastore.test_batch import _Key
key = _Key(self.DATASET_ID)
creds = object()
client = self._makeOne(credentials=creds)
client.connection._commit.append(_CommitResult())
result = client.delete_multi([key])
self.assertEqual(result, None)
self.assertEqual(len(client.connection._commit_cw), 1)
dataset_id, mutation, transaction_id = client.connection._commit_cw[0]
self.assertEqual(dataset_id, self.DATASET_ID)
self.assertEqual(list(mutation.delete), [key.to_protobuf()])
self.assertTrue(transaction_id is None)
def test_delete_multi_w_existing_transaction(self):
from gcloud.datastore.test_batch import _Key
creds = object()
client = self._makeOne(credentials=creds)
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(client.connection._commit_cw), 0)
def test_delete_multi_no_batch(self):
from gcloud.datastore.test_batch import _CommitResult
from gcloud.datastore.test_batch import _Key
key = _Key(self.DATASET_ID)
creds = object()
client = self._makeOne(credentials=creds)
client.connection._commit.append(_CommitResult())
result = client.delete_multi([key])
self.assertEqual(result, None)
self.assertEqual(len(client.connection._commit_cw), 1)
dataset_id, mutation, transaction_id = client.connection._commit_cw[0]
self.assertEqual(dataset_id, self.DATASET_ID)
self.assertEqual(list(mutation.delete), [key.to_protobuf()])
self.assertTrue(transaction_id is None)
def test_delete_multi_w_existing_transaction(self):
from gcloud.datastore.test_batch import _Key
creds = object()
client = self._makeOne(credentials=creds)
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(client.connection._commit_cw), 0)
def test_delete_multi_no_batch(self):
from gcloud.datastore.test_batch import _Key
key = _Key(self.PROJECT)
creds = object()
client = self._makeOne(credentials=creds)
client.connection._commit.append([])
result = client.delete_multi([key])
self.assertEqual(result, None)
self.assertEqual(len(client.connection._commit_cw), 1)
(project,
commit_req, transaction_id) = client.connection._commit_cw[0]
self.assertEqual(project, self.PROJECT)
self.assertEqual(list(commit_req.mutation.delete), [key.to_protobuf()])
self.assertTrue(transaction_id is None)
def test_delete_multi_w_existing_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)
with _NoCommitBatch(client) as CURR_BATCH:
result = client.delete_multi([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_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_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_existing_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)
# Set up Batch on stack so we can check it is used.
with _NoCommitBatch(_DATASET, connection) as CURR_BATCH:
result = self._callFUT([key], connection=connection)
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 _Entity
from gcloud.datastore.test_batch import _Key
creds = object()
client = self._makeOne(credentials=creds)
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_put_multi_existing_batch_w_completed_key(self):
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
creds = object()
client = self._makeOne(credentials=creds)
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_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)
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_put_multi_existing_batch_w_completed_key(self):
from gcloud.datastore.helpers import _property_tuples
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
from gcloud.datastore.test_batch import _mutated_pb
creds = object()
client = self._makeOne(credentials=creds)
entity = _Entity(foo=u'bar')
key = entity.key = _Key(self.PROJECT)
with _NoCommitBatch(client) as CURR_BATCH:
result = client.put_multi([entity])
self.assertEqual(result, None)
mutated_entity = _mutated_pb(self, CURR_BATCH.mutations, 'upsert')
self.assertEqual(mutated_entity.key, key.to_protobuf())
prop_list = list(_property_tuples(mutated_entity))
self.assertTrue(len(prop_list), 1)
name, value_pb = prop_list[0]
self.assertEqual(name, 'foo')
self.assertEqual(value_pb.string_value, u'bar')
def test_put_multi_existing_batch_w_completed_key(self):
from gcloud.datastore.helpers import _property_tuples
from gcloud.datastore.test_batch import _Entity
from gcloud.datastore.test_batch import _Key
from gcloud.datastore.test_batch import _mutated_pb
creds = object()
client = self._makeOne(credentials=creds)
entity = _Entity(foo=u"bar")
key = entity.key = _Key(self.PROJECT)
with _NoCommitBatch(client) as CURR_BATCH:
result = client.put_multi([entity])
self.assertEqual(result, None)
mutated_entity = _mutated_pb(self, CURR_BATCH.mutations, "upsert")
self.assertEqual(mutated_entity.key, key.to_protobuf())
prop_list = list(_property_tuples(mutated_entity))
self.assertTrue(len(prop_list), 1)
name, value_pb = prop_list[0]
self.assertEqual(name, "foo")
self.assertEqual(value_pb.string_value, u"bar")
def test_implicit_unset_w_keys(self):
from gcloud.datastore.test_batch import _Key
ID = 'DATASET'
with self._monkey(None):
self.assertEqual(self._callFUT(first_key=_Key(ID)), ID)
def test_implicit_unset_w_keys(self):
from gcloud.datastore.test_batch import _Key
ID = 'DATASET'
with self._monkey(None):
self.assertEqual(self._callFUT(first_key=_Key(ID)), ID)
