Python TaskRequest.from_message 예제들

예제 #1

파일: test_request.py 프로젝트: fxiang21/company_bt

 def test_from_message_missing_required_fields(self):
     body = {}
     m = Message(None, body=anyjson.dumps(body), backend='foo',
                 content_type='application/json',
                 content_encoding='utf-8')
     with self.assertRaises(KeyError):
         TaskRequest.from_message(m, m.decode())

예제 #2

파일: test_worker_job.py 프로젝트: psnj/celery

 def test_from_message_nonexistant_task(self):
     body = {"task": "cu.mytask.doesnotexist", "id": uuid(), "args": [2], "kwargs": {u"æØåveéðƒeæ": "bar"}}
     m = Message(
         None, body=anyjson.dumps(body), backend="foo", content_type="application/json", content_encoding="utf-8"
     )
     with self.assertRaises(KeyError):
         TaskRequest.from_message(m, m.decode())

예제 #3

파일: test_worker_job.py 프로젝트: ivirabyan/celery

 def test_from_message_missing_required_fields(self):
     body = {}
     m = Message(None, body=anyjson.dumps(body), backend="foo",
                       content_type="application/json",
                       content_encoding="utf-8")
     with self.assertRaises(KeyError):
         TaskRequest.from_message(m, m.decode())

예제 #4

파일: test_worker_job.py 프로젝트: amplify-education/celery

 def test_from_message_missing_required_fields(self):
     body = {}
     m = Message(None, body=anyjson.serialize(body), backend="foo",
                       content_type="application/json",
                       content_encoding="utf-8")
     with self.assertRaises(InvalidTaskError):
         TaskRequest.from_message(m, m.decode())

예제 #5

파일: test_worker_job.py 프로젝트: amplify-education/celery

 def test_from_message_nonexistant_task(self):
     body = {"task": "cu.mytask.doesnotexist", "id": uuid(),
             "args": [2], "kwargs": {u"æØåveéðƒeæ": "bar"}}
     m = Message(None, body=anyjson.serialize(body), backend="foo",
                       content_type="application/json",
                       content_encoding="utf-8")
     with self.assertRaises(KeyError):
         TaskRequest.from_message(m, m.decode())

예제 #6

파일: test_request.py 프로젝트: fxiang21/company_bt

 def test_from_message_nonexistant_task(self):
     body = {'task': 'cu.mytask.doesnotexist', 'id': uuid(),
             'args': [2], 'kwargs': {u'æØåveéðƒeæ': 'bar'}}
     m = Message(None, body=anyjson.dumps(body), backend='foo',
                 content_type='application/json',
                 content_encoding='utf-8')
     with self.assertRaises(KeyError):
         TaskRequest.from_message(m, m.decode())

예제 #7

파일: test_request.py 프로젝트: EzyInsights/celery

 def test_from_message_nonexistant_task(self):
     body = {'task': 'cu.mytask.doesnotexist', 'id': uuid(),
             'args': [2], 'kwargs': {'æØåveéðƒeæ': 'bar'}}
     m = Message(None, body=anyjson.dumps(body), backend='foo',
                 content_type='application/json',
                 content_encoding='utf-8')
     with self.assertRaises(KeyError):
         TaskRequest.from_message(m, m.decode(), app=self.app)

예제 #8

 def test_from_message(self):
     us = u"æØåveéðƒeæ"
     body = {
         "task": mytask.name,
         "id": uuid(),
         "args": [2],
         "kwargs": {
             us: "bar"
         }
     }
     m = Message(None,
                 body=anyjson.serialize(body),
                 backend="foo",
                 content_type="application/json",
                 content_encoding="utf-8")
     tw = TaskRequest.from_message(m, m.decode())
     self.assertIsInstance(tw, Request)
     self.assertEqual(tw.task_name, body["task"])
     self.assertEqual(tw.task_id, body["id"])
     self.assertEqual(tw.args, body["args"])
     us = from_utf8(us)
     if sys.version_info < (2, 6):
         self.assertEqual(tw.kwargs.keys()[0], us)
         self.assertIsInstance(tw.kwargs.keys()[0], str)
     self.assertTrue(tw.logger)

예제 #9

파일: test_worker_job.py 프로젝트: amplify-education/celery

 def test_from_message_empty_args(self):
     body = {"task": mytask.name, "id": uuid()}
     m = Message(None, body=anyjson.serialize(body), backend="foo",
                       content_type="application/json",
                       content_encoding="utf-8")
     tw = TaskRequest.from_message(m, m.decode())
     self.assertIsInstance(tw, TaskRequest)
     self.assertEquals(tw.args, [])
     self.assertEquals(tw.kwargs, {})

예제 #10

파일: test_worker.py 프로젝트: OddBloke/celery

 def test_process_task_raise_regular(self):
     worker = self.worker
     worker.pool = Mock()
     worker.pool.apply_async.side_effect = KeyError("some exception")
     backend = Mock()
     m = create_message(backend, task=foo_task.name, args=[4, 8, 10], kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.process_task(task)
     worker.pool.stop()

예제 #11

파일: test_worker.py 프로젝트: flaper87/celery

 def test_process_task_raise_regular(self):
     worker = self.worker
     worker.pool = MockPool(raise_regular=True)
     backend = MockBackend()
     m = create_message(backend, task=foo_task.name, args=[4, 8, 10],
                        kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.process_task(task)
     worker.pool.stop()

예제 #12

파일: test_worker_job.py 프로젝트: ivirabyan/celery

 def test_from_message_empty_args(self):
     body = {"task": mytask.name, "id": uuid()}
     m = Message(None, body=anyjson.dumps(body), backend="foo",
                       content_type="application/json",
                       content_encoding="utf-8")
     tw = TaskRequest.from_message(m, m.decode())
     self.assertIsInstance(tw, Request)
     self.assertEquals(tw.args, [])
     self.assertEquals(tw.kwargs, {})

예제 #13

파일: test_worker.py 프로젝트: OddBloke/celery

 def test_process_task(self):
     worker = self.worker
     worker.pool = Mock()
     backend = Mock()
     m = create_message(backend, task=foo_task.name, args=[4, 8, 10], kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.process_task(task)
     self.assertEqual(worker.pool.apply_async.call_count, 1)
     worker.pool.stop()

예제 #14

파일: test_request.py 프로젝트: fxiang21/company_bt

 def test_from_message_empty_args(self):
     body = {'task': mytask.name, 'id': uuid()}
     m = Message(None, body=anyjson.dumps(body), backend='foo',
                 content_type='application/json',
                 content_encoding='utf-8')
     tw = TaskRequest.from_message(m, m.decode())
     self.assertIsInstance(tw, Request)
     self.assertEquals(tw.args, [])
     self.assertEquals(tw.kwargs, {})

예제 #15

파일: test_request.py 프로젝트: EzyInsights/celery

 def test_from_message_empty_args(self):
     body = {'task': self.mytask.name, 'id': uuid()}
     m = Message(None, body=anyjson.dumps(body), backend='foo',
                 content_type='application/json',
                 content_encoding='utf-8')
     job = TaskRequest.from_message(m, m.decode(), app=self.app)
     self.assertIsInstance(job, Request)
     self.assertEqual(job.args, [])
     self.assertEqual(job.kwargs, {})

예제 #16

파일: test_worker.py 프로젝트: WoLpH/celery

 def test_process_task(self):
     worker = self.worker
     worker.pool = Mock()
     backend = Mock()
     m = create_message(backend, task=foo_task.name, args=[4, 8, 10],
                        kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.process_task(task)
     self.assertEqual(worker.pool.apply_async.call_count, 1)
     worker.pool.stop()

예제 #17

파일: test_worker.py 프로젝트: WoLpH/celery

 def test_process_task_raise_regular(self):
     worker = self.worker
     worker.pool = Mock()
     worker.pool.apply_async.side_effect = KeyError("some exception")
     backend = Mock()
     m = create_message(backend, task=foo_task.name, args=[4, 8, 10],
                        kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.process_task(task)
     worker.pool.stop()

예제 #18

파일: test_worker.py 프로젝트: Mozilla-GitHub-Standards/441e91400508d94b5a6931d7693918293007697b91395acd9460441a437990ec

 def test_process_task_raise_regular(self):
     worker = self.worker
     worker.pool = MockPool(raise_regular=True)
     backend = MockBackend()
     m = create_message(backend,
                        task=foo_task.name,
                        args=[4, 8, 10],
                        kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.process_task(task)
     worker.pool.stop()

예제 #19

파일: test_worker.py 프로젝트: OddBloke/celery

 def test_process_task_raise_SystemTerminate(self):
     worker = self.worker
     worker.pool = Mock()
     worker.pool.apply_async.side_effect = SystemTerminate()
     backend = Mock()
     m = create_message(backend, task=foo_task.name, args=[4, 8, 10], kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.components = []
     worker._state = worker.RUN
     self.assertRaises(SystemExit, worker.process_task, task)
     self.assertEqual(worker._state, worker.TERMINATE)

예제 #20

파일: test_worker.py 프로젝트: vkryachko/celery

 def test_process_task_raise_base(self):
     worker = self.worker
     worker.pool = MockPool(raise_base=True)
     backend = MockBackend()
     m = create_message(backend, task=foo_task.name, args=[4, 8, 10],
                        kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.components = []
     worker._state = worker.RUN
     self.assertRaises(KeyboardInterrupt, worker.process_task, task)
     self.assertEqual(worker._state, worker.TERMINATE)

예제 #21

파일: test_worker.py 프로젝트: WoLpH/celery

 def test_process_task_raise_SystemTerminate(self):
     worker = self.worker
     worker.pool = Mock()
     worker.pool.apply_async.side_effect = SystemTerminate()
     backend = Mock()
     m = create_message(backend, task=foo_task.name, args=[4, 8, 10],
                        kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.components = []
     worker._state = worker.RUN
     self.assertRaises(SystemExit, worker.process_task, task)
     self.assertEqual(worker._state, worker.TERMINATE)

예제 #22

파일: __init__.py 프로젝트: Ignas/celery

 def test_process_task_raise_base(self):
     worker = self.worker
     worker.pool = Mock()
     worker.pool.apply_async.side_effect = KeyboardInterrupt("Ctrl+C")
     backend = Mock()
     m = create_message(backend, task=foo_task.name, args=[4, 8, 10],
                        kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.components = []
     worker._state = worker.RUN
     with self.assertRaises(KeyboardInterrupt):
         worker.process_task(task)
     self.assertEqual(worker._state, worker.TERMINATE)

예제 #23

파일: test_worker.py 프로젝트: mozilla/webifyme-lib

 def test_process_task_raise_base(self):
     worker = self.worker
     worker.pool = MockPool(raise_base=True)
     backend = MockBackend()
     m = create_message(backend,
                        task=foo_task.name,
                        args=[4, 8, 10],
                        kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.components = []
     worker._state = worker.RUN
     self.assertRaises(KeyboardInterrupt, worker.process_task, task)
     self.assertEqual(worker._state, worker.TERMINATE)

예제 #24

파일: test_worker_job.py 프로젝트: jasonbaker/celery

 def test_from_message(self):
     body = {"task": mytask.name, "id": gen_unique_id(), "args": [2], "kwargs": {u"æØåveéðƒeæ": "bar"}}
     m = BaseMessage(
         body=simplejson.dumps(body), backend="foo", content_type="application/json", content_encoding="utf-8"
     )
     tw = TaskRequest.from_message(m, m.decode())
     self.assertIsInstance(tw, TaskRequest)
     self.assertEqual(tw.task_name, body["task"])
     self.assertEqual(tw.task_id, body["id"])
     self.assertEqual(tw.args, body["args"])
     self.assertEqual(tw.kwargs.keys()[0], u"æØåveéðƒeæ".encode("utf-8"))
     self.assertNotIsInstance(tw.kwargs.keys()[0], unicode)
     self.assertTrue(tw.logger)

예제 #25

파일: __init__.py 프로젝트: amplify-education/celery

 def test_process_task_raise_base(self):
     worker = self.worker
     worker.pool = Mock()
     worker.pool.apply_async.side_effect = KeyboardInterrupt("Ctrl+C")
     backend = Mock()
     m = create_message(backend,
                        task=foo_task.name,
                        args=[4, 8, 10],
                        kwargs={})
     task = TaskRequest.from_message(m, m.decode())
     worker.components = []
     worker._state = worker.RUN
     with self.assertRaises(KeyboardInterrupt):
         worker.process_task(task)
     self.assertEqual(worker._state, worker.TERMINATE)

예제 #26

 def test_from_message(self):
     body = {"task": mytask.name, "id": gen_unique_id(),
             "args": [2], "kwargs": {u"æØåveéðƒeæ": "bar"}}
     m = Message(None, body=anyjson.serialize(body), backend="foo",
                       content_type="application/json",
                       content_encoding="utf-8")
     tw = TaskRequest.from_message(m, m.decode())
     self.assertIsInstance(tw, TaskRequest)
     self.assertEqual(tw.task_name, body["task"])
     self.assertEqual(tw.task_id, body["id"])
     self.assertEqual(tw.args, body["args"])
     self.assertEqual(tw.kwargs.keys()[0],
                       u"æØåveéðƒeæ".encode("utf-8"))
     self.assertNotIsInstance(tw.kwargs.keys()[0], unicode)
     self.assertTrue(tw.logger)

예제 #27

파일: test_request.py 프로젝트: nonoDevil/celery

 def test_from_message(self):
     us = "æØåveéðƒeæ"
     body = {"task": self.mytask.name, "id": uuid(), "args": [2], "kwargs": {us: "bar"}}
     m = Message(
         None, body=anyjson.dumps(body), backend="foo", content_type="application/json", content_encoding="utf-8"
     )
     job = TaskRequest.from_message(m, m.decode(), app=self.app)
     self.assertIsInstance(job, Request)
     self.assertEqual(job.name, body["task"])
     self.assertEqual(job.id, body["id"])
     self.assertEqual(job.args, body["args"])
     us = from_utf8(us)
     if sys.version_info < (2, 6):
         self.assertEqual(next(keys(job.kwargs)), us)
         self.assertIsInstance(next(keys(job.kwargs)), str)

예제 #28

파일: test_request.py 프로젝트: fxiang21/company_bt

 def test_from_message(self):
     us = u'æØåveéðƒeæ'
     body = {'task': mytask.name, 'id': uuid(),
             'args': [2], 'kwargs': {us: 'bar'}}
     m = Message(None, body=anyjson.dumps(body), backend='foo',
                 content_type='application/json',
                 content_encoding='utf-8')
     tw = TaskRequest.from_message(m, m.decode())
     self.assertIsInstance(tw, Request)
     self.assertEqual(tw.name, body['task'])
     self.assertEqual(tw.id, body['id'])
     self.assertEqual(tw.args, body['args'])
     us = from_utf8(us)
     if sys.version_info < (2, 6):
         self.assertEqual(tw.kwargs.keys()[0], us)
         self.assertIsInstance(tw.kwargs.keys()[0], str)

예제 #29

파일: test_request.py 프로젝트: EzyInsights/celery

 def test_from_message(self):
     us = 'æØåveéðƒeæ'
     body = {'task': self.mytask.name, 'id': uuid(),
             'args': [2], 'kwargs': {us: 'bar'}}
     m = Message(None, body=anyjson.dumps(body), backend='foo',
                 content_type='application/json',
                 content_encoding='utf-8')
     job = TaskRequest.from_message(m, m.decode(), app=self.app)
     self.assertIsInstance(job, Request)
     self.assertEqual(job.name, body['task'])
     self.assertEqual(job.id, body['id'])
     self.assertEqual(job.args, body['args'])
     us = from_utf8(us)
     if sys.version_info < (2, 6):
         self.assertEqual(next(keys(job.kwargs)), us)
         self.assertIsInstance(next(keys(job.kwargs)), str)

예제 #30

파일: test_worker_job.py 프로젝트: psnj/celery

 def test_from_message(self):
     us = u"æØåveéðƒeæ"
     body = {"task": mytask.name, "id": uuid(), "args": [2], "kwargs": {us: "bar"}}
     m = Message(
         None, body=anyjson.dumps(body), backend="foo", content_type="application/json", content_encoding="utf-8"
     )
     tw = TaskRequest.from_message(m, m.decode())
     self.assertIsInstance(tw, Request)
     self.assertEqual(tw.name, body["task"])
     self.assertEqual(tw.id, body["id"])
     self.assertEqual(tw.args, body["args"])
     us = from_utf8(us)
     if sys.version_info < (2, 6):
         self.assertEqual(tw.kwargs.keys()[0], us)
         self.assertIsInstance(tw.kwargs.keys()[0], str)
     self.assertTrue(tw.logger)

예제 #31

 def test_from_message_invalid_kwargs(self):
     body = dict(task=mytask.name, id=1, args=(), kwargs="foo")
     with self.assertRaises(InvalidTaskError):
         TaskRequest.from_message(None, body)

예제 #32

파일: jobs.py 프로젝트: spsu/sylph

 def on_message(self, message_data, message):
     try:
         task = TaskRequest.from_message(message, message_data, logger=self.logger, hostname=self.hostname)
     except Exception, exc:
         message.ack()
         raise

예제 #33

파일: test_worker_job.py 프로젝트: ivirabyan/celery

 def test_from_message_invalid_kwargs(self):
     body = dict(task=mytask.name, id=1, args=(), kwargs="foo")
     with self.assertRaises(InvalidTaskError):
         TaskRequest.from_message(None, body)