Did I find the right examples for you? yes no      Crawl my project      Python Jobs

All Samples(0)  |  Call(0)  |  Derive(0)  |  Import(0)

src/s/o/socorro-HEAD/webapp-django/vendor/lib/python/celery/tests/test_app/test_routes.py   socorro(Download)
    def test_route_for_task_expanded_route(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({mytask.name: {"queue": "foo"}})
        self.assertDictContainsSubset(a_queue,
                             expand(route.route_for_task(mytask.name)))
        self.assertIsNone(route.route_for_task("celery.awesome"))
 
    @with_queues(foo=a_queue, bar=b_queue)
    def test_route_for_task(self):
        expand = E(current_app.conf.CELERY_QUEUES)
    def test_expand_route_not_found(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({"a": {"queue": "x"}})
        with self.assertRaises(QueueNotFound):
            expand(route.route_for_task("a"))
    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,
    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,

src/o/p/openquake-packages-HEAD/celery/celery/tests/test_app/test_routes.py   openquake-packages(Download)
    def test_route_for_task_expanded_route(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({"celery.ping": {"queue": "foo"}})
        self.assertDictContainsSubset(a_queue,
                             expand(route.route_for_task("celery.ping")))
        self.assertIsNone(route.route_for_task("celery.awesome"))
 
    @with_queues(foo=a_queue, bar=b_queue)
    def test_route_for_task(self):
        expand = E(current_app.conf.CELERY_QUEUES)
    def test_expand_route_not_found(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({"a": {"queue": "x"}})
        with self.assertRaises(QueueNotFound):
            expand(route.route_for_task("a"))
    def test_lookup_takes_first(self):
        R = routes.prepare(({"celery.ping": {"queue": "bar"}},
                            {"celery.ping": {"queue": "foo"}}))
        router = routes.Router(R, current_app.conf.CELERY_QUEUES)
        self.assertDictContainsSubset(b_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,

src/m/a/make.mozilla.org-HEAD/vendor-local/lib/python/celery/tests/test_app/test_routes.py   make.mozilla.org(Download)
    def test_route_for_task_expanded_route(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({mytask.name: {"queue": "foo"}})
        self.assertDictContainsSubset(a_queue,
                             expand(route.route_for_task(mytask.name)))
        self.assertIsNone(route.route_for_task("celery.awesome"))
 
    @with_queues(foo=a_queue, bar=b_queue)
    def test_route_for_task(self):
        expand = E(current_app.conf.CELERY_QUEUES)
    def test_expand_route_not_found(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({"a": {"queue": "x"}})
        with self.assertRaises(QueueNotFound):
            expand(route.route_for_task("a"))
    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,
    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,

src/o/h/oh-mainline-HEAD/vendor/packages/celery/celery/tests/test_app/test_routes.py   oh-mainline(Download)
    def test_route_for_task_expanded_route(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({"celery.ping": {"queue": "foo"}})
        self.assertDictContainsSubset(a_queue,
                             expand(route.route_for_task("celery.ping")))
        self.assertIsNone(route.route_for_task("celery.awesome"))
 
    @with_queues(foo=a_queue, bar=b_queue)
    def test_route_for_task(self):
        expand = E(current_app.conf.CELERY_QUEUES)
    def test_expand_route_not_found(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({"a": {"queue": "x"}})
        with self.assertRaises(QueueNotFound):
            expand(route.route_for_task("a"))
    def test_lookup_takes_first(self):
        R = routes.prepare(({"celery.ping": {"queue": "bar"}},
                            {"celery.ping": {"queue": "foo"}}))
        router = routes.Router(R, current_app.conf.CELERY_QUEUES)
        self.assertDictContainsSubset(b_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,

src/m/o/mozillians-HEAD/vendor-local/lib/python/celery/tests/test_app/test_routes.py   mozillians(Download)
    def test_route_for_task_expanded_route(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({mytask.name: {"queue": "foo"}})
        self.assertDictContainsSubset(a_queue,
                             expand(route.route_for_task(mytask.name)))
        self.assertIsNone(route.route_for_task("celery.awesome"))
 
    @with_queues(foo=a_queue, bar=b_queue)
    def test_route_for_task(self):
        expand = E(current_app.conf.CELERY_QUEUES)
    def test_expand_route_not_found(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({"a": {"queue": "x"}})
        with self.assertRaises(QueueNotFound):
            expand(route.route_for_task("a"))
    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,
    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,

src/p/l/playdoh-lib-HEAD/lib/python/celery/tests/test_app/test_routes.py   playdoh-lib(Download)
    def test_route_for_task_expanded_route(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({mytask.name: {"queue": "foo"}})
        self.assertDictContainsSubset(a_queue,
                             expand(route.route_for_task(mytask.name)))
        self.assertIsNone(route.route_for_task("celery.awesome"))
 
    @with_queues(foo=a_queue, bar=b_queue)
    def test_route_for_task(self):
        expand = E(current_app.conf.CELERY_QUEUES)
    def test_expand_route_not_found(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({"a": {"queue": "x"}})
        with self.assertRaises(QueueNotFound):
            expand(route.route_for_task("a"))
    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,
    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,

src/k/u/kuma-lib-HEAD/packages/celery/celery/tests/test_app/test_routes.py   kuma-lib(Download)
    def test_route_for_task_expanded_route(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({mytask.name: {"queue": "foo"}})
        self.assertDictContainsSubset(a_queue,
                             expand(route.route_for_task(mytask.name)))
        self.assertIsNone(route.route_for_task("celery.awesome"))
 
    @with_queues(foo=a_queue, bar=b_queue)
    def test_route_for_task(self):
        expand = E(current_app.conf.CELERY_QUEUES)
    def test_expand_route_not_found(self):
        expand = E(current_app.conf.CELERY_QUEUES)
        route = routes.MapRoute({"a": {"queue": "x"}})
        with self.assertRaises(QueueNotFound):
            expand(route.route_for_task("a"))
    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,
    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,

src/f/i/firefox-flicks-HEAD/vendor-local/lib/python/celery/tests/app/test_routes.py   firefox-flicks(Download)
    def test_expand_route_not_found(self):
        expand = E(current_app.amqp.Queues(
            current_app.conf.CELERY_QUEUES, False))
        route = routes.MapRoute({'a': {'queue': 'x'}})
        with self.assertRaises(QueueNotFound):

src/a/n/antisocial-HEAD/ve/lib/python2.7/site-packages/celery/tests/app/test_routes.py   antisocial(Download)
    def test_expand_route_not_found(self):
        expand = E(current_app.amqp.Queues(
            current_app.conf.CELERY_QUEUES, False))
        route = routes.MapRoute({'a': {'queue': 'x'}})
        with self.assertRaises(QueueNotFound):