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)