Ejemplo n.º 1
0
 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)
Ejemplo n.º 2
0
 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
Ejemplo n.º 3
0
 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)
Ejemplo n.º 4
0
 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
Ejemplo n.º 5
0
 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)
Ejemplo n.º 6
0
 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"))
Ejemplo n.º 7
0
 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)
Ejemplo n.º 8
0
    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)
Ejemplo n.º 9
0
    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
Ejemplo n.º 10
0
    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)
Ejemplo n.º 11
0
    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)
Ejemplo n.º 12
0
    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"))
Ejemplo n.º 13
0
    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)
Ejemplo n.º 14
0
    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))
Ejemplo n.º 15
0
    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"
Ejemplo n.º 16
0
    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
Ejemplo n.º 17
0
    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)
Ejemplo n.º 18
0
    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
Ejemplo n.º 19
0
    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)
Ejemplo n.º 20
0
    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
Ejemplo n.º 21
0
    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'))
Ejemplo n.º 22
0
    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()
Ejemplo n.º 23
0
    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"))
Ejemplo n.º 24
0
    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()
Ejemplo n.º 25
0
    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"})
Ejemplo n.º 26
0
 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)
Ejemplo n.º 27
0
 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
Ejemplo n.º 28
0
    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)
Ejemplo n.º 29
0
    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)
Ejemplo n.º 30
0
 def test_process_cleanup(self):
     tb = DatabaseBackend()
     tb.process_cleanup()
Ejemplo n.º 31
0
 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')
Ejemplo n.º 32
0
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(
Ejemplo n.º 33
0
 def test_mark_as_revoked(self):
     tb = DatabaseBackend()
     tid = uuid()
     tb.mark_as_revoked(tid)
     self.assertEqual(tb.get_status(tid), states.REVOKED)
Ejemplo n.º 34
0
 def test_mark_as_started(self):
     tb = DatabaseBackend()
     tid = uuid()
     tb.mark_as_started(tid)
     self.assertEqual(tb.get_status(tid), states.STARTED)
Ejemplo n.º 35
0
 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
Ejemplo n.º 36
0
 def test_reduce(self):
     tb = DatabaseBackend()
     self.assertTrue(loads(dumps(tb)))
Ejemplo n.º 37
0
 def test_mark_as_revoked(self):
     tb = DatabaseBackend()
     tid = uuid()
     tb.mark_as_revoked(tid)
     self.assertEqual(tb.get_status(tid), states.REVOKED)
Ejemplo n.º 38
0
 def test_missing_task_id_is_PENDING(self):
     tb = DatabaseBackend()
     self.assertEqual(tb.get_status("xxx-does-not-exist"), states.PENDING)
Ejemplo n.º 39
0
 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
Ejemplo n.º 40
0
 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
Ejemplo n.º 41
0
 def test_process_cleanup(self):
     tb = DatabaseBackend(self.uri, app=self.app)
     tb.process_cleanup()
Ejemplo n.º 42
0
 def test_mark_as_started(self):
     tb = DatabaseBackend()
     tid = uuid()
     tb.mark_as_started(tid)
     self.assertEqual(tb.get_status(tid), states.STARTED)
Ejemplo n.º 43
0
 def test_reduce(self):
     tb = DatabaseBackend(self.uri, app=self.app)
     assert loads(dumps(tb))
Ejemplo n.º 44
0
 def test_process_cleanup(self):
     tb = DatabaseBackend()
     tb.process_cleanup()
Ejemplo n.º 45
0
 def test_missing_dburi_raises_ImproperlyConfigured(self):
     self.app.conf.sqlalchemy_dburi = None
     with pytest.raises(ImproperlyConfigured):
         DatabaseBackend(app=self.app)
Ejemplo n.º 46
0
 def test_missing_task_id_is_PENDING(self):
     tb = DatabaseBackend()
     self.assertEqual(tb.get_status('xxx-does-not-exist'), states.PENDING)
Ejemplo n.º 47
0
 def test_missing_dburi_raises_ImproperlyConfigured(self):
     self.app.conf.CELERY_RESULT_DBURI = None
     with self.assertRaises(ImproperlyConfigured):
         DatabaseBackend(app=self.app)