def test_forget(self): tb = DatabaseBackend(backend="memory://") tid = uuid() tb.mark_as_done(tid, {"foo": "bar"}) x = AsyncResult(tid) x.forget() self.assertIsNone(x.result)
def test_missing_task_meta_is_dict_with_pending(self): tb = DatabaseBackend(self.uri, app=self.app) meta = tb.get_task_meta('xxx-does-not-exist-at-all') assert meta['status'] == states.PENDING assert meta['task_id'] == 'xxx-does-not-exist-at-all' assert meta['result'] is None assert meta['traceback'] is None
def test_forget(self): tb = DatabaseBackend(backend='memory://') tid = uuid() tb.mark_as_done(tid, {'foo': 'bar'}) tb.mark_as_done(tid, {'foo': 'bar'}) x = AsyncResult(tid, backend=tb) x.forget() self.assertIsNone(x.result)
def test_forget(self): tb = DatabaseBackend(self.uri, backend='memory://', app=self.app) tid = uuid() tb.mark_as_done(tid, {'foo': 'bar'}) tb.mark_as_done(tid, {'foo': 'bar'}) x = self.app.AsyncResult(tid, backend=tb) x.forget() assert x.result is None
def test_forget(self): tb = DatabaseBackend(self.uri, backend="memory://", app=self.app) tid = uuid() tb.mark_as_done(tid, {"foo": "bar"}) tb.mark_as_done(tid, {"foo": "bar"}) x = self.app.AsyncResult(tid, backend=tb) x.forget() self.assertIsNone(x.result)
def test_missing_task_meta_is_dict_with_pending(self): tb = DatabaseBackend() self.assertDictContainsSubset({ 'status': states.PENDING, 'task_id': "xxx-does-not-exist-at-all", 'result': None, 'traceback': None, }, tb.get_task_meta("xxx-does-not-exist-at-all"))
def test_mark_as_retry(self): tb = DatabaseBackend() tid = uuid() try: raise KeyError("foo") except KeyError, exception: import traceback trace = "\n".join(traceback.format_stack()) tb.mark_as_retry(tid, exception, traceback=trace)
def test_mark_as_failure(self): tb = DatabaseBackend() tid3 = uuid() try: raise KeyError('foo') except KeyError, exception: import traceback trace = '\n'.join(traceback.format_stack()) tb.mark_as_failure(tid3, exception, traceback=trace)
def test_is_pickled(self): tb = DatabaseBackend(self.uri, app=self.app) tid2 = uuid() result = {'foo': 'baz', 'bar': SomeClass(12345)} tb.mark_as_done(tid2, result) # is serialized properly. rindb = tb.get_result(tid2) assert rindb.get('foo') == 'baz' assert rindb.get('bar').data == 12345
def test_is_pickled(self): tb = DatabaseBackend() tid2 = uuid() result = {"foo": "baz", "bar": SomeClass(12345)} tb.mark_as_done(tid2, result) # is serialized properly. rindb = tb.get_result(tid2) self.assertEqual(rindb.get("foo"), "baz") self.assertEqual(rindb.get("bar").data, 12345)
def test_is_pickled(self): tb = DatabaseBackend() tid2 = uuid() result = {'foo': 'baz', 'bar': SomeClass(12345)} tb.mark_as_done(tid2, result) # is serialized properly. rindb = tb.get_result(tid2) self.assertEqual(rindb.get('foo'), 'baz') self.assertEqual(rindb.get('bar').data, 12345)
def test_save___restore_taskset(self): tb = DatabaseBackend() tid = gen_unique_id() res = {u"something": "special"} self.assertEqual(tb.save_taskset(tid, res), res) res2 = tb.restore_taskset(tid) self.assertEqual(res2, res) self.assertIsNone(tb.restore_taskset("xxx-nonexisting-id"))
def test_taskset_store(self): b = DatabaseBackend() tid = gen_unique_id() self.assertIsNone(b.restore_taskset(tid)) result = {"foo": "baz", "bar": SomeClass(12345)} b.save_taskset(tid, result) rindb = b.restore_taskset(tid) self.assertIsNotNone(rindb) self.assertEqual(rindb.get("foo"), "baz") self.assertEqual(rindb.get("bar").data, 12345)
def test_taskset_store(self): b = DatabaseBackend() tid = gen_unique_id() self.assertTrue(b.get_taskset(tid) is None) result = {"foo": "baz", "bar": SomeClass(12345)} b.store_taskset(tid, result) rindb = b.get_taskset(tid) self.assertTrue(rindb is not None) self.assertEquals(rindb.get("foo"), "baz") self.assertEquals(rindb.get("bar").data, 12345) self.assertTrue(b._cache.get(tid))
def test_store_result(self, result_serializer, args, kwargs): self.app.conf.result_serializer = result_serializer tb = DatabaseBackend(self.uri, app=self.app) tid = uuid() request = Context(args=args, kwargs=kwargs, task_name='mytask', retries=2, hostname='celery@worker_1', delivery_info={'routing_key': 'celery'}) tb.store_result(tid, {'fizz': 'buzz'}, states.SUCCESS, request=request) meta = tb.get_task_meta(tid) assert meta['result'] == {'fizz': 'buzz'} assert meta['args'] == args assert meta['kwargs'] == kwargs assert meta['queue'] == 'celery' assert meta['name'] == 'mytask' assert meta['retries'] == 2 assert meta['worker'] == "celery@worker_1"
def test_mark_as_done(self): tb = DatabaseBackend(self.uri, app=self.app) tid = uuid() assert tb.get_state(tid) == states.PENDING assert tb.get_result(tid) is None tb.mark_as_done(tid, 42) assert tb.get_state(tid) == states.SUCCESS assert tb.get_result(tid) == 42
def test_mark_as_done(self): tb = DatabaseBackend() tid = uuid() self.assertEqual(tb.get_status(tid), states.PENDING) self.assertIsNone(tb.get_result(tid)) tb.mark_as_done(tid, 42) self.assertEqual(tb.get_status(tid), states.SUCCESS) self.assertEqual(tb.get_result(tid), 42)
def test_mark_as_failure(self): tb = DatabaseBackend(self.uri, app=self.app) tid3 = uuid() try: raise KeyError('foo') except KeyError as exception: import traceback trace = '\n'.join(traceback.format_stack()) tb.mark_as_failure(tid3, exception, traceback=trace) assert tb.get_state(tid3) == states.FAILURE assert isinstance(tb.get_result(tid3), KeyError) assert tb.get_traceback(tid3) == trace
def test_mark_as_failure(self): tb = DatabaseBackend() tid3 = uuid() try: raise KeyError('foo') except KeyError, exception: import traceback trace = '\n'.join(traceback.format_stack()) tb.mark_as_failure(tid3, exception, traceback=trace) self.assertEqual(tb.get_status(tid3), states.FAILURE) self.assertIsInstance(tb.get_result(tid3), KeyError) self.assertEqual(tb.get_traceback(tid3), trace)
def test_save__restore__delete_group(self): tb = DatabaseBackend(self.uri, app=self.app) tid = uuid() res = {'something': 'special'} assert tb.save_group(tid, res) == res res2 = tb.restore_group(tid) assert res2 == res tb.delete_group(tid) assert tb.restore_group(tid) is None assert tb.restore_group('xxx-nonexisting-id') is None
def test_save__restore__delete_group(self): tb = DatabaseBackend(self.uri, app=self.app) tid = uuid() res = {'something': 'special'} self.assertEqual(tb.save_group(tid, res), res) res2 = tb.restore_group(tid) self.assertEqual(res2, res) tb.delete_group(tid) self.assertIsNone(tb.restore_group(tid)) self.assertIsNone(tb.restore_group('xxx-nonexisting-id'))
def test_cleanup(self): tb = DatabaseBackend(self.uri, app=self.app) for i in range(10): tb.mark_as_done(uuid(), 42) tb.save_group(uuid(), {'foo': 'bar'}) s = tb.ResultSession() for t in s.query(Task).all(): t.date_done = datetime.now() - tb.expires * 2 for t in s.query(TaskSet).all(): t.date_done = datetime.now() - tb.expires * 2 s.commit() s.close() tb.cleanup()
def test_save__restore__delete_group(self): tb = DatabaseBackend() tid = uuid() res = {u"something": "special"} self.assertEqual(tb.save_group(tid, res), res) res2 = tb.restore_group(tid) self.assertEqual(res2, res) tb.delete_group(tid) self.assertIsNone(tb.restore_group(tid)) self.assertIsNone(tb.restore_group("xxx-nonexisting-id"))
def test_cleanup(self): tb = DatabaseBackend() for i in range(10): tb.mark_as_done(uuid(), 42) tb.save_taskset(uuid(), {"foo": "bar"}) s = tb.ResultSession() for t in s.query(Task).all(): t.date_done = datetime.now() - tb.expires * 2 for t in s.query(TaskSet).all(): t.date_done = datetime.now() - tb.expires * 2 s.commit() s.close() tb.cleanup()
def test_should_support_db_backend(self, mock_session): with _prepare_app(): mock_backend = DatabaseBackend(app=celery_executor.app, url="sqlite3://") with mock.patch.object(celery_executor.app, 'backend', mock_backend): mock_session = mock_backend.ResultSession.return_value # pylint: disable=no-member mock_session.query.return_value.filter.return_value.all.return_value = [ mock.MagicMock(**{"to_dict.return_value": {"status": "SUCCESS", "task_id": "123"}}) ] fetcher = BulkStateFetcher() result = fetcher.get_many([ mock.MagicMock(task_id="123"), mock.MagicMock(task_id="456"), ]) self.assertEqual(result, {'123': 'SUCCESS', '456': "PENDING"})
def test_mark_as_retry(self): tb = DatabaseBackend() tid = uuid() try: raise KeyError('foo') except KeyError as exception: import traceback trace = '\n'.join(traceback.format_stack()) tb.mark_as_retry(tid, exception, traceback=trace) self.assertEqual(tb.get_status(tid), states.RETRY) self.assertIsInstance(tb.get_result(tid), KeyError) self.assertEqual(tb.get_traceback(tid), trace)
def test_mark_as_retry(self): tb = DatabaseBackend(self.uri, app=self.app) tid = uuid() try: raise KeyError('foo') except KeyError as exception: import traceback trace = '\n'.join(traceback.format_stack()) tb.mark_as_retry(tid, exception, traceback=trace) assert tb.get_state(tid) == states.RETRY assert isinstance(tb.get_result(tid), KeyError) assert tb.get_traceback(tid) == trace
def test_mark_as_failure(self): tb = DatabaseBackend(self.uri, app=self.app) tid3 = uuid() try: raise KeyError('foo') except KeyError as exception: import traceback trace = '\n'.join(traceback.format_stack()) tb.mark_as_failure(tid3, exception, traceback=trace) self.assertEqual(tb.get_state(tid3), states.FAILURE) self.assertIsInstance(tb.get_result(tid3), KeyError) self.assertEqual(tb.get_traceback(tid3), trace)
def test_cleanup(self): tb = DatabaseBackend() for i in range(10): tb.mark_as_done(gen_unique_id(), 42) tb.save_taskset(gen_unique_id(), {"foo": "bar"}) s = tb.ResultSession() for t in s.query(Task).all(): t.date_done = datetime.now() - tb.result_expires * 2 for t in s.query(TaskSet).all(): t.date_done = datetime.now() - tb.result_expires * 2 s.commit() s.close() tb.cleanup() s2 = tb.ResultSession() self.assertEqual(s2.query(Task).count(), 0) self.assertEqual(s2.query(TaskSet).count(), 0)
def test_process_cleanup(self): tb = DatabaseBackend() tb.process_cleanup()
def on_success_patched(self, retval, task_id, args, kwargs): app = current_app._get_current_object() DatabaseBackend(app=app).store_result(task_id, retval, 'SUCCESS')
from baruwa.lib.helpers import flash, flash_alert from baruwa.lib.query import DynaQuery, UserFilter, filter_sphinx from baruwa.lib.query import clean_sphinx_q, restore_sphinx_q, MsgCount from baruwa.lib.pagination import paginator from baruwa.lib.caching_query import FromCache from baruwa.lib.templates.helpers import media_url from baruwa.lib.audit import audit_log #, msg_audit_log from baruwa.tasks import preview_msg, update_autorelease from baruwa.tasks import release_message, process_quarantined_msg from baruwa.model.meta import Session from baruwa.model.messages import Message, Archive, Release, MessageStatus from baruwa.forms.messages import ReleaseMsgForm, BulkReleaseForm from baruwa.lib.audit.msgs.messages import MSGDOWNLOAD_MSG, MSGPREVIEW_MSG # celery backend dbbackend = DatabaseBackend(dburi=Session.bind.url, engine_options={'echo': True}) def ajax_code(code, msg): #response.headers['Content-Type'] = 'application/json' response.status = code response.body = msg return response def process_release_results(context, msg, result, session): "Process the results of a release task" html = [] context.id = msg.messageid errors = dict(result['errors']) templates = dict(
def test_mark_as_revoked(self): tb = DatabaseBackend() tid = uuid() tb.mark_as_revoked(tid) self.assertEqual(tb.get_status(tid), states.REVOKED)
def test_mark_as_started(self): tb = DatabaseBackend() tid = uuid() tb.mark_as_started(tid) self.assertEqual(tb.get_status(tid), states.STARTED)
def test_missing_task_id_is_PENDING(self): tb = DatabaseBackend(self.uri, app=self.app) assert tb.get_state('xxx-does-not-exist') == states.PENDING
def test_reduce(self): tb = DatabaseBackend() self.assertTrue(loads(dumps(tb)))
def test_missing_task_id_is_PENDING(self): tb = DatabaseBackend() self.assertEqual(tb.get_status("xxx-does-not-exist"), states.PENDING)
def test_mark_as_started(self): tb = DatabaseBackend(self.uri, app=self.app) tid = uuid() tb.mark_as_started(tid) assert tb.get_state(tid) == states.STARTED
def test_mark_as_revoked(self): tb = DatabaseBackend(self.uri, app=self.app) tid = uuid() tb.mark_as_revoked(tid) assert tb.get_state(tid) == states.REVOKED
def test_process_cleanup(self): tb = DatabaseBackend(self.uri, app=self.app) tb.process_cleanup()
def test_reduce(self): tb = DatabaseBackend(self.uri, app=self.app) assert loads(dumps(tb))
def test_missing_dburi_raises_ImproperlyConfigured(self): self.app.conf.sqlalchemy_dburi = None with pytest.raises(ImproperlyConfigured): DatabaseBackend(app=self.app)
def test_missing_task_id_is_PENDING(self): tb = DatabaseBackend() self.assertEqual(tb.get_status('xxx-does-not-exist'), states.PENDING)
def test_missing_dburi_raises_ImproperlyConfigured(self): self.app.conf.CELERY_RESULT_DBURI = None with self.assertRaises(ImproperlyConfigured): DatabaseBackend(app=self.app)