Example #1
0
    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])
Example #2
0
    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):
        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])
Example #5
0
    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]
Example #6
0
    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])
Example #7
0
 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')
Example #8
0
 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={}))
Example #9
0
 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
Example #10
0
 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')
Example #11
0
 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')
Example #12
0
 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))
Example #13
0
 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))
Example #14
0
 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')
Example #15
0
 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')
Example #16
0
 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')
Example #17
0
 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,
     )
Example #19
0
 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},
     )
Example #20
0
 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
Example #21
0
 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)
Example #22
0
 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={}))
Example #23
0
 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)
Example #25
0
 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,
         )
Example #26
0
 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))
Example #29
0
 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,
     )
Example #30
0
 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)
Example #31
0
 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)
Example #32
0
 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,
     )
Example #33
0
 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)
Example #34
0
 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
Example #35
0
 def test_prepare_item_is_dict(self):
     R = {'foo': 'bar'}
     p = routes.prepare(R)
     assert isinstance(p[0], routes.MapRoute)
Example #36
0
 def test_prepare_item_is_dict(self):
     R = {"foo": "bar"}
     p = routes.prepare(R)
     self.assertIsInstance(p[0], routes.MapRoute)
Example #37
0
 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)
Example #38
0
 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)
Example #40
0
 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')
Example #42
0
 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)