def test_without_expires(_batch): batch = _batch.get_batch.return_value assert _cache.global_set(b"key", b"value") is batch.add.return_value _batch.get_batch.assert_called_once_with( _cache._GlobalCacheSetBatch, {} ) batch.add.assert_called_once_with(b"key", b"value")
def test_with_expires(_batch): batch = _batch.get_batch.return_value future = _cache.global_set(b"key", b"value", expires=5) assert future is batch.add.return_value _batch.get_batch.assert_called_once_with(_cache._GlobalCacheSetBatch, {"expires": 5}) batch.add.assert_called_once_with(b"key", b"value")
def put(entity, options): """Store an entity in datastore. The entity can be a new entity to be saved for the first time or an existing entity that has been updated. Args: entity_pb (datastore.Entity): The entity to be stored. options (_options.Options): Options for this request. Returns: tasklets.Future: Result will be completed datastore key (datastore.Key) for the entity. """ context = context_module.get_context() use_global_cache = context._use_global_cache(entity.key, options) use_datastore = context._use_datastore(entity.key, options) if not (use_global_cache or use_datastore): raise TypeError("use_global_cache and use_datastore can't both be False") if not use_datastore and entity.key.is_partial: raise TypeError("Can't store partial keys when use_datastore is False") lock = None entity_pb = helpers.entity_to_protobuf(entity) cache_key = _cache.global_cache_key(entity.key) if use_global_cache and not entity.key.is_partial: if use_datastore: lock = yield _cache.global_lock_for_write(cache_key) else: expires = context._global_cache_timeout(entity.key, options) cache_value = entity_pb.SerializeToString() yield _cache.global_set(cache_key, cache_value, expires=expires) if use_datastore: transaction = context.transaction if transaction: batch = _get_commit_batch(transaction, options) else: batch = _batch.get_batch(_NonTransactionalCommitBatch, options) key_pb = yield batch.put(entity_pb) if key_pb: key = helpers.key_from_protobuf(key_pb) else: key = None if lock: if transaction: def callback(): _cache.global_unlock_for_write(cache_key, lock).result() context.call_on_transaction_complete(callback) else: yield _cache.global_unlock_for_write(cache_key, lock) raise tasklets.Return(key)
def test_error_strict(_batch, _global_cache, sleep): class TransientError(Exception): pass sleep.return_value = future_result(None) batch = _batch.get_batch.return_value future = _future_exception(TransientError("oops")) batch.add.return_value = future _global_cache.return_value = mock.Mock( transient_errors=(TransientError,), spec=("transient_errors", "strict_write"), ) with pytest.raises(TransientError): _cache.global_set(b"key", b"value").result() _batch.get_batch.assert_called_with(_cache._GlobalCacheSetBatch, {}) batch.add.assert_called_with(b"key", b"value")
def test_error_strict(_batch, _global_cache): class TransientError(Exception): pass batch = _batch.get_batch.return_value future = _future_exception(TransientError("oops")) batch.add.return_value = future _global_cache.return_value = mock.Mock( transient_errors=(TransientError, ), clear_cache_soon=False, spec=("transient_errors", "clear_cache_soon", "strict_write"), ) with pytest.raises(TransientError): _cache.global_set(b"key", b"value").result() _batch.get_batch.assert_called_once_with(_cache._GlobalCacheSetBatch, {}) batch.add.assert_called_once_with(b"key", b"value") assert _global_cache.return_value.clear_cache_soon is True
def test_without_expires(_batch, _global_cache): batch = _batch.get_batch.return_value future = _future_result("hi mom!") batch.add.return_value = future _global_cache.return_value = mock.Mock( transient_errors=(), strict_write=False, spec=("transient_errors", "strict_write"), ) assert _cache.global_set(b"key", b"value").result() == "hi mom!" _batch.get_batch.assert_called_once_with(_cache._GlobalCacheSetBatch, {}) batch.add.assert_called_once_with(b"key", b"value")
def test_with_expires(_batch, _global_cache): batch = _batch.get_batch.return_value future = _future_result("hi mom!") batch.add.return_value = future _global_cache.return_value = mock.Mock( transient_errors=(), clear_cache_soon=False, spec=("transient_errors", "clear_cache_soon"), ) future = _cache.global_set(b"key", b"value", expires=5) assert future.result() == "hi mom!" _batch.get_batch.assert_called_once_with(_cache._GlobalCacheSetBatch, {"expires": 5}) batch.add.assert_called_once_with(b"key", b"value")
def test_error_not_strict_already_warned(_batch, _global_cache): class TransientError(Exception): pass batch = _batch.get_batch.return_value error = TransientError("oops") error._ndb_warning_logged = True future = _future_exception(error) batch.add.return_value = future _global_cache.return_value = mock.Mock( transient_errors=(TransientError,), strict_write=False, spec=("transient_errors", "strict_write"), ) with warnings.catch_warnings(record=True) as logged: assert _cache.global_set(b"key", b"value").result() is None assert len(logged) == 0 _batch.get_batch.assert_called_once_with(_cache._GlobalCacheSetBatch, {}) batch.add.assert_called_once_with(b"key", b"value")