def test_prepare(self): o = object() R = [{'foo': 'bar'}, 'celery.utils.functional.LRUCache', o] p = routes.prepare(R) self.assertIsInstance(p[0], routes.MapRoute) self.assertIsInstance(maybe_evaluate(p[1]), LRUCache) self.assertIs(p[2], o) self.assertEqual(routes.prepare(o), [o])
def test_prepare(self): from celery.datastructures import LRUCache o = object() R = [{'foo': 'bar'}, 'celery.datastructures.LRUCache', o] p = routes.prepare(R) self.assertIsInstance(p[0], routes.MapRoute) self.assertIsInstance(maybe_promise(p[1]), LRUCache) self.assertIs(p[2], o) self.assertEqual(routes.prepare(o), [o])
def test_prepare(self): o = object() R = [ {'foo': 'bar'}, qualname(TestRouter), o, ] p = routes.prepare(R) assert isinstance(p[0], routes.MapRoute) assert isinstance(maybe_evaluate(p[1]), TestRouter) assert p[2] is o assert routes.prepare(o) == [o]
def test_prepare(self): o = object() R = [ {'foo': 'bar'}, qualname(TestRouter), o, ] p = routes.prepare(R) self.assertIsInstance(p[0], routes.MapRoute) self.assertIsInstance(maybe_evaluate(p[1]), TestRouter) self.assertIs(p[2], o) self.assertEqual(routes.prepare(o), [o])
def test_lookup_takes_first(self): set_queues(self.app, foo=self.a_queue, bar=self.b_queue) R = routes.prepare(({self.mytask.name: {'queue': 'bar'}}, {self.mytask.name: {'queue': 'foo'}})) router = Router(self.app, R, self.app.amqp.queues) self.assertEqual(router.route({}, self.mytask.name, args=[1, 2], kwargs={})['queue'].name, 'bar')
def test_lookup_takes_first(self): R = routes.prepare(({mytask.name: {"queue": "bar"}}, {mytask.name: {"queue": "foo"}})) router = routes.Router(R, current_app.conf.CELERY_QUEUES) self.assertDictContainsSubset(b_queue, router.route({}, mytask.name, args=[1, 2], kwargs={}))
def test_expands_queue_in_options(self): set_queues(self.app) R = routes.prepare(()) router = Router( self.app, R, self.app.amqp.queues, create_missing=True, ) # apply_async forwards all arguments, even exchange=None etc, # so need to make sure it's merged correctly. route = router.route( { 'queue': 'testq', 'exchange': None, 'routing_key': None, 'immediate': False }, self.mytask.name, args=[1, 2], kwargs={}, ) assert route['queue'].name == 'testq' assert route['queue'].exchange == Exchange('testq') assert route['queue'].routing_key == 'testq' assert route['immediate'] is False
def test_lookup_takes_first(self): with _queues(self.app, foo=self.a_queue, bar=self.b_queue): R = routes.prepare(({mytask.name: {'queue': 'bar'}}, {mytask.name: {'queue': 'foo'}})) router = Router(self.app, R, self.app.amqp.queues) self.assertEqual(router.route({}, mytask.name, args=[1, 2], kwargs={})['queue'].name, 'bar')
def test_compat_router_class(self): self.simple_queue_setup() R = routes.prepare(( TestRouter(), )) router = Router(self.app, R, self.app.amqp.queues) self.assert_routes_to_queue('bar', router, 'celery.xaza') self.assert_routes_to_default_queue(router, 'celery.poza')
def test_lookup_paths_traversed(self): R = routes.prepare(({'celery.xaza': {'queue': 'bar'}}, {mytask.name: {'queue': 'foo'}})) router = Router(R, current_app.amqp.queues) self.assertAnswer(router.route({}, mytask.name, args=[1, 2], kwargs={}), a_queue) self.assertAnswer(router.route({}, 'celery.poza'), dict(d_queue, queue=current_app.conf.CELERY_DEFAULT_QUEUE))
def test_lookup_paths_traversed(self): R = routes.prepare(({"celery.xaza": {"queue": "bar"}}, {mytask.name: {"queue": "foo"}})) router = routes.Router(R, current_app.amqp.queues) self.assertAnswer(router.route({}, mytask.name, args=[1, 2], kwargs={}), a_queue) self.assertAnswer(router.route({}, "celery.poza"), dict(d_queue, queue=current_app.conf.CELERY_DEFAULT_QUEUE))
def test_lookup_paths_traversed(self): self.simple_queue_setup() R = routes.prepare(( {'celery.xaza': {'queue': 'bar'}}, {self.mytask.name: {'queue': 'foo'}} )) router = Router(self.app, R, self.app.amqp.queues) self.assert_routes_to_queue('foo', router, self.mytask.name) self.assert_routes_to_default_queue(router, 'celery.poza')
def test_compat_router_classes__called_with(self): self.simple_queue_setup() step = Mock(spec=['route_for_task']) step.route_for_task.return_value = None R = routes.prepare([step]) router = Router(self.app, R, self.app.amqp.queues) self.mytask.apply_async((2, 2), {'kw': 3}, router=router, priority=3) step.route_for_task.assert_called_with( self.mytask.name, (2, 2), {'kw': 3}, )
def test_lookup_paths_traversed(self): R = routes.prepare(({'celery.xaza': {'queue': 'bar'}}, {mytask.name: {'queue': 'foo'}})) router = Router(R, current_app.amqp.queues) self.assertEqual(router.route({}, mytask.name, args=[1, 2], kwargs={})['queue'].name, 'foo') self.assertEqual( router.route({}, 'celery.poza')['queue'].name, current_app.conf.CELERY_DEFAULT_QUEUE, )
def test_router_fun__called_with(self): self.simple_queue_setup() step = Mock(spec=['__call__']) step.return_value = None R = routes.prepare([step]) router = Router(self.app, R, self.app.amqp.queues) self.mytask.apply_async((2, 2), {'kw': 3}, router=router, priority=3) step.assert_called_with( self.mytask.name, (2, 2), {'kw': 3}, ANY, task=self.mytask, ) options = step.call_args[0][3] assert options['priority'] == 3
def test_lookup_takes_first(self): set_queues(self.app, foo=self.a_queue, bar=self.b_queue) R = routes.prepare(({ self.mytask.name: { 'queue': 'bar' } }, { self.mytask.name: { 'queue': 'foo' } })) router = Router(self.app, R, self.app.amqp.queues) self.assert_routes_to_queue('bar', router, self.mytask.name)
def test_lookup_takes_first(self): R = routes.prepare(({ mytask.name: { "queue": "bar" } }, { mytask.name: { "queue": "foo" } })) router = routes.Router(R, current_app.conf.CELERY_QUEUES) self.assertDictContainsSubset( b_queue, router.route({}, mytask.name, args=[1, 2], kwargs={}))
def test_router_fun__called_with(self): self.simple_queue_setup() step = Mock(spec=['__call__']) step.return_value = None R = routes.prepare([step]) router = Router(self.app, R, self.app.amqp.queues) self.mytask.apply_async((2, 2), {'kw': 3}, router=router, priority=3) step.assert_called_with( self.mytask.name, (2, 2), {'kw': 3}, ANY, task=self.mytask, ) options = step.call_args[0][3] self.assertEqual(options['priority'], 3)
def test_lookup_takes_first(self): R = routes.prepare(({ mytask.name: { 'queue': 'bar' } }, { mytask.name: { 'queue': 'foo' } })) router = Router(R, current_app.amqp.queues) self.assertAnswer( router.route({}, mytask.name, args=[1, 2], kwargs={}), b_queue)
def test_lookup_paths_traversed(self): with _queues(self.app, foo=self.a_queue, bar=self.b_queue, **{ self.app.conf.CELERY_DEFAULT_QUEUE: self.d_queue}): R = routes.prepare(( {'celery.xaza': {'queue': 'bar'}}, {mytask.name: {'queue': 'foo'}} )) router = Router(self.app, R, self.app.amqp.queues) self.assertEqual(router.route({}, mytask.name, args=[1, 2], kwargs={})['queue'].name, 'foo') self.assertEqual( router.route({}, 'celery.poza')['queue'].name, self.app.conf.CELERY_DEFAULT_QUEUE, )
def test_expands_queue_in_options(self): R = routes.prepare(()) router = Router(R, current_app.amqp.queues, create_missing=True) # apply_async forwards all arguments, even exchange=None etc, # so need to make sure it's merged correctly. route = router.route({'queue': 'testq', 'exchange': None, 'routing_key': None, 'immediate': False}, mytask.name, args=[1, 2], kwargs={}) self.assertEqual(route['queue'].name, 'testq') self.assertEqual(route['queue'].exchange, Exchange('testq')) self.assertEqual(route['queue'].routing_key, 'testq') self.assertEqual(route['immediate'], False)
def test_lookup_paths_traversed(self): R = routes.prepare(({ 'celery.xaza': { 'queue': 'bar' } }, { mytask.name: { 'queue': 'foo' } })) router = Router(R, current_app.amqp.queues) self.assertAnswer( router.route({}, mytask.name, args=[1, 2], kwargs={}), a_queue) self.assertAnswer( router.route({}, 'celery.poza'), dict(d_queue, queue=current_app.conf.CELERY_DEFAULT_QUEUE))
def test_lookup_paths_traversed(self): set_queues( self.app, foo=self.a_queue, bar=self.b_queue, **{self.app.conf.task_default_queue: self.d_queue} ) R = routes.prepare(( {'celery.xaza': {'queue': 'bar'}}, {self.mytask.name: {'queue': 'foo'}} )) router = Router(self.app, R, self.app.amqp.queues) self.assertEqual(router.route({}, self.mytask.name, args=[1, 2], kwargs={})['queue'].name, 'foo') self.assertEqual( router.route({}, 'celery.poza')['queue'].name, self.app.conf.task_default_queue, )
def test_expands_queue_in_options(self): R = routes.prepare(()) router = routes.Router(R, current_app.conf.CELERY_QUEUES, create_missing=True) # apply_async forwards all arguments, even exchange=None etc, # so need to make sure it's merged correctly. route = router.route({"queue": "testq", "exchange": None, "routing_key": None, "immediate": False}, mytask.name, args=[1, 2], kwargs={}) self.assertDictContainsSubset({"exchange": "testq", "routing_key": "testq", "immediate": False}, route) self.assertIn("queue", route)
def test_expands_queue_in_options(self): R = routes.prepare(()) router = routes.Router(R, current_app.amqp.queues, create_missing=True) # apply_async forwards all arguments, even exchange=None etc, # so need to make sure it's merged correctly. route = router.route({"queue": "testq", "exchange": None, "routing_key": None, "immediate": False}, mytask.name, args=[1, 2], kwargs={}) self.assertDictContainsSubset({"routing_key": "testq", "immediate": False}, route) self.assertEqual(route["exchange"].name, "testq") self.assertIn("queue", route)
def test_lookup_paths_traversed(self): R = routes.prepare(({ 'celery.xaza': { 'queue': 'bar' } }, { mytask.name: { 'queue': 'foo' } })) router = Router(R, current_app.amqp.queues) self.assertEqual( router.route({}, mytask.name, args=[1, 2], kwargs={})['queue'].name, 'foo') self.assertEqual( router.route({}, 'celery.poza')['queue'].name, current_app.conf.CELERY_DEFAULT_QUEUE, )
def test_expands_queue_in_options(self): R = routes.prepare(()) router = Router(R, current_app.amqp.queues, create_missing=True) # apply_async forwards all arguments, even exchange=None etc, # so need to make sure it's merged correctly. route = router.route( { 'queue': 'testq', 'exchange': None, 'routing_key': None, 'immediate': False }, mytask.name, args=[1, 2], kwargs={}) self.assertEqual(route['queue'].name, 'testq') self.assertEqual(route['queue'].exchange, Exchange('testq')) self.assertEqual(route['queue'].routing_key, 'testq') self.assertEqual(route['immediate'], False)
def test_expands_queue_in_options(self): set_queues(self.app) R = routes.prepare(()) router = Router( self.app, R, self.app.amqp.queues, create_missing=True, ) # apply_async forwards all arguments, even exchange=None etc, # so need to make sure it's merged correctly. route = router.route( {'queue': 'testq', 'exchange': None, 'routing_key': None, 'immediate': False}, self.mytask.name, args=[1, 2], kwargs={}, ) assert route['queue'].name == 'testq' assert route['queue'].exchange == Exchange('testq') assert route['queue'].routing_key == 'testq' assert route['immediate'] is False
def test_prepare_item_is_dict(self): R = {'foo': 'bar'} p = routes.prepare(R) assert isinstance(p[0], routes.MapRoute)
def test_prepare_item_is_dict(self): R = {"foo": "bar"} p = routes.prepare(R) self.assertIsInstance(p[0], routes.MapRoute)
def test_lookup_takes_first(self): set_queues(self.app, foo=self.a_queue, bar=self.b_queue) R = routes.prepare(({self.mytask.name: {'queue': 'bar'}}, {self.mytask.name: {'queue': 'foo'}})) router = Router(self.app, R, self.app.amqp.queues) self.assert_routes_to_queue('bar', router, self.mytask.name)
def flush_routes(self): self._rtable = _routes.prepare(self.app.conf.task_routes)
def test_prepare_item_is_dict(self): R = {'foo': 'bar'} p = routes.prepare(R) self.assertIsInstance(p[0], routes.MapRoute)
def test_lookup_takes_first(self): R = routes.prepare(({mytask.name: {'queue': 'bar'}}, {mytask.name: {'queue': 'foo'}})) router = Router(R, current_app.amqp.queues) self.assertEqual(router.route({}, mytask.name, args=[1, 2], kwargs={})['queue'].name, 'bar')
def test_lookup_takes_first(self): R = routes.prepare(({mytask.name: {"queue": "bar"}}, {mytask.name: {"queue": "foo"}})) router = routes.Router(R, current_app.amqp.queues) self.assertAnswer(router.route({}, mytask.name, args=[1, 2], kwargs={}), b_queue)