More single quotes

celery/app/control.py

@@ -190,7 +190,6 @@ class Control(object):
         return self.broadcast('cancel_consumer',
                 arguments={'queue': queue}, **kwargs)
 
-
     def time_limit(self, task_name, soft=None, hard=None, **kwargs):
         """Tell all (or specific) workers to set time limits for
         a task by type.

celery/app/task.py

@@ -559,7 +559,7 @@ class Task(object):
         # so just raise the original exception.
         if request.called_directly:
             maybe_reraise()
-            raise exc or RetryTaskError("Task can be retried', None)
+            raise exc or RetryTaskError('Task can be retried', None)
 
         if delivery_info:
             options.setdefault('exchange', delivery_info.get('exchange'))

celery/bin/base.py

@@ -93,6 +93,7 @@ Try --help?
 find_long_opt = re.compile(r'.+?(--.+?)(?:\s|,|$)')
 find_rst_ref = re.compile(r':\w+:`(.+?)`')
 
+
 class HelpFormatter(IndentedHelpFormatter):
 
     def format_epilog(self, epilog):

celery/bin/celery.py

@@ -468,7 +468,7 @@ class _RemoteControl(Command):
     def do_call_method(self, args, **kwargs):
         method = args[0]
         if method == 'help':
-            raise Error("Did you mean '%s --help'?' % self.name)
+            raise Error("Did you mean '%s --help'?" % self.name)
         if method not in self.choices:
             raise Error('Unknown %s method %s' % (self.name, method))
 

celery/schedules.py

@@ -310,7 +310,7 @@ class crontab(schedule):
             if number >= max_ + min_ or number < min_:
                 raise ValueError(
                         'Invalid crontab pattern. Valid '
-                        'range is %d-%d. '%d' was found.' %
+                        "range is %d-%d. '%d' was found." %
                         (min_, max_ - 1 + min_, number))
 
         return result

celery/tests/__init__.py

@@ -8,15 +8,15 @@ import warnings
 
 from importlib import import_module
 
-config_module = os.environ.setdefault("CELERY_TEST_CONFIG_MODULE",
-                                      "celery.tests.config")
+config_module = os.environ.setdefault('CELERY_TEST_CONFIG_MODULE',
+                                      'celery.tests.config')
 
-os.environ.setdefault("CELERY_CONFIG_MODULE", config_module)
-os.environ["CELERY_LOADER"] = "default"
-os.environ["EVENTLET_NOPATCH"] = "yes"
-os.environ["GEVENT_NOPATCH"] = "yes"
-os.environ["KOMBU_DISABLE_LIMIT_PROTECTION"] = "yes"
-os.environ["CELERY_BROKER_URL"] = "memory://"
+os.environ.setdefault('CELERY_CONFIG_MODULE', config_module)
+os.environ['CELERY_LOADER'] = 'default'
+os.environ['EVENTLET_NOPATCH'] = 'yes'
+os.environ['GEVENT_NOPATCH'] = 'yes'
+os.environ['KOMBU_DISABLE_LIMIT_PROTECTION'] = 'yes'
+os.environ['CELERY_BROKER_URL'] = 'memory://'
 
 try:
     WindowsError = WindowsError  # noqa
@@ -37,40 +37,40 @@ def teardown():
 
     # Make sure test database is removed.
     import os
-    if os.path.exists("test.db"):
+    if os.path.exists('test.db'):
         try:
-            os.remove("test.db")
+            os.remove('test.db')
         except WindowsError:
             pass
 
     # Make sure there are no remaining threads at shutdown.
     import threading
     remaining_threads = [thread for thread in threading.enumerate()
-                            if thread.getName() != "MainThread"]
+                            if thread.getName() != 'MainThread']
     if remaining_threads:
         sys.stderr.write(
-            "\n\n**WARNING**: Remaining threads at teardown: %r...\n" % (
+            '\n\n**WARNING**: Remaining threads at teardown: %r...\n' % (
                 remaining_threads))
 
 
 def find_distribution_modules(name=__name__, file=__file__):
-    current_dist_depth = len(name.split(".")) - 1
+    current_dist_depth = len(name.split('.')) - 1
     current_dist = os.path.join(os.path.dirname(file),
                                 *([os.pardir] * current_dist_depth))
     abs = os.path.abspath(current_dist)
     dist_name = os.path.basename(abs)
 
     for dirpath, dirnames, filenames in os.walk(abs):
-        package = (dist_name + dirpath[len(abs):]).replace("/", ".")
-        if "__init__.py" in filenames:
+        package = (dist_name + dirpath[len(abs):]).replace('/', '.')
+        if '__init__.py' in filenames:
             yield package
             for filename in filenames:
-                if filename.endswith(".py") and filename != "__init__.py":
-                    yield ".".join([package, filename])[:-3]
+                if filename.endswith('.py') and filename != '__init__.py':
+                    yield '.'.join([package, filename])[:-3]
 
 
 def import_all_modules(name=__name__, file=__file__,
-        skip=["celery.decorators", "celery.contrib.batches"]):
+        skip=['celery.decorators', 'celery.contrib.batches']):
     for module in find_distribution_modules(name, file):
         if module not in skip:
             try:
@@ -79,7 +79,7 @@ def import_all_modules(name=__name__, file=__file__,
                 pass
 
 
-if os.environ.get("COVER_ALL_MODULES") or "--with-coverage3" in sys.argv:
+if os.environ.get('COVER_ALL_MODULES') or '--with-coverage3' in sys.argv:
     from celery.tests.utils import catch_warnings
     with catch_warnings(record=True):
         import_all_modules()

celery/tests/app/test_amqp.py

@@ -20,7 +20,7 @@ class test_TaskProducer(AppCase):
 
     def test_declare(self):
         publisher = self.app.amqp.TaskProducer(self.app.broker_connection())
-        publisher.exchange.name = "foo"
+        publisher.exchange.name = 'foo'
         publisher.declare()
         publisher.exchange.name = None
         publisher.declare()
@@ -28,30 +28,30 @@ class test_TaskProducer(AppCase):
     def test_retry_policy(self):
         pub = self.app.amqp.TaskProducer(Mock())
         pub.channel.connection.client.declared_entities = set()
-        pub.delay_task("tasks.add", (2, 2), {},
-                       retry_policy={"frobulate": 32.4})
+        pub.delay_task('tasks.add', (2, 2), {},
+                       retry_policy={'frobulate': 32.4})
 
     def test_publish_no_retry(self):
         pub = self.app.amqp.TaskProducer(Mock())
         pub.channel.connection.client.declared_entities = set()
-        pub.delay_task("tasks.add", (2, 2), {}, retry=False, chord=123)
+        pub.delay_task('tasks.add', (2, 2), {}, retry=False, chord=123)
         self.assertFalse(pub.connection.ensure.call_count)
 
 
 class test_compat_TaskPublisher(AppCase):
 
     def test_compat_exchange_is_string(self):
-        producer = TaskPublisher(exchange="foo", app=self.app)
+        producer = TaskPublisher(exchange='foo', app=self.app)
         self.assertIsInstance(producer.exchange, Exchange)
-        self.assertEqual(producer.exchange.name, "foo")
-        self.assertEqual(producer.exchange.type, "direct")
-        producer = TaskPublisher(exchange="foo", exchange_type="topic",
+        self.assertEqual(producer.exchange.name, 'foo')
+        self.assertEqual(producer.exchange.type, 'direct')
+        producer = TaskPublisher(exchange='foo', exchange_type='topic',
                                  app=self.app)
-        self.assertEqual(producer.exchange.type, "topic")
+        self.assertEqual(producer.exchange.type, 'topic')
 
     def test_compat_exchange_is_Exchange(self):
-        producer = TaskPublisher(exchange=Exchange("foo"))
-        self.assertEqual(producer.exchange.name, "foo")
+        producer = TaskPublisher(exchange=Exchange('foo'))
+        self.assertEqual(producer.exchange.name, 'foo')
 
 
 class test_PublisherPool(AppCase):
@@ -60,10 +60,10 @@ class test_PublisherPool(AppCase):
         L = self.app.conf.BROKER_POOL_LIMIT
         self.app.conf.BROKER_POOL_LIMIT = None
         try:
-            delattr(self.app, "_pool")
+            delattr(self.app, '_pool')
         except AttributeError:
             pass
-        self.app.amqp.__dict__.pop("producer_pool", None)
+        self.app.amqp.__dict__.pop('producer_pool', None)
         try:
             pool = self.app.amqp.producer_pool
             self.assertEqual(pool.limit, self.app.pool.limit)
@@ -82,10 +82,10 @@ class test_PublisherPool(AppCase):
         L = self.app.conf.BROKER_POOL_LIMIT
         self.app.conf.BROKER_POOL_LIMIT = 2
         try:
-            delattr(self.app, "_pool")
+            delattr(self.app, '_pool')
         except AttributeError:
             pass
-        self.app.amqp.__dict__.pop("producer_pool", None)
+        self.app.amqp.__dict__.pop('producer_pool', None)
         try:
             pool = self.app.amqp.producer_pool
             self.assertEqual(pool.limit, self.app.pool.limit)
@@ -111,7 +111,7 @@ class test_Queues(AppCase):
         prev, self.app.amqp.queues._consume_from = \
                 self.app.amqp.queues._consume_from, {}
         try:
-            self.assertEqual(self.app.amqp.queues.format(), "")
+            self.assertEqual(self.app.amqp.queues.format(), '')
         finally:
             self.app.amqp.queues._consume_from = prev
 
@@ -120,18 +120,18 @@ class test_Queues(AppCase):
 
     def test_add(self):
         q = Queues()
-        q.add("foo", exchange="ex", routing_key="rk")
-        self.assertIn("foo", q)
-        self.assertIsInstance(q["foo"], Queue)
-        self.assertEqual(q["foo"].routing_key, "rk")
+        q.add('foo', exchange='ex', routing_key='rk')
+        self.assertIn('foo', q)
+        self.assertIsInstance(q['foo'], Queue)
+        self.assertEqual(q['foo'].routing_key, 'rk')
 
     def test_add_default_exchange(self):
-        ex = Exchange("fff", "fanout")
+        ex = Exchange('fff', 'fanout')
         q = Queues(default_exchange=ex)
-        q.add(Queue("foo"))
-        self.assertEqual(q["foo"].exchange, ex)
+        q.add(Queue('foo'))
+        self.assertEqual(q['foo'].exchange, ex)
 
     def test_alias(self):
         q = Queues()
-        q.add(Queue("foo", alias="barfoo"))
-        self.assertIs(q["barfoo"], q["foo"])
+        q.add(Queue('foo', alias='barfoo'))
+        self.assertIs(q['barfoo'], q['foo'])

celery/tests/app/test_annotations.py

@@ -24,13 +24,13 @@ class MyAnnotation(object):
 class test_MapAnnotation(Case):
 
     def test_annotate(self):
-        x = MapAnnotation({add.name: {"foo": 1}})
-        self.assertDictEqual(x.annotate(add), {"foo": 1})
+        x = MapAnnotation({add.name: {'foo': 1}})
+        self.assertDictEqual(x.annotate(add), {'foo': 1})
         self.assertIsNone(x.annotate(mul))
 
     def test_annotate_any(self):
-        x = MapAnnotation({'*': {"foo": 2}})
-        self.assertDictEqual(x.annotate_any(), {"foo": 2})
+        x = MapAnnotation({'*': {'foo': 2}})
+        self.assertDictEqual(x.annotate_any(), {'foo': 2})
 
         x = MapAnnotation()
         self.assertIsNone(x.annotate_any())
@@ -39,7 +39,7 @@ class test_MapAnnotation(Case):
 class test_prepare(Case):
 
     def test_dict_to_MapAnnotation(self):
-        x = prepare({add.name: {"foo": 3}})
+        x = prepare({add.name: {'foo': 3}})
         self.assertIsInstance(x[0], MapAnnotation)
 
     def test_returns_list(self):

celery/tests/app/test_app.py

@@ -22,7 +22,7 @@ from celery.tests.utils import (Case, mask_modules, platform_pyimp,
 from celery.utils import uuid
 from celery.utils.mail import ErrorMail
 
-THIS_IS_A_KEY = "this is a value"
+THIS_IS_A_KEY = 'this is a value'
 
 
 class Object(object):
@@ -35,7 +35,7 @@ class Object(object):
 def _get_test_config():
     return dict((key, getattr(config, key))
                     for key in dir(config)
-                        if key.isupper() and not key.startswith("_"))
+                        if key.isupper() and not key.startswith('_'))
 
 test_config = _get_test_config()
 
@@ -56,23 +56,23 @@ class test_App(Case):
         self.app.conf.update(test_config)
 
     def test_task(self):
-        app = Celery("foozibari", set_as_current=False)
+        app = Celery('foozibari', set_as_current=False)
 
         def fun():
             pass
 
-        fun.__module__ = "__main__"
+        fun.__module__ = '__main__'
         task = app.task(fun)
-        self.assertEqual(task.name, app.main + ".fun")
+        self.assertEqual(task.name, app.main + '.fun')
 
     def test_with_broker(self):
-        prev = os.environ.get("CELERY_BROKER_URL")
-        os.environ.pop("CELERY_BROKER_URL", None)
+        prev = os.environ.get('CELERY_BROKER_URL')
+        os.environ.pop('CELERY_BROKER_URL', None)
         try:
-            app = Celery(set_as_current=False, broker="foo://baribaz")
-            self.assertEqual(app.conf.BROKER_HOST, "foo://baribaz")
+            app = Celery(set_as_current=False, broker='foo://baribaz')
+            self.assertEqual(app.conf.BROKER_HOST, 'foo://baribaz')
         finally:
-            os.environ["CELERY_BROKER_URL"] = prev
+            os.environ['CELERY_BROKER_URL'] = prev
 
     def test_repr(self):
         self.assertTrue(repr(self.app))
@@ -83,8 +83,8 @@ class test_App(Case):
         self.assertIs(app2.tasks, app1.tasks)
 
     def test_include_argument(self):
-        app = Celery(set_as_current=False, include=("foo", "bar.foo"))
-        self.assertEqual(app.conf.CELERY_IMPORTS, ("foo", "bar.foo"))
+        app = Celery(set_as_current=False, include=('foo', 'bar.foo'))
+        self.assertEqual(app.conf.CELERY_IMPORTS, ('foo', 'bar.foo'))
 
     def test_set_as_current(self):
         current = state._tls.current_app
@@ -108,7 +108,7 @@ class test_App(Case):
             state._task_stack.pop()
 
     def test_task_not_shared(self):
-        with patch("celery.app.base.shared_task") as shared_task:
+        with patch('celery.app.base.shared_task') as shared_task:
             app = Celery(set_as_current=False)
 
             @app.task(shared=False)
@@ -146,13 +146,13 @@ class test_App(Case):
         from celery.app import task as _task
         _task.MP_MAIN_FILE = __file__
         try:
-            app = Celery("xuzzy", set_as_current=False)
+            app = Celery('xuzzy', set_as_current=False)
 
             @app.task
             def foo():
                 pass
 
-            self.assertEqual(foo.name, "xuzzy.foo")
+            self.assertEqual(foo.name, 'xuzzy.foo')
         finally:
             _task.MP_MAIN_FILE = None
 
@@ -186,7 +186,7 @@ class test_App(Case):
 
         app = Celery(set_as_current=False)
         app.conf.CELERY_ANNOTATIONS = {
-                adX.name: {"@__call__": deco}
+                adX.name: {'@__call__': deco}
         }
         adX.bind(app)
         self.assertIs(adX.app, app)
@@ -201,14 +201,14 @@ class test_App(Case):
     def test_apply_async_has__self__(self):
         app = Celery(set_as_current=False)
 
-        @app.task(__self__="hello")
+        @app.task(__self__='hello')
         def aawsX():
             pass
 
-        with patch("celery.app.amqp.TaskProducer.delay_task") as dt:
+        with patch('celery.app.amqp.TaskProducer.delay_task') as dt:
             aawsX.apply_async((4, 5))
             args = dt.call_args[0][1]
-            self.assertEqual(args, ("hello", 4, 5))
+            self.assertEqual(args, ('hello', 4, 5))
 
     def test_apply_async__connection_arg(self):
         app = Celery(set_as_current=False)
@@ -217,7 +217,7 @@ class test_App(Case):
         def aacaX():
             pass
 
-        connection = app.broker_connection("asd://")
+        connection = app.broker_connection('asd://')
         with self.assertRaises(KeyError):
             aacaX.apply_async(connection=connection)
 
@@ -250,8 +250,8 @@ class test_App(Case):
         self.assertIs(ts.app, self.app)
 
     def test_pickle_app(self):
-        changes = dict(THE_FOO_BAR="bars",
-                       THE_MII_MAR="jars")
+        changes = dict(THE_FOO_BAR='bars',
+                       THE_MII_MAR='jars')
         self.app.conf.update(changes)
         saved = pickle.dumps(self.app)
         self.assertLess(len(saved), 2048)
@@ -268,15 +268,15 @@ class test_App(Case):
 
         prev, celeryd.WorkerCommand = celeryd.WorkerCommand, WorkerCommand
         try:
-            ret = self.app.worker_main(argv=["--version"])
-            self.assertListEqual(ret, ["--version"])
+            ret = self.app.worker_main(argv=['--version'])
+            self.assertListEqual(ret, ['--version'])
         finally:
             celeryd.WorkerCommand = prev
 
     def test_config_from_envvar(self):
-        os.environ["CELERYTEST_CONFIG_OBJECT"] = "celery.tests.app.test_app"
-        self.app.config_from_envvar("CELERYTEST_CONFIG_OBJECT")
-        self.assertEqual(self.app.conf.THIS_IS_A_KEY, "this is a value")
+        os.environ['CELERYTEST_CONFIG_OBJECT'] = 'celery.tests.app.test_app'
+        self.app.config_from_envvar('CELERYTEST_CONFIG_OBJECT')
+        self.assertEqual(self.app.conf.THIS_IS_A_KEY, 'this is a value')
 
     def test_config_from_object(self):
 
@@ -296,28 +296,28 @@ class test_App(Case):
         self.assertTrue(self.app.conf.UNDERSTAND_ME)
 
     def test_config_from_cmdline(self):
-        cmdline = [".always_eager=no",
-                   ".result_backend=/dev/null",
+        cmdline = ['.always_eager=no',
+                   '.result_backend=/dev/null',
                    '.task_error_whitelist=(list)["a", "b", "c"]',
-                   "celeryd.prefetch_multiplier=368",
-                   ".foobarstring=(string)300",
-                   ".foobarint=(int)300",
+                   'celeryd.prefetch_multiplier=368',
+                   '.foobarstring=(string)300',
+                   '.foobarint=(int)300',
                    '.result_engine_options=(dict){"foo": "bar"}']
-        self.app.config_from_cmdline(cmdline, namespace="celery")
+        self.app.config_from_cmdline(cmdline, namespace='celery')
         self.assertFalse(self.app.conf.CELERY_ALWAYS_EAGER)
-        self.assertEqual(self.app.conf.CELERY_RESULT_BACKEND, "/dev/null")
+        self.assertEqual(self.app.conf.CELERY_RESULT_BACKEND, '/dev/null')
         self.assertEqual(self.app.conf.CELERYD_PREFETCH_MULTIPLIER, 368)
         self.assertListEqual(self.app.conf.CELERY_TASK_ERROR_WHITELIST,
-                             ["a", "b", "c"])
-        self.assertEqual(self.app.conf.CELERY_FOOBARSTRING, "300")
+                             ['a', 'b', 'c'])
+        self.assertEqual(self.app.conf.CELERY_FOOBARSTRING, '300')
         self.assertEqual(self.app.conf.CELERY_FOOBARINT, 300)
         self.assertDictEqual(self.app.conf.CELERY_RESULT_ENGINE_OPTIONS,
-                             {"foo": "bar"})
+                             {'foo': 'bar'})
 
     def test_compat_setting_CELERY_BACKEND(self):
 
-        self.app.config_from_object(Object(CELERY_BACKEND="set_by_us"))
-        self.assertEqual(self.app.conf.CELERY_RESULT_BACKEND, "set_by_us")
+        self.app.config_from_object(Object(CELERY_BACKEND='set_by_us'))
+        self.assertEqual(self.app.conf.CELERY_RESULT_BACKEND, 'set_by_us')
 
     def test_setting_BROKER_TRANSPORT_OPTIONS(self):
 
@@ -334,8 +334,8 @@ class test_App(Case):
         self.assertFalse(self.app.log.supports_color())
 
     def test_compat_setting_CARROT_BACKEND(self):
-        self.app.config_from_object(Object(CARROT_BACKEND="set_by_us"))
-        self.assertEqual(self.app.conf.BROKER_TRANSPORT, "set_by_us")
+        self.app.config_from_object(Object(CARROT_BACKEND='set_by_us'))
+        self.assertEqual(self.app.conf.BROKER_TRANSPORT, 'set_by_us')
 
     def test_WorkController(self):
         x = self.app.WorkController
@@ -346,13 +346,13 @@ class test_App(Case):
         self.assertIs(x.app, self.app)
 
     def test_AsyncResult(self):
-        x = self.app.AsyncResult("1")
+        x = self.app.AsyncResult('1')
         self.assertIs(x.app, self.app)
         r = loads(dumps(x))
         # not set as current, so ends up as default app after reduce
         self.assertIs(r.app, state.default_app)
 
-    @patch("celery.bin.celery.CeleryCommand.execute_from_commandline")
+    @patch('celery.bin.celery.CeleryCommand.execute_from_commandline')
     def test_start(self, execute):
         self.app.start()
         self.assertTrue(execute.called)
@@ -366,23 +366,23 @@ class test_App(Case):
 
         self.app.loader = Loader()
         self.app.conf.ADMINS = None
-        self.assertFalse(self.app.mail_admins("Subject", "Body"))
-        self.app.conf.ADMINS = [("George Costanza", "george@vandelay.com")]
-        self.assertTrue(self.app.mail_admins("Subject", "Body"))
+        self.assertFalse(self.app.mail_admins('Subject', 'Body'))
+        self.app.conf.ADMINS = [('George Costanza', 'george@vandelay.com')]
+        self.assertTrue(self.app.mail_admins('Subject', 'Body'))
 
     def test_amqp_get_broker_info(self):
-        self.assertDictContainsSubset({"hostname": "localhost",
-                                       "userid": "guest",
-                                       "password": "guest",
-                                       "virtual_host": "/"},
-                            self.app.broker_connection("amqplib://").info())
+        self.assertDictContainsSubset({'hostname': 'localhost',
+                                       'userid': 'guest',
+                                       'password': 'guest',
+                                       'virtual_host': '/'},
+                            self.app.broker_connection('amqplib://').info())
         self.app.conf.BROKER_PORT = 1978
-        self.app.conf.BROKER_VHOST = "foo"
-        self.assertDictContainsSubset({"port": 1978,
-                                       "virtual_host": "foo"},
-                    self.app.broker_connection("amqplib://:1978/foo").info())
-        conn = self.app.broker_connection("amqplib:////value")
-        self.assertDictContainsSubset({"virtual_host": "/value"},
+        self.app.conf.BROKER_VHOST = 'foo'
+        self.assertDictContainsSubset({'port': 1978,
+                                       'virtual_host': 'foo'},
+                    self.app.broker_connection('amqplib://:1978/foo').info())
+        conn = self.app.broker_connection('amqplib:////value')
+        self.assertDictContainsSubset({'virtual_host': '/value'},
                                       conn.info())
 
     def test_BROKER_BACKEND_alias(self):
@@ -407,7 +407,7 @@ class test_App(Case):
         self.app._after_fork(self.app)
 
     def test_pool_no_multiprocessing(self):
-        with mask_modules("multiprocessing.util"):
+        with mask_modules('multiprocessing.util'):
             pool = self.app.pool
             self.assertIs(pool, self.app._pool)
 
@@ -425,46 +425,46 @@ class test_App(Case):
         conn = self.app.broker_connection()
         chan = conn.channel()
         try:
-            for e in ("foo_exchange", "moo_exchange", "bar_exchange"):
-                chan.exchange_declare(e, "direct", durable=True)
+            for e in ('foo_exchange', 'moo_exchange', 'bar_exchange'):
+                chan.exchange_declare(e, 'direct', durable=True)
                 chan.queue_declare(e, durable=True)
                 chan.queue_bind(e, e, e)
         finally:
             chan.close()
-        assert conn.transport_cls == "memory"
+        assert conn.transport_cls == 'memory'
 
         pub = self.app.amqp.TaskProducer(conn,
-                exchange=Exchange("foo_exchange"))
+                exchange=Exchange('foo_exchange'))
 
         dispatcher = Dispatcher()
-        self.assertTrue(pub.delay_task("footask", (), {},
-                                       exchange="moo_exchange",
-                                       routing_key="moo_exchange",
+        self.assertTrue(pub.delay_task('footask', (), {},
+                                       exchange='moo_exchange',
+                                       routing_key='moo_exchange',
                                        event_dispatcher=dispatcher))
         self.assertTrue(dispatcher.sent)
-        self.assertEqual(dispatcher.sent[0][0], "task-sent")
-        self.assertTrue(pub.delay_task("footask", (), {},
+        self.assertEqual(dispatcher.sent[0][0], 'task-sent')
+        self.assertTrue(pub.delay_task('footask', (), {},
                                        event_dispatcher=dispatcher,
-                                       exchange="bar_exchange",
-                                       routing_key="bar_exchange"))
+                                       exchange='bar_exchange',
+                                       routing_key='bar_exchange'))
 
     def test_error_mail_sender(self):
-        x = ErrorMail.subject % {"name": "task_name",
-                                 "id": uuid(),
-                                 "exc": "FOOBARBAZ",
-                                 "hostname": "lana"}
+        x = ErrorMail.subject % {'name': 'task_name',
+                                 'id': uuid(),
+                                 'exc': 'FOOBARBAZ',
+                                 'hostname': 'lana'}
         self.assertTrue(x)
 
 
 class test_defaults(Case):
 
     def test_str_to_bool(self):
-        for s in ("false", "no", "0"):
+        for s in ('false', 'no', '0'):
             self.assertFalse(defaults.strtobool(s))
-        for s in ("true", "yes", "1"):
+        for s in ('true', 'yes', '1'):
             self.assertTrue(defaults.strtobool(s))
         with self.assertRaises(TypeError):
-            defaults.strtobool("unsure")
+            defaults.strtobool('unsure')
 
 
 class test_debugging_utils(Case):
@@ -482,24 +482,24 @@ class test_debugging_utils(Case):
 class test_pyimplementation(Case):
 
     def test_platform_python_implementation(self):
-        with platform_pyimp(lambda: "Xython"):
-            self.assertEqual(pyimplementation(), "Xython")
+        with platform_pyimp(lambda: 'Xython'):
+            self.assertEqual(pyimplementation(), 'Xython')
 
     def test_platform_jython(self):
         with platform_pyimp():
-            with sys_platform("java 1.6.51"):
-                self.assertIn("Jython", pyimplementation())
+            with sys_platform('java 1.6.51'):
+                self.assertIn('Jython', pyimplementation())
 
     def test_platform_pypy(self):
         with platform_pyimp():
-            with sys_platform("darwin"):
+            with sys_platform('darwin'):
                 with pypy_version((1, 4, 3)):
-                    self.assertIn("PyPy", pyimplementation())
-                with pypy_version((1, 4, 3, "a4")):
-                    self.assertIn("PyPy", pyimplementation())
+                    self.assertIn('PyPy', pyimplementation())
+                with pypy_version((1, 4, 3, 'a4')):
+                    self.assertIn('PyPy', pyimplementation())
 
     def test_platform_fallback(self):
         with platform_pyimp():
-            with sys_platform("darwin"):
+            with sys_platform('darwin'):
                 with pypy_version():
-                    self.assertEqual("CPython", pyimplementation())
+                    self.assertEqual('CPython', pyimplementation())

celery/tests/app/test_beat.py

@@ -49,10 +49,10 @@ class test_ScheduleEntry(Case):
     Entry = beat.ScheduleEntry
 
     def create_entry(self, **kwargs):
-        entry = dict(name="celery.unittest.add",
+        entry = dict(name='celery.unittest.add',
                      schedule=schedule(timedelta(seconds=10)),
                      args=(2, 2),
-                     options={"routing_key": "cpu"})
+                     options={'routing_key': 'cpu'})
         return self.Entry(**dict(entry, **kwargs))
 
     def test_next(self):
@@ -80,24 +80,24 @@ class test_ScheduleEntry(Case):
 
     def test_repr(self):
         entry = self.create_entry()
-        self.assertIn("<Entry:", repr(entry))
+        self.assertIn('<Entry:', repr(entry))
 
     def test_update(self):
         entry = self.create_entry()
         self.assertEqual(entry.schedule, timedelta(seconds=10))
         self.assertTupleEqual(entry.args, (2, 2))
         self.assertDictEqual(entry.kwargs, {})
-        self.assertDictEqual(entry.options, {"routing_key": "cpu"})
+        self.assertDictEqual(entry.options, {'routing_key': 'cpu'})
 
         entry2 = self.create_entry(schedule=timedelta(minutes=20),
                                    args=(16, 16),
-                                   kwargs={"callback": "foo.bar.baz"},
-                                   options={"routing_key": "urgent"})
+                                   kwargs={'callback': 'foo.bar.baz'},
+                                   options={'routing_key': 'urgent'})
         entry.update(entry2)
         self.assertEqual(entry.schedule, schedule(timedelta(minutes=20)))
         self.assertTupleEqual(entry.args, (16, 16))
-        self.assertDictEqual(entry.kwargs, {"callback": "foo.bar.baz"})
-        self.assertDictEqual(entry.options, {"routing_key": "urgent"})
+        self.assertDictEqual(entry.kwargs, {'callback': 'foo.bar.baz'})
+        self.assertDictEqual(entry.options, {'routing_key': 'urgent'})
 
 
 class mScheduler(beat.Scheduler):
@@ -107,23 +107,23 @@ class mScheduler(beat.Scheduler):
         beat.Scheduler.__init__(self, *args, **kwargs)
 
     def send_task(self, name=None, args=None, kwargs=None, **options):
-        self.sent.append({"name": name,
-                          "args": args,
-                          "kwargs": kwargs,
-                          "options": options})
+        self.sent.append({'name': name,
+                          'args': args,
+                          'kwargs': kwargs,
+                          'options': options})
         return AsyncResult(uuid())
 
 
 class mSchedulerSchedulingError(mScheduler):
 
     def send_task(self, *args, **kwargs):
-        raise beat.SchedulingError("Could not apply task")
+        raise beat.SchedulingError('Could not apply task')
 
 
 class mSchedulerRuntimeError(mScheduler):
 
     def maybe_due(self, *args, **kwargs):
-        raise RuntimeError("dict modified while itervalues")
+        raise RuntimeError('dict modified while itervalues')
 
 
 class mocked_schedule(schedule):
@@ -144,7 +144,7 @@ always_pending = mocked_schedule(False, 1)
 class test_Scheduler(Case):
 
     def test_custom_schedule_dict(self):
-        custom = {"foo": "bar"}
+        custom = {'foo': 'bar'}
         scheduler = mScheduler(schedule=custom, lazy=True)
         self.assertIs(scheduler.data, custom)
 
@@ -182,11 +182,11 @@ class test_Scheduler(Case):
         s.apply_async(s.Entry(task=not_sync.name))
         self.assertFalse(s._do_sync.called)
 
-    @patch("celery.app.base.Celery.send_task")
+    @patch('celery.app.base.Celery.send_task')
     def test_send_task(self, send_task):
         b = beat.Scheduler()
-        b.send_task("tasks.add", countdown=10)
-        send_task.assert_called_with("tasks.add", countdown=10)
+        b.send_task('tasks.add', countdown=10)
+        send_task.assert_called_with('tasks.add', countdown=10)
 
     def test_info(self):
         scheduler = mScheduler()
@@ -194,18 +194,18 @@ class test_Scheduler(Case):
 
     def test_maybe_entry(self):
         s = mScheduler()
-        entry = s.Entry(name="add every", task="tasks.add")
+        entry = s.Entry(name='add every', task='tasks.add')
         self.assertIs(s._maybe_entry(entry.name, entry), entry)
-        self.assertTrue(s._maybe_entry("add every", {
-            "task": "tasks.add",
+        self.assertTrue(s._maybe_entry('add every', {
+            'task': 'tasks.add',
         }))
 
     def test_set_schedule(self):
         s = mScheduler()
-        s.schedule = {"foo": "bar"}
-        self.assertEqual(s.data, {"foo": "bar"})
+        s.schedule = {'foo': 'bar'}
+        self.assertEqual(s.data, {'foo': 'bar'})
 
-    @patch("kombu.connection.Connection.ensure_connection")
+    @patch('kombu.connection.Connection.ensure_connection')
     def test_ensure_connection_error_handler(self, ensure):
         s = mScheduler()
         self.assertTrue(s._ensure_connected())
@@ -219,60 +219,60 @@ class test_Scheduler(Case):
                             CELERYBEAT_SCHEDULE={}):
             s = mScheduler()
             s.install_default_entries({})
-            self.assertNotIn("celery.backend_cleanup", s.data)
+            self.assertNotIn('celery.backend_cleanup', s.data)
         with patch_settings(CELERY_TASK_RESULT_EXPIRES=30,
                             CELERYBEAT_SCHEDULE={}):
             s = mScheduler()
             s.install_default_entries({})
-            self.assertIn("celery.backend_cleanup", s.data)
+            self.assertIn('celery.backend_cleanup', s.data)
 
     def test_due_tick(self):
         scheduler = mScheduler()
-        scheduler.add(name="test_due_tick",
+        scheduler.add(name='test_due_tick',
                       schedule=always_due,
                       args=(1, 2),
-                      kwargs={"foo": "bar"})
+                      kwargs={'foo': 'bar'})
         self.assertEqual(scheduler.tick(), 1)
 
-    @patch("celery.beat.error")
+    @patch('celery.beat.error')
     def test_due_tick_SchedulingError(self, error):
         scheduler = mSchedulerSchedulingError()
-        scheduler.add(name="test_due_tick_SchedulingError",
+        scheduler.add(name='test_due_tick_SchedulingError',
                       schedule=always_due)
         self.assertEqual(scheduler.tick(), 1)
         self.assertTrue(error.called)
 
     def test_due_tick_RuntimeError(self):
         scheduler = mSchedulerRuntimeError()
-        scheduler.add(name="test_due_tick_RuntimeError",
+        scheduler.add(name='test_due_tick_RuntimeError',
                       schedule=always_due)
         self.assertEqual(scheduler.tick(), scheduler.max_interval)
 
     def test_pending_tick(self):
         scheduler = mScheduler()
-        scheduler.add(name="test_pending_tick",
+        scheduler.add(name='test_pending_tick',
                       schedule=always_pending)
         self.assertEqual(scheduler.tick(), 1)
 
     def test_honors_max_interval(self):
         scheduler = mScheduler()
         maxi = scheduler.max_interval
-        scheduler.add(name="test_honors_max_interval",
+        scheduler.add(name='test_honors_max_interval',
                       schedule=mocked_schedule(False, maxi * 4))
         self.assertEqual(scheduler.tick(), maxi)
 
     def test_ticks(self):
         scheduler = mScheduler()
         nums = [600, 300, 650, 120, 250, 36]
-        s = dict(("test_ticks%s" % i,
-                 {"schedule": mocked_schedule(False, j)})
+        s = dict(('test_ticks%s' % i,
+                 {'schedule': mocked_schedule(False, j)})
                     for i, j in enumerate(nums))
         scheduler.update_from_dict(s)
         self.assertEqual(scheduler.tick(), min(nums))
 
     def test_schedule_no_remain(self):
         scheduler = mScheduler()
-        scheduler.add(name="test_schedule_no_remain",
+        scheduler.add(name='test_schedule_no_remain',
                       schedule=mocked_schedule(False, None))
         self.assertEqual(scheduler.tick(), scheduler.max_interval)
 
@@ -285,15 +285,15 @@ class test_Scheduler(Case):
     def test_merge_inplace(self):
         a = mScheduler()
         b = mScheduler()
-        a.update_from_dict({"foo": {"schedule": mocked_schedule(True, 10)},
-                            "bar": {"schedule": mocked_schedule(True, 20)}})
-        b.update_from_dict({"bar": {"schedule": mocked_schedule(True, 40)},
-                            "baz": {"schedule": mocked_schedule(True, 10)}})
+        a.update_from_dict({'foo': {'schedule': mocked_schedule(True, 10)},
+                            'bar': {'schedule': mocked_schedule(True, 20)}})
+        b.update_from_dict({'bar': {'schedule': mocked_schedule(True, 40)},
+                            'baz': {'schedule': mocked_schedule(True, 10)}})
         a.merge_inplace(b.schedule)
 
-        self.assertNotIn("foo", a.schedule)
-        self.assertIn("baz", a.schedule)
-        self.assertEqual(a.schedule["bar"].schedule._next_run_at, 40)
+        self.assertNotIn('foo', a.schedule)
+        self.assertIn('baz', a.schedule)
+        self.assertEqual(a.schedule['bar'].schedule._next_run_at, 40)
 
 
 def create_persistent_scheduler(shelv=None):
@@ -319,12 +319,12 @@ def create_persistent_scheduler(shelv=None):
 
 class test_PersistentScheduler(Case):
 
-    @patch("os.remove")
+    @patch('os.remove')
     def test_remove_db(self, remove):
-        s = create_persistent_scheduler()[0](schedule_filename="schedule")
+        s = create_persistent_scheduler()[0](schedule_filename='schedule')
         s._remove_db()
         remove.assert_has_calls(
-            [call("schedule" + suffix) for suffix in s.known_suffixes]
+            [call('schedule' + suffix) for suffix in s.known_suffixes]
         )
         err = OSError()
         err.errno = errno.ENOENT
@@ -335,7 +335,7 @@ class test_PersistentScheduler(Case):
             s._remove_db()
 
     def test_setup_schedule(self):
-        s = create_persistent_scheduler()[0](schedule_filename="schedule")
+        s = create_persistent_scheduler()[0](schedule_filename='schedule')
         opens = s.persistence.open = Mock()
         s._remove_db = Mock()
 
@@ -347,15 +347,15 @@ class test_PersistentScheduler(Case):
         s.setup_schedule()
         s._remove_db.assert_called_with()
 
-        s._store = {"__version__": 1}
+        s._store = {'__version__': 1}
         s.setup_schedule()
 
     def test_get_schedule(self):
-        s = create_persistent_scheduler()[0](schedule_filename="schedule")
-        s._store = {"entries": {}}
-        s.schedule = {"foo": "bar"}
-        self.assertDictEqual(s.schedule, {"foo": "bar"})
-        self.assertDictEqual(s._store["entries"], s.schedule)
+        s = create_persistent_scheduler()[0](schedule_filename='schedule')
+        s._store = {'entries': {}}
+        s.schedule = {'foo': 'bar'}
+        self.assertDictEqual(s.schedule, {'foo': 'bar'})
+        self.assertDictEqual(s._store['entries'], s.schedule)
 
 
 class test_Service(Case):
@@ -370,7 +370,7 @@ class test_Service(Case):
         self.assertIsInstance(schedule, dict)
         self.assertIsInstance(s.scheduler, beat.Scheduler)
         scheduled = schedule.keys()
-        for task_name in sh["entries"].keys():
+        for task_name in sh['entries'].keys():
             self.assertIn(task_name, scheduled)
 
         s.sync()
@@ -419,7 +419,7 @@ class test_EmbeddedService(Case):
         try:
             import _multiprocessing  # noqa
         except ImportError:
-            raise SkipTest("multiprocessing not available")
+            raise SkipTest('multiprocessing not available')
 
         from billiard.process import Process
 

celery/tests/app/test_builtins.py

@@ -23,7 +23,7 @@ class test_backend_cleanup(Case):
     def test_run(self):
         prev = app.backend
         app.backend.cleanup = Mock()
-        app.backend.cleanup.__name__ = "cleanup"
+        app.backend.cleanup.__name__ = 'cleanup'
         try:
             cleanup_task = builtins.add_backend_cleanup_task(app)
             cleanup_task()
@@ -40,7 +40,7 @@ class test_map(Case):
         def map_mul(x):
             return x[0] * x[1]
 
-        res = app.tasks["celery.map"](map_mul, [(2, 2), (4, 4), (8, 8)])
+        res = app.tasks['celery.map'](map_mul, [(2, 2), (4, 4), (8, 8)])
         self.assertEqual(res, [4, 16, 64])
 
 
@@ -52,20 +52,20 @@ class test_starmap(Case):
         def smap_mul(x, y):
             return x * y
 
-        res = app.tasks["celery.starmap"](smap_mul, [(2, 2), (4, 4), (8, 8)])
+        res = app.tasks['celery.starmap'](smap_mul, [(2, 2), (4, 4), (8, 8)])
         self.assertEqual(res, [4, 16, 64])
 
 
 class test_chunks(Case):
 
-    @patch("celery.canvas.chunks.apply_chunks")
+    @patch('celery.canvas.chunks.apply_chunks')
     def test_run(self, apply_chunks):
 
         @app.task()
         def chunks_mul(l):
             return l
 
-        app.tasks["celery.chunks"](chunks_mul,
+        app.tasks['celery.chunks'](chunks_mul,
                 [(2, 2), (4, 4), (8, 8)], 1)
         self.assertTrue(apply_chunks.called)
 
@@ -73,11 +73,11 @@ class test_chunks(Case):
 class test_group(Case):
 
     def setUp(self):
-        self.prev = app.tasks.get("celery.group")
+        self.prev = app.tasks.get('celery.group')
         self.task = builtins.add_group_task(app)()
 
     def tearDown(self):
-        app.tasks["celery.group"] = self.prev
+        app.tasks['celery.group'] = self.prev
 
     def test_apply_async_eager(self):
         self.task.apply = Mock()
@@ -118,11 +118,11 @@ class test_group(Case):
 class test_chain(Case):
 
     def setUp(self):
-        self.prev = app.tasks.get("celery.chain")
+        self.prev = app.tasks.get('celery.chain')
         self.task = builtins.add_chain_task(app)()
 
     def tearDown(self):
-        app.tasks["celery.chain"] = self.prev
+        app.tasks['celery.chain'] = self.prev
 
     def test_apply_async(self):
         c = add.s(2, 2) | add.s(4) | add.s(8)
@@ -135,11 +135,11 @@ class test_chain(Case):
 class test_chord(Case):
 
     def setUp(self):
-        self.prev = app.tasks.get("celery.chord")
+        self.prev = app.tasks.get('celery.chord')
         self.task = builtins.add_chord_task(app)()
 
     def tearDown(self):
-        app.tasks["celery.chord"] = self.prev
+        app.tasks['celery.chord'] = self.prev
 
     def test_apply_async(self):
         x = chord([add.s(i, i) for i in xrange(10)], body=xsum.s())

celery/tests/app/test_celery.py

@@ -10,9 +10,9 @@ class test_celery_package(Case):
         self.assertTrue(celery.VERSION)
         self.assertGreaterEqual(len(celery.VERSION), 3)
         celery.VERSION = (0, 3, 0)
-        self.assertGreaterEqual(celery.__version__.count("."), 2)
+        self.assertGreaterEqual(celery.__version__.count('.'), 2)
 
     def test_meta(self):
-        for m in ("__author__", "__contact__", "__homepage__",
-                "__docformat__"):
+        for m in ('__author__', '__contact__', '__homepage__',
+                '__docformat__'):
             self.assertTrue(getattr(celery, m, None))

celery/tests/app/test_control.py

@@ -58,58 +58,58 @@ class test_inspect(Case):
         self.app.control = self.prev
 
     def test_prepare_reply(self):
-        self.assertDictEqual(self.i._prepare([{"w1": {"ok": 1}},
-                                              {"w2": {"ok": 1}}]),
-                             {"w1": {"ok": 1}, "w2": {"ok": 1}})
+        self.assertDictEqual(self.i._prepare([{'w1': {'ok': 1}},
+                                              {'w2': {'ok': 1}}]),
+                             {'w1': {'ok': 1}, 'w2': {'ok': 1}})
 
-        i = self.c.inspect(destination="w1")
-        self.assertEqual(i._prepare([{"w1": {"ok": 1}}]),
-                         {"ok": 1})
+        i = self.c.inspect(destination='w1')
+        self.assertEqual(i._prepare([{'w1': {'ok': 1}}]),
+                         {'ok': 1})
 
     @with_mock_broadcast
     def test_active(self):
         self.i.active()
-        self.assertIn("dump_active", MockMailbox.sent)
+        self.assertIn('dump_active', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_scheduled(self):
         self.i.scheduled()
-        self.assertIn("dump_schedule", MockMailbox.sent)
+        self.assertIn('dump_schedule', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_reserved(self):
         self.i.reserved()
-        self.assertIn("dump_reserved", MockMailbox.sent)
+        self.assertIn('dump_reserved', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_stats(self):
         self.i.stats()
-        self.assertIn("stats", MockMailbox.sent)
+        self.assertIn('stats', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_revoked(self):
         self.i.revoked()
-        self.assertIn("dump_revoked", MockMailbox.sent)
+        self.assertIn('dump_revoked', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_tasks(self):
         self.i.registered()
-        self.assertIn("dump_tasks", MockMailbox.sent)
+        self.assertIn('dump_tasks', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_ping(self):
         self.i.ping()
-        self.assertIn("ping", MockMailbox.sent)
+        self.assertIn('ping', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_active_queues(self):
         self.i.active_queues()
-        self.assertIn("active_queues", MockMailbox.sent)
+        self.assertIn('active_queues', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_report(self):
         self.i.report()
-        self.assertIn("report", MockMailbox.sent)
+        self.assertIn('report', MockMailbox.sent)
 
 
 class test_Broadcast(Case):
@@ -127,65 +127,65 @@ class test_Broadcast(Case):
 
     @with_mock_broadcast
     def test_broadcast(self):
-        self.control.broadcast("foobarbaz", arguments=[])
-        self.assertIn("foobarbaz", MockMailbox.sent)
+        self.control.broadcast('foobarbaz', arguments=[])
+        self.assertIn('foobarbaz', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_broadcast_limit(self):
-        self.control.broadcast("foobarbaz1", arguments=[], limit=None,
+        self.control.broadcast('foobarbaz1', arguments=[], limit=None,
                 destination=[1, 2, 3])
-        self.assertIn("foobarbaz1", MockMailbox.sent)
+        self.assertIn('foobarbaz1', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_broadcast_validate(self):
         with self.assertRaises(ValueError):
-            self.control.broadcast("foobarbaz2",
-                                   destination="foo")
+            self.control.broadcast('foobarbaz2',
+                                   destination='foo')
 
     @with_mock_broadcast
     def test_rate_limit(self):
-        self.control.rate_limit(mytask.name, "100/m")
-        self.assertIn("rate_limit", MockMailbox.sent)
+        self.control.rate_limit(mytask.name, '100/m')
+        self.assertIn('rate_limit', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_time_limit(self):
         self.control.time_limit(mytask.name, soft=10, hard=20)
-        self.assertIn("time_limit", MockMailbox.sent)
+        self.assertIn('time_limit', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_add_consumer(self):
-        self.control.add_consumer("foo")
-        self.assertIn("add_consumer", MockMailbox.sent)
+        self.control.add_consumer('foo')
+        self.assertIn('add_consumer', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_cancel_consumer(self):
-        self.control.cancel_consumer("foo")
-        self.assertIn("cancel_consumer", MockMailbox.sent)
+        self.control.cancel_consumer('foo')
+        self.assertIn('cancel_consumer', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_enable_events(self):
         self.control.enable_events()
-        self.assertIn("enable_events", MockMailbox.sent)
+        self.assertIn('enable_events', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_disable_events(self):
         self.control.disable_events()
-        self.assertIn("disable_events", MockMailbox.sent)
+        self.assertIn('disable_events', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_revoke(self):
-        self.control.revoke("foozbaaz")
-        self.assertIn("revoke", MockMailbox.sent)
+        self.control.revoke('foozbaaz')
+        self.assertIn('revoke', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_ping(self):
         self.control.ping()
-        self.assertIn("ping", MockMailbox.sent)
+        self.assertIn('ping', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_revoke_from_result(self):
-        self.app.AsyncResult("foozbazzbar").revoke()
-        self.assertIn("revoke", MockMailbox.sent)
+        self.app.AsyncResult('foozbazzbar').revoke()
+        self.assertIn('revoke', MockMailbox.sent)
 
     @with_mock_broadcast
     def test_revoke_from_resultset(self):
@@ -193,4 +193,4 @@ class test_Broadcast(Case):
                                  map(self.app.AsyncResult,
                                         [uuid() for i in range(10)]))
         r.revoke()
-        self.assertIn("revoke", MockMailbox.sent)
+        self.assertIn('revoke', MockMailbox.sent)

celery/tests/app/test_defaults.py

@@ -12,44 +12,44 @@ from celery.tests.utils import Case, pypy_version, sys_platform
 class test_defaults(Case):
 
     def setUp(self):
-        self._prev = sys.modules.pop("celery.app.defaults", None)
+        self._prev = sys.modules.pop('celery.app.defaults', None)
 
     def tearDown(self):
         if self._prev:
-            sys.modules["celery.app.defaults"] = self._prev
+            sys.modules['celery.app.defaults'] = self._prev
 
     def test_any(self):
         val = object()
-        self.assertIs(self.defaults.Option.typemap["any"](val), val)
+        self.assertIs(self.defaults.Option.typemap['any'](val), val)
 
     def test_default_pool_pypy_14(self):
-        with sys_platform("darwin"):
+        with sys_platform('darwin'):
             with pypy_version((1, 4, 0)):
-                self.assertEqual(self.defaults.DEFAULT_POOL, "solo")
+                self.assertEqual(self.defaults.DEFAULT_POOL, 'solo')
 
     def test_default_pool_pypy_15(self):
-        with sys_platform("darwin"):
+        with sys_platform('darwin'):
             with pypy_version((1, 5, 0)):
-                self.assertEqual(self.defaults.DEFAULT_POOL, "processes")
+                self.assertEqual(self.defaults.DEFAULT_POOL, 'processes')
 
     def test_deprecated(self):
         source = Mock()
         source.BROKER_INSIST = True
-        with patch("celery.utils.warn_deprecated") as warn:
+        with patch('celery.utils.warn_deprecated') as warn:
             self.defaults.find_deprecated_settings(source)
             self.assertTrue(warn.called)
 
     def test_default_pool_jython(self):
-        with sys_platform("java 1.6.51"):
-            self.assertEqual(self.defaults.DEFAULT_POOL, "threads")
+        with sys_platform('java 1.6.51'):
+            self.assertEqual(self.defaults.DEFAULT_POOL, 'threads')
 
     def test_find(self):
         find = self.defaults.find
 
-        self.assertEqual(find("server_email")[2].default, "celery@localhost")
-        self.assertEqual(find("default_queue")[2].default, "celery")
-        self.assertEqual(find("celery_default_exchange")[2], "celery")
+        self.assertEqual(find('server_email')[2].default, 'celery@localhost')
+        self.assertEqual(find('default_queue')[2].default, 'celery')
+        self.assertEqual(find('celery_default_exchange')[2], 'celery')
 
     @property
     def defaults(self):
-        return import_module("celery.app.defaults")
+        return import_module('celery.app.defaults')

celery/tests/app/test_loaders.py

@@ -41,14 +41,14 @@ class Object(object):
 class DummyLoader(base.BaseLoader):
 
     def read_configuration(self):
-        return {"foo": "bar", "CELERY_IMPORTS": ("os", "sys")}
+        return {'foo': 'bar', 'CELERY_IMPORTS': ('os', 'sys')}
 
 
 class test_loaders(AppCase):
 
     def test_get_loader_cls(self):
 
-        self.assertEqual(loaders.get_loader_cls("default"),
+        self.assertEqual(loaders.get_loader_cls('default'),
                           default.Loader)
 
     def test_current_loader(self):
@@ -63,26 +63,26 @@ class test_loaders(AppCase):
 
 
 class test_LoaderBase(Case):
-    message_options = {"subject": "Subject",
-                       "body": "Body",
-                       "sender": "x@x.com",
-                       "to": "y@x.com"}
-    server_options = {"host": "smtp.x.com",
-                      "port": 1234,
-                      "user": "x",
-                      "password": "qwerty",
-                      "timeout": 3}
+    message_options = {'subject': 'Subject',
+                       'body': 'Body',
+                       'sender': 'x@x.com',
+                       'to': 'y@x.com'}
+    server_options = {'host': 'smtp.x.com',
+                      'port': 1234,
+                      'user': 'x',
+                      'password': 'qwerty',
+                      'timeout': 3}
 
     def setUp(self):
         self.loader = DummyLoader()
         self.app = app_or_default()
 
     def test_handlers_pass(self):
-        self.loader.on_task_init("foo.task", "feedface-cafebabe")
+        self.loader.on_task_init('foo.task', 'feedface-cafebabe')
         self.loader.on_worker_init()
 
     def test_import_task_module(self):
-        self.assertEqual(sys, self.loader.import_task_module("sys"))
+        self.assertEqual(sys, self.loader.import_task_module('sys'))
 
     def test_init_worker_process(self):
         self.loader.on_worker_process_init()
@@ -92,18 +92,18 @@ class test_LoaderBase(Case):
 
     def test_config_from_object_module(self):
         self.loader.import_from_cwd = Mock()
-        self.loader.config_from_object("module_name")
-        self.loader.import_from_cwd.assert_called_with("module_name")
+        self.loader.config_from_object('module_name')
+        self.loader.import_from_cwd.assert_called_with('module_name')
 
     def test_conf_property(self):
-        self.assertEqual(self.loader.conf["foo"], "bar")
-        self.assertEqual(self.loader._conf["foo"], "bar")
-        self.assertEqual(self.loader.conf["foo"], "bar")
+        self.assertEqual(self.loader.conf['foo'], 'bar')
+        self.assertEqual(self.loader._conf['foo'], 'bar')
+        self.assertEqual(self.loader.conf['foo'], 'bar')
 
     def test_import_default_modules(self):
         modnames = lambda l: [m.__name__ for m in l]
         prev, self.app.conf.CELERY_IMPORTS = \
-                self.app.conf.CELERY_IMPORTS, ("os", "sys")
+                self.app.conf.CELERY_IMPORTS, ('os', 'sys')
         try:
             self.assertEqual(sorted(modnames(
                                 self.loader.import_default_modules())),
@@ -117,10 +117,10 @@ class test_LoaderBase(Case):
             imp.called = True
         imp.called = False
 
-        self.loader.import_from_cwd("foo", imp=imp)
+        self.loader.import_from_cwd('foo', imp=imp)
         self.assertTrue(imp.called)
 
-    @patch("celery.utils.mail.Mailer._send")
+    @patch('celery.utils.mail.Mailer._send')
     def test_mail_admins_errors(self, send):
         send.side_effect = KeyError()
         opts = dict(self.message_options, **self.server_options)
@@ -131,16 +131,16 @@ class test_LoaderBase(Case):
         with self.assertRaises(KeyError):
             self.loader.mail_admins(fail_silently=False, **opts)
 
-    @patch("celery.utils.mail.Mailer._send")
+    @patch('celery.utils.mail.Mailer._send')
     def test_mail_admins(self, send):
         opts = dict(self.message_options, **self.server_options)
         self.loader.mail_admins(**opts)
         self.assertTrue(send.call_args)
         message = send.call_args[0][0]
-        self.assertEqual(message.to, [self.message_options["to"]])
-        self.assertEqual(message.subject, self.message_options["subject"])
-        self.assertEqual(message.sender, self.message_options["sender"])
-        self.assertEqual(message.body, self.message_options["body"])
+        self.assertEqual(message.to, [self.message_options['to']])
+        self.assertEqual(message.subject, self.message_options['subject'])
+        self.assertEqual(message.sender, self.message_options['sender'])
+        self.assertEqual(message.body, self.message_options['body'])
 
     def test_mail_attribute(self):
         from celery.utils import mail
@@ -149,39 +149,39 @@ class test_LoaderBase(Case):
 
     def test_cmdline_config_ValueError(self):
         with self.assertRaises(ValueError):
-            self.loader.cmdline_config_parser(["broker.port=foobar"])
+            self.loader.cmdline_config_parser(['broker.port=foobar'])
 
 
 class test_DefaultLoader(Case):
 
     def test_wanted_module_item(self):
         l = default.Loader()
-        self.assertTrue(l.wanted_module_item("FOO"))
-        self.assertTrue(l.wanted_module_item("Foo"))
-        self.assertFalse(l.wanted_module_item("_FOO"))
-        self.assertFalse(l.wanted_module_item("__FOO"))
-        self.assertFalse(l.wanted_module_item("foo"))
+        self.assertTrue(l.wanted_module_item('FOO'))
+        self.assertTrue(l.wanted_module_item('Foo'))
+        self.assertFalse(l.wanted_module_item('_FOO'))
+        self.assertFalse(l.wanted_module_item('__FOO'))
+        self.assertFalse(l.wanted_module_item('foo'))
 
-    @patch("celery.loaders.default.find_module")
+    @patch('celery.loaders.default.find_module')
     def test_read_configuration_not_a_package(self, find_module):
         find_module.side_effect = NotAPackage()
         l = default.Loader()
         with self.assertRaises(NotAPackage):
             l.read_configuration()
 
-    @patch("celery.loaders.default.find_module")
+    @patch('celery.loaders.default.find_module')
     def test_read_configuration_py_in_name(self, find_module):
-        prev = os.environ["CELERY_CONFIG_MODULE"]
-        os.environ["CELERY_CONFIG_MODULE"] = "celeryconfig.py"
+        prev = os.environ['CELERY_CONFIG_MODULE']
+        os.environ['CELERY_CONFIG_MODULE'] = 'celeryconfig.py'
         try:
             find_module.side_effect = NotAPackage()
             l = default.Loader()
             with self.assertRaises(NotAPackage):
                 l.read_configuration()
         finally:
-            os.environ["CELERY_CONFIG_MODULE"] = prev
+            os.environ['CELERY_CONFIG_MODULE'] = prev
 
-    @patch("celery.loaders.default.find_module")
+    @patch('celery.loaders.default.find_module')
     def test_read_configuration_importerror(self, find_module):
         default.C_WNOCONF = True
         find_module.side_effect = ImportError()
@@ -195,18 +195,18 @@ class test_DefaultLoader(Case):
         class ConfigModule(ModuleType):
             pass
 
-        celeryconfig = ConfigModule("celeryconfig")
-        celeryconfig.CELERY_IMPORTS = ("os", "sys")
-        configname = os.environ.get("CELERY_CONFIG_MODULE") or "celeryconfig"
+        celeryconfig = ConfigModule('celeryconfig')
+        celeryconfig.CELERY_IMPORTS = ('os', 'sys')
+        configname = os.environ.get('CELERY_CONFIG_MODULE') or 'celeryconfig'
 
         prevconfig = sys.modules.get(configname)
         sys.modules[configname] = celeryconfig
         try:
             l = default.Loader()
             settings = l.read_configuration()
-            self.assertTupleEqual(settings.CELERY_IMPORTS, ("os", "sys"))
+            self.assertTupleEqual(settings.CELERY_IMPORTS, ('os', 'sys'))
             settings = l.read_configuration()
-            self.assertTupleEqual(settings.CELERY_IMPORTS, ("os", "sys"))
+            self.assertTupleEqual(settings.CELERY_IMPORTS, ('os', 'sys'))
             l.on_worker_init()
         finally:
             if prevconfig:
@@ -219,15 +219,15 @@ class test_DefaultLoader(Case):
             sys.path.remove(os.getcwd())
         except ValueError:
             pass
-        celery = sys.modules.pop("celery", None)
+        celery = sys.modules.pop('celery', None)
         try:
-            self.assertTrue(l.import_from_cwd("celery"))
-            sys.modules.pop("celery", None)
+            self.assertTrue(l.import_from_cwd('celery'))
+            sys.modules.pop('celery', None)
             sys.path.insert(0, os.getcwd())
-            self.assertTrue(l.import_from_cwd("celery"))
+            self.assertTrue(l.import_from_cwd('celery'))
         finally:
             sys.path = old_path
-            sys.modules["celery"] = celery
+            sys.modules['celery'] = celery
 
     def test_unconfigured_settings(self):
         context_executed = [False]
@@ -250,32 +250,32 @@ class test_AppLoader(Case):
         self.app = app_or_default()
         self.loader = AppLoader(app=self.app)
 
-    def test_config_from_envvar(self, key="CELERY_HARNESS_CFG1"):
-        self.assertFalse(self.loader.config_from_envvar("HDSAJIHWIQHEWQU",
+    def test_config_from_envvar(self, key='CELERY_HARNESS_CFG1'):
+        self.assertFalse(self.loader.config_from_envvar('HDSAJIHWIQHEWQU',
                                                         silent=True))
         with self.assertRaises(ImproperlyConfigured):
-            self.loader.config_from_envvar("HDSAJIHWIQHEWQU", silent=False)
-        os.environ[key] = __name__ + ".object_config"
+            self.loader.config_from_envvar('HDSAJIHWIQHEWQU', silent=False)
+        os.environ[key] = __name__ + '.object_config'
         self.assertTrue(self.loader.config_from_envvar(key))
-        self.assertEqual(self.loader.conf["FOO"], 1)
-        self.assertEqual(self.loader.conf["BAR"], 2)
+        self.assertEqual(self.loader.conf['FOO'], 1)
+        self.assertEqual(self.loader.conf['BAR'], 2)
 
-        os.environ[key] = "unknown_asdwqe.asdwqewqe"
+        os.environ[key] = 'unknown_asdwqe.asdwqewqe'
         with self.assertRaises(ImportError):
             self.loader.config_from_envvar(key, silent=False)
         self.assertFalse(self.loader.config_from_envvar(key, silent=True))
 
-        os.environ[key] = __name__ + ".dict_config"
+        os.environ[key] = __name__ + '.dict_config'
         self.assertTrue(self.loader.config_from_envvar(key))
-        self.assertEqual(self.loader.conf["FOO"], 10)
-        self.assertEqual(self.loader.conf["BAR"], 20)
+        self.assertEqual(self.loader.conf['FOO'], 10)
+        self.assertEqual(self.loader.conf['BAR'], 20)
 
     def test_on_worker_init(self):
         prev, self.app.conf.CELERY_IMPORTS = \
-                self.app.conf.CELERY_IMPORTS, ("subprocess", )
+                self.app.conf.CELERY_IMPORTS, ('subprocess', )
         try:
-            sys.modules.pop("subprocess", None)
+            sys.modules.pop('subprocess', None)
             self.loader.init_worker()
-            self.assertIn("subprocess", sys.modules)
+            self.assertIn('subprocess', sys.modules)
         finally:
             self.app.conf.CELERY_IMPORTS = prev

celery/tests/app/test_log.py

@@ -29,8 +29,8 @@ class test_TaskFormatter(Case):
 
     def test_no_task(self):
         class Record(object):
-            msg = "hello world"
-            levelname = "info"
+            msg = 'hello world'
+            levelname = 'info'
             exc_text = exc_info = None
             stack_info = None
 
@@ -39,50 +39,50 @@ class test_TaskFormatter(Case):
         record = Record()
         x = TaskFormatter()
         x.format(record)
-        self.assertEqual(record.task_name, "???")
-        self.assertEqual(record.task_id, "???")
+        self.assertEqual(record.task_name, '???')
+        self.assertEqual(record.task_id, '???')
 
 
 class test_ColorFormatter(Case):
 
-    @patch("celery.utils.log.safe_str")
-    @patch("logging.Formatter.formatException")
+    @patch('celery.utils.log.safe_str')
+    @patch('logging.Formatter.formatException')
     def test_formatException_not_string(self, fe, safe_str):
-        x = ColorFormatter("HELLO")
+        x = ColorFormatter('HELLO')
         value = KeyError()
         fe.return_value = value
         self.assertIs(x.formatException(value), value)
         self.assertTrue(fe.called)
         self.assertFalse(safe_str.called)
 
-    @patch("logging.Formatter.formatException")
-    @patch("celery.utils.log.safe_str")
-    def test_formatException_string(self, safe_str, fe, value="HELLO"):
+    @patch('logging.Formatter.formatException')
+    @patch('celery.utils.log.safe_str')
+    def test_formatException_string(self, safe_str, fe, value='HELLO'):
         x = ColorFormatter(value)
         fe.return_value = value
         self.assertTrue(x.formatException(value))
         if sys.version_info[0] == 2:
             self.assertTrue(safe_str.called)
 
-    @patch("celery.utils.log.safe_str")
+    @patch('celery.utils.log.safe_str')
     def test_format_raises(self, safe_str):
-        x = ColorFormatter("HELLO")
+        x = ColorFormatter('HELLO')
 
         def on_safe_str(s):
             try:
-                raise ValueError("foo")
+                raise ValueError('foo')
             finally:
                 safe_str.side_effect = None
         safe_str.side_effect = on_safe_str
 
         class Record(object):
-            levelname = "ERROR"
-            msg = "HELLO"
-            exc_text = "error text"
+            levelname = 'ERROR'
+            msg = 'HELLO'
+            exc_text = 'error text'
             stack_info = None
 
             def __str__(self):
-                return on_safe_str("")
+                return on_safe_str('')
 
             def getMessage(self):
                 return self.msg
@@ -91,18 +91,18 @@ class test_ColorFormatter(Case):
         safe_str.return_value = record
 
         x.format(record)
-        self.assertIn("<Unrepresentable", record.msg)
+        self.assertIn('<Unrepresentable', record.msg)
         self.assertEqual(safe_str.call_count, 2)
 
-    @patch("celery.utils.log.safe_str")
+    @patch('celery.utils.log.safe_str')
     def test_format_raises_no_color(self, safe_str):
         if sys.version_info[0] == 3:
-            raise SkipTest("py3k")
-        x = ColorFormatter("HELLO", False)
+            raise SkipTest('py3k')
+        x = ColorFormatter('HELLO', False)
         record = Mock()
-        record.levelname = "ERROR"
-        record.msg = "HELLO"
-        record.exc_text = "error text"
+        record.levelname = 'ERROR'
+        record.msg = 'HELLO'
+        record.exc_text = 'error text'
         x.format(record)
         self.assertEqual(safe_str.call_count, 1)
 
@@ -116,7 +116,7 @@ class test_default_logger(AppCase):
         Logging._setup = False
 
     def test_get_logger_sets_parent(self):
-        logger = get_logger("celery.test_get_logger")
+        logger = get_logger('celery.test_get_logger')
         self.assertEqual(logger.parent.name, base_logger.name)
 
     def test_get_logger_root(self):
@@ -165,7 +165,7 @@ class test_default_logger(AppCase):
         logger = self.setup_logger(loglevel=logging.ERROR, logfile=None,
                                    root=False, colorize=None)
         self.assertIs(get_handlers(logger)[0].stream, sys.__stderr__,
-                "setup_logger logs to stderr without logfile argument.")
+                'setup_logger logs to stderr without logfile argument.')
 
     def test_setup_logger_no_handlers_stream(self):
         l = self.get_logger()
@@ -175,13 +175,13 @@ class test_default_logger(AppCase):
             stdout, stderr = outs
             l = self.setup_logger(logfile=sys.stderr, loglevel=logging.INFO,
                                 root=False)
-            l.info("The quick brown fox...")
-            self.assertIn("The quick brown fox...", stderr.getvalue())
+            l.info('The quick brown fox...')
+            self.assertIn('The quick brown fox...', stderr.getvalue())
 
     def test_setup_logger_no_handlers_file(self):
         l = self.get_logger()
         l.handlers = []
-        tempfile = mktemp(suffix="unittest", prefix="celery")
+        tempfile = mktemp(suffix='unittest', prefix='celery')
         l = self.setup_logger(logfile=tempfile, loglevel=0, root=False)
         self.assertIsInstance(get_handlers(l)[0],
                               logging.FileHandler)
@@ -192,8 +192,8 @@ class test_default_logger(AppCase):
         try:
             with wrap_logger(logger) as sio:
                 log.redirect_stdouts_to_logger(logger, loglevel=logging.ERROR)
-                logger.error("foo")
-                self.assertIn("foo", sio.getvalue())
+                logger.error('foo')
+                self.assertIn('foo', sio.getvalue())
                 log.redirect_stdouts_to_logger(logger, stdout=False,
                         stderr=False)
         finally:
@@ -206,12 +206,12 @@ class test_default_logger(AppCase):
         with wrap_logger(logger) as sio:
             p = LoggingProxy(logger, loglevel=logging.ERROR)
             p.close()
-            p.write("foo")
-            self.assertNotIn("foo", sio.getvalue())
+            p.write('foo')
+            self.assertNotIn('foo', sio.getvalue())
             p.closed = False
-            p.write("foo")
-            self.assertIn("foo", sio.getvalue())
-            lines = ["baz", "xuzzy"]
+            p.write('foo')
+            self.assertIn('foo', sio.getvalue())
+            lines = ['baz', 'xuzzy']
             p.writelines(lines)
             for line in lines:
                 self.assertIn(line, sio.getvalue())
@@ -226,7 +226,7 @@ class test_default_logger(AppCase):
         p = LoggingProxy(logger, loglevel=logging.ERROR)
         p._thread.recurse_protection = True
         try:
-            self.assertIsNone(p.write("FOOFO"))
+            self.assertIsNone(p.write('FOOFO'))
         finally:
             p._thread.recurse_protection = False
 
@@ -234,7 +234,7 @@ class test_default_logger(AppCase):
 class test_task_logger(test_default_logger):
 
     def setup(self):
-        logger = self.logger = get_logger("celery.task")
+        logger = self.logger = get_logger('celery.task')
         logger.handlers = []
         logging.root.manager.loggerDict.pop(logger.name, None)
         self.uid = uuid()

celery/tests/app/test_routes.py

@@ -43,24 +43,24 @@ def with_queues(**queues):
     return patch_fun
 
 
-a_queue = {"exchange": "fooexchange",
-           "exchange_type": "fanout",
-           "routing_key": "xuzzy"}
-b_queue = {"exchange": "barexchange",
-           "exchange_type": "topic",
-           "routing_key": "b.b.#"}
-d_queue = {"exchange": current_app.conf.CELERY_DEFAULT_EXCHANGE,
-           "exchange_type": current_app.conf.CELERY_DEFAULT_EXCHANGE_TYPE,
-           "routing_key": current_app.conf.CELERY_DEFAULT_ROUTING_KEY}
+a_queue = {'exchange': 'fooexchange',
+           'exchange_type': 'fanout',
+           'routing_key': 'xuzzy'}
+b_queue = {'exchange': 'barexchange',
+           'exchange_type': 'topic',
+           'routing_key': 'b.b.#'}
+d_queue = {'exchange': current_app.conf.CELERY_DEFAULT_EXCHANGE,
+           'exchange_type': current_app.conf.CELERY_DEFAULT_EXCHANGE_TYPE,
+           'routing_key': current_app.conf.CELERY_DEFAULT_ROUTING_KEY}
 
 
 class RouteCase(Case):
 
     def assertAnswer(self, answer, expected):
-        self.assertEqual(answer["exchange"].name, expected["exchange"])
-        self.assertEqual(answer["routing_key"], expected["routing_key"])
-        if "queue" in expected:
-            self.assertEqual(answer["queue"], expected["queue"])
+        self.assertEqual(answer['exchange'].name, expected['exchange'])
+        self.assertEqual(answer['routing_key'], expected['routing_key'])
+        if 'queue' in expected:
+            self.assertEqual(answer['queue'], expected['queue'])
 
 
 class test_MapRoute(RouteCase):
@@ -68,9 +68,9 @@ class test_MapRoute(RouteCase):
     @with_queues(foo=a_queue, bar=b_queue)
     def test_route_for_task_expanded_route(self):
         expand = E(current_app.amqp.queues)
-        route = routes.MapRoute({mytask.name: {"queue": "foo"}})
+        route = routes.MapRoute({mytask.name: {'queue': 'foo'}})
         self.assertAnswer(expand(route.route_for_task(mytask.name)), a_queue)
-        self.assertIsNone(route.route_for_task("celery.awesome"))
+        self.assertIsNone(route.route_for_task('celery.awesome'))
 
     @with_queues(foo=a_queue, bar=b_queue)
     def test_route_for_task(self):
@@ -78,14 +78,14 @@ class test_MapRoute(RouteCase):
         route = routes.MapRoute({mytask.name: b_queue})
         self.assertDictContainsSubset(b_queue,
                              expand(route.route_for_task(mytask.name)))
-        self.assertIsNone(route.route_for_task("celery.awesome"))
+        self.assertIsNone(route.route_for_task('celery.awesome'))
 
     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"}})
+        route = routes.MapRoute({'a': {'queue': 'x'}})
         with self.assertRaises(QueueNotFound):
-            expand(route.route_for_task("a"))
+            expand(route.route_for_task('a'))
 
 
 class test_lookup_route(RouteCase):
@@ -96,8 +96,8 @@ class test_lookup_route(RouteCase):
 
     @with_queues(foo=a_queue, bar=b_queue)
     def test_lookup_takes_first(self):
-        R = routes.prepare(({mytask.name: {"queue": "bar"}},
-                            {mytask.name: {"queue": "foo"}}))
+        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)
@@ -109,33 +109,33 @@ class test_lookup_route(RouteCase):
                                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},
+        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},
+        self.assertDictContainsSubset({'routing_key': 'testq',
+                                       'immediate': False},
                                        route)
-        self.assertEqual(route["exchange"].name, "testq")
-        self.assertIn("queue", route)
+        self.assertEqual(route['exchange'].name, 'testq')
+        self.assertIn('queue', route)
 
     @with_queues(foo=a_queue, bar=b_queue)
     def test_expand_destination_string(self):
         x = routes.Router({}, current_app.amqp.queues)
-        dest = x.expand_destination("foo")
-        self.assertEqual(dest["exchange"].name, "fooexchange")
+        dest = x.expand_destination('foo')
+        self.assertEqual(dest['exchange'].name, 'fooexchange')
 
     @with_queues(foo=a_queue, bar=b_queue, **{
         current_app.conf.CELERY_DEFAULT_QUEUE: d_queue})
     def test_lookup_paths_traversed(self):
-        R = routes.prepare(({"celery.xaza": {"queue": "bar"}},
-                            {mytask.name: {"queue": "foo"}}))
+        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"),
+        self.assertAnswer(router.route({}, 'celery.poza'),
                 dict(d_queue, queue=current_app.conf.CELERY_DEFAULT_QUEUE))
 
 
@@ -144,8 +144,8 @@ class test_prepare(Case):
     def test_prepare(self):
         from celery.datastructures import LRUCache
         o = object()
-        R = [{"foo": "bar"},
-                  "celery.datastructures.LRUCache",
+        R = [{'foo': 'bar'},
+                  'celery.datastructures.LRUCache',
                   o]
         p = routes.prepare(R)
         self.assertIsInstance(p[0], routes.MapRoute)
@@ -155,6 +155,6 @@ class test_prepare(Case):
         self.assertEqual(routes.prepare(o), [o])
 
     def test_prepare_item_is_dict(self):
-        R = {"foo": "bar"}
+        R = {'foo': 'bar'}
         p = routes.prepare(R)
         self.assertIsInstance(p[0], routes.MapRoute)

celery/tests/backends/test_amqp.py

@@ -26,7 +26,7 @@ class SomeClass(object):
 class test_AMQPBackend(AppCase):
 
     def create_backend(self, **opts):
-        opts = dict(dict(serializer="pickle", persistent=False), **opts)
+        opts = dict(dict(serializer='pickle', persistent=False), **opts)
         return AMQPBackend(**opts)
 
     def test_mark_as_done(self):
@@ -50,12 +50,12 @@ class test_AMQPBackend(AppCase):
         tb2 = self.create_backend()
 
         tid2 = uuid()
-        result = {"foo": "baz", "bar": SomeClass(12345)}
+        result = {'foo': 'baz', 'bar': SomeClass(12345)}
         tb1.mark_as_done(tid2, result)
         # is serialized properly.
         rindb = tb2.get_result(tid2)
-        self.assertEqual(rindb.get("foo"), "baz")
-        self.assertEqual(rindb.get("bar").data, 12345)
+        self.assertEqual(rindb.get('foo'), 'baz')
+        self.assertEqual(rindb.get('bar').data, 12345)
 
     def test_mark_as_failure(self):
         tb1 = self.create_backend()
@@ -63,7 +63,7 @@ class test_AMQPBackend(AppCase):
 
         tid3 = uuid()
         try:
-            raise KeyError("foo")
+            raise KeyError('foo')
         except KeyError, exception:
             einfo = ExceptionInfo()
             tb1.mark_as_failure(tid3, exception, traceback=einfo.traceback)
@@ -75,7 +75,7 @@ class test_AMQPBackend(AppCase):
         from celery.backends.amqp import repair_uuid
         for i in range(10):
             tid = uuid()
-            self.assertEqual(repair_uuid(tid.replace("-", "")), tid)
+            self.assertEqual(repair_uuid(tid.replace('-', '')), tid)
 
     def test_expires_defaults_to_config_deprecated_setting(self):
         app = app_or_default()
@@ -83,21 +83,21 @@ class test_AMQPBackend(AppCase):
         app.conf.CELERY_AMQP_TASK_RESULT_EXPIRES = 10
         try:
             b = self.create_backend()
-            self.assertEqual(b.queue_arguments.get("x-expires"), 10 * 1000.0)
+            self.assertEqual(b.queue_arguments.get('x-expires'), 10 * 1000.0)
         finally:
             app.conf.CELERY_AMQP_TASK_RESULT_EXPIRES = prev
 
     def test_expires_is_int(self):
         b = self.create_backend(expires=48)
-        self.assertEqual(b.queue_arguments.get("x-expires"), 48 * 1000.0)
+        self.assertEqual(b.queue_arguments.get('x-expires'), 48 * 1000.0)
 
     def test_expires_is_float(self):
         b = self.create_backend(expires=48.3)
-        self.assertEqual(b.queue_arguments.get("x-expires"), 48.3 * 1000.0)
+        self.assertEqual(b.queue_arguments.get('x-expires'), 48.3 * 1000.0)
 
     def test_expires_is_timedelta(self):
         b = self.create_backend(expires=timedelta(minutes=1))
-        self.assertEqual(b.queue_arguments.get("x-expires"), 60 * 1000.0)
+        self.assertEqual(b.queue_arguments.get('x-expires'), 60 * 1000.0)
 
     @sleepdeprived()
     def test_store_result_retries(self):
@@ -108,24 +108,24 @@ class test_AMQPBackend(AppCase):
             if iterations[0] > stop_raising_at[0]:
                 return
             iterations[0] += 1
-            raise KeyError("foo")
+            raise KeyError('foo')
 
         backend = AMQPBackend()
         from celery.app.amqp import TaskProducer
         prod, TaskProducer.publish = TaskProducer.publish, publish
         try:
             with self.assertRaises(KeyError):
-                backend.retry_policy["max_retries"] = None
-                backend.store_result("foo", "bar", "STARTED")
+                backend.retry_policy['max_retries'] = None
+                backend.store_result('foo', 'bar', 'STARTED')
 
             with self.assertRaises(KeyError):
-                backend.retry_policy["max_retries"] = 10
-                backend.store_result("foo", "bar", "STARTED")
+                backend.retry_policy['max_retries'] = 10
+                backend.store_result('foo', 'bar', 'STARTED')
         finally:
             TaskProducer.publish = prod
 
     def assertState(self, retval, state):
-        self.assertEqual(retval["status"], state)
+        self.assertEqual(retval['status'], state)
 
     def test_poll_no_messages(self):
         b = self.create_backend()
@@ -138,8 +138,8 @@ class test_AMQPBackend(AppCase):
         class Message(object):
 
             def __init__(self, **merge):
-                self.payload = dict({"status": states.STARTED,
-                                     "result": None}, **merge)
+                self.payload = dict({'status': states.STARTED,
+                                     'result': None}, **merge)
 
         class MockBinding(object):
 
@@ -168,22 +168,22 @@ class test_AMQPBackend(AppCase):
         results.put(Message(status=states.STARTED, seq=2))
         results.put(Message(status=states.FAILURE, seq=3))
         r1 = backend.get_task_meta(uuid())
-        self.assertDictContainsSubset({"status": states.FAILURE,
-                                       "seq": 3}, r1,
-                                       "FFWDs to the last state")
+        self.assertDictContainsSubset({'status': states.FAILURE,
+                                       'seq': 3}, r1,
+                                       'FFWDs to the last state')
 
         # Caches last known state.
         results.put(Message())
         tid = uuid()
         backend.get_task_meta(tid)
-        self.assertIn(tid, backend._cache, "Caches last known state")
+        self.assertIn(tid, backend._cache, 'Caches last known state')
 
         # Returns cache if no new states.
         results.queue.clear()
         assert not results.qsize()
-        backend._cache[tid] = "hello"
-        self.assertEqual(backend.get_task_meta(tid), "hello",
-                         "Returns cache if no new states")
+        backend._cache[tid] = 'hello'
+        self.assertEqual(backend.get_task_meta(tid), 'hello',
+                         'Returns cache if no new states')
 
     def test_wait_for(self):
         b = self.create_backend()
@@ -201,9 +201,9 @@ class test_AMQPBackend(AppCase):
         self.assertEqual(b.wait_for(tid, timeout=1), 42)
         b.store_result(tid, 56, states.SUCCESS)
         self.assertEqual(b.wait_for(tid, timeout=1), 42,
-                         "result is cached")
+                         'result is cached')
         self.assertEqual(b.wait_for(tid, timeout=1, cache=False), 56)
-        b.store_result(tid, KeyError("foo"), states.FAILURE)
+        b.store_result(tid, KeyError('foo'), states.FAILURE)
         with self.assertRaises(KeyError):
             b.wait_for(tid, timeout=1, cache=False)
 
@@ -231,17 +231,17 @@ class test_AMQPBackend(AppCase):
             tids.append(tid)
 
         res = list(b.get_many(tids, timeout=1))
-        expected_results = [(tid, {"status": states.SUCCESS,
-                                    "result": i,
-                                    "traceback": None,
-                                    "task_id": tid,
-                                    "children": None})
+        expected_results = [(tid, {'status': states.SUCCESS,
+                                    'result': i,
+                                    'traceback': None,
+                                    'task_id': tid,
+                                    'children': None})
                                 for i, tid in enumerate(tids)]
         self.assertEqual(sorted(res), sorted(expected_results))
         self.assertDictEqual(b._cache[res[0][0]], res[0][1])
         cached_res = list(b.get_many(tids, timeout=1))
         self.assertEqual(sorted(cached_res), sorted(expected_results))
-        b._cache[res[0][0]]["status"] = states.RETRY
+        b._cache[res[0][0]]['status'] = states.RETRY
         with self.assertRaises(socket.timeout):
             list(b.get_many(tids, timeout=0.01))
 
@@ -250,22 +250,22 @@ class test_AMQPBackend(AppCase):
         class Backend(AMQPBackend):
 
             def Consumer(*args, **kwargs):
-                raise KeyError("foo")
+                raise KeyError('foo')
 
         b = Backend()
         with self.assertRaises(KeyError):
-            b.get_many(["id1"]).next()
+            b.get_many(['id1']).next()
 
     def test_test_get_many_raises_inner_block(self):
 
         class Backend(AMQPBackend):
 
             def drain_events(self, *args, **kwargs):
-                raise KeyError("foo")
+                raise KeyError('foo')
 
         b = Backend()
         with self.assertRaises(KeyError):
-            b.get_many(["id1"]).next()
+            b.get_many(['id1']).next()
 
     def test_no_expires(self):
         b = self.create_backend(expires=None)
@@ -275,7 +275,7 @@ class test_AMQPBackend(AppCase):
         try:
             b = self.create_backend(expires=None)
             with self.assertRaises(KeyError):
-                b.queue_arguments["x-expires"]
+                b.queue_arguments['x-expires']
         finally:
             app.conf.CELERY_AMQP_TASK_RESULT_EXPIRES = prev
 
@@ -284,20 +284,20 @@ class test_AMQPBackend(AppCase):
 
     def test_reload_task_result(self):
         with self.assertRaises(NotImplementedError):
-            self.create_backend().reload_task_result("x")
+            self.create_backend().reload_task_result('x')
 
     def test_reload_group_result(self):
         with self.assertRaises(NotImplementedError):
-            self.create_backend().reload_group_result("x")
+            self.create_backend().reload_group_result('x')
 
     def test_save_group(self):
         with self.assertRaises(NotImplementedError):
-            self.create_backend().save_group("x", "x")
+            self.create_backend().save_group('x', 'x')
 
     def test_restore_group(self):
         with self.assertRaises(NotImplementedError):
-            self.create_backend().restore_group("x")
+            self.create_backend().restore_group('x')
 
     def test_delete_group(self):
         with self.assertRaises(NotImplementedError):
-            self.create_backend().delete_group("x")
+            self.create_backend().delete_group('x')

celery/tests/backends/test_backends.py

@@ -13,8 +13,8 @@ from celery.tests.utils import Case
 class test_backends(Case):
 
     def test_get_backend_aliases(self):
-        expects = [("amqp", AMQPBackend),
-                   ("cache", CacheBackend)]
+        expects = [('amqp', AMQPBackend),
+                   ('cache', CacheBackend)]
         for expect_name, expect_cls in expects:
             self.assertIsInstance(backends.get_backend_cls(expect_name)(),
                                   expect_cls)
@@ -23,26 +23,26 @@ class test_backends(Case):
         backends.get_backend_cls.clear()
         hits = backends.get_backend_cls.hits
         misses = backends.get_backend_cls.misses
-        self.assertTrue(backends.get_backend_cls("amqp"))
+        self.assertTrue(backends.get_backend_cls('amqp'))
         self.assertEqual(backends.get_backend_cls.misses, misses + 1)
-        self.assertTrue(backends.get_backend_cls("amqp"))
+        self.assertTrue(backends.get_backend_cls('amqp'))
         self.assertEqual(backends.get_backend_cls.hits, hits + 1)
 
     def test_unknown_backend(self):
         with self.assertRaises(ImportError):
-            backends.get_backend_cls("fasodaopjeqijwqe")
+            backends.get_backend_cls('fasodaopjeqijwqe')
 
     def test_default_backend(self):
         self.assertEqual(backends.default_backend, current_app.backend)
 
-    def test_backend_by_url(self, url="redis://localhost/1"):
+    def test_backend_by_url(self, url='redis://localhost/1'):
         from celery.backends.redis import RedisBackend
         backend, url_ = backends.get_backend_by_url(url)
         self.assertIs(backend, RedisBackend)
         self.assertEqual(url_, url)
 
     def test_sym_raises_ValuError(self):
-        with patch("celery.backends.symbol_by_name") as sbn:
+        with patch('celery.backends.symbol_by_name') as sbn:
             sbn.side_effect = ValueError()
             with self.assertRaises(ValueError):
-                backends.get_backend_cls("xxx.xxx:foo")
+                backends.get_backend_cls('xxx.xxx:foo')

celery/tests/backends/test_base.py

@@ -32,19 +32,18 @@ class wrapobject(object):
 if sys.version_info >= (3, 0):
     Oldstyle = None
 else:
-    Oldstyle = types.ClassType("Oldstyle", (), {})
-Unpickleable = subclass_exception("Unpickleable", KeyError, "foo.module")
-Impossible = subclass_exception("Impossible", object, "foo.module")
-Lookalike = subclass_exception("Lookalike", wrapobject, "foo.module")
+    Oldstyle = types.ClassType('Oldstyle', (), {})
+Unpickleable = subclass_exception('Unpickleable', KeyError, 'foo.module')
+Impossible = subclass_exception('Impossible', object, 'foo.module')
+Lookalike = subclass_exception('Lookalike', wrapobject, 'foo.module')
 b = BaseBackend()
 
 
 class test_serialization(Case):
 
     def test_create_exception_cls(self):
-        self.assertTrue(serialization.create_exception_cls("FooError", "m"))
-        self.assertTrue(serialization.create_exception_cls("FooError",
-                                                            "m",
+        self.assertTrue(serialization.create_exception_cls('FooError', 'm'))
+        self.assertTrue(serialization.create_exception_cls('FooError', 'm',
                                                             KeyError))
 
 
@@ -52,63 +51,63 @@ class test_BaseBackend_interface(Case):
 
     def test_get_status(self):
         with self.assertRaises(NotImplementedError):
-            b.get_status("SOMExx-N0Nex1stant-IDxx-")
+            b.get_status('SOMExx-N0Nex1stant-IDxx-')
 
     def test__forget(self):
         with self.assertRaises(NotImplementedError):
-            b.forget("SOMExx-N0Nex1stant-IDxx-")
+            b.forget('SOMExx-N0Nex1stant-IDxx-')
 
     def test_get_children(self):
         with self.assertRaises(NotImplementedError):
-            b.get_children("SOMExx-N0Nex1stant-IDxx-")
+            b.get_children('SOMExx-N0Nex1stant-IDxx-')
 
     def test_store_result(self):
         with self.assertRaises(NotImplementedError):
-            b.store_result("SOMExx-N0nex1stant-IDxx-", 42, states.SUCCESS)
+            b.store_result('SOMExx-N0nex1stant-IDxx-', 42, states.SUCCESS)
 
     def test_mark_as_started(self):
         with self.assertRaises(NotImplementedError):
-            b.mark_as_started("SOMExx-N0nex1stant-IDxx-")
+            b.mark_as_started('SOMExx-N0nex1stant-IDxx-')
 
     def test_reload_task_result(self):
         with self.assertRaises(NotImplementedError):
-            b.reload_task_result("SOMExx-N0nex1stant-IDxx-")
+            b.reload_task_result('SOMExx-N0nex1stant-IDxx-')
 
     def test_reload_group_result(self):
         with self.assertRaises(NotImplementedError):
-            b.reload_group_result("SOMExx-N0nex1stant-IDxx-")
+            b.reload_group_result('SOMExx-N0nex1stant-IDxx-')
 
     def test_get_result(self):
         with self.assertRaises(NotImplementedError):
-            b.get_result("SOMExx-N0nex1stant-IDxx-")
+            b.get_result('SOMExx-N0nex1stant-IDxx-')
 
     def test_restore_group(self):
         with self.assertRaises(NotImplementedError):
-            b.restore_group("SOMExx-N0nex1stant-IDxx-")
+            b.restore_group('SOMExx-N0nex1stant-IDxx-')
 
     def test_delete_group(self):
         with self.assertRaises(NotImplementedError):
-            b.delete_group("SOMExx-N0nex1stant-IDxx-")
+            b.delete_group('SOMExx-N0nex1stant-IDxx-')
 
     def test_save_group(self):
         with self.assertRaises(NotImplementedError):
-            b.save_group("SOMExx-N0nex1stant-IDxx-", "blergh")
+            b.save_group('SOMExx-N0nex1stant-IDxx-', 'blergh')
 
     def test_get_traceback(self):
         with self.assertRaises(NotImplementedError):
-            b.get_traceback("SOMExx-N0nex1stant-IDxx-")
+            b.get_traceback('SOMExx-N0nex1stant-IDxx-')
 
     def test_forget(self):
         with self.assertRaises(NotImplementedError):
-            b.forget("SOMExx-N0nex1stant-IDxx-")
+            b.forget('SOMExx-N0nex1stant-IDxx-')
 
     def test_on_chord_part_return(self):
         b.on_chord_part_return(None)
 
-    def test_on_chord_apply(self, unlock="celery.chord_unlock"):
+    def test_on_chord_apply(self, unlock='celery.chord_unlock'):
         p, current_app.tasks[unlock] = current_app.tasks.get(unlock), Mock()
         try:
-            b.on_chord_apply("dakj221", "sdokqweok",
+            b.on_chord_apply('dakj221', 'sdokqweok',
                              result=map(AsyncResult, [1, 2, 3]))
             self.assertTrue(current_app.tasks[unlock].apply_async.call_count)
         finally:
@@ -119,14 +118,14 @@ class test_exception_pickle(Case):
 
     def test_oldstyle(self):
         if Oldstyle is None:
-            raise SkipTest("py3k does not support old style classes")
+            raise SkipTest('py3k does not support old style classes')
         self.assertIsNone(fnpe(Oldstyle()))
 
     def test_BaseException(self):
         self.assertIsNone(fnpe(Exception()))
 
     def test_get_pickleable_exception(self):
-        exc = Exception("foo")
+        exc = Exception('foo')
         self.assertEqual(gpe(exc), exc)
 
     def test_unpickleable(self):
@@ -137,7 +136,7 @@ class test_exception_pickle(Case):
 class test_prepare_exception(Case):
 
     def test_unpickleable(self):
-        x = b.prepare_exception(Unpickleable(1, 2, "foo"))
+        x = b.prepare_exception(Unpickleable(1, 2, 'foo'))
         self.assertIsInstance(x, KeyError)
         y = b.exception_to_python(x)
         self.assertIsInstance(y, KeyError)
@@ -147,14 +146,14 @@ class test_prepare_exception(Case):
         self.assertIsInstance(x, UnpickleableExceptionWrapper)
         self.assertTrue(str(x))
         y = b.exception_to_python(x)
-        self.assertEqual(y.__class__.__name__, "Impossible")
+        self.assertEqual(y.__class__.__name__, 'Impossible')
         if sys.version_info < (2, 5):
             self.assertTrue(y.__class__.__module__)
         else:
-            self.assertEqual(y.__class__.__module__, "foo.module")
+            self.assertEqual(y.__class__.__module__, 'foo.module')
 
     def test_regular(self):
-        x = b.prepare_exception(KeyError("baz"))
+        x = b.prepare_exception(KeyError('baz'))
         self.assertIsInstance(x, KeyError)
         y = b.exception_to_python(x)
         self.assertIsInstance(y, KeyError)
@@ -187,15 +186,15 @@ class DictBackend(BaseDictBackend):
 
     def __init__(self, *args, **kwargs):
         BaseDictBackend.__init__(self, *args, **kwargs)
-        self._data = {"can-delete": {"result": "foo"}}
+        self._data = {'can-delete': {'result': 'foo'}}
 
     def _restore_group(self, group_id):
-        if group_id == "exists":
-            return {"result": "group"}
+        if group_id == 'exists':
+            return {'result': 'group'}
 
     def _get_task_meta_for(self, task_id):
-        if task_id == "task-exists":
-            return {"result": "task"}
+        if task_id == 'task-exists':
+            return {'result': 'task'}
 
     def _delete_group(self, group_id):
         self._data.pop(group_id, None)
@@ -207,45 +206,44 @@ class test_BaseDictBackend(Case):
         self.b = DictBackend()
 
     def test_delete_group(self):
-        self.b.delete_group("can-delete")
-        self.assertNotIn("can-delete", self.b._data)
+        self.b.delete_group('can-delete')
+        self.assertNotIn('can-delete', self.b._data)
 
     def test_prepare_exception_json(self):
-        x = DictBackend(serializer="json")
-        e = x.prepare_exception(KeyError("foo"))
-        self.assertIn("exc_type", e)
+        x = DictBackend(serializer='json')
+        e = x.prepare_exception(KeyError('foo'))
+        self.assertIn('exc_type', e)
         e = x.exception_to_python(e)
-        self.assertEqual(e.__class__.__name__, "KeyError")
+        self.assertEqual(e.__class__.__name__, 'KeyError')
         self.assertEqual(str(e), "'foo'")
 
     def test_save_group(self):
         b = BaseDictBackend()
         b._save_group = Mock()
-        b.save_group("foofoo", "xxx")
-        b._save_group.assert_called_with("foofoo", "xxx")
+        b.save_group('foofoo', 'xxx')
+        b._save_group.assert_called_with('foofoo', 'xxx')
 
     def test_forget_interface(self):
         b = BaseDictBackend()
         with self.assertRaises(NotImplementedError):
-            b.forget("foo")
+            b.forget('foo')
 
     def test_restore_group(self):
-        self.assertIsNone(self.b.restore_group("missing"))
-        self.assertIsNone(self.b.restore_group("missing"))
-        self.assertEqual(self.b.restore_group("exists"), "group")
-        self.assertEqual(self.b.restore_group("exists"), "group")
-        self.assertEqual(self.b.restore_group("exists", cache=False),
-                         "group")
+        self.assertIsNone(self.b.restore_group('missing'))
+        self.assertIsNone(self.b.restore_group('missing'))
+        self.assertEqual(self.b.restore_group('exists'), 'group')
+        self.assertEqual(self.b.restore_group('exists'), 'group')
+        self.assertEqual(self.b.restore_group('exists', cache=False), 'group')
 
     def test_reload_group_result(self):
         self.b._cache = {}
-        self.b.reload_group_result("exists")
-        self.b._cache["exists"] = {"result": "group"}
+        self.b.reload_group_result('exists')
+        self.b._cache['exists'] = {'result': 'group'}
 
     def test_reload_task_result(self):
         self.b._cache = {}
-        self.b.reload_task_result("task-exists")
-        self.b._cache["task-exists"] = {"result": "task"}
+        self.b.reload_task_result('task-exists')
+        self.b._cache['task-exists'] = {'result': 'task'}
 
 
 class test_KeyValueStoreBackend(Case):
@@ -259,16 +257,16 @@ class test_KeyValueStoreBackend(Case):
 
     def test_get_store_delete_result(self):
         tid = uuid()
-        self.b.mark_as_done(tid, "Hello world")
-        self.assertEqual(self.b.get_result(tid), "Hello world")
+        self.b.mark_as_done(tid, 'Hello world')
+        self.assertEqual(self.b.get_result(tid), 'Hello world')
         self.assertEqual(self.b.get_status(tid), states.SUCCESS)
         self.b.forget(tid)
         self.assertEqual(self.b.get_status(tid), states.PENDING)
 
     def test_strip_prefix(self):
-        x = self.b.get_key_for_task("x1b34")
-        self.assertEqual(self.b._strip_prefix(x), "x1b34")
-        self.assertEqual(self.b._strip_prefix("x1b34"), "x1b34")
+        x = self.b.get_key_for_task('x1b34')
+        self.assertEqual(self.b._strip_prefix(x), 'x1b34')
+        self.assertEqual(self.b._strip_prefix('x1b34'), 'x1b34')
 
     def test_get_many(self):
         for is_dict in True, False:
@@ -278,13 +276,13 @@ class test_KeyValueStoreBackend(Case):
                 self.b.mark_as_done(id, i)
             it = self.b.get_many(ids.keys())
             for i, (got_id, got_state) in enumerate(it):
-                self.assertEqual(got_state["result"], ids[got_id])
+                self.assertEqual(got_state['result'], ids[got_id])
             self.assertEqual(i, 9)
             self.assertTrue(list(self.b.get_many(ids.keys())))
 
     def test_get_missing_meta(self):
-        self.assertIsNone(self.b.get_result("xxx-missing"))
-        self.assertEqual(self.b.get_status("xxx-missing"), states.PENDING)
+        self.assertIsNone(self.b.get_result('xxx-missing'))
+        self.assertEqual(self.b.get_status('xxx-missing'), states.PENDING)
 
     def test_save_restore_delete_group(self):
         tid = uuid()
@@ -297,37 +295,37 @@ class test_KeyValueStoreBackend(Case):
         self.assertIsNone(self.b.restore_group(tid))
 
     def test_restore_missing_group(self):
-        self.assertIsNone(self.b.restore_group("xxx-nonexistant"))
+        self.assertIsNone(self.b.restore_group('xxx-nonexistant'))
 
 
 class test_KeyValueStoreBackend_interface(Case):
 
     def test_get(self):
         with self.assertRaises(NotImplementedError):
-            KeyValueStoreBackend().get("a")
+            KeyValueStoreBackend().get('a')
 
     def test_set(self):
         with self.assertRaises(NotImplementedError):
-            KeyValueStoreBackend().set("a", 1)
+            KeyValueStoreBackend().set('a', 1)
 
     def test_incr(self):
         with self.assertRaises(NotImplementedError):
-            KeyValueStoreBackend().incr("a")
+            KeyValueStoreBackend().incr('a')
 
     def test_cleanup(self):
         self.assertFalse(KeyValueStoreBackend().cleanup())
 
     def test_delete(self):
         with self.assertRaises(NotImplementedError):
-            KeyValueStoreBackend().delete("a")
+            KeyValueStoreBackend().delete('a')
 
     def test_mget(self):
         with self.assertRaises(NotImplementedError):
-            KeyValueStoreBackend().mget(["a"])
+            KeyValueStoreBackend().mget(['a'])
 
     def test_forget(self):
         with self.assertRaises(NotImplementedError):
-            KeyValueStoreBackend().forget("a")
+            KeyValueStoreBackend().forget('a')
 
 
 class test_DisabledBackend(Case):
@@ -337,4 +335,4 @@ class test_DisabledBackend(Case):
 
     def test_is_disabled(self):
         with self.assertRaises(NotImplementedError):
-            DisabledBackend().get_status("foo")
+            DisabledBackend().get_status('foo')

celery/tests/backends/test_cache.py

@@ -29,7 +29,7 @@ class SomeClass(object):
 class test_CacheBackend(Case):
 
     def setUp(self):
-        self.tb = CacheBackend(backend="memory://")
+        self.tb = CacheBackend(backend='memory://')
         self.tid = uuid()
 
     def test_mark_as_done(self):
@@ -41,38 +41,38 @@ class test_CacheBackend(Case):
         self.assertEqual(self.tb.get_result(self.tid), 42)
 
     def test_is_pickled(self):
-        result = {"foo": "baz", "bar": SomeClass(12345)}
+        result = {'foo': 'baz', 'bar': SomeClass(12345)}
         self.tb.mark_as_done(self.tid, result)
         # is serialized properly.
         rindb = self.tb.get_result(self.tid)
-        self.assertEqual(rindb.get("foo"), "baz")
-        self.assertEqual(rindb.get("bar").data, 12345)
+        self.assertEqual(rindb.get('foo'), 'baz')
+        self.assertEqual(rindb.get('bar').data, 12345)
 
     def test_mark_as_failure(self):
         try:
-            raise KeyError("foo")
+            raise KeyError('foo')
         except KeyError, exception:
             self.tb.mark_as_failure(self.tid, exception)
             self.assertEqual(self.tb.get_status(self.tid), states.FAILURE)
             self.assertIsInstance(self.tb.get_result(self.tid), KeyError)
 
     def test_on_chord_apply(self):
-        tb = CacheBackend(backend="memory://")
-        tb.on_chord_apply("group_id", [])
+        tb = CacheBackend(backend='memory://')
+        tb.on_chord_apply('group_id', [])
 
-    @patch("celery.result.GroupResult")
+    @patch('celery.result.GroupResult')
     def test_on_chord_part_return(self, setresult):
-        tb = CacheBackend(backend="memory://")
+        tb = CacheBackend(backend='memory://')
 
         deps = Mock()
         deps.total = 2
         setresult.restore.return_value = deps
         task = Mock()
-        task.name = "foobarbaz"
+        task.name = 'foobarbaz'
         try:
-            current_app.tasks["foobarbaz"] = task
+            current_app.tasks['foobarbaz'] = task
             task.request.chord = subtask(task)
-            task.request.group = "group_id"
+            task.request.group = 'group_id'
 
             tb.on_chord_apply(task.request.group, [])
 
@@ -85,17 +85,17 @@ class test_CacheBackend(Case):
             deps.delete.assert_called_with()
 
         finally:
-            current_app.tasks.pop("foobarbaz")
+            current_app.tasks.pop('foobarbaz')
 
     def test_mget(self):
-        self.tb.set("foo", 1)
-        self.tb.set("bar", 2)
+        self.tb.set('foo', 1)
+        self.tb.set('bar', 2)
 
-        self.assertDictEqual(self.tb.mget(["foo", "bar"]),
-                             {"foo": 1, "bar": 2})
+        self.assertDictEqual(self.tb.mget(['foo', 'bar']),
+                             {'foo': 1, 'bar': 2})
 
     def test_forget(self):
-        self.tb.mark_as_done(self.tid, {"foo": "bar"})
+        self.tb.mark_as_done(self.tid, {'foo': 'bar'})
         x = AsyncResult(self.tid, backend=self.tb)
         x.forget()
         self.assertIsNone(x.result)
@@ -104,12 +104,12 @@ class test_CacheBackend(Case):
         self.tb.process_cleanup()
 
     def test_expires_as_int(self):
-        tb = CacheBackend(backend="memory://", expires=10)
+        tb = CacheBackend(backend='memory://', expires=10)
         self.assertEqual(tb.expires, 10)
 
     def test_unknown_backend_raises_ImproperlyConfigured(self):
         with self.assertRaises(ImproperlyConfigured):
-            CacheBackend(backend="unknown://")
+            CacheBackend(backend='unknown://')
 
 
 class MyMemcachedStringEncodingError(Exception):
@@ -121,8 +121,8 @@ class MemcachedClient(DummyClient):
     def set(self, key, value, *args, **kwargs):
         if isinstance(key, unicode):
             raise MyMemcachedStringEncodingError(
-                    "Keys must be str()'s, not unicode.  Convert your unicode "
-                    "strings using mystring.encode(charset)!")
+                    'Keys must be str, not unicode.  Convert your unicode '
+                    'strings using mystring.encode(charset)!')
         return super(MemcachedClient, self).set(key, value, *args, **kwargs)
 
 
@@ -130,48 +130,48 @@ class MockCacheMixin(object):
 
     @contextmanager
     def mock_memcache(self):
-        memcache = types.ModuleType("memcache")
+        memcache = types.ModuleType('memcache')
         memcache.Client = MemcachedClient
         memcache.Client.__module__ = memcache.__name__
-        prev, sys.modules["memcache"] = sys.modules.get("memcache"), memcache
+        prev, sys.modules['memcache'] = sys.modules.get('memcache'), memcache
         yield True
         if prev is not None:
-            sys.modules["memcache"] = prev
+            sys.modules['memcache'] = prev
 
     @contextmanager
     def mock_pylibmc(self):
-        pylibmc = types.ModuleType("pylibmc")
+        pylibmc = types.ModuleType('pylibmc')
         pylibmc.Client = MemcachedClient
         pylibmc.Client.__module__ = pylibmc.__name__
-        prev = sys.modules.get("pylibmc")
-        sys.modules["pylibmc"] = pylibmc
+        prev = sys.modules.get('pylibmc')
+        sys.modules['pylibmc'] = pylibmc
         yield True
         if prev is not None:
-            sys.modules["pylibmc"] = prev
+            sys.modules['pylibmc'] = prev
 
 
 class test_get_best_memcache(Case, MockCacheMixin):
 
     def test_pylibmc(self):
         with self.mock_pylibmc():
-            with reset_modules("celery.backends.cache"):
+            with reset_modules('celery.backends.cache'):
                 from celery.backends import cache
                 cache._imp = [None]
                 self.assertEqual(cache.get_best_memcache().__module__,
-                                 "pylibmc")
+                                 'pylibmc')
 
     def test_memcache(self):
         with self.mock_memcache():
-            with reset_modules("celery.backends.cache"):
-                with mask_modules("pylibmc"):
+            with reset_modules('celery.backends.cache'):
+                with mask_modules('pylibmc'):
                     from celery.backends import cache
                     cache._imp = [None]
                     self.assertEqual(cache.get_best_memcache().__module__,
-                                     "memcache")
+                                     'memcache')
 
     def test_no_implementations(self):
-        with mask_modules("pylibmc", "memcache"):
-            with reset_modules("celery.backends.cache"):
+        with mask_modules('pylibmc', 'memcache'):
+            with reset_modules('celery.backends.cache'):
                 from celery.backends import cache
                 cache._imp = [None]
                 with self.assertRaises(ImproperlyConfigured):
@@ -179,10 +179,10 @@ class test_get_best_memcache(Case, MockCacheMixin):
 
     def test_cached(self):
         with self.mock_pylibmc():
-            with reset_modules("celery.backends.cache"):
+            with reset_modules('celery.backends.cache'):
                 from celery.backends import cache
                 cache._imp = [None]
-                cache.get_best_memcache(behaviors={"foo": "bar"})
+                cache.get_best_memcache(behaviors={'foo': 'bar'})
                 self.assertTrue(cache._imp[0])
                 cache.get_best_memcache()
 
@@ -196,8 +196,8 @@ class test_memcache_key(Case, MockCacheMixin):
 
     def test_memcache_unicode_key(self):
         with self.mock_memcache():
-            with reset_modules("celery.backends.cache"):
-                with mask_modules("pylibmc"):
+            with reset_modules('celery.backends.cache'):
+                with mask_modules('pylibmc'):
                     from celery.backends import cache
                     cache._imp = [None]
                     task_id, result = unicode(uuid()), 42
@@ -207,8 +207,8 @@ class test_memcache_key(Case, MockCacheMixin):
 
     def test_memcache_bytes_key(self):
         with self.mock_memcache():
-            with reset_modules("celery.backends.cache"):
-                with mask_modules("pylibmc"):
+            with reset_modules('celery.backends.cache'):
+                with mask_modules('pylibmc'):
                     from celery.backends import cache
                     cache._imp = [None]
                     task_id, result = str_to_bytes(uuid()), 42
@@ -217,7 +217,7 @@ class test_memcache_key(Case, MockCacheMixin):
                     self.assertEqual(b.get_result(task_id), result)
 
     def test_pylibmc_unicode_key(self):
-        with reset_modules("celery.backends.cache"):
+        with reset_modules('celery.backends.cache'):
             with self.mock_pylibmc():
                 from celery.backends import cache
                 cache._imp = [None]
@@ -227,7 +227,7 @@ class test_memcache_key(Case, MockCacheMixin):
                 self.assertEqual(b.get_result(task_id), result)
 
     def test_pylibmc_bytes_key(self):
-        with reset_modules("celery.backends.cache"):
+        with reset_modules('celery.backends.cache'):
             with self.mock_pylibmc():
                 from celery.backends import cache
                 cache._imp = [None]

celery/tests/backends/test_cassandra.py

@@ -44,7 +44,7 @@ def install_exceptions(mod):
 class test_CassandraBackend(AppCase):
 
     def test_init_no_pycassa(self):
-        with mock_module("pycassa"):
+        with mock_module('pycassa'):
             from celery.backends import cassandra as mod
             prev, mod.pycassa = mod.pycassa, None
             try:
@@ -55,40 +55,40 @@ class test_CassandraBackend(AppCase):
 
     def get_app(self):
         celery = Celery(set_as_current=False)
-        celery.conf.CASSANDRA_SERVERS = ["example.com"]
-        celery.conf.CASSANDRA_KEYSPACE = "keyspace"
-        celery.conf.CASSANDRA_COLUMN_FAMILY = "columns"
+        celery.conf.CASSANDRA_SERVERS = ['example.com']
+        celery.conf.CASSANDRA_KEYSPACE = 'keyspace'
+        celery.conf.CASSANDRA_COLUMN_FAMILY = 'columns'
         return celery
 
     def test_init_with_and_without_LOCAL_QUROM(self):
-        with mock_module("pycassa"):
+        with mock_module('pycassa'):
             from celery.backends import cassandra as mod
             mod.pycassa = Mock()
             install_exceptions(mod.pycassa)
             cons = mod.pycassa.ConsistencyLevel = Object()
-            cons.LOCAL_QUORUM = "foo"
+            cons.LOCAL_QUORUM = 'foo'
 
             app = self.get_app()
-            app.conf.CASSANDRA_READ_CONSISTENCY = "LOCAL_FOO"
-            app.conf.CASSANDRA_WRITE_CONSISTENCY = "LOCAL_FOO"
+            app.conf.CASSANDRA_READ_CONSISTENCY = 'LOCAL_FOO'
+            app.conf.CASSANDRA_WRITE_CONSISTENCY = 'LOCAL_FOO'
 
             mod.CassandraBackend(app=app)
-            cons.LOCAL_FOO = "bar"
+            cons.LOCAL_FOO = 'bar'
             mod.CassandraBackend(app=app)
 
             # no servers raises ImproperlyConfigured
             with self.assertRaises(ImproperlyConfigured):
                 app.conf.CASSANDRA_SERVERS = None
-                mod.CassandraBackend(app=app, keyspace="b",
-                        column_family="c")
+                mod.CassandraBackend(app=app, keyspace='b',
+                        column_family='c')
 
     def test_reduce(self):
-        with mock_module("pycassa"):
+        with mock_module('pycassa'):
             from celery.backends.cassandra import CassandraBackend
             self.assertTrue(loads(dumps(CassandraBackend(app=self.get_app()))))
 
     def test_get_task_meta_for(self):
-        with mock_module("pycassa"):
+        with mock_module('pycassa'):
             from celery.backends import cassandra as mod
             mod.pycassa = Mock()
             install_exceptions(mod.pycassa)
@@ -99,29 +99,29 @@ class test_CassandraBackend(AppCase):
             Get_Column = x._get_column_family = Mock()
             get_column = Get_Column.return_value = Mock()
             get = get_column.get
-            META = get.return_value = {"task_id": "task_id",
-                                "status": states.SUCCESS,
-                                "result": "1",
-                                "date_done": "date",
-                                "traceback": "",
-                                "children": None}
+            META = get.return_value = {'task_id': 'task_id',
+                                'status': states.SUCCESS,
+                                'result': '1',
+                                'date_done': 'date',
+                                'traceback': '',
+                                'children': None}
             x.decode = Mock()
             x.detailed_mode = False
-            meta = x._get_task_meta_for("task_id")
-            self.assertEqual(meta["status"], states.SUCCESS)
+            meta = x._get_task_meta_for('task_id')
+            self.assertEqual(meta['status'], states.SUCCESS)
 
             x.detailed_mode = True
             row = get.return_value = Mock()
             row.values.return_value = [Mock()]
             x.decode.return_value = META
-            meta = x._get_task_meta_for("task_id")
-            self.assertEqual(meta["status"], states.SUCCESS)
+            meta = x._get_task_meta_for('task_id')
+            self.assertEqual(meta['status'], states.SUCCESS)
             x.decode.return_value = Mock()
 
             x.detailed_mode = False
             get.side_effect = KeyError()
-            meta = x._get_task_meta_for("task_id")
-            self.assertEqual(meta["status"], states.PENDING)
+            meta = x._get_task_meta_for('task_id')
+            self.assertEqual(meta['status'], states.PENDING)
 
             calls = [0]
             end = [10]
@@ -136,16 +136,16 @@ class test_CassandraBackend(AppCase):
             get.side_effect = work_eventually
             x._retry_timeout = 10
             x._retry_wait = 0.01
-            meta = x._get_task_meta_for("task")
-            self.assertEqual(meta["status"], states.SUCCESS)
+            meta = x._get_task_meta_for('task')
+            self.assertEqual(meta['status'], states.SUCCESS)
 
             x._retry_timeout = 0.1
             calls[0], end[0] = 0, 100
             with self.assertRaises(socket.error):
-                x._get_task_meta_for("task")
+                x._get_task_meta_for('task')
 
     def test_store_result(self):
-        with mock_module("pycassa"):
+        with mock_module('pycassa'):
             from celery.backends import cassandra as mod
             mod.pycassa = Mock()
             install_exceptions(mod.pycassa)
@@ -156,16 +156,16 @@ class test_CassandraBackend(AppCase):
             Get_Column = x._get_column_family = Mock()
             cf = Get_Column.return_value = Mock()
             x.detailed_mode = False
-            x._store_result("task_id", "result", states.SUCCESS)
+            x._store_result('task_id', 'result', states.SUCCESS)
             self.assertTrue(cf.insert.called)
 
             cf.insert.reset()
             x.detailed_mode = True
-            x._store_result("task_id", "result", states.SUCCESS)
+            x._store_result('task_id', 'result', states.SUCCESS)
             self.assertTrue(cf.insert.called)
 
     def test_process_cleanup(self):
-        with mock_module("pycassa"):
+        with mock_module('pycassa'):
             from celery.backends import cassandra as mod
             app = self.get_app()
             x = mod.CassandraBackend(app=app)
@@ -177,7 +177,7 @@ class test_CassandraBackend(AppCase):
             self.assertIsNone(x._column_family)
 
     def test_get_column_family(self):
-        with mock_module("pycassa"):
+        with mock_module('pycassa'):
             from celery.backends import cassandra as mod
             mod.pycassa = Mock()
             install_exceptions(mod.pycassa)

celery/tests/backends/test_database.py

@@ -34,15 +34,15 @@ class SomeClass(object):
 class test_DatabaseBackend(Case):
 
     def setUp(self):
-        if sys.platform.startswith("java"):
-            raise SkipTest("SQLite not available on Jython")
-        if hasattr(sys, "pypy_version_info"):
-            raise SkipTest("Known to not pass on PyPy")
+        if sys.platform.startswith('java'):
+            raise SkipTest('SQLite not available on Jython')
+        if hasattr(sys, 'pypy_version_info'):
+            raise SkipTest('Known to not pass on PyPy')
         if DatabaseBackend is None:
-            raise SkipTest("sqlalchemy not installed")
+            raise SkipTest('sqlalchemy not installed')
 
     def test_missing_SQLAlchemy_raises_ImproperlyConfigured(self):
-        with mask_modules("sqlalchemy"):
+        with mask_modules('sqlalchemy'):
             from celery.backends.database import _sqlalchemy_installed
             with self.assertRaises(ImproperlyConfigured):
                 _sqlalchemy_installed()
@@ -51,8 +51,8 @@ class test_DatabaseBackend(Case):
         import sqlalchemy as sa
         from celery.backends.database import session
         prev_base = session.ResultModelBase
-        prev_ver, sa.__version__ = sa.__version__, "0.5.0"
-        prev_models = sys.modules.pop("celery.backends.database.models", None)
+        prev_ver, sa.__version__ = sa.__version__, '0.5.0'
+        prev_models = sys.modules.pop('celery.backends.database.models', None)
         try:
             from sqlalchemy.ext.declarative import declarative_base
             session.ResultModelBase = declarative_base()
@@ -60,7 +60,7 @@ class test_DatabaseBackend(Case):
             from celery.backends.database.models import PickleType as Type2
             self.assertIs(Type1, Type2)
         finally:
-            sys.modules["celery.backends.database.models"] = prev_models
+            sys.modules['celery.backends.database.models'] = prev_models
             sa.__version__ = prev_ver
             session.ResultModelBase = prev_base
 
@@ -75,16 +75,16 @@ class test_DatabaseBackend(Case):
 
     def test_missing_task_id_is_PENDING(self):
         tb = DatabaseBackend()
-        self.assertEqual(tb.get_status("xxx-does-not-exist"), states.PENDING)
+        self.assertEqual(tb.get_status('xxx-does-not-exist'), states.PENDING)
 
     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",
+            'task_id': 'xxx-does-not-exist-at-all',
             'result': None,
             'traceback': None,
-            }, tb.get_task_meta("xxx-does-not-exist-at-all"))
+            }, tb.get_task_meta('xxx-does-not-exist-at-all'))
 
     def test_mark_as_done(self):
         tb = DatabaseBackend()
@@ -102,12 +102,12 @@ class test_DatabaseBackend(Case):
         tb = DatabaseBackend()
 
         tid2 = uuid()
-        result = {"foo": "baz", "bar": SomeClass(12345)}
+        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)
+        self.assertEqual(rindb.get('foo'), 'baz')
+        self.assertEqual(rindb.get('bar').data, 12345)
 
     def test_mark_as_started(self):
         tb = DatabaseBackend()
@@ -125,10 +125,10 @@ class test_DatabaseBackend(Case):
         tb = DatabaseBackend()
         tid = uuid()
         try:
-            raise KeyError("foo")
+            raise KeyError('foo')
         except KeyError, exception:
             import traceback
-            trace = "\n".join(traceback.format_stack())
+            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)
@@ -139,20 +139,20 @@ class test_DatabaseBackend(Case):
 
         tid3 = uuid()
         try:
-            raise KeyError("foo")
+            raise KeyError('foo')
         except KeyError, exception:
             import traceback
-            trace = "\n".join(traceback.format_stack())
+            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)
 
     def test_forget(self):
-        tb = DatabaseBackend(backend="memory://")
+        tb = DatabaseBackend(backend='memory://')
         tid = uuid()
-        tb.mark_as_done(tid, {"foo": "bar"})
-        tb.mark_as_done(tid, {"foo": "bar"})
+        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)
@@ -169,7 +169,7 @@ class test_DatabaseBackend(Case):
         tb = DatabaseBackend()
 
         tid = uuid()
-        res = {u"something": "special"}
+        res = {u'something': 'special'}
         self.assertEqual(tb.save_group(tid, res), res)
 
         res2 = tb.restore_group(tid)
@@ -178,13 +178,13 @@ class test_DatabaseBackend(Case):
         tb.delete_group(tid)
         self.assertIsNone(tb.restore_group(tid))
 
-        self.assertIsNone(tb.restore_group("xxx-nonexisting-id"))
+        self.assertIsNone(tb.restore_group('xxx-nonexisting-id'))
 
     def test_cleanup(self):
         tb = DatabaseBackend()
         for i in range(10):
             tb.mark_as_done(uuid(), 42)
-            tb.save_group(uuid(), {"foo": "bar"})
+            tb.save_group(uuid(), {'foo': 'bar'})
         s = tb.ResultSession()
         for t in s.query(Task).all():
             t.date_done = datetime.now() - tb.expires * 2
@@ -196,7 +196,7 @@ class test_DatabaseBackend(Case):
         tb.cleanup()
 
     def test_Task__repr__(self):
-        self.assertIn("foo", repr(Task("foo")))
+        self.assertIn('foo', repr(Task('foo')))
 
     def test_TaskSet__repr__(self):
-        self.assertIn("foo", repr(TaskSet("foo", None)))
+        self.assertIn('foo', repr(TaskSet('foo', None)))

celery/tests/backends/test_mongodb.py

@@ -15,39 +15,39 @@ from celery.backends.mongodb import MongoBackend, Bunch, pymongo
 from celery.exceptions import ImproperlyConfigured
 from celery.tests.utils import AppCase
 
-COLLECTION = "taskmeta_celery"
+COLLECTION = 'taskmeta_celery'
 TASK_ID = str(uuid.uuid1())
-MONGODB_HOST = "localhost"
+MONGODB_HOST = 'localhost'
 MONGODB_PORT = 27017
-MONGODB_USER = "mongo"
-MONGODB_PASSWORD = "1234"
-MONGODB_DATABASE = "testing"
-MONGODB_COLLECTION = "collection1"
+MONGODB_USER = 'mongo'
+MONGODB_PASSWORD = '1234'
+MONGODB_DATABASE = 'testing'
+MONGODB_COLLECTION = 'collection1'
 
 
 class test_MongoBackend(AppCase):
 
     def setUp(self):
         if pymongo is None:
-            raise SkipTest("pymongo is not installed.")
+            raise SkipTest('pymongo is not installed.')
 
         R = self._reset = {}
-        R["encode"], MongoBackend.encode = MongoBackend.encode, Mock()
-        R["decode"], MongoBackend.decode = MongoBackend.decode, Mock()
-        R["Binary"], module.Binary = module.Binary, Mock()
-        R["datetime"], datetime.datetime = datetime.datetime, Mock()
+        R['encode'], MongoBackend.encode = MongoBackend.encode, Mock()
+        R['decode'], MongoBackend.decode = MongoBackend.decode, Mock()
+        R['Binary'], module.Binary = module.Binary, Mock()
+        R['datetime'], datetime.datetime = datetime.datetime, Mock()
 
         self.backend = MongoBackend()
 
     def tearDown(self):
-        MongoBackend.encode = self._reset["encode"]
-        MongoBackend.decode = self._reset["decode"]
-        module.Binary = self._reset["Binary"]
-        datetime.datetime = self._reset["datetime"]
+        MongoBackend.encode = self._reset['encode']
+        MongoBackend.decode = self._reset['decode']
+        module.Binary = self._reset['Binary']
+        datetime.datetime = self._reset['datetime']
 
     def test_Bunch(self):
-        x = Bunch(foo="foo", bar=2)
-        self.assertEqual(x.foo, "foo")
+        x = Bunch(foo='foo', bar=2)
+        self.assertEqual(x.foo, 'foo')
         self.assertEqual(x.bar, 2)
 
     def test_init_no_mongodb(self):
@@ -74,7 +74,7 @@ class test_MongoBackend(AppCase):
         x.collection = Mock()
         fo = x.collection.find_one = Mock()
         fo.return_value = None
-        self.assertIsNone(x._restore_group("1f3fab"))
+        self.assertIsNone(x._restore_group('1f3fab'))
 
     def test_reduce(self):
         x = MongoBackend()
@@ -82,7 +82,7 @@ class test_MongoBackend(AppCase):
 
     def test_get_connection_connection_exists(self):
 
-        with patch("pymongo.connection.Connection") as mock_Connection:
+        with patch('pymongo.connection.Connection') as mock_Connection:
             self.backend._connection = sentinel._connection
 
             connection = self.backend._get_connection()
@@ -92,7 +92,7 @@ class test_MongoBackend(AppCase):
 
     def test_get_connection_no_connection_host(self):
 
-        with patch("pymongo.connection.Connection") as mock_Connection:
+        with patch('pymongo.connection.Connection') as mock_Connection:
             self.backend._connection = None
             self.backend.mongodb_host = MONGODB_HOST
             self.backend.mongodb_port = MONGODB_PORT
@@ -105,8 +105,8 @@ class test_MongoBackend(AppCase):
 
     def test_get_connection_no_connection_mongodb_uri(self):
 
-        with patch("pymongo.connection.Connection") as mock_Connection:
-            mongodb_uri = "mongodb://%s:%d" % (MONGODB_HOST, MONGODB_PORT)
+        with patch('pymongo.connection.Connection') as mock_Connection:
+            mongodb_uri = 'mongodb://%s:%d' % (MONGODB_HOST, MONGODB_PORT)
             self.backend._connection = None
             self.backend.mongodb_host = mongodb_uri
 
@@ -116,7 +116,7 @@ class test_MongoBackend(AppCase):
             mock_Connection.assert_called_once_with(mongodb_uri)
             self.assertEquals(sentinel.connection, connection)
 
-    @patch("celery.backends.mongodb.MongoBackend._get_connection")
+    @patch('celery.backends.mongodb.MongoBackend._get_connection')
     def test_get_database_no_existing(self, mock_get_connection):
         # Should really check for combinations of these two, to be complete.
         self.backend.mongodb_user = MONGODB_USER
@@ -130,11 +130,11 @@ class test_MongoBackend(AppCase):
         database = self.backend.database
 
         self.assertTrue(database is mock_database)
-        self.assertTrue(self.backend.__dict__["database"] is mock_database)
+        self.assertTrue(self.backend.__dict__['database'] is mock_database)
         mock_database.authenticate.assert_called_once_with(
             MONGODB_USER, MONGODB_PASSWORD)
 
-    @patch("celery.backends.mongodb.MongoBackend._get_connection")
+    @patch('celery.backends.mongodb.MongoBackend._get_connection')
     def test_get_database_no_existing_no_auth(self, mock_get_connection):
         # Should really check for combinations of these two, to be complete.
         self.backend.mongodb_user = None
@@ -149,18 +149,18 @@ class test_MongoBackend(AppCase):
 
         self.assertTrue(database is mock_database)
         self.assertFalse(mock_database.authenticate.called)
-        self.assertTrue(self.backend.__dict__["database"] is mock_database)
+        self.assertTrue(self.backend.__dict__['database'] is mock_database)
 
     def test_process_cleanup(self):
         self.backend._connection = None
         self.backend.process_cleanup()
         self.assertEquals(self.backend._connection, None)
 
-        self.backend._connection = "not none"
+        self.backend._connection = 'not none'
         self.backend.process_cleanup()
         self.assertEquals(self.backend._connection, None)
 
-    @patch("celery.backends.mongodb.MongoBackend._get_database")
+    @patch('celery.backends.mongodb.MongoBackend._get_database')
     def test_store_result(self, mock_get_database):
         self.backend.mongodb_taskmeta_collection = MONGODB_COLLECTION
 
@@ -178,9 +178,9 @@ class test_MongoBackend(AppCase):
         mock_collection.save.assert_called_once()
         self.assertEquals(sentinel.result, ret_val)
 
-    @patch("celery.backends.mongodb.MongoBackend._get_database")
+    @patch('celery.backends.mongodb.MongoBackend._get_database')
     def test_get_task_meta_for(self, mock_get_database):
-        datetime.datetime = self._reset["datetime"]
+        datetime.datetime = self._reset['datetime']
         self.backend.mongodb_taskmeta_collection = MONGODB_COLLECTION
 
         mock_database = MagicMock(spec=['__getitem__', '__setitem__'])
@@ -199,7 +199,7 @@ class test_MongoBackend(AppCase):
              'children'],
             ret_val.keys())
 
-    @patch("celery.backends.mongodb.MongoBackend._get_database")
+    @patch('celery.backends.mongodb.MongoBackend._get_database')
     def test_get_task_meta_for_no_result(self, mock_get_database):
         self.backend.mongodb_taskmeta_collection = MONGODB_COLLECTION
 
@@ -214,9 +214,9 @@ class test_MongoBackend(AppCase):
 
         mock_get_database.assert_called_once_with()
         mock_database.__getitem__.assert_called_once_with(MONGODB_COLLECTION)
-        self.assertEquals({"status": states.PENDING, "result": None}, ret_val)
+        self.assertEquals({'status': states.PENDING, 'result': None}, ret_val)
 
-    @patch("celery.backends.mongodb.MongoBackend._get_database")
+    @patch('celery.backends.mongodb.MongoBackend._get_database')
     def test_save_group(self, mock_get_database):
         self.backend.mongodb_taskmeta_collection = MONGODB_COLLECTION
 
@@ -234,7 +234,7 @@ class test_MongoBackend(AppCase):
         mock_collection.save.assert_called_once()
         self.assertEquals(sentinel.result, ret_val)
 
-    @patch("celery.backends.mongodb.MongoBackend._get_database")
+    @patch('celery.backends.mongodb.MongoBackend._get_database')
     def test_restore_group(self, mock_get_database):
         self.backend.mongodb_taskmeta_collection = MONGODB_COLLECTION
 
@@ -250,10 +250,10 @@ class test_MongoBackend(AppCase):
         mock_get_database.assert_called_once_with()
         mock_database.__getitem__.assert_called_once_with(MONGODB_COLLECTION)
         mock_collection.find_one.assert_called_once_with(
-            {"_id": sentinel.taskset_id})
+            {'_id': sentinel.taskset_id})
         self.assertEquals(['date_done', 'result', 'task_id'], ret_val.keys())
 
-    @patch("celery.backends.mongodb.MongoBackend._get_database")
+    @patch('celery.backends.mongodb.MongoBackend._get_database')
     def test_delete_group(self, mock_get_database):
         self.backend.mongodb_taskmeta_collection = MONGODB_COLLECTION
 
@@ -268,9 +268,9 @@ class test_MongoBackend(AppCase):
         mock_get_database.assert_called_once_with()
         mock_database.__getitem__.assert_called_once_with(MONGODB_COLLECTION)
         mock_collection.remove.assert_called_once_with(
-            {"_id": sentinel.taskset_id})
+            {'_id': sentinel.taskset_id})
 
-    @patch("celery.backends.mongodb.MongoBackend._get_database")
+    @patch('celery.backends.mongodb.MongoBackend._get_database')
     def test_forget(self, mock_get_database):
         self.backend.mongodb_taskmeta_collection = MONGODB_COLLECTION
 
@@ -286,11 +286,11 @@ class test_MongoBackend(AppCase):
         mock_database.__getitem__.assert_called_once_with(
             MONGODB_COLLECTION)
         mock_collection.remove.assert_called_once_with(
-            {"_id": sentinel.task_id}, safe=True)
+            {'_id': sentinel.task_id}, safe=True)
 
-    @patch("celery.backends.mongodb.MongoBackend._get_database")
+    @patch('celery.backends.mongodb.MongoBackend._get_database')
     def test_cleanup(self, mock_get_database):
-        datetime.datetime = self._reset["datetime"]
+        datetime.datetime = self._reset['datetime']
         self.backend.mongodb_taskmeta_collection = MONGODB_COLLECTION
 
         mock_database = MagicMock(spec=['__getitem__', '__setitem__'])
@@ -313,8 +313,8 @@ class test_MongoBackend(AppCase):
         conn = x._get_connection.return_value = {}
         db = conn[x.mongodb_database] = Mock()
         db.authenticate.return_value = False
-        x.mongodb_user = "jerry"
-        x.mongodb_password = "cere4l"
+        x.mongodb_user = 'jerry'
+        x.mongodb_password = 'cere4l'
         with self.assertRaises(ImproperlyConfigured):
             x._get_database()
-        db.authenticate.assert_called_with("jerry", "cere4l")
+        db.authenticate.assert_called_with('jerry', 'cere4l')

celery/tests/backends/test_redis.py

@@ -92,7 +92,7 @@ class test_RedisBackend(Case):
             x = RedisBackend()
             self.assertTrue(loads(dumps(x)))
         except ImportError:
-            raise SkipTest("redis not installed")
+            raise SkipTest('redis not installed')
 
     def test_no_redis(self):
         self.MockBackend.redis = None
@@ -100,14 +100,14 @@ class test_RedisBackend(Case):
             self.MockBackend()
 
     def test_url(self):
-        x = self.MockBackend("redis://foobar//1")
-        self.assertEqual(x.host, "foobar")
-        self.assertEqual(x.db, "1")
+        x = self.MockBackend('redis://foobar//1')
+        self.assertEqual(x.host, 'foobar')
+        self.assertEqual(x.db, '1')
 
     def test_conf_raises_KeyError(self):
-        conf = AttributeDict({"CELERY_RESULT_SERIALIZER": "json",
-                              "CELERY_MAX_CACHED_RESULTS": 1,
-                              "CELERY_TASK_RESULT_EXPIRES": None})
+        conf = AttributeDict({'CELERY_RESULT_SERIALIZER': 'json',
+                              'CELERY_MAX_CACHED_RESULTS': 1,
+                              'CELERY_TASK_RESULT_EXPIRES': None})
         prev, current_app.conf = current_app.conf, conf
         try:
             self.MockBackend()
@@ -138,20 +138,20 @@ class test_RedisBackend(Case):
         self.assertEqual(b.expires, 60)
 
     def test_on_chord_apply(self):
-        self.Backend().on_chord_apply("group_id", {},
+        self.Backend().on_chord_apply('group_id', {},
                                       result=map(AsyncResult, [1, 2, 3]))
 
     def test_mget(self):
         b = self.MockBackend()
-        self.assertTrue(b.mget(["a", "b", "c"]))
-        b.client.mget.assert_called_with(["a", "b", "c"])
+        self.assertTrue(b.mget(['a', 'b', 'c']))
+        b.client.mget.assert_called_with(['a', 'b', 'c'])
 
     def test_set_no_expire(self):
         b = self.MockBackend()
         b.expires = None
-        b.set("foo", "bar")
+        b.set('foo', 'bar')
 
-    @patch("celery.result.GroupResult")
+    @patch('celery.result.GroupResult')
     def test_on_chord_part_return(self, setresult):
         b = self.MockBackend()
         deps = Mock()
@@ -159,11 +159,11 @@ class test_RedisBackend(Case):
         setresult.restore.return_value = deps
         b.client.incr.return_value = 1
         task = Mock()
-        task.name = "foobarbaz"
+        task.name = 'foobarbaz'
         try:
-            current_app.tasks["foobarbaz"] = task
+            current_app.tasks['foobarbaz'] = task
             task.request.chord = subtask(task)
-            task.request.group = "group_id"
+            task.request.group = 'group_id'
 
             b.on_chord_part_return(task)
             self.assertTrue(b.client.incr.call_count)
@@ -175,7 +175,7 @@ class test_RedisBackend(Case):
 
             self.assertTrue(b.client.expire.call_count)
         finally:
-            current_app.tasks.pop("foobarbaz")
+            current_app.tasks.pop('foobarbaz')
 
     def test_process_cleanup(self):
         self.Backend().process_cleanup()

celery/tests/bin/test_base.py

@@ -20,11 +20,11 @@ APP = MyApp()  # <-- Used by test_with_custom_app
 
 
 class MockCommand(Command):
-    mock_args = ("arg1", "arg2", "arg3")
+    mock_args = ('arg1', 'arg2', 'arg3')
 
     def parse_options(self, prog_name, arguments):
         options = Object()
-        options.foo = "bar"
+        options.foo = 'bar'
         options.prog_name = prog_name
         return options, self.mock_args
 
@@ -43,22 +43,22 @@ class test_Command(AppCase):
         with self.assertRaises(NotImplementedError):
             Command().run()
 
-    @patch("sys.stdout")
+    @patch('sys.stdout')
     def test_parse_options_version_only(self, stdout):
         cmd = Command()
         with self.assertRaises(SystemExit):
-            cmd.parse_options("prog", ["--version"])
-        stdout.write.assert_called_with(cmd.version + "\n")
+            cmd.parse_options('prog', ['--version'])
+        stdout.write.assert_called_with(cmd.version + '\n')
 
     def test_execute_from_commandline(self):
         cmd = MockCommand()
         args1, kwargs1 = cmd.execute_from_commandline()     # sys.argv
         self.assertTupleEqual(args1, cmd.mock_args)
-        self.assertDictContainsSubset({"foo": "bar"}, kwargs1)
-        self.assertTrue(kwargs1.get("prog_name"))
-        args2, kwargs2 = cmd.execute_from_commandline(["foo"])   # pass list
+        self.assertDictContainsSubset({'foo': 'bar'}, kwargs1)
+        self.assertTrue(kwargs1.get('prog_name'))
+        args2, kwargs2 = cmd.execute_from_commandline(['foo'])   # pass list
         self.assertTupleEqual(args2, cmd.mock_args)
-        self.assertDictContainsSubset({"foo": "bar", "prog_name": "foo"},
+        self.assertDictContainsSubset({'foo': 'bar', 'prog_name': 'foo'},
                                       kwargs2)
 
     def test_with_bogus_args(self):
@@ -66,79 +66,79 @@ class test_Command(AppCase):
         cmd.supports_args = False
         with override_stdouts() as (_, stderr):
             with self.assertRaises(SystemExit):
-                cmd.execute_from_commandline(argv=["--bogus"])
+                cmd.execute_from_commandline(argv=['--bogus'])
         self.assertTrue(stderr.getvalue())
-        self.assertIn("Unrecognized", stderr.getvalue())
+        self.assertIn('Unrecognized', stderr.getvalue())
 
     def test_with_custom_config_module(self):
-        prev = os.environ.pop("CELERY_CONFIG_MODULE", None)
+        prev = os.environ.pop('CELERY_CONFIG_MODULE', None)
         try:
             cmd = MockCommand()
-            cmd.setup_app_from_commandline(["--config=foo.bar.baz"])
-            self.assertEqual(os.environ.get("CELERY_CONFIG_MODULE"),
-                             "foo.bar.baz")
+            cmd.setup_app_from_commandline(['--config=foo.bar.baz'])
+            self.assertEqual(os.environ.get('CELERY_CONFIG_MODULE'),
+                             'foo.bar.baz')
         finally:
             if prev:
-                os.environ["CELERY_CONFIG_MODULE"] = prev
+                os.environ['CELERY_CONFIG_MODULE'] = prev
             else:
-                os.environ.pop("CELERY_CONFIG_MODULE", None)
+                os.environ.pop('CELERY_CONFIG_MODULE', None)
 
     def test_with_custom_broker(self):
-        prev = os.environ.pop("CELERY_BROKER_URL", None)
+        prev = os.environ.pop('CELERY_BROKER_URL', None)
         try:
             cmd = MockCommand()
-            cmd.setup_app_from_commandline(["--broker=xyzza://"])
-            self.assertEqual(os.environ.get("CELERY_BROKER_URL"),
-                    "xyzza://")
+            cmd.setup_app_from_commandline(['--broker=xyzza://'])
+            self.assertEqual(os.environ.get('CELERY_BROKER_URL'),
+                    'xyzza://')
         finally:
             if prev:
-                os.environ["CELERY_BROKER_URL"] = prev
+                os.environ['CELERY_BROKER_URL'] = prev
             else:
-                os.environ.pop("CELERY_BROKER_URL", None)
+                os.environ.pop('CELERY_BROKER_URL', None)
 
     def test_with_custom_app(self):
         cmd = MockCommand()
-        app = ".".join([__name__, "APP"])
-        cmd.setup_app_from_commandline(["--app=%s" % (app, ),
-                                        "--loglevel=INFO"])
+        app = '.'.join([__name__, 'APP'])
+        cmd.setup_app_from_commandline(['--app=%s' % (app, ),
+                                        '--loglevel=INFO'])
         self.assertIs(cmd.app, APP)
 
     def test_with_cmdline_config(self):
         cmd = MockCommand()
         try:
             cmd.enable_config_from_cmdline = True
-            cmd.namespace = "celeryd"
+            cmd.namespace = 'celeryd'
             rest = cmd.setup_app_from_commandline(argv=[
-                "--loglevel=INFO", "--",
-                "broker.url=amqp://broker.example.com",
-                ".prefetch_multiplier=100"])
+                '--loglevel=INFO', '--',
+                'broker.url=amqp://broker.example.com',
+                '.prefetch_multiplier=100'])
             self.assertEqual(cmd.app.conf.BROKER_URL,
-                             "amqp://broker.example.com")
+                             'amqp://broker.example.com')
             self.assertEqual(cmd.app.conf.CELERYD_PREFETCH_MULTIPLIER, 100)
-            self.assertListEqual(rest, ["--loglevel=INFO"])
+            self.assertListEqual(rest, ['--loglevel=INFO'])
         finally:
-            cmd.app.conf.BROKER_URL = "memory://"
+            cmd.app.conf.BROKER_URL = 'memory://'
 
     def test_find_app(self):
         cmd = MockCommand()
-        with patch("celery.bin.base.symbol_by_name") as sbn:
+        with patch('celery.bin.base.symbol_by_name') as sbn:
             from types import ModuleType
-            x = ModuleType("proj")
+            x = ModuleType('proj')
 
             def on_sbn(*args, **kwargs):
 
                 def after(*args, **kwargs):
-                    x.celery = "quick brown fox"
+                    x.celery = 'quick brown fox'
                     x.__path__ = None
                     return x
                 sbn.side_effect = after
                 return x
             sbn.side_effect = on_sbn
             x.__path__ = [True]
-            self.assertEqual(cmd.find_app("proj"), "quick brown fox")
+            self.assertEqual(cmd.find_app('proj'), 'quick brown fox')
 
     def test_parse_preload_options_shortopt(self):
         cmd = Command()
-        cmd.preload_options = (Option("-s", action="store", dest="silent"), )
-        acc = cmd.parse_preload_options(["-s", "yes"])
-        self.assertEqual(acc.get("silent"), "yes")
+        cmd.preload_options = (Option('-s', action='store', dest='silent'), )
+        acc = cmd.parse_preload_options(['-s', 'yes'])
+        self.assertEqual(acc.get('silent'), 'yes')

celery/tests/bin/test_camqadm.py

@@ -20,7 +20,7 @@ class test_AMQShell(AppCase):
 
     def setup(self):
         self.fh = WhateverIO()
-        self.app = Celery(broker="memory://", set_as_current=False)
+        self.app = Celery(broker='memory://', set_as_current=False)
         self.adm = self.create_adm()
         self.shell = AMQShell(connect=self.adm.connect, out=self.fh)
 
@@ -28,93 +28,93 @@ class test_AMQShell(AppCase):
         return AMQPAdmin(app=self.app, out=self.fh, *args, **kwargs)
 
     def test_queue_declare(self):
-        self.shell.onecmd("queue.declare foo")
-        self.assertIn("ok", self.fh.getvalue())
+        self.shell.onecmd('queue.declare foo')
+        self.assertIn('ok', self.fh.getvalue())
 
     def test_missing_command(self):
-        self.shell.onecmd("foo foo")
-        self.assertIn("unknown syntax", self.fh.getvalue())
+        self.shell.onecmd('foo foo')
+        self.assertIn('unknown syntax', self.fh.getvalue())
 
     def RV(self):
         raise Exception(self.fh.getvalue())
 
     def test_missing_namespace(self):
-        self.shell.onecmd("ns.cmd arg")
-        self.assertIn("unknown syntax", self.fh.getvalue())
+        self.shell.onecmd('ns.cmd arg')
+        self.assertIn('unknown syntax', self.fh.getvalue())
 
     def test_help(self):
-        self.shell.onecmd("help")
-        self.assertIn("Example:", self.fh.getvalue())
+        self.shell.onecmd('help')
+        self.assertIn('Example:', self.fh.getvalue())
 
     def test_help_command(self):
-        self.shell.onecmd("help queue.declare")
-        self.assertIn("passive:no", self.fh.getvalue())
+        self.shell.onecmd('help queue.declare')
+        self.assertIn('passive:no', self.fh.getvalue())
 
     def test_help_unknown_command(self):
-        self.shell.onecmd("help foo.baz")
-        self.assertIn("unknown syntax", self.fh.getvalue())
+        self.shell.onecmd('help foo.baz')
+        self.assertIn('unknown syntax', self.fh.getvalue())
 
     def test_exit(self):
         with self.assertRaises(SystemExit):
-            self.shell.onecmd("exit")
+            self.shell.onecmd('exit')
         self.assertIn("don't leave!", self.fh.getvalue())
 
     def test_note_silent(self):
         self.shell.silent = True
-        self.shell.note("foo bar")
-        self.assertNotIn("foo bar", self.fh.getvalue())
+        self.shell.note('foo bar')
+        self.assertNotIn('foo bar', self.fh.getvalue())
 
     def test_reconnect(self):
-        self.shell.onecmd("queue.declare foo")
+        self.shell.onecmd('queue.declare foo')
         self.shell.needs_reconnect = True
-        self.shell.onecmd("queue.delete foo")
+        self.shell.onecmd('queue.delete foo')
 
     def test_completenames(self):
-        self.assertEqual(self.shell.completenames("queue.dec"),
-                ["queue.declare"])
-        self.assertEqual(self.shell.completenames("declare"),
-                ["queue.declare", "exchange.declare"])
+        self.assertEqual(self.shell.completenames('queue.dec'),
+                ['queue.declare'])
+        self.assertEqual(self.shell.completenames('declare'),
+                ['queue.declare', 'exchange.declare'])
 
     def test_empty_line(self):
         self.shell.emptyline = Mock()
         self.shell.default = Mock()
-        self.shell.onecmd("")
+        self.shell.onecmd('')
         self.shell.emptyline.assert_called_with()
-        self.shell.onecmd("foo")
-        self.shell.default.assert_called_with("foo")
+        self.shell.onecmd('foo')
+        self.shell.default.assert_called_with('foo')
 
     def test_respond(self):
-        self.shell.respond({"foo": "bar"})
-        self.assertIn("foo", self.fh.getvalue())
+        self.shell.respond({'foo': 'bar'})
+        self.assertIn('foo', self.fh.getvalue())
 
     def test_prompt(self):
         self.assertTrue(self.shell.prompt)
 
     def test_no_returns(self):
-        self.shell.onecmd("queue.declare foo")
-        self.shell.onecmd("exchange.declare bar direct yes")
-        self.shell.onecmd("queue.bind foo bar baz")
-        self.shell.onecmd("basic.ack 1")
+        self.shell.onecmd('queue.declare foo')
+        self.shell.onecmd('exchange.declare bar direct yes')
+        self.shell.onecmd('queue.bind foo bar baz')
+        self.shell.onecmd('basic.ack 1')
 
     def test_dump_message(self):
         m = Mock()
-        m.body = "the quick brown fox"
-        m.properties = {"a": 1}
-        m.delivery_info = {"exchange": "bar"}
+        m.body = 'the quick brown fox'
+        m.properties = {'a': 1}
+        m.delivery_info = {'exchange': 'bar'}
         self.assertTrue(dump_message(m))
 
     def test_dump_message_no_message(self):
-        self.assertIn("No messages in queue", dump_message(None))
+        self.assertIn('No messages in queue', dump_message(None))
 
     def test_note(self):
         self.adm.silent = True
-        self.adm.note("FOO")
-        self.assertNotIn("FOO", self.fh.getvalue())
+        self.adm.note('FOO')
+        self.assertNotIn('FOO', self.fh.getvalue())
 
     def test_run(self):
-        a = self.create_adm("queue.declare foo")
+        a = self.create_adm('queue.declare foo')
         a.run()
-        self.assertIn("ok", self.fh.getvalue())
+        self.assertIn('ok', self.fh.getvalue())
 
     def test_run_loop(self):
         a = self.create_adm()
@@ -126,21 +126,21 @@ class test_AMQShell(AppCase):
 
         shell.cmdloop.side_effect = KeyboardInterrupt()
         a.run()
-        self.assertIn("bibi", self.fh.getvalue())
+        self.assertIn('bibi', self.fh.getvalue())
 
-    @patch("celery.bin.camqadm.AMQPAdminCommand")
+    @patch('celery.bin.camqadm.AMQPAdminCommand')
     def test_main(self, Command):
         c = Command.return_value = Mock()
         main()
         c.execute_from_commandline.assert_called_with()
 
-    @patch("celery.bin.camqadm.AMQPAdmin")
+    @patch('celery.bin.camqadm.AMQPAdmin')
     def test_camqadm(self, cls):
         c = cls.return_value = Mock()
         camqadm()
         c.run.assert_called_with()
 
-    @patch("celery.bin.camqadm.AMQPAdmin")
+    @patch('celery.bin.camqadm.AMQPAdmin')
     def test_AMQPAdminCommand(self, cls):
         c = cls.return_value = Mock()
         camqadm()
@@ -148,5 +148,5 @@ class test_AMQShell(AppCase):
 
         x = AMQPAdminCommand(app=self.app)
         x.run()
-        self.assertIs(cls.call_args[1]["app"], self.app)
+        self.assertIs(cls.call_args[1]['app'], self.app)
         c.run.assert_called_with()

celery/tests/bin/test_celery.py

@@ -36,7 +36,7 @@ def add(x, y):
 class test_Command(AppCase):
 
     def test_Error_repr(self):
-        x = Error("something happened")
+        x = Error('something happened')
         self.assertIsNotNone(x.status)
         self.assertTrue(x.reason)
         self.assertTrue(str(x))
@@ -48,49 +48,49 @@ class test_Command(AppCase):
 
     def test_show_help(self):
         self.cmd.run_from_argv = Mock()
-        self.assertEqual(self.cmd.show_help("foo"), EX_USAGE)
+        self.assertEqual(self.cmd.show_help('foo'), EX_USAGE)
         self.cmd.run_from_argv.assert_called_with(
-                self.cmd.prog_name, ["foo", "--help"]
+                self.cmd.prog_name, ['foo', '--help']
         )
 
     def test_error(self):
         self.cmd.out = Mock()
-        self.cmd.error("FOO")
+        self.cmd.error('FOO')
         self.assertTrue(self.cmd.out.called)
 
     def test_out(self):
         f = Mock()
-        self.cmd.out("foo", f)
-        f.write.assert_called_with("foo\n")
-        self.cmd.out("foo\n", f)
+        self.cmd.out('foo', f)
+        f.write.assert_called_with('foo\n')
+        self.cmd.out('foo\n', f)
 
     def test_call(self):
         self.cmd.run = Mock()
         self.cmd.run.return_value = None
         self.assertEqual(self.cmd(), EX_OK)
 
-        self.cmd.run.side_effect = Error("error", EX_FAILURE)
+        self.cmd.run.side_effect = Error('error', EX_FAILURE)
         self.assertEqual(self.cmd(), EX_FAILURE)
 
     def test_run_from_argv(self):
         with self.assertRaises(NotImplementedError):
-            self.cmd.run_from_argv("prog", ["foo", "bar"])
-        self.assertEqual(self.cmd.prog_name, "prog")
+            self.cmd.run_from_argv('prog', ['foo', 'bar'])
+        self.assertEqual(self.cmd.prog_name, 'prog')
 
     def test_prettify_list(self):
-        self.assertEqual(self.cmd.prettify([])[1], "- empty -")
-        self.assertIn("bar", self.cmd.prettify(["foo", "bar"])[1])
+        self.assertEqual(self.cmd.prettify([])[1], '- empty -')
+        self.assertIn('bar', self.cmd.prettify(['foo', 'bar'])[1])
 
     def test_prettify_dict(self):
-        self.assertIn("OK",
-            str(self.cmd.prettify({"ok": "the quick brown fox"})[0]))
-        self.assertIn("ERROR",
-            str(self.cmd.prettify({"error": "the quick brown fox"})[0]))
+        self.assertIn('OK',
+            str(self.cmd.prettify({'ok': 'the quick brown fox'})[0]))
+        self.assertIn('ERROR',
+            str(self.cmd.prettify({'error': 'the quick brown fox'})[0]))
 
     def test_prettify(self):
-        self.assertIn("OK", str(self.cmd.prettify("the quick brown")))
-        self.assertIn("OK", str(self.cmd.prettify(object())))
-        self.assertIn("OK", str(self.cmd.prettify({"foo": "bar"})))
+        self.assertIn('OK', str(self.cmd.prettify('the quick brown')))
+        self.assertIn('OK', str(self.cmd.prettify(object())))
+        self.assertIn('OK', str(self.cmd.prettify({'foo': 'bar'})))
 
 
 class test_Delegate(AppCase):
@@ -116,74 +116,74 @@ class test_list(AppCase):
 
     def test_run(self):
         l = list_(app=self.app, stderr=WhateverIO())
-        l.run("bindings")
+        l.run('bindings')
 
         with self.assertRaises(Error):
             l.run(None)
 
         with self.assertRaises(Error):
-            l.run("foo")
+            l.run('foo')
 
 
 class test_apply(AppCase):
 
-    @patch("celery.app.base.Celery.send_task")
+    @patch('celery.app.base.Celery.send_task')
     def test_run(self, send_task):
         a = apply(app=self.app, stderr=WhateverIO(), stdout=WhateverIO())
-        a.run("tasks.add")
+        a.run('tasks.add')
         self.assertTrue(send_task.called)
 
-        a.run("tasks.add",
+        a.run('tasks.add',
               args=dumps([4, 4]),
-              kwargs=dumps({"x": 2, "y": 2}))
-        self.assertEqual(send_task.call_args[1]["args"], [4, 4])
-        self.assertEqual(send_task.call_args[1]["kwargs"], {"x": 2, "y": 2})
+              kwargs=dumps({'x': 2, 'y': 2}))
+        self.assertEqual(send_task.call_args[1]['args'], [4, 4])
+        self.assertEqual(send_task.call_args[1]['kwargs'], {'x': 2, 'y': 2})
 
-        a.run("tasks.add", expires=10, countdown=10)
-        self.assertEqual(send_task.call_args[1]["expires"], 10)
-        self.assertEqual(send_task.call_args[1]["countdown"], 10)
+        a.run('tasks.add', expires=10, countdown=10)
+        self.assertEqual(send_task.call_args[1]['expires'], 10)
+        self.assertEqual(send_task.call_args[1]['countdown'], 10)
 
         now = datetime.now()
         iso = now.isoformat()
-        a.run("tasks.add", expires=iso)
-        self.assertEqual(send_task.call_args[1]["expires"], now)
+        a.run('tasks.add', expires=iso)
+        self.assertEqual(send_task.call_args[1]['expires'], now)
         with self.assertRaises(ValueError):
-            a.run("tasks.add", expires="foobaribazibar")
+            a.run('tasks.add', expires='foobaribazibar')
 
 
 class test_purge(AppCase):
 
-    @patch("celery.app.control.Control.purge")
+    @patch('celery.app.control.Control.purge')
     def test_run(self, purge_):
         out = WhateverIO()
         a = purge(app=self.app, stdout=out)
         purge_.return_value = 0
         a.run()
-        self.assertIn("No messages purged", out.getvalue())
+        self.assertIn('No messages purged', out.getvalue())
 
         purge_.return_value = 100
         a.run()
-        self.assertIn("100 messages", out.getvalue())
+        self.assertIn('100 messages', out.getvalue())
 
 
 class test_result(AppCase):
 
-    @patch("celery.result.AsyncResult.get")
+    @patch('celery.result.AsyncResult.get')
     def test_run(self, get):
         out = WhateverIO()
         r = result(app=self.app, stdout=out)
-        get.return_value = "Jerry"
-        r.run("id")
-        self.assertIn("Jerry", out.getvalue())
+        get.return_value = 'Jerry'
+        r.run('id')
+        self.assertIn('Jerry', out.getvalue())
 
-        get.return_value = "Elaine"
-        r.run("id", task=add.name)
-        self.assertIn("Elaine", out.getvalue())
+        get.return_value = 'Elaine'
+        r.run('id', task=add.name)
+        self.assertIn('Elaine', out.getvalue())
 
 
 class test_status(AppCase):
 
-    @patch("celery.bin.celery.inspect")
+    @patch('celery.bin.celery.inspect')
     def test_run(self, inspect_):
         out, err = WhateverIO(), WhateverIO()
         ins = inspect_.return_value = Mock()
@@ -192,15 +192,15 @@ class test_status(AppCase):
         with self.assertRaises(Error):
             s.run()
 
-        ins.run.return_value = ["a", "b", "c"]
+        ins.run.return_value = ['a', 'b', 'c']
         s.run()
-        self.assertIn("3 nodes online", out.getvalue())
+        self.assertIn('3 nodes online', out.getvalue())
         s.run(quiet=True)
 
 
 class test_migrate(AppCase):
 
-    @patch("celery.contrib.migrate.migrate_tasks")
+    @patch('celery.contrib.migrate.migrate_tasks')
     def test_run(self, migrate_tasks):
         out = WhateverIO()
         m = migrate(app=self.app, stdout=out, stderr=WhateverIO())
@@ -208,14 +208,14 @@ class test_migrate(AppCase):
             m.run()
         self.assertFalse(migrate_tasks.called)
 
-        m.run("memory://foo", "memory://bar")
+        m.run('memory://foo', 'memory://bar')
         self.assertTrue(migrate_tasks.called)
 
         state = Mock()
         state.count = 10
         state.strtotal = 30
-        m.on_migrate_task(state, {"task": "tasks.add", "id": "ID"}, None)
-        self.assertIn("10/30", out.getvalue())
+        m.on_migrate_task(state, {'task': 'tasks.add', 'id': 'ID'}, None)
+        self.assertIn('10/30', out.getvalue())
 
 
 class test_report(AppCase):
@@ -235,7 +235,7 @@ class test_help(AppCase):
         h.parser = Mock()
         self.assertEqual(h.run(), EX_USAGE)
         self.assertTrue(out.getvalue())
-        self.assertTrue(h.usage("help"))
+        self.assertTrue(h.usage('help'))
         h.parser.print_help.assert_called_with()
 
 
@@ -257,86 +257,86 @@ class test_CeleryCommand(AppCase):
             x.execute_from_commandline()
 
     def test_determine_exit_status(self):
-        self.assertEqual(determine_exit_status("true"), EX_OK)
-        self.assertEqual(determine_exit_status(""), EX_FAILURE)
+        self.assertEqual(determine_exit_status('true'), EX_OK)
+        self.assertEqual(determine_exit_status(''), EX_FAILURE)
 
     def test_remove_options_at_beginning(self):
         x = CeleryCommand(app=self.app)
         self.assertEqual(x.remove_options_at_beginning(None), [])
-        self.assertEqual(x.remove_options_at_beginning(["-c 3", "--foo"]), [])
-        self.assertEqual(x.remove_options_at_beginning(["--foo", "-c 3"]), [])
+        self.assertEqual(x.remove_options_at_beginning(['-c 3', '--foo']), [])
+        self.assertEqual(x.remove_options_at_beginning(['--foo', '-c 3']), [])
         self.assertEqual(x.remove_options_at_beginning(
-            ["foo", "--foo=1"]), ["foo", "--foo=1"])
+            ['foo', '--foo=1']), ['foo', '--foo=1'])
 
     def test_handle_argv(self):
         x = CeleryCommand(app=self.app)
         x.execute = Mock()
-        x.handle_argv("celery", [])
-        x.execute.assert_called_with("help", ["help"])
+        x.handle_argv('celery', [])
+        x.execute.assert_called_with('help', ['help'])
 
-        x.handle_argv("celery", ["start", "foo"])
-        x.execute.assert_called_with("start", ["start", "foo"])
+        x.handle_argv('celery', ['start', 'foo'])
+        x.execute.assert_called_with('start', ['start', 'foo'])
 
     def test_execute(self):
         x = CeleryCommand(app=self.app)
-        Help = x.commands["help"] = Mock()
+        Help = x.commands['help'] = Mock()
         help = Help.return_value = Mock()
-        x.execute("fooox", ["a"])
-        help.run_from_argv.assert_called_with(x.prog_name, ["help"])
+        x.execute('fooox', ['a'])
+        help.run_from_argv.assert_called_with(x.prog_name, ['help'])
         help.reset()
-        x.execute("help", ["help"])
-        help.run_from_argv.assert_called_with(x.prog_name, ["help"])
+        x.execute('help', ['help'])
+        help.run_from_argv.assert_called_with(x.prog_name, ['help'])
 
-        Dummy = x.commands["dummy"] = Mock()
+        Dummy = x.commands['dummy'] = Mock()
         dummy = Dummy.return_value = Mock()
-        dummy.run_from_argv.side_effect = Error("foo", status="EX_FAILURE")
+        dummy.run_from_argv.side_effect = Error('foo', status='EX_FAILURE')
         help.reset()
-        x.execute("dummy", ["dummy"])
-        dummy.run_from_argv.assert_called_with(x.prog_name, ["dummy"])
-        help.run_from_argv.assert_called_with(x.prog_name, ["dummy"])
+        x.execute('dummy', ['dummy'])
+        dummy.run_from_argv.assert_called_with(x.prog_name, ['dummy'])
+        help.run_from_argv.assert_called_with(x.prog_name, ['dummy'])
 
 
 class test_inspect(AppCase):
 
     def test_usage(self):
-        self.assertTrue(inspect(app=self.app).usage("foo"))
+        self.assertTrue(inspect(app=self.app).usage('foo'))
 
-    @patch("celery.app.control.Control.inspect")
+    @patch('celery.app.control.Control.inspect')
     def test_run(self, real):
         out = WhateverIO()
         i = inspect(app=self.app, stdout=out)
         with self.assertRaises(Error):
             i.run()
         with self.assertRaises(Error):
-            i.run("help")
+            i.run('help')
         with self.assertRaises(Error):
-            i.run("xyzzybaz")
+            i.run('xyzzybaz')
 
-        i.run("ping")
+        i.run('ping')
         self.assertTrue(real.called)
-        i.run("ping", destination="foo,bar")
-        self.assertEqual(real.call_args[1]["destination"], ["foo", "bar"])
-        self.assertEqual(real.call_args[1]["timeout"], 0.2)
-        callback = real.call_args[1]["callback"]
+        i.run('ping', destination='foo,bar')
+        self.assertEqual(real.call_args[1]['destination'], ['foo', 'bar'])
+        self.assertEqual(real.call_args[1]['timeout'], 0.2)
+        callback = real.call_args[1]['callback']
 
-        callback({"foo": {"ok": "pong"}})
-        self.assertIn("OK", out.getvalue())
+        callback({'foo': {'ok': 'pong'}})
+        self.assertIn('OK', out.getvalue())
 
         instance = real.return_value = Mock()
         instance.ping.return_value = None
         with self.assertRaises(Error):
-            i.run("ping")
+            i.run('ping')
 
         out.seek(0)
         out.truncate()
         i.quiet = True
-        i.say('<-', "hello")
+        i.say('<-', 'hello')
         self.assertFalse(out.getvalue())
 
 
 class test_main(AppCase):
 
-    @patch("celery.bin.celery.CeleryCommand")
+    @patch('celery.bin.celery.CeleryCommand')
     def test_main(self, Command):
         command = Command.return_value = Mock()
         main()

celery/tests/bin/test_celerybeat.py

@@ -56,13 +56,13 @@ class MockBeat3(beatapp.Beat):
     Service = MockService
 
     def install_sync_handler(self, b):
-        raise TypeError("xxx")
+        raise TypeError('xxx')
 
 
 class test_Beat(AppCase):
 
     def test_loglevel_string(self):
-        b = beatapp.Beat(loglevel="DEBUG")
+        b = beatapp.Beat(loglevel='DEBUG')
         self.assertEqual(b.loglevel, logging.DEBUG)
 
         b2 = beatapp.Beat(loglevel=logging.DEBUG)
@@ -103,14 +103,14 @@ class test_Beat(AppCase):
         MockService.in_sync = False
         handlers = self.psig(b.install_sync_handler, clock)
         with self.assertRaises(SystemExit):
-            handlers["SIGINT"]("SIGINT", object())
+            handlers['SIGINT']('SIGINT', object())
         self.assertTrue(MockService.in_sync)
         MockService.in_sync = False
 
     def test_setup_logging(self):
         try:
             # py3k
-            delattr(sys.stdout, "logger")
+            delattr(sys.stdout, 'logger')
         except AttributeError:
             pass
         b = beatapp.Beat()
@@ -120,16 +120,16 @@ class test_Beat(AppCase):
             sys.stdout.logger
 
     @redirect_stdouts
-    @patch("celery.apps.beat.logger")
+    @patch('celery.apps.beat.logger')
     def test_logs_errors(self, logger, stdout, stderr):
         b = MockBeat3(socket_timeout=None)
         b.start_scheduler()
         self.assertTrue(logger.critical.called)
 
     @redirect_stdouts
-    @patch("celery.platforms.create_pidlock")
+    @patch('celery.platforms.create_pidlock')
     def test_use_pidfile(self, create_pidlock, stdout, stderr):
-        b = MockBeat2(pidfile="pidfilelockfilepid", socket_timeout=None)
+        b = MockBeat2(pidfile='pidfilelockfilepid', socket_timeout=None)
         b.start_scheduler()
         self.assertTrue(create_pidlock.called)
 
@@ -162,7 +162,7 @@ class test_div(AppCase):
         beatapp.Beat = self.prev
 
     def test_main(self):
-        sys.argv = [sys.argv[0], "-s", "foo"]
+        sys.argv = [sys.argv[0], '-s', 'foo']
         try:
             celerybeat_bin.main()
             self.assertTrue(MockBeat.running)
@@ -176,14 +176,14 @@ class test_div(AppCase):
         self.assertTrue(MockDaemonContext.opened)
         self.assertTrue(MockDaemonContext.closed)
 
-    @patch("os.chdir")
+    @patch('os.chdir')
     def test_prepare_preload_options(self, chdir):
         cmd = celerybeat_bin.BeatCommand()
-        cmd.prepare_preload_options({"working_directory": "/opt/Project"})
-        chdir.assert_called_with("/opt/Project")
+        cmd.prepare_preload_options({'working_directory': '/opt/Project'})
+        chdir.assert_called_with('/opt/Project')
 
     def test_parse_options(self):
         cmd = celerybeat_bin.BeatCommand()
         cmd.app = app_or_default()
-        options, args = cmd.parse_options("celerybeat", ["-s", "foo"])
-        self.assertEqual(options.schedule, "foo")
+        options, args = cmd.parse_options('celerybeat', ['-s', 'foo'])
+        self.assertEqual(options.schedule, 'foo')

celery/tests/bin/test_celeryd.py

@@ -69,15 +69,15 @@ class test_Worker(AppCase):
     @disable_stdouts
     def test_queues_string(self):
         celery = Celery(set_as_current=False)
-        worker = celery.Worker(queues="foo,bar,baz")
+        worker = celery.Worker(queues='foo,bar,baz')
         worker.init_queues()
-        self.assertEqual(worker.use_queues, ["foo", "bar", "baz"])
-        self.assertTrue("foo" in celery.amqp.queues)
+        self.assertEqual(worker.use_queues, ['foo', 'bar', 'baz'])
+        self.assertTrue('foo' in celery.amqp.queues)
 
     @disable_stdouts
     def test_cpu_count(self):
         celery = Celery(set_as_current=False)
-        with patch("celery.apps.worker.cpu_count") as cpu_count:
+        with patch('celery.apps.worker.cpu_count') as cpu_count:
             cpu_count.side_effect = NotImplementedError()
             worker = celery.Worker(concurrency=None)
             self.assertEqual(worker.concurrency, 2)
@@ -95,13 +95,13 @@ class test_Worker(AppCase):
         x = WorkerCommand()
         x.run = Mock()
         with self.assertRaises(ImportError):
-            x.execute_from_commandline(["celeryd", "-P", "xyzybox"])
+            x.execute_from_commandline(['celeryd', '-P', 'xyzybox'])
 
     @disable_stdouts
     def test_invalid_loglevel_gives_error(self):
         x = WorkerCommand(app=Celery(set_as_current=False))
         with self.assertRaises(SystemExit):
-            x.run(loglevel="GRIM_REAPER")
+            x.run(loglevel='GRIM_REAPER')
 
     def test_no_loglevel(self):
         app = Celery(set_as_current=False)
@@ -126,7 +126,7 @@ class test_Worker(AppCase):
 
     @disable_stdouts
     def test_loglevel_string(self):
-        worker = self.Worker(loglevel="INFO")
+        worker = self.Worker(loglevel='INFO')
         self.assertEqual(worker.loglevel, logging.INFO)
 
     def test_run_worker(self):
@@ -143,16 +143,16 @@ class test_Worker(AppCase):
             w = self.Worker()
             w._isatty = False
             w.run_worker()
-            for sig in "SIGINT", "SIGHUP", "SIGTERM":
+            for sig in 'SIGINT', 'SIGHUP', 'SIGTERM':
                 self.assertIn(sig, handlers)
 
             handlers.clear()
             w = self.Worker()
             w._isatty = True
             w.run_worker()
-            for sig in "SIGINT", "SIGTERM":
+            for sig in 'SIGINT', 'SIGTERM':
                 self.assertIn(sig, handlers)
-            self.assertNotIn("SIGHUP", handlers)
+            self.assertNotIn('SIGHUP', handlers)
         finally:
             platforms.signals = p
 
@@ -168,18 +168,18 @@ class test_Worker(AppCase):
         worker.autoscale = 13, 10
         self.assertTrue(worker.startup_info())
 
-        worker = self.Worker(queues="foo,bar,baz,xuzzy,do,re,mi")
+        worker = self.Worker(queues='foo,bar,baz,xuzzy,do,re,mi')
         app = worker.app
         prev, app.loader = app.loader, Mock()
         try:
-            app.loader.__module__ = "acme.baked_beans"
+            app.loader.__module__ = 'acme.baked_beans'
             self.assertTrue(worker.startup_info())
         finally:
             app.loader = prev
 
         prev, app.loader = app.loader, Mock()
         try:
-            app.loader.__module__ = "celery.loaders.foo"
+            app.loader.__module__ = 'celery.loaders.foo'
             self.assertTrue(worker.startup_info())
         finally:
             app.loader = prev
@@ -197,7 +197,7 @@ class test_Worker(AppCase):
         # test when there are too few output lines
         # to draft the ascii art onto
         prev, cd.ARTLINES = (cd.ARTLINES,
-            ["the quick brown fox"])
+            ['the quick brown fox'])
         self.assertTrue(worker.startup_info())
 
     @disable_stdouts
@@ -224,58 +224,58 @@ class test_Worker(AppCase):
         app = current_app
         c = app.conf
         p, app.amqp.queues = app.amqp.queues, app.amqp.Queues({
-                "celery": {"exchange": "celery",
-                           "routing_key": "celery"},
-                "video": {"exchange": "video",
-                           "routing_key": "video"}})
+                'celery': {'exchange': 'celery',
+                           'routing_key': 'celery'},
+                'video': {'exchange': 'video',
+                           'routing_key': 'video'}})
         try:
-            worker = self.Worker(queues=["video"])
+            worker = self.Worker(queues=['video'])
             worker.init_queues()
-            self.assertIn("video", app.amqp.queues)
-            self.assertIn("video", app.amqp.queues.consume_from)
-            self.assertIn("celery", app.amqp.queues)
-            self.assertNotIn("celery", app.amqp.queues.consume_from)
+            self.assertIn('video', app.amqp.queues)
+            self.assertIn('video', app.amqp.queues.consume_from)
+            self.assertIn('celery', app.amqp.queues)
+            self.assertNotIn('celery', app.amqp.queues.consume_from)
 
             c.CELERY_CREATE_MISSING_QUEUES = False
             del(app.amqp.queues)
             with self.assertRaises(ImproperlyConfigured):
-                self.Worker(queues=["image"]).init_queues()
+                self.Worker(queues=['image']).init_queues()
             del(app.amqp.queues)
             c.CELERY_CREATE_MISSING_QUEUES = True
-            worker = self.Worker(queues=["image"])
+            worker = self.Worker(queues=['image'])
             worker.init_queues()
-            self.assertIn("image", app.amqp.queues.consume_from)
-            self.assertEqual(Queue("image", Exchange("image"),
-                             routing_key="image"), app.amqp.queues["image"])
+            self.assertIn('image', app.amqp.queues.consume_from)
+            self.assertEqual(Queue('image', Exchange('image'),
+                             routing_key='image'), app.amqp.queues['image'])
         finally:
             app.amqp.queues = p
 
     @disable_stdouts
     def test_autoscale_argument(self):
-        worker1 = self.Worker(autoscale="10,3")
+        worker1 = self.Worker(autoscale='10,3')
         self.assertListEqual(worker1.autoscale, [10, 3])
-        worker2 = self.Worker(autoscale="10")
+        worker2 = self.Worker(autoscale='10')
         self.assertListEqual(worker2.autoscale, [10, 0])
 
     def test_include_argument(self):
-        worker1 = self.Worker(include="some.module")
-        self.assertListEqual(worker1.include, ["some.module"])
-        worker2 = self.Worker(include="some.module,another.package")
+        worker1 = self.Worker(include='some.module')
+        self.assertListEqual(worker1.include, ['some.module'])
+        worker2 = self.Worker(include='some.module,another.package')
         self.assertListEqual(worker2.include,
-                ["some.module", "another.package"])
-        self.Worker(include=["os", "sys"])
+                ['some.module', 'another.package'])
+        self.Worker(include=['os', 'sys'])
 
     @disable_stdouts
     def test_unknown_loglevel(self):
         with self.assertRaises(SystemExit):
-            WorkerCommand(app=self.app).run(loglevel="ALIEN")
+            WorkerCommand(app=self.app).run(loglevel='ALIEN')
         worker1 = self.Worker(loglevel=0xFFFF)
         self.assertEqual(worker1.loglevel, 0xFFFF)
 
     def test_warns_if_running_as_privileged_user(self):
         app = current_app
         if app.IS_WINDOWS:
-            raise SkipTest("Not applicable on Windows")
+            raise SkipTest('Not applicable on Windows')
 
         def getuid():
             return 0
@@ -383,23 +383,23 @@ class test_funs(AppCase):
     @disable_stdouts
     def test_set_process_status(self):
         try:
-            __import__("setproctitle")
+            __import__('setproctitle')
         except ImportError:
-            raise SkipTest("setproctitle not installed")
-        worker = Worker(hostname="xyzza")
-        prev1, sys.argv = sys.argv, ["Arg0"]
+            raise SkipTest('setproctitle not installed')
+        worker = Worker(hostname='xyzza')
+        prev1, sys.argv = sys.argv, ['Arg0']
         try:
-            st = worker.set_process_status("Running")
-            self.assertIn("celeryd", st)
-            self.assertIn("xyzza", st)
-            self.assertIn("Running", st)
-            prev2, sys.argv = sys.argv, ["Arg0", "Arg1"]
+            st = worker.set_process_status('Running')
+            self.assertIn('celeryd', st)
+            self.assertIn('xyzza', st)
+            self.assertIn('Running', st)
+            prev2, sys.argv = sys.argv, ['Arg0', 'Arg1']
             try:
-                st = worker.set_process_status("Running")
-                self.assertIn("celeryd", st)
-                self.assertIn("xyzza", st)
-                self.assertIn("Running", st)
-                self.assertIn("Arg1", st)
+                st = worker.set_process_status('Running')
+                self.assertIn('celeryd', st)
+                self.assertIn('xyzza', st)
+                self.assertIn('Running', st)
+                self.assertIn('Arg1', st)
             finally:
                 sys.argv = prev2
         finally:
@@ -409,13 +409,13 @@ class test_funs(AppCase):
     def test_parse_options(self):
         cmd = WorkerCommand()
         cmd.app = current_app
-        opts, args = cmd.parse_options("celeryd", ["--concurrency=512"])
+        opts, args = cmd.parse_options('celeryd', ['--concurrency=512'])
         self.assertEqual(opts.concurrency, 512)
 
     @disable_stdouts
     def test_main(self):
         p, cd.Worker = cd.Worker, Worker
-        s, sys.argv = sys.argv, ["celeryd", "--discard"]
+        s, sys.argv = sys.argv, ['celeryd', '--discard']
         try:
             celeryd_main()
         finally:
@@ -462,60 +462,60 @@ class test_signal_handlers(AppCase):
             def __setitem__(self, sig, handler):
                 next_handlers[sig] = handler
 
-        with patch("celery.apps.worker.active_thread_count") as c:
+        with patch('celery.apps.worker.active_thread_count') as c:
             c.return_value = 3
             p, platforms.signals = platforms.signals, Signals()
             try:
-                handlers["SIGINT"]("SIGINT", object())
+                handlers['SIGINT']('SIGINT', object())
                 self.assertTrue(state.should_stop)
             finally:
                 platforms.signals = p
                 state.should_stop = False
 
             try:
-                next_handlers["SIGINT"]("SIGINT", object())
+                next_handlers['SIGINT']('SIGINT', object())
                 self.assertTrue(state.should_terminate)
             finally:
                 state.should_terminate = False
 
-        with patch("celery.apps.worker.active_thread_count") as c:
+        with patch('celery.apps.worker.active_thread_count') as c:
             c.return_value = 1
             p, platforms.signals = platforms.signals, Signals()
             try:
                 with self.assertRaises(SystemExit):
-                    handlers["SIGINT"]("SIGINT", object())
+                    handlers['SIGINT']('SIGINT', object())
             finally:
                 platforms.signals = p
 
             with self.assertRaises(SystemTerminate):
-                next_handlers["SIGINT"]("SIGINT", object())
+                next_handlers['SIGINT']('SIGINT', object())
 
     @disable_stdouts
     def test_worker_int_handler_only_stop_MainProcess(self):
         try:
             import _multiprocessing  # noqa
         except ImportError:
-            raise SkipTest("only relevant for multiprocessing")
+            raise SkipTest('only relevant for multiprocessing')
         process = current_process()
-        name, process.name = process.name, "OtherProcess"
-        with patch("celery.apps.worker.active_thread_count") as c:
+        name, process.name = process.name, 'OtherProcess'
+        with patch('celery.apps.worker.active_thread_count') as c:
             c.return_value = 3
             try:
                 worker = self._Worker()
                 handlers = self.psig(cd.install_worker_int_handler, worker)
-                handlers["SIGINT"]("SIGINT", object())
+                handlers['SIGINT']('SIGINT', object())
                 self.assertTrue(state.should_stop)
             finally:
                 process.name = name
                 state.should_stop = False
 
-        with patch("celery.apps.worker.active_thread_count") as c:
+        with patch('celery.apps.worker.active_thread_count') as c:
             c.return_value = 1
             try:
                 worker = self._Worker()
                 handlers = self.psig(cd.install_worker_int_handler, worker)
                 with self.assertRaises(SystemExit):
-                    handlers["SIGINT"]("SIGINT", object())
+                    handlers['SIGINT']('SIGINT', object())
             finally:
                 process.name = name
                 state.should_stop = False
@@ -524,105 +524,105 @@ class test_signal_handlers(AppCase):
     def test_install_HUP_not_supported_handler(self):
         worker = self._Worker()
         handlers = self.psig(cd.install_HUP_not_supported_handler, worker)
-        handlers["SIGHUP"]("SIGHUP", object())
+        handlers['SIGHUP']('SIGHUP', object())
 
     @disable_stdouts
     def test_worker_term_hard_handler_only_stop_MainProcess(self):
         try:
             import _multiprocessing  # noqa
         except ImportError:
-            raise SkipTest("only relevant for multiprocessing")
+            raise SkipTest('only relevant for multiprocessing')
         process = current_process()
-        name, process.name = process.name, "OtherProcess"
+        name, process.name = process.name, 'OtherProcess'
         try:
-            with patch("celery.apps.worker.active_thread_count") as c:
+            with patch('celery.apps.worker.active_thread_count') as c:
                 c.return_value = 3
                 worker = self._Worker()
                 handlers = self.psig(
                         cd.install_worker_term_hard_handler, worker)
                 try:
-                    handlers["SIGQUIT"]("SIGQUIT", object())
+                    handlers['SIGQUIT']('SIGQUIT', object())
                     self.assertTrue(state.should_terminate)
                 finally:
                     state.should_terminate = False
-            with patch("celery.apps.worker.active_thread_count") as c:
+            with patch('celery.apps.worker.active_thread_count') as c:
                 c.return_value = 1
                 worker = self._Worker()
                 handlers = self.psig(
                         cd.install_worker_term_hard_handler, worker)
                 with self.assertRaises(SystemTerminate):
-                    handlers["SIGQUIT"]("SIGQUIT", object())
+                    handlers['SIGQUIT']('SIGQUIT', object())
         finally:
             process.name = name
 
     @disable_stdouts
     def test_worker_term_handler_when_threads(self):
-        with patch("celery.apps.worker.active_thread_count") as c:
+        with patch('celery.apps.worker.active_thread_count') as c:
             c.return_value = 3
             worker = self._Worker()
             handlers = self.psig(cd.install_worker_term_handler, worker)
             try:
-                handlers["SIGTERM"]("SIGTERM", object())
+                handlers['SIGTERM']('SIGTERM', object())
                 self.assertTrue(state.should_stop)
             finally:
                 state.should_stop = False
 
     @disable_stdouts
     def test_worker_term_handler_when_single_thread(self):
-        with patch("celery.apps.worker.active_thread_count") as c:
+        with patch('celery.apps.worker.active_thread_count') as c:
             c.return_value = 1
             worker = self._Worker()
             handlers = self.psig(cd.install_worker_term_handler, worker)
             try:
                 with self.assertRaises(SystemExit):
-                    handlers["SIGTERM"]("SIGTERM", object())
+                    handlers['SIGTERM']('SIGTERM', object())
             finally:
                 state.should_stop = False
 
-    @patch("sys.__stderr__")
+    @patch('sys.__stderr__')
     def test_worker_cry_handler(self, stderr):
-        if sys.platform.startswith("java"):
-            raise SkipTest("Cry handler does not work on Jython")
-        if hasattr(sys, "pypy_version_info"):
-            raise SkipTest("Cry handler does not work on PyPy")
+        if sys.platform.startswith('java'):
+            raise SkipTest('Cry handler does not work on Jython')
+        if hasattr(sys, 'pypy_version_info'):
+            raise SkipTest('Cry handler does not work on PyPy')
         if sys.version_info > (2, 5):
             handlers = self.psig(cd.install_cry_handler)
-            self.assertIsNone(handlers["SIGUSR1"]("SIGUSR1", object()))
+            self.assertIsNone(handlers['SIGUSR1']('SIGUSR1', object()))
             self.assertTrue(stderr.write.called)
         else:
-            raise SkipTest("Needs Python 2.5 or later")
+            raise SkipTest('Needs Python 2.5 or later')
 
     @disable_stdouts
     def test_worker_term_handler_only_stop_MainProcess(self):
         try:
             import _multiprocessing  # noqa
         except ImportError:
-            raise SkipTest("only relevant for multiprocessing")
+            raise SkipTest('only relevant for multiprocessing')
         process = current_process()
-        name, process.name = process.name, "OtherProcess"
+        name, process.name = process.name, 'OtherProcess'
         try:
-            with patch("celery.apps.worker.active_thread_count") as c:
+            with patch('celery.apps.worker.active_thread_count') as c:
                 c.return_value = 3
                 worker = self._Worker()
                 handlers = self.psig(cd.install_worker_term_handler, worker)
-                handlers["SIGTERM"]("SIGTERM", object())
+                handlers['SIGTERM']('SIGTERM', object())
                 self.assertTrue(state.should_stop)
-            with patch("celery.apps.worker.active_thread_count") as c:
+            with patch('celery.apps.worker.active_thread_count') as c:
                 c.return_value = 1
                 worker = self._Worker()
                 handlers = self.psig(cd.install_worker_term_handler, worker)
                 with self.assertRaises(SystemExit):
-                    handlers["SIGTERM"]("SIGTERM", object())
+                    handlers['SIGTERM']('SIGTERM', object())
         finally:
             process.name = name
             state.should_stop = False
 
     @disable_stdouts
-    @patch("os.fork")
+    @patch('os.fork')
     def test_worker_restart_handler(self, fork):
         fork.return_value = 0
-        if getattr(os, "execv", None) is None:
-            raise SkipTest("platform does not have excv")
+        if getattr(os, 'execv', None) is None:
+            raise SkipTest('platform does not have excv')
         argv = []
 
         def _execv(*args):
@@ -632,12 +632,12 @@ class test_signal_handlers(AppCase):
         try:
             worker = self._Worker()
             handlers = self.psig(cd.install_worker_restart_handler, worker)
-            handlers["SIGHUP"]("SIGHUP", object())
+            handlers['SIGHUP']('SIGHUP', object())
             self.assertTrue(state.should_stop)
             self.assertTrue(argv)
             argv[:] = []
             fork.return_value = 1
-            handlers["SIGHUP"]("SIGHUP", object())
+            handlers['SIGHUP']('SIGHUP', object())
             self.assertFalse(argv)
         finally:
             os.execv = execv
@@ -645,21 +645,21 @@ class test_signal_handlers(AppCase):
 
     @disable_stdouts
     def test_worker_term_hard_handler_when_threaded(self):
-        with patch("celery.apps.worker.active_thread_count") as c:
+        with patch('celery.apps.worker.active_thread_count') as c:
             c.return_value = 3
             worker = self._Worker()
             handlers = self.psig(cd.install_worker_term_hard_handler, worker)
             try:
-                handlers["SIGQUIT"]("SIGQUIT", object())
+                handlers['SIGQUIT']('SIGQUIT', object())
                 self.assertTrue(state.should_terminate)
             finally:
                 state.should_terminate = False
 
     @disable_stdouts
     def test_worker_term_hard_handler_when_single_threaded(self):
-        with patch("celery.apps.worker.active_thread_count") as c:
+        with patch('celery.apps.worker.active_thread_count') as c:
             c.return_value = 1
             worker = self._Worker()
             handlers = self.psig(cd.install_worker_term_hard_handler, worker)
             with self.assertRaises(SystemTerminate):
-                handlers["SIGQUIT"]("SIGQUIT", object())
+                handlers['SIGQUIT']('SIGQUIT', object())

celery/tests/bin/test_celeryd_detach.py

@@ -16,27 +16,27 @@ from celery.tests.utils import Case, override_stdouts
 if not current_app.IS_WINDOWS:
     class test_detached(Case):
 
-        @patch("celery.bin.celeryd_detach.detached")
-        @patch("os.execv")
-        @patch("celery.bin.celeryd_detach.logger")
-        @patch("celery.app.log.Logging.setup_logging_subsystem")
+        @patch('celery.bin.celeryd_detach.detached')
+        @patch('os.execv')
+        @patch('celery.bin.celeryd_detach.logger')
+        @patch('celery.app.log.Logging.setup_logging_subsystem')
         def test_execs(self, setup_logs, logger, execv, detached):
             context = detached.return_value = Mock()
             context.__enter__ = Mock()
             context.__exit__ = Mock()
 
-            detach("/bin/boo", ["a", "b", "c"], logfile="/var/log",
-                    pidfile="/var/pid")
-            detached.assert_called_with("/var/log", "/var/pid", None, None, 0,
+            detach('/bin/boo', ['a', 'b', 'c'], logfile='/var/log',
+                    pidfile='/var/pid')
+            detached.assert_called_with('/var/log', '/var/pid', None, None, 0,
                                         None, False)
-            execv.assert_called_with("/bin/boo", ["/bin/boo", "a", "b", "c"])
+            execv.assert_called_with('/bin/boo', ['/bin/boo', 'a', 'b', 'c'])
 
-            execv.side_effect = Exception("foo")
-            r = detach("/bin/boo", ["a", "b", "c"], logfile="/var/log",
-                    pidfile="/var/pid")
+            execv.side_effect = Exception('foo')
+            r = detach('/bin/boo', ['a', 'b', 'c'], logfile='/var/log',
+                    pidfile='/var/pid')
             context.__enter__.assert_called_with()
             self.assertTrue(logger.critical.called)
-            setup_logs.assert_called_with("ERROR", "/var/log")
+            setup_logs.assert_called_with('ERROR', '/var/log')
             self.assertEqual(r, 1)
 
 
@@ -44,43 +44,43 @@ class test_PartialOptionParser(Case):
 
     def test_parser(self):
         x = detached_celeryd()
-        p = x.Parser("celeryd_detach")
-        options, values = p.parse_args(['--logfile=foo', "--fake", "--enable",
-                                        "a", "b", "-c1", "-d", "2"])
-        self.assertEqual(options.logfile, "foo")
-        self.assertEqual(values, ["a", "b"])
-        self.assertEqual(p.leftovers, ["--enable", "-c1", "-d", "2"])
+        p = x.Parser('celeryd_detach')
+        options, values = p.parse_args(['--logfile=foo', '--fake', '--enable',
+                                        'a', 'b', '-c1', '-d', '2'])
+        self.assertEqual(options.logfile, 'foo')
+        self.assertEqual(values, ['a', 'b'])
+        self.assertEqual(p.leftovers, ['--enable', '-c1', '-d', '2'])
 
         with override_stdouts():
             with self.assertRaises(SystemExit):
-                p.parse_args(["--logfile"])
-            p.get_option("--logfile").nargs = 2
+                p.parse_args(['--logfile'])
+            p.get_option('--logfile').nargs = 2
             with self.assertRaises(SystemExit):
-                p.parse_args(["--logfile=a"])
+                p.parse_args(['--logfile=a'])
             with self.assertRaises(SystemExit):
-                p.parse_args(["--fake=abc"])
+                p.parse_args(['--fake=abc'])
 
-        assert p.get_option("--logfile").nargs == 2
-        p.parse_args(["--logfile=a", "b"])
-        p.get_option("--logfile").nargs = 1
+        assert p.get_option('--logfile').nargs == 2
+        p.parse_args(['--logfile=a', 'b'])
+        p.get_option('--logfile').nargs = 1
 
 
 class test_Command(Case):
-    argv = ["--autoscale=10,2", "-c", "1",
-            "--logfile=/var/log", "-lDEBUG",
-            "--", ".disable_rate_limits=1"]
+    argv = ['--autoscale=10,2', '-c', '1',
+            '--logfile=/var/log', '-lDEBUG',
+            '--', '.disable_rate_limits=1']
 
     def test_parse_options(self):
         x = detached_celeryd()
-        o, v, l = x.parse_options("cd", self.argv)
-        self.assertEqual(o.logfile, "/var/log")
-        self.assertEqual(l, ["--autoscale=10,2", "-c", "1",
-                             "-lDEBUG", "--logfile=/var/log",
-                             "--pidfile=celeryd.pid"])
-        x.parse_options("cd", [])  # no args
-
-    @patch("sys.exit")
-    @patch("celery.bin.celeryd_detach.detach")
+        o, v, l = x.parse_options('cd', self.argv)
+        self.assertEqual(o.logfile, '/var/log')
+        self.assertEqual(l, ['--autoscale=10,2', '-c', '1',
+                             '-lDEBUG', '--logfile=/var/log',
+                             '--pidfile=celeryd.pid'])
+        x.parse_options('cd', [])  # no args
+
+    @patch('sys.exit')
+    @patch('celery.bin.celeryd_detach.detach')
     def test_execute_from_commandline(self, detach, exit):
         x = detached_celeryd()
         x.execute_from_commandline(self.argv)
@@ -93,7 +93,7 @@ class test_Command(Case):
                   '--', '.disable_rate_limits=1'],
         )
 
-    @patch("celery.bin.celeryd_detach.detached_celeryd")
+    @patch('celery.bin.celeryd_detach.detached_celeryd')
     def test_main(self, command):
         c = command.return_value = Mock()
         main()

celery/tests/bin/test_celeryd_multi.py

@@ -26,31 +26,31 @@ from celery.tests.utils import Case, WhateverIO
 class test_functions(Case):
 
     def test_findsig(self):
-        self.assertEqual(findsig(["a", "b", "c", "-1"]), 1)
-        self.assertEqual(findsig(["--foo=1", "-9"]), 9)
-        self.assertEqual(findsig(["-INT"]), signal.SIGINT)
+        self.assertEqual(findsig(['a', 'b', 'c', '-1']), 1)
+        self.assertEqual(findsig(['--foo=1', '-9']), 9)
+        self.assertEqual(findsig(['-INT']), signal.SIGINT)
         self.assertEqual(findsig([]), signal.SIGTERM)
-        self.assertEqual(findsig(["-s"]), signal.SIGTERM)
-        self.assertEqual(findsig(["-log"]), signal.SIGTERM)
+        self.assertEqual(findsig(['-s']), signal.SIGTERM)
+        self.assertEqual(findsig(['-log']), signal.SIGTERM)
 
     def test_abbreviations(self):
-        expander = abbreviations({"%s": "START",
-                                  "%x": "STOP"})
-        self.assertEqual(expander("foo%s"), "fooSTART")
-        self.assertEqual(expander("foo%x"), "fooSTOP")
-        self.assertEqual(expander("foo%y"), "foo%y")
+        expander = abbreviations({'%s': 'START',
+                                  '%x': 'STOP'})
+        self.assertEqual(expander('foo%s'), 'fooSTART')
+        self.assertEqual(expander('foo%x'), 'fooSTOP')
+        self.assertEqual(expander('foo%y'), 'foo%y')
         self.assertIsNone(expander(None))
 
     def test_parse_ns_range(self):
-        self.assertEqual(parse_ns_range("1-3", True), ['1', '2', '3'])
-        self.assertEqual(parse_ns_range("1-3", False), ['1-3'])
-        self.assertEqual(parse_ns_range("1-3,10,11,20", True),
+        self.assertEqual(parse_ns_range('1-3', True), ['1', '2', '3'])
+        self.assertEqual(parse_ns_range('1-3', False), ['1-3'])
+        self.assertEqual(parse_ns_range('1-3,10,11,20', True),
                 ['1', '2', '3', '10', '11', '20'])
 
     def test_format_opt(self):
-        self.assertEqual(format_opt("--foo", None), "--foo")
-        self.assertEqual(format_opt("-c", 1), "-c 1")
-        self.assertEqual(format_opt("--log", "foo"), "--log=foo")
+        self.assertEqual(format_opt('--foo', None), '--foo')
+        self.assertEqual(format_opt('-c', 1), '-c 1')
+        self.assertEqual(format_opt('--log', 'foo'), '--log=foo')
 
     def test_quote(self):
         self.assertEqual(quote("the 'quick"), "'the '\\''quick'")
@@ -59,34 +59,34 @@ class test_functions(Case):
 class test_NamespacedOptionParser(Case):
 
     def test_parse(self):
-        x = NamespacedOptionParser(["-c:1,3", "4"])
-        self.assertEqual(x.namespaces.get("1,3"), {"-c": "4"})
-        x = NamespacedOptionParser(["-c:jerry,elaine", "5",
-                                    "--loglevel:kramer=DEBUG",
-                                    "--flag",
-                                    "--logfile=foo", "-Q", "bar", "a", "b",
-                                    "--", ".disable_rate_limits=1"])
-        self.assertEqual(x.options, {"--logfile": "foo",
-                                     "-Q": "bar",
-                                     "--flag": None})
-        self.assertEqual(x.values, ["a", "b"])
-        self.assertEqual(x.namespaces.get("jerry,elaine"), {"-c": "5"})
-        self.assertEqual(x.namespaces.get("kramer"), {"--loglevel": "DEBUG"})
-        self.assertEqual(x.passthrough, "-- .disable_rate_limits=1")
+        x = NamespacedOptionParser(['-c:1,3', '4'])
+        self.assertEqual(x.namespaces.get('1,3'), {'-c': '4'})
+        x = NamespacedOptionParser(['-c:jerry,elaine', '5',
+                                    '--loglevel:kramer=DEBUG',
+                                    '--flag',
+                                    '--logfile=foo', '-Q', 'bar', 'a', 'b',
+                                    '--', '.disable_rate_limits=1'])
+        self.assertEqual(x.options, {'--logfile': 'foo',
+                                     '-Q': 'bar',
+                                     '--flag': None})
+        self.assertEqual(x.values, ['a', 'b'])
+        self.assertEqual(x.namespaces.get('jerry,elaine'), {'-c': '5'})
+        self.assertEqual(x.namespaces.get('kramer'), {'--loglevel': 'DEBUG'})
+        self.assertEqual(x.passthrough, '-- .disable_rate_limits=1')
 
 
 class test_multi_args(Case):
 
-    @patch("socket.gethostname")
+    @patch('socket.gethostname')
     def test_parse(self, gethostname):
-        p = NamespacedOptionParser(["-c:jerry,elaine", "5",
-                                    "--loglevel:kramer=DEBUG",
-                                    "--flag",
-                                    "--logfile=foo", "-Q", "bar", "jerry",
-                                    "elaine", "kramer",
-                                    "--", ".disable_rate_limits=1"])
-        it = multi_args(p, cmd="COMMAND", append="*AP*",
-                prefix="*P*", suffix="*S*")
+        p = NamespacedOptionParser(['-c:jerry,elaine', '5',
+                                    '--loglevel:kramer=DEBUG',
+                                    '--flag',
+                                    '--logfile=foo', '-Q', 'bar', 'jerry',
+                                    'elaine', 'kramer',
+                                    '--', '.disable_rate_limits=1'])
+        it = multi_args(p, cmd='COMMAND', append='*AP*',
+                prefix='*P*', suffix='*S*')
         names = list(it)
         self.assertEqual(names[0][0:2], ('*P*jerry*S*',
             [
@@ -110,15 +110,15 @@ class test_multi_args(Case):
             ]
         ))
         expand = names[0][2]
-        self.assertEqual(expand("%h"), "*P*jerry*S*")
-        self.assertEqual(expand("%n"), "jerry")
-        names2 = list(multi_args(p, cmd="COMMAND", append="",
-                prefix="*P*", suffix="*S*"))
+        self.assertEqual(expand('%h'), '*P*jerry*S*')
+        self.assertEqual(expand('%n'), 'jerry')
+        names2 = list(multi_args(p, cmd='COMMAND', append='',
+                prefix='*P*', suffix='*S*'))
         self.assertEqual(names2[0][1][-1], '-- .disable_rate_limits=1')
 
         gethostname.return_value = 'example.com'
-        p2 = NamespacedOptionParser(["10", "-c:1", "5"])
-        names3 = list(multi_args(p2, cmd="COMMAND"))
+        p2 = NamespacedOptionParser(['10', '-c:1', '5'])
+        names3 = list(multi_args(p2, cmd='COMMAND'))
         self.assertEqual(len(names3), 10)
         self.assertEqual(names3[0][0:2], ('celery1.example.com',
             ['COMMAND', '-n celery1.example.com', '-c 5', '']))
@@ -126,13 +126,13 @@ class test_multi_args(Case):
             self.assertEqual(worker[0:2], ('celery%s.example.com' % (i + 2),
                 ['COMMAND', '-n celery%s.example.com' % (i + 2), '']))
 
-        names4 = list(multi_args(p2, cmd="COMMAND", suffix='""'))
+        names4 = list(multi_args(p2, cmd='COMMAND', suffix='""'))
         self.assertEqual(len(names4), 10)
         self.assertEqual(names4[0][0:2], ('celery1',
             ['COMMAND', '-n celery1', '-c 5', '']))
 
-        p3 = NamespacedOptionParser(["foo", "-c:foo", "5"])
-        names5 = list(multi_args(p3, cmd="COMMAND", suffix='""'))
+        p3 = NamespacedOptionParser(['foo', '-c:foo', '5'])
+        names5 = list(multi_args(p3, cmd='COMMAND', suffix='""'))
         self.assertEqual(names5[0][0:2], ('foo',
             ['COMMAND', '-n foo', '-c 5', '']))
 
@@ -145,29 +145,29 @@ class test_MultiTool(Case):
         self.t = MultiTool(env=self.env, fh=self.fh)
 
     def test_note(self):
-        self.t.note("hello world")
-        self.assertEqual(self.fh.getvalue(), "hello world\n")
+        self.t.note('hello world')
+        self.assertEqual(self.fh.getvalue(), 'hello world\n')
 
     def test_note_quiet(self):
         self.t.quiet = True
-        self.t.note("hello world")
+        self.t.note('hello world')
         self.assertFalse(self.fh.getvalue())
 
     def test_info(self):
         self.t.verbose = True
-        self.t.info("hello info")
+        self.t.info('hello info')
         self.assertEqual(self.fh.getvalue(), 'hello info\n')
 
     def test_info_not_verbose(self):
         self.t.verbose = False
-        self.t.info("hello info")
+        self.t.info('hello info')
         self.assertFalse(self.fh.getvalue())
 
     def test_error(self):
         self.t.say = Mock()
         self.t.usage = Mock()
-        self.assertEqual(self.t.error("foo"), 1)
-        self.t.say.assert_called_with("foo")
+        self.assertEqual(self.t.error('foo'), 1)
+        self.t.say.assert_called_with('foo')
         self.t.usage.assert_called_with()
 
         self.t.say = Mock()
@@ -176,22 +176,22 @@ class test_MultiTool(Case):
 
         self.assertEqual(self.t.retcode, 1)
 
-    @patch("celery.bin.celeryd_multi.Popen")
+    @patch('celery.bin.celeryd_multi.Popen')
     def test_waitexec(self, Popen):
         self.t.note = Mock()
         pipe = Popen.return_value = Mock()
         pipe.wait.return_value = -10
-        self.assertEqual(self.t.waitexec(["-m", "foo"], "path"), 10)
+        self.assertEqual(self.t.waitexec(['-m', 'foo'], 'path'), 10)
         Popen.assert_called_with(['path', '-m', 'foo'], env=self.t.env)
-        self.t.note.assert_called_with("* Child was terminated by signal 10")
+        self.t.note.assert_called_with('* Child was terminated by signal 10')
 
         pipe.wait.return_value = 2
-        self.assertEqual(self.t.waitexec(["-m", "foo"], "path"), 2)
+        self.assertEqual(self.t.waitexec(['-m', 'foo'], 'path'), 2)
         self.t.note.assert_called_with(
-                "* Child terminated with failure code 2")
+                '* Child terminated with failure code 2')
 
         pipe.wait.return_value = 0
-        self.assertFalse(self.t.waitexec(["-m", "foo", "path"]))
+        self.assertFalse(self.t.waitexec(['-m', 'foo', 'path']))
 
     def test_nosplash(self):
         self.t.nosplash = True
@@ -201,7 +201,7 @@ class test_MultiTool(Case):
     def test_splash(self):
         self.t.nosplash = False
         self.t.splash()
-        self.assertIn("celeryd-multi", self.fh.getvalue())
+        self.assertIn('celeryd-multi', self.fh.getvalue())
 
     def test_usage(self):
         self.t.usage()
@@ -214,32 +214,32 @@ class test_MultiTool(Case):
     def test_expand(self):
         self.t.expand(['foo%n', 'ask', 'klask', 'dask'])
         self.assertEqual(self.fh.getvalue(),
-                "fooask\nfooklask\nfoodask\n")
+                'fooask\nfooklask\nfoodask\n')
 
     def test_restart(self):
         stop = self.t._stop_nodes = Mock()
-        self.t.restart(['jerry', 'george'], "celeryd")
+        self.t.restart(['jerry', 'george'], 'celeryd')
         waitexec = self.t.waitexec = Mock()
         self.assertTrue(stop.called)
-        callback = stop.call_args[1]["callback"]
+        callback = stop.call_args[1]['callback']
         self.assertTrue(callback)
 
         waitexec.return_value = 0
-        callback("jerry", ["arg"], 13)
-        waitexec.assert_called_with(["arg"])
-        self.assertIn("OK", self.fh.getvalue())
+        callback('jerry', ['arg'], 13)
+        waitexec.assert_called_with(['arg'])
+        self.assertIn('OK', self.fh.getvalue())
         self.fh.seek(0)
         self.fh.truncate()
 
         waitexec.return_value = 1
-        callback("jerry", ["arg"], 13)
-        self.assertIn("FAILED", self.fh.getvalue())
+        callback('jerry', ['arg'], 13)
+        self.assertIn('FAILED', self.fh.getvalue())
 
     def test_stop(self):
         self.t.getpids = Mock()
         self.t.getpids.return_value = [2, 3, 4]
         self.t.shutdown_nodes = Mock()
-        self.t.stop(["a", "b", "-INT"], "celeryd")
+        self.t.stop(['a', 'b', '-INT'], 'celeryd')
         self.t.shutdown_nodes.assert_called_with(
             [2, 3, 4], sig=signal.SIGINT, retry=None, callback=None,
 
@@ -248,19 +248,19 @@ class test_MultiTool(Case):
     def test_kill(self):
         self.t.getpids = Mock()
         self.t.getpids.return_value = [
-            ("a", None, 10),
-            ("b", None, 11),
-            ("c", None, 12)
+            ('a', None, 10),
+            ('b', None, 11),
+            ('c', None, 12)
         ]
         sig = self.t.signal_node = Mock()
 
-        self.t.kill(["a", "b", "c"], "celeryd")
+        self.t.kill(['a', 'b', 'c'], 'celeryd')
 
         sigs = sig.call_args_list
         self.assertEqual(len(sigs), 3)
-        self.assertEqual(sigs[0][0], ("a", 10, signal.SIGKILL))
-        self.assertEqual(sigs[1][0], ("b", 11, signal.SIGKILL))
-        self.assertEqual(sigs[2][0], ("c", 12, signal.SIGKILL))
+        self.assertEqual(sigs[0][0], ('a', 10, signal.SIGKILL))
+        self.assertEqual(sigs[1][0], ('b', 11, signal.SIGKILL))
+        self.assertEqual(sigs[2][0], ('c', 12, signal.SIGKILL))
 
     def prepare_pidfile_for_getpids(self, PIDFile):
         class pids(object):
@@ -270,21 +270,21 @@ class test_MultiTool(Case):
 
             def read_pid(self):
                 try:
-                    return {"celeryd@foo.pid": 10,
-                            "celeryd@bar.pid": 11}[self.path]
+                    return {'celeryd@foo.pid': 10,
+                            'celeryd@bar.pid': 11}[self.path]
                 except KeyError:
                     raise ValueError()
         PIDFile.side_effect = pids
 
-    @patch("celery.bin.celeryd_multi.PIDFile")
-    @patch("socket.gethostname")
+    @patch('celery.bin.celeryd_multi.PIDFile')
+    @patch('socket.gethostname')
     def test_getpids(self, gethostname, PIDFile):
-        gethostname.return_value = "e.com"
+        gethostname.return_value = 'e.com'
         self.prepare_pidfile_for_getpids(PIDFile)
         callback = Mock()
 
-        p = NamespacedOptionParser(["foo", "bar", "baz"])
-        nodes = self.t.getpids(p, "celeryd", callback=callback)
+        p = NamespacedOptionParser(['foo', 'bar', 'baz'])
+        nodes = self.t.getpids(p, 'celeryd', callback=callback)
         self.assertEqual(nodes, [
             ('foo.e.com',
               ('celeryd', '--pidfile=celeryd@foo.pid', '-n foo.e.com', ''),
@@ -295,20 +295,20 @@ class test_MultiTool(Case):
         ])
         self.assertTrue(callback.called)
         callback.assert_called_with(
-            "baz.e.com",
+            'baz.e.com',
             ['celeryd', '--pidfile=celeryd@baz.pid', '-n baz.e.com', ''],
             None,
         )
-        self.assertIn("DOWN", self.fh.getvalue())
+        self.assertIn('DOWN', self.fh.getvalue())
 
         # without callback, should work
-        nodes = self.t.getpids(p, "celeryd", callback=None)
+        nodes = self.t.getpids(p, 'celeryd', callback=None)
 
-    @patch("celery.bin.celeryd_multi.PIDFile")
-    @patch("socket.gethostname")
-    @patch("celery.bin.celeryd_multi.sleep")
+    @patch('celery.bin.celeryd_multi.PIDFile')
+    @patch('socket.gethostname')
+    @patch('celery.bin.celeryd_multi.sleep')
     def test_shutdown_nodes(self, slepp, gethostname, PIDFile):
-        gethostname.return_value = "e.com"
+        gethostname.return_value = 'e.com'
         self.prepare_pidfile_for_getpids(PIDFile)
         self.assertIsNone(self.t.shutdown_nodes([]))
         self.t.signal_node = Mock()
@@ -316,14 +316,14 @@ class test_MultiTool(Case):
         self.t.node_alive.return_value = False
 
         callback = Mock()
-        self.t.stop(["foo", "bar", "baz"], "celeryd", callback=callback)
+        self.t.stop(['foo', 'bar', 'baz'], 'celeryd', callback=callback)
         sigs = self.t.signal_node.call_args_list
         self.assertEqual(len(sigs), 2)
-        self.assertEqual(sigs[0][0], ("foo.e.com", 10, signal.SIGTERM))
-        self.assertEqual(sigs[1][0], ("bar.e.com", 11, signal.SIGTERM))
+        self.assertEqual(sigs[0][0], ('foo.e.com', 10, signal.SIGTERM))
+        self.assertEqual(sigs[1][0], ('bar.e.com', 11, signal.SIGTERM))
         self.t.signal_node.return_value = False
         self.assertTrue(callback.called)
-        self.t.stop(["foo", "bar", "baz"], "celeryd", callback=None)
+        self.t.stop(['foo', 'bar', 'baz'], 'celeryd', callback=None)
 
         def on_node_alive(pid):
             if node_alive.call_count > 4:
@@ -331,9 +331,9 @@ class test_MultiTool(Case):
             return False
         self.t.signal_node.return_value = True
         self.t.node_alive.side_effect = on_node_alive
-        self.t.stop(["foo", "bar", "baz"], "celeryd", retry=True)
+        self.t.stop(['foo', 'bar', 'baz'], 'celeryd', retry=True)
 
-    @patch("os.kill")
+    @patch('os.kill')
     def test_node_alive(self, kill):
         kill.return_value = True
         self.assertTrue(self.t.node_alive(13))
@@ -349,70 +349,70 @@ class test_MultiTool(Case):
         with self.assertRaises(OSError):
             self.t.node_alive(13)
 
-    @patch("os.kill")
+    @patch('os.kill')
     def test_signal_node(self, kill):
         kill.return_value = True
-        self.assertTrue(self.t.signal_node("foo", 13, 9))
+        self.assertTrue(self.t.signal_node('foo', 13, 9))
         esrch = OSError()
         esrch.errno = errno.ESRCH
         kill.side_effect = esrch
-        self.assertFalse(self.t.signal_node("foo", 13, 9))
+        self.assertFalse(self.t.signal_node('foo', 13, 9))
         kill.assert_called_with(13, 9)
-        self.assertIn("Could not signal foo", self.fh.getvalue())
+        self.assertIn('Could not signal foo', self.fh.getvalue())
 
         enoent = OSError()
         enoent.errno = errno.ENOENT
         kill.side_effect = enoent
         with self.assertRaises(OSError):
-            self.t.signal_node("foo", 13, 9)
+            self.t.signal_node('foo', 13, 9)
 
     def test_start(self):
         self.t.waitexec = Mock()
         self.t.waitexec.return_value = 0
-        self.assertFalse(self.t.start(["foo", "bar", "baz"], "celeryd"))
+        self.assertFalse(self.t.start(['foo', 'bar', 'baz'], 'celeryd'))
 
         self.t.waitexec.return_value = 1
-        self.assertFalse(self.t.start(["foo", "bar", "baz"], "celeryd"))
+        self.assertFalse(self.t.start(['foo', 'bar', 'baz'], 'celeryd'))
 
     def test_show(self):
-        self.t.show(["foo", "bar", "baz"], "celeryd")
+        self.t.show(['foo', 'bar', 'baz'], 'celeryd')
         self.assertTrue(self.fh.getvalue())
 
-    @patch("socket.gethostname")
+    @patch('socket.gethostname')
     def test_get(self, gethostname):
-        gethostname.return_value = "e.com"
-        self.t.get(["xuzzy.e.com", "foo", "bar", "baz"], "celeryd")
+        gethostname.return_value = 'e.com'
+        self.t.get(['xuzzy.e.com', 'foo', 'bar', 'baz'], 'celeryd')
         self.assertFalse(self.fh.getvalue())
-        self.t.get(["foo.e.com", "foo", "bar", "baz"], "celeryd")
+        self.t.get(['foo.e.com', 'foo', 'bar', 'baz'], 'celeryd')
         self.assertTrue(self.fh.getvalue())
 
-    @patch("socket.gethostname")
+    @patch('socket.gethostname')
     def test_names(self, gethostname):
-        gethostname.return_value = "e.com"
-        self.t.names(["foo", "bar", "baz"], "celeryd")
-        self.assertIn("foo.e.com\nbar.e.com\nbaz.e.com", self.fh.getvalue())
+        gethostname.return_value = 'e.com'
+        self.t.names(['foo', 'bar', 'baz'], 'celeryd')
+        self.assertIn('foo.e.com\nbar.e.com\nbaz.e.com', self.fh.getvalue())
 
     def test_execute_from_commandline(self):
-        start = self.t.commands["start"] = Mock()
+        start = self.t.commands['start'] = Mock()
         self.t.error = Mock()
-        self.t.execute_from_commandline(["multi", "start", "foo", "bar"])
+        self.t.execute_from_commandline(['multi', 'start', 'foo', 'bar'])
         self.assertFalse(self.t.error.called)
-        start.assert_called_with(["foo", "bar"], "celeryd")
+        start.assert_called_with(['foo', 'bar'], 'celeryd')
 
         self.t.error = Mock()
-        self.t.execute_from_commandline(["multi", "frob", "foo", "bar"])
-        self.t.error.assert_called_with("Invalid command: frob")
+        self.t.execute_from_commandline(['multi', 'frob', 'foo', 'bar'])
+        self.t.error.assert_called_with('Invalid command: frob')
 
         self.t.error = Mock()
-        self.t.execute_from_commandline(["multi"])
+        self.t.execute_from_commandline(['multi'])
         self.t.error.assert_called_with()
 
         self.t.error = Mock()
-        self.t.execute_from_commandline(["multi", "-foo"])
+        self.t.execute_from_commandline(['multi', '-foo'])
         self.t.error.assert_called_with()
 
-        self.t.execute_from_commandline(["multi", "start", "foo",
-                "--nosplash", "--quiet", "-q", "--verbose", "--no-color"])
+        self.t.execute_from_commandline(['multi', 'start', 'foo',
+                '--nosplash', '--quiet', '-q', '--verbose', '--no-color'])
         self.assertTrue(self.t.nosplash)
         self.assertTrue(self.t.quiet)
         self.assertTrue(self.t.verbose)
@@ -420,10 +420,10 @@ class test_MultiTool(Case):
 
     def test_stop_verify(self):
         self.t._stop_nodes = Mock()
-        self.t.stop_verify(["foo", "bar", "baz"], "celeryd")
-        self.assertEqual(self.t._stop_nodes.call_args[1]["retry"], 2)
+        self.t.stop_verify(['foo', 'bar', 'baz'], 'celeryd')
+        self.assertEqual(self.t._stop_nodes.call_args[1]['retry'], 2)
 
-    @patch("celery.bin.celeryd_multi.MultiTool")
+    @patch('celery.bin.celeryd_multi.MultiTool')
     def test_main(self, MultiTool):
         m = MultiTool.return_value = Mock()
         with self.assertRaises(SystemExit):

celery/tests/bin/test_celeryev.py

@@ -28,16 +28,16 @@ class test_EvCommand(Case):
         self.app = app_or_default()
         self.ev = celeryev.EvCommand(app=self.app)
 
-    @patch("celery.events.dumper", "evdump", lambda **kw: "me dumper, you?")
-    @patch("celery.bin.celeryev", "set_process_title", proctitle)
+    @patch('celery.events.dumper', 'evdump', lambda **kw: 'me dumper, you?')
+    @patch('celery.bin.celeryev', 'set_process_title', proctitle)
     def test_run_dump(self):
-        self.assertEqual(self.ev.run(dump=True), "me dumper, you?")
-        self.assertIn("celeryev:dump", proctitle.last[0])
+        self.assertEqual(self.ev.run(dump=True), 'me dumper, you?')
+        self.assertIn('celeryev:dump', proctitle.last[0])
 
-    @mpatch("os.chdir")
+    @mpatch('os.chdir')
     def test_prepare_preload_options(self, chdir):
-        self.ev.prepare_preload_options({"working_directory": "/opt/Project"})
-        chdir.assert_called_with("/opt/Project")
+        self.ev.prepare_preload_options({'working_directory': '/opt/Project'})
+        chdir.assert_called_with('/opt/Project')
         chdir.called = False
         self.ev.prepare_preload_options({})
         self.assertFalse(chdir.called)
@@ -46,38 +46,38 @@ class test_EvCommand(Case):
         try:
             import curses  # noqa
         except ImportError:
-            raise SkipTest("curses monitor requires curses")
+            raise SkipTest('curses monitor requires curses')
 
-        @patch("celery.events.cursesmon", "evtop", lambda **kw: "me top, you?")
-        @patch("celery.bin.celeryev", "set_process_title", proctitle)
+        @patch('celery.events.cursesmon', 'evtop', lambda **kw: 'me top, you?')
+        @patch('celery.bin.celeryev', 'set_process_title', proctitle)
         def _inner():
-            self.assertEqual(self.ev.run(), "me top, you?")
-            self.assertIn("celeryev:top", proctitle.last[0])
+            self.assertEqual(self.ev.run(), 'me top, you?')
+            self.assertIn('celeryev:top', proctitle.last[0])
         return _inner()
 
-    @patch("celery.events.snapshot", "evcam", lambda *a, **k: (a, k))
-    @patch("celery.bin.celeryev", "set_process_title", proctitle)
+    @patch('celery.events.snapshot', 'evcam', lambda *a, **k: (a, k))
+    @patch('celery.bin.celeryev', 'set_process_title', proctitle)
     def test_run_cam(self):
-        a, kw = self.ev.run(camera="foo.bar.baz", logfile="logfile")
-        self.assertEqual(a[0], "foo.bar.baz")
-        self.assertEqual(kw["freq"], 1.0)
-        self.assertIsNone(kw["maxrate"])
-        self.assertEqual(kw["loglevel"], "INFO")
-        self.assertEqual(kw["logfile"], "logfile")
-        self.assertIn("celeryev:cam", proctitle.last[0])
-
-    @mpatch("celery.events.snapshot.evcam")
-    @mpatch("celery.bin.celeryev.detached")
+        a, kw = self.ev.run(camera='foo.bar.baz', logfile='logfile')
+        self.assertEqual(a[0], 'foo.bar.baz')
+        self.assertEqual(kw['freq'], 1.0)
+        self.assertIsNone(kw['maxrate'])
+        self.assertEqual(kw['loglevel'], 'INFO')
+        self.assertEqual(kw['logfile'], 'logfile')
+        self.assertIn('celeryev:cam', proctitle.last[0])
+
+    @mpatch('celery.events.snapshot.evcam')
+    @mpatch('celery.bin.celeryev.detached')
     def test_run_cam_detached(self, detached, evcam):
-        self.ev.prog_name = "celeryev"
-        self.ev.run_evcam("myapp.Camera", detach=True)
+        self.ev.prog_name = 'celeryev'
+        self.ev.run_evcam('myapp.Camera', detach=True)
         self.assertTrue(detached.called)
         self.assertTrue(evcam.called)
 
     def test_get_options(self):
         self.assertTrue(self.ev.get_options())
 
-    @patch("celery.bin.celeryev", "EvCommand", MockCommand)
+    @patch('celery.bin.celeryev', 'EvCommand', MockCommand)
     def test_main(self):
         MockCommand.executed = []
         celeryev.main()

celery/tests/bin/test_celeryevdump.py

@@ -19,29 +19,29 @@ class test_Dumper(Case):
         self.dumper = Dumper(out=self.out)
 
     def test_humanize_type(self):
-        self.assertEqual(humanize_type("worker-offline"), "shutdown")
-        self.assertEqual(humanize_type("task-started"), "task started")
+        self.assertEqual(humanize_type('worker-offline'), 'shutdown')
+        self.assertEqual(humanize_type('task-started'), 'task started')
 
     def test_format_task_event(self):
         self.dumper.format_task_event(
-            "worker.example.com", time(), "task-started", "tasks.add", {})
+            'worker.example.com', time(), 'task-started', 'tasks.add', {})
         self.assertTrue(self.out.getvalue())
 
     def test_on_event(self):
         event = {
-            "hostname": "worker.example.com",
-            "timestamp": time(),
-            "uuid": "1ef",
-            "name": "tasks.add",
-            "args": "(2, 2)",
-            "kwargs": "{}",
+            'hostname': 'worker.example.com',
+            'timestamp': time(),
+            'uuid': '1ef',
+            'name': 'tasks.add',
+            'args': '(2, 2)',
+            'kwargs': '{}',
         }
-        self.dumper.on_event(dict(event, type="task-received"))
+        self.dumper.on_event(dict(event, type='task-received'))
         self.assertTrue(self.out.getvalue())
-        self.dumper.on_event(dict(event, type="task-revoked"))
-        self.dumper.on_event(dict(event, type="worker-online"))
+        self.dumper.on_event(dict(event, type='task-revoked'))
+        self.dumper.on_event(dict(event, type='worker-online'))
 
-    @patch("celery.events.EventReceiver.capture")
+    @patch('celery.events.EventReceiver.capture')
     def test_evdump(self, capture):
         evdump()
         capture.side_effect = KeyboardInterrupt()

celery/tests/compat.py

@@ -7,8 +7,8 @@ class WarningMessage(object):
 
     """Holds the result of a single showwarning() call."""
 
-    _WARNING_DETAILS = ("message", "category", "filename", "lineno", "file",
-                        "line")
+    _WARNING_DETAILS = ('message', 'category', 'filename', 'lineno', 'file',
+                        'line')
 
     def __init__(self, message, category, filename, lineno, file=None,
                     line=None):
@@ -19,8 +19,8 @@ class WarningMessage(object):
         self._category_name = category and category.__name__ or None
 
     def __str__(self):
-        return ("{message : %r, category : %r, filename : %r, lineno : %s, "
-                    "line : %r}" % (self.message, self._category_name,
+        return ('{message : %r, category : %r, filename : %r, lineno : %s, '
+                    'line : %r}' % (self.message, self._category_name,
                                     self.filename, self.lineno, self.line))
 
 
@@ -50,21 +50,21 @@ class catch_warnings(object):
 
         """
         self._record = record
-        self._module = module is None and sys.modules["warnings"] or module
+        self._module = module is None and sys.modules['warnings'] or module
         self._entered = False
 
     def __repr__(self):
         args = []
         if self._record:
-            args.append("record=True")
+            args.append('record=True')
         if self._module is not sys.modules['warnings']:
-            args.append("module=%r" % self._module)
+            args.append('module=%r' % self._module)
         name = type(self).__name__
-        return "%s(%s)" % (name, ", ".join(args))
+        return '%s(%s)' % (name, ', '.join(args))
 
     def __enter__(self):
         if self._entered:
-            raise RuntimeError("Cannot enter %r twice" % self)
+            raise RuntimeError('Cannot enter %r twice' % self)
         self._entered = True
         self._filters = self._module.filters
         self._module.filters = self._filters[:]
@@ -80,6 +80,6 @@ class catch_warnings(object):
 
     def __exit__(self, *exc_info):
         if not self._entered:
-            raise RuntimeError("Cannot exit %r without entering first" % self)
+            raise RuntimeError('Cannot exit %r without entering first' % self)
         self._module.filters = self._filters
         self._module.showwarning = self._showwarning

celery/tests/concurrency/test_concurrency.py

@@ -24,28 +24,28 @@ class test_BasePool(Case):
 
             return callback
 
-        apply_target(gen_callback("target", 42),
+        apply_target(gen_callback('target', 42),
                      args=(8, 16),
-                     callback=gen_callback("callback"),
-                     accept_callback=gen_callback("accept_callback"))
+                     callback=gen_callback('callback'),
+                     accept_callback=gen_callback('accept_callback'))
 
         self.assertDictContainsSubset({
-                              "target": (1, (8, 16)),
-                              "callback": (2, (42, ))}, scratch)
-        pa1 = scratch["accept_callback"]
+                              'target': (1, (8, 16)),
+                              'callback': (2, (42, ))}, scratch)
+        pa1 = scratch['accept_callback']
         self.assertEqual(0, pa1[0])
         self.assertEqual(pa1[1][0], os.getpid())
         self.assertTrue(pa1[1][1])
 
         # No accept callback
         scratch.clear()
-        apply_target(gen_callback("target", 42),
+        apply_target(gen_callback('target', 42),
                      args=(8, 16),
-                     callback=gen_callback("callback"),
+                     callback=gen_callback('callback'),
                      accept_callback=None)
         self.assertDictEqual(scratch,
-                              {"target": (3, (8, 16)),
-                               "callback": (4, (42, ))})
+                              {'target': (3, (8, 16)),
+                               'callback': (4, (42, ))})
 
     def test_does_not_debug(self):
         x = BasePool(10)

celery/tests/concurrency/test_eventlet.py

@@ -20,13 +20,13 @@ from celery.tests.utils import Case, mock_module, patch_many
 class EventletCase(Case):
 
     def setUp(self):
-        if getattr(sys, "pypy_version_info", None):
-            raise SkipTest("Does not work on PyPy")
+        if getattr(sys, 'pypy_version_info', None):
+            raise SkipTest('Does not work on PyPy')
         try:
-            self.eventlet = __import__("eventlet")
+            self.eventlet = __import__('eventlet')
         except ImportError:
             raise SkipTest(
-                "eventlet not installed, skipping related tests.")
+                'eventlet not installed, skipping related tests.')
 
 
 class test_eventlet_patch(EventletCase):
@@ -35,23 +35,23 @@ class test_eventlet_patch(EventletCase):
         monkey_patched = []
         prev_monkey_patch = self.eventlet.monkey_patch
         self.eventlet.monkey_patch = lambda: monkey_patched.append(True)
-        prev_eventlet = sys.modules.pop("celery.concurrency.eventlet", None)
-        os.environ.pop("EVENTLET_NOPATCH")
+        prev_eventlet = sys.modules.pop('celery.concurrency.eventlet', None)
+        os.environ.pop('EVENTLET_NOPATCH')
         try:
             import celery.concurrency.eventlet  # noqa
             self.assertTrue(monkey_patched)
         finally:
-            sys.modules["celery.concurrency.eventlet"] = prev_eventlet
-            os.environ["EVENTLET_NOPATCH"] = "yes"
+            sys.modules['celery.concurrency.eventlet'] = prev_eventlet
+            os.environ['EVENTLET_NOPATCH'] = 'yes'
             self.eventlet.monkey_patch = prev_monkey_patch
 
 
 eventlet_modules = (
-    "eventlet",
-    "eventlet.debug",
-    "eventlet.greenthread",
-    "eventlet.greenpool",
-    "greenlet",
+    'eventlet',
+    'eventlet.debug',
+    'eventlet.greenthread',
+    'eventlet.greenpool',
+    'greenlet',
 )
 
 
@@ -59,8 +59,8 @@ class test_Schedule(Case):
 
     def test_sched(self):
         with mock_module(*eventlet_modules):
-            with patch_many("eventlet.greenthread.spawn_after",
-                            "greenlet.GreenletExit") as (spawn_after,
+            with patch_many('eventlet.greenthread.spawn_after',
+                            'greenlet.GreenletExit') as (spawn_after,
                                                          GreenletExit):
                 x = Schedule()
                 x.GreenletExit = KeyError
@@ -85,8 +85,8 @@ class test_TasKPool(Case):
 
     def test_pool(self):
         with mock_module(*eventlet_modules):
-            with patch_many("eventlet.greenpool.GreenPool",
-                            "eventlet.greenthread") as (GreenPool,
+            with patch_many('eventlet.greenpool.GreenPool',
+                            'eventlet.greenthread') as (GreenPool,
                                                         greenthread):
                 x = TaskPool()
                 x.on_start()
@@ -96,7 +96,7 @@ class test_TasKPool(Case):
                 x.on_stop()
                 self.assertTrue(x.getpid())
 
-    @patch("celery.concurrency.eventlet.base")
+    @patch('celery.concurrency.eventlet.base')
     def test_apply_target(self, base):
         apply_target(Mock(), getpid=Mock())
         self.assertTrue(base.apply_target.called)

celery/tests/concurrency/test_gevent.py

@@ -15,24 +15,24 @@ from celery.concurrency.gevent import (
 
 from celery.tests.utils import Case, mock_module, patch_many
 gevent_modules = (
-    "gevent",
-    "gevent.monkey",
-    "gevent.greenlet",
-    "gevent.pool",
-    "greenlet",
+    'gevent',
+    'gevent.monkey',
+    'gevent.greenlet',
+    'gevent.pool',
+    'greenlet',
 )
 
 
 class GeventCase(Case):
 
     def setUp(self):
-        if getattr(sys, "pypy_version_info", None):
-            raise SkipTest("Does not work on PyPy")
+        if getattr(sys, 'pypy_version_info', None):
+            raise SkipTest('Does not work on PyPy')
         try:
-            self.eventlet = __import__("gevent")
+            self.eventlet = __import__('gevent')
         except ImportError:
             raise SkipTest(
-                "gevent not installed, skipping related tests.")
+                'gevent not installed, skipping related tests.')
 
 
 class test_gevent_patch(GeventCase):
@@ -43,14 +43,14 @@ class test_gevent_patch(GeventCase):
             from gevent import monkey
             prev_monkey_patch = monkey.patch_all
             monkey.patch_all = lambda: monkey_patched.append(True)
-            prev_gevent = sys.modules.pop("celery.concurrency.gevent", None)
-            os.environ.pop("GEVENT_NOPATCH")
+            prev_gevent = sys.modules.pop('celery.concurrency.gevent', None)
+            os.environ.pop('GEVENT_NOPATCH')
             try:
                 import celery.concurrency.gevent  # noqa
                 self.assertTrue(monkey_patched)
             finally:
-                sys.modules["celery.concurrency.gevent"] = prev_gevent
-                os.environ["GEVENT_NOPATCH"] = "yes"
+                sys.modules['celery.concurrency.gevent'] = prev_gevent
+                os.environ['GEVENT_NOPATCH'] = 'yes'
                 monkey.patch_all = prev_monkey_patch
 
 
@@ -58,8 +58,8 @@ class test_Schedule(Case):
 
     def test_sched(self):
         with mock_module(*gevent_modules):
-            with patch_many("gevent.greenlet",
-                    "gevent.greenlet.GreenletExit") as (greenlet,
+            with patch_many('gevent.greenlet',
+                    'gevent.greenlet.GreenletExit') as (greenlet,
                                                         GreenletExit):
                 greenlet.Greenlet = object
                 x = Schedule()
@@ -85,7 +85,7 @@ class test_TasKPool(Case):
 
     def test_pool(self):
         with mock_module(*gevent_modules):
-            with patch_many("gevent.spawn_raw", "gevent.pool.Pool") as (
+            with patch_many('gevent.spawn_raw', 'gevent.pool.Pool') as (
                     spawn_raw, Pool):
                 x = TaskPool()
                 x.on_start()

celery/tests/concurrency/test_pool.py

@@ -19,7 +19,7 @@ def long_something():
 
 def raise_something(i):
     try:
-        raise KeyError("FOO EXCEPTION")
+        raise KeyError('FOO EXCEPTION')
     except KeyError:
         return ExceptionInfo()
 
@@ -28,9 +28,9 @@ class test_TaskPool(Case):
 
     def setUp(self):
         try:
-            __import__("multiprocessing")
+            __import__('multiprocessing')
         except ImportError:
-            raise SkipTest("multiprocessing not supported")
+            raise SkipTest('multiprocessing not supported')
         from celery.concurrency.processes import TaskPool
         self.TaskPool = TaskPool
 
@@ -48,7 +48,7 @@ class test_TaskPool(Case):
         def mycallback(ret_value):
             process = proc_counter()
             scratchpad[process] = {}
-            scratchpad[process]["ret_value"] = ret_value
+            scratchpad[process]['ret_value'] = ret_value
 
         myerrback = mycallback
 
@@ -58,26 +58,26 @@ class test_TaskPool(Case):
 
         self.assertEqual(res.get(), 100)
         time.sleep(0.5)
-        self.assertDictContainsSubset({"ret_value": 100},
+        self.assertDictContainsSubset({'ret_value': 100},
                                        scratchpad.get(0))
 
         self.assertIsInstance(res2.get(), ExceptionInfo)
         self.assertTrue(scratchpad.get(1))
         time.sleep(1)
-        self.assertIsInstance(scratchpad[1]["ret_value"],
+        self.assertIsInstance(scratchpad[1]['ret_value'],
                               ExceptionInfo)
-        self.assertEqual(scratchpad[1]["ret_value"].exception.args,
-                          ("FOO EXCEPTION", ))
+        self.assertEqual(scratchpad[1]['ret_value'].exception.args,
+                          ('FOO EXCEPTION', ))
 
         self.assertEqual(res3.get(), 400)
         time.sleep(0.5)
-        self.assertDictContainsSubset({"ret_value": 400},
+        self.assertDictContainsSubset({'ret_value': 400},
                                        scratchpad.get(2))
 
         res3 = p.apply_async(do_something, args=[30], callback=mycallback)
 
         self.assertEqual(res3.get(), 900)
         time.sleep(0.5)
-        self.assertDictContainsSubset({"ret_value": 900},
+        self.assertDictContainsSubset({'ret_value': 900},
                                        scratchpad.get(3))
         p.stop()

celery/tests/concurrency/test_processes.py

@@ -66,13 +66,13 @@ class MockPool(object):
     def __init__(self, *args, **kwargs):
         self.started = True
         self._state = mp.RUN
-        self._processes = kwargs.get("processes")
+        self._processes = kwargs.get('processes')
         self._pool = [Object(pid=i) for i in range(self._processes)]
         self._current_proc = cycle(xrange(self._processes)).next
 
     def close(self):
         self.closed = True
-        self._state = "CLOSE"
+        self._state = 'CLOSE'
 
     def join(self):
         self.joined = True
@@ -113,7 +113,7 @@ class test_TaskPool(Case):
         try:
             import multiprocessing  # noqa
         except ImportError:
-            raise SkipTest("multiprocessing not supported")
+            raise SkipTest('multiprocessing not supported')
 
     def test_start(self):
         pool = TaskPool(10)
@@ -135,7 +135,7 @@ class test_TaskPool(Case):
 
     def test_safe_apply_callback(self):
         if safe_apply_callback is None:
-            raise SkipTest("multiprocessig not supported")
+            raise SkipTest('multiprocessig not supported')
         _good_called = [0]
         _evil_called = [0]
 
@@ -159,7 +159,7 @@ class test_TaskPool(Case):
 
     def test_terminate_job(self):
 
-        @patch("celery.concurrency.processes._kill")
+        @patch('celery.concurrency.processes._kill')
         def _do_test(_kill):
             pool = TaskPool(10)
             pool.terminate_job(1341)
@@ -184,9 +184,9 @@ class test_TaskPool(Case):
                             timeout=10,
                             soft_timeout=5)
         info = pool.info
-        self.assertEqual(info["max-concurrency"], pool.limit)
-        self.assertIsNone(info["max-tasks-per-child"])
-        self.assertEqual(info["timeouts"], (5, 10))
+        self.assertEqual(info['max-concurrency'], pool.limit)
+        self.assertIsNone(info['max-tasks-per-child'])
+        self.assertEqual(info['timeouts'], (5, 10))
 
     def test_num_processes(self):
         pool = TaskPool(7)
@@ -200,7 +200,7 @@ class test_TaskPool(Case):
         pool._pool.restart.assert_called_with()
 
     def test_restart(self):
-        raise SkipTest("functional test")
+        raise SkipTest('functional test')
 
         def get_pids(pool):
             return set([p.pid for p in pool._pool._pool])

celery/tests/concurrency/test_threads.py

@@ -12,49 +12,49 @@ class test_NullDict(Case):
 
     def test_setitem(self):
         x = NullDict()
-        x["foo"] = 1
+        x['foo'] = 1
         with self.assertRaises(KeyError):
-            x["foo"]
+            x['foo']
 
 
 class test_TaskPool(Case):
 
     def test_without_threadpool(self):
 
-        with mask_modules("threadpool"):
+        with mask_modules('threadpool'):
             with self.assertRaises(ImportError):
                 TaskPool()
 
     def test_with_threadpool(self):
-        with mock_module("threadpool"):
+        with mock_module('threadpool'):
             x = TaskPool()
             self.assertTrue(x.ThreadPool)
             self.assertTrue(x.WorkRequest)
 
     def test_on_start(self):
-        with mock_module("threadpool"):
+        with mock_module('threadpool'):
             x = TaskPool()
             x.on_start()
             self.assertTrue(x._pool)
             self.assertIsInstance(x._pool.workRequests, NullDict)
 
     def test_on_stop(self):
-        with mock_module("threadpool"):
+        with mock_module('threadpool'):
             x = TaskPool()
             x.on_start()
             x.on_stop()
             x._pool.dismissWorkers.assert_called_with(x.limit, do_join=True)
 
     def test_on_apply(self):
-        with mock_module("threadpool"):
+        with mock_module('threadpool'):
             x = TaskPool()
             x.on_start()
             callback = Mock()
             accept_callback = Mock()
             target = Mock()
-            req = x.on_apply(target, args=(1, 2), kwargs={"a": 10},
+            req = x.on_apply(target, args=(1, 2), kwargs={'a': 10},
                 callback=callback, accept_callback=accept_callback)
             x.WorkRequest.assert_called_with(apply_target, (
-                target, (1, 2), {"a": 10}, callback, accept_callback))
+                target, (1, 2), {'a': 10}, callback, accept_callback))
             x._pool.putRequest.assert_called_with(req)
             x._pool._results_queue.queue.clear.assert_called_with()

celery/tests/config.py

@@ -4,24 +4,24 @@ import os
 
 from kombu import Queue
 
-BROKER_URL = "memory://"
+BROKER_URL = 'memory://'
 
 #: warn if config module not found
-os.environ["C_WNOCONF"] = "yes"
+os.environ['C_WNOCONF'] = 'yes'
 
 #: Don't want log output when running suite.
 CELERYD_HIJACK_ROOT_LOGGER = False
 
-CELERY_RESULT_BACKEND = "cache"
-CELERY_CACHE_BACKEND = "memory"
-CELERY_RESULT_DBURI = "sqlite:///test.db"
+CELERY_RESULT_BACKEND = 'cache'
+CELERY_CACHE_BACKEND = 'memory'
+CELERY_RESULT_DBURI = 'sqlite:///test.db'
 CELERY_SEND_TASK_ERROR_EMAILS = False
 
-CELERY_DEFAULT_QUEUE = "testcelery"
-CELERY_DEFAULT_EXCHANGE = "testcelery"
-CELERY_DEFAULT_ROUTING_KEY = "testcelery"
+CELERY_DEFAULT_QUEUE = 'testcelery'
+CELERY_DEFAULT_EXCHANGE = 'testcelery'
+CELERY_DEFAULT_ROUTING_KEY = 'testcelery'
 CELERY_QUEUES = (
-    Queue("testcelery", routing_key="testcelery"),
+    Queue('testcelery', routing_key='testcelery'),
 )
 
 CELERY_ENABLE_UTC = True
@@ -29,25 +29,25 @@ CELERY_ENABLE_UTC = True
 CELERYD_LOG_COLOR = False
 
 # Tyrant results tests (only executed if installed and running)
-TT_HOST = os.environ.get("TT_HOST") or "localhost"
-TT_PORT = int(os.environ.get("TT_PORT") or 1978)
+TT_HOST = os.environ.get('TT_HOST') or 'localhost'
+TT_PORT = int(os.environ.get('TT_PORT') or 1978)
 
 # Redis results tests (only executed if installed and running)
-CELERY_REDIS_HOST = os.environ.get("REDIS_HOST") or "localhost"
-CELERY_REDIS_PORT = int(os.environ.get("REDIS_PORT") or 6379)
-CELERY_REDIS_DB = os.environ.get("REDIS_DB") or 0
-CELERY_REDIS_PASSWORD = os.environ.get("REDIS_PASSWORD")
+CELERY_REDIS_HOST = os.environ.get('REDIS_HOST') or 'localhost'
+CELERY_REDIS_PORT = int(os.environ.get('REDIS_PORT') or 6379)
+CELERY_REDIS_DB = os.environ.get('REDIS_DB') or 0
+CELERY_REDIS_PASSWORD = os.environ.get('REDIS_PASSWORD')
 
 # Mongo results tests (only executed if installed and running)
 CELERY_MONGODB_BACKEND_SETTINGS = {
-    "host": os.environ.get("MONGO_HOST") or "localhost",
-    "port": os.environ.get("MONGO_PORT") or 27017,
-    "database": os.environ.get("MONGO_DB") or "celery_unittests",
-    "taskmeta_collection": os.environ.get("MONGO_TASKMETA_COLLECTION") or
-        "taskmeta_collection",
+    'host': os.environ.get('MONGO_HOST') or 'localhost',
+    'port': os.environ.get('MONGO_PORT') or 27017,
+    'database': os.environ.get('MONGO_DB') or 'celery_unittests',
+    'taskmeta_collection': os.environ.get('MONGO_TASKMETA_COLLECTION') or
+        'taskmeta_collection',
 }
-if os.environ.get("MONGO_USER"):
-    CELERY_MONGODB_BACKEND_SETTINGS["user"] = os.environ.get("MONGO_USER")
-if os.environ.get("MONGO_PASSWORD"):
-    CELERY_MONGODB_BACKEND_SETTINGS["password"] = \
-        os.environ.get("MONGO_PASSWORD")
+if os.environ.get('MONGO_USER'):
+    CELERY_MONGODB_BACKEND_SETTINGS['user'] = os.environ.get('MONGO_USER')
+if os.environ.get('MONGO_PASSWORD'):
+    CELERY_MONGODB_BACKEND_SETTINGS['password'] = \
+        os.environ.get('MONGO_PASSWORD')

celery/tests/contrib/test_abortable.py

@@ -28,7 +28,7 @@ class test_AbortableTask(Case):
     def test_is_aborted_not_abort_result(self):
         t = MyAbortableTask()
         t.AsyncResult = AsyncResult
-        t.request.id = "foo"
+        t.request.id = 'foo'
         self.assertFalse(t.is_aborted())
 
     def test_abort_yields_aborted(self):

celery/tests/contrib/test_migrate.py

@@ -14,9 +14,9 @@ from celery.utils.encoding import bytes_t, ensure_bytes
 from celery.tests.utils import AppCase, Case, Mock
 
 
-def Message(body, exchange="exchange", routing_key="rkey",
-        compression=None, content_type="application/json",
-        content_encoding="utf-8"):
+def Message(body, exchange='exchange', routing_key='rkey',
+        compression=None, content_type='application/json',
+        content_encoding='utf-8'):
     return Mock(attrs=dict(body=body,
         delivery_info=dict(exchange=exchange, routing_key=routing_key),
         headers=dict(compression=compression),
@@ -28,72 +28,72 @@ class test_State(Case):
 
     def test_strtotal(self):
         x = State()
-        self.assertEqual(x.strtotal, u"?")
+        self.assertEqual(x.strtotal, u'?')
         x.total_apx = 100
-        self.assertEqual(x.strtotal, u"100")
+        self.assertEqual(x.strtotal, u'100')
 
 
 class test_migrate_task(Case):
 
     def test_removes_compression_header(self):
-        x = Message("foo", compression="zlib")
+        x = Message('foo', compression='zlib')
         producer = Mock()
         migrate_task(producer, x.body, x)
         self.assertTrue(producer.publish.called)
         args, kwargs = producer.publish.call_args
         self.assertIsInstance(args[0], bytes_t)
-        self.assertNotIn("compression", kwargs["headers"])
-        self.assertEqual(kwargs["compression"], "zlib")
-        self.assertEqual(kwargs["content_type"], "application/json")
-        self.assertEqual(kwargs["content_encoding"], "utf-8")
-        self.assertEqual(kwargs["exchange"], "exchange")
-        self.assertEqual(kwargs["routing_key"], "rkey")
+        self.assertNotIn('compression', kwargs['headers'])
+        self.assertEqual(kwargs['compression'], 'zlib')
+        self.assertEqual(kwargs['content_type'], 'application/json')
+        self.assertEqual(kwargs['content_encoding'], 'utf-8')
+        self.assertEqual(kwargs['exchange'], 'exchange')
+        self.assertEqual(kwargs['routing_key'], 'rkey')
 
 
 class test_migrate_tasks(AppCase):
 
-    def test_migrate(self, name="testcelery"):
-        x = BrokerConnection("memory://foo")
-        y = BrokerConnection("memory://foo")
+    def test_migrate(self, name='testcelery'):
+        x = BrokerConnection('memory://foo')
+        y = BrokerConnection('memory://foo')
         # use separate state
         x.default_channel.queues = {}
         y.default_channel.queues = {}
 
-        ex = Exchange(name, "direct")
+        ex = Exchange(name, 'direct')
         q = Queue(name, exchange=ex, routing_key=name)
         q(x.default_channel).declare()
-        Producer(x).publish("foo", exchange=name, routing_key=name)
-        Producer(x).publish("bar", exchange=name, routing_key=name)
-        Producer(x).publish("baz", exchange=name, routing_key=name)
+        Producer(x).publish('foo', exchange=name, routing_key=name)
+        Producer(x).publish('bar', exchange=name, routing_key=name)
+        Producer(x).publish('baz', exchange=name, routing_key=name)
         self.assertTrue(x.default_channel.queues)
         self.assertFalse(y.default_channel.queues)
 
         migrate_tasks(x, y)
 
         yq = q(y.default_channel)
-        self.assertEqual(yq.get().body, ensure_bytes("foo"))
-        self.assertEqual(yq.get().body, ensure_bytes("bar"))
-        self.assertEqual(yq.get().body, ensure_bytes("baz"))
+        self.assertEqual(yq.get().body, ensure_bytes('foo'))
+        self.assertEqual(yq.get().body, ensure_bytes('bar'))
+        self.assertEqual(yq.get().body, ensure_bytes('baz'))
 
-        Producer(x).publish("foo", exchange=name, routing_key=name)
+        Producer(x).publish('foo', exchange=name, routing_key=name)
         callback = Mock()
         migrate_tasks(x, y, callback=callback)
         self.assertTrue(callback.called)
         migrate = Mock()
-        Producer(x).publish("baz", exchange=name, routing_key=name)
+        Producer(x).publish('baz', exchange=name, routing_key=name)
         migrate_tasks(x, y, callback=callback, migrate=migrate)
         self.assertTrue(migrate.called)
 
-        with patch("kombu.transport.virtual.Channel.queue_declare") as qd:
+        with patch('kombu.transport.virtual.Channel.queue_declare') as qd:
 
             def effect(*args, **kwargs):
-                if kwargs.get("passive"):
+                if kwargs.get('passive'):
                     raise StdChannelError()
                 return 0, 3, 0
             qd.side_effect = effect
             migrate_tasks(x, y)
 
-        x = BrokerConnection("memory://")
+        x = BrokerConnection('memory://')
         x.default_channel.queues = {}
         y.default_channel.queues = {}
         callback = Mock()

celery/tests/contrib/test_rdb.py

@@ -16,37 +16,37 @@ from celery.tests.utils import Case, WhateverIO
 
 class test_Rdb(Case):
 
-    @patch("celery.contrib.rdb.Rdb")
+    @patch('celery.contrib.rdb.Rdb')
     def test_debugger(self, Rdb):
         x = debugger()
         self.assertTrue(x)
         self.assertIs(x, debugger())
 
-    @patch("celery.contrib.rdb.debugger")
-    @patch("celery.contrib.rdb._frame")
+    @patch('celery.contrib.rdb.debugger')
+    @patch('celery.contrib.rdb._frame')
     def test_set_trace(self, _frame, debugger):
         self.assertTrue(set_trace(Mock()))
         self.assertTrue(set_trace())
         self.assertTrue(debugger.return_value.set_trace.called)
 
-    @patch("celery.contrib.rdb.Rdb.get_avail_port")
+    @patch('celery.contrib.rdb.Rdb.get_avail_port')
     def test_rdb(self, get_avail_port):
         sock = Mock()
         get_avail_port.return_value = (sock, 8000)
-        sock.accept.return_value = (Mock(), ["helu"])
+        sock.accept.return_value = (Mock(), ['helu'])
         out = WhateverIO()
         rdb = Rdb(out=out)
         self.assertTrue(get_avail_port.called)
-        self.assertIn("helu", out.getvalue())
+        self.assertIn('helu', out.getvalue())
 
         # set_quit
-        with patch("sys.settrace") as settrace:
+        with patch('sys.settrace') as settrace:
             rdb.set_quit()
             settrace.assert_called_with(None)
 
         # set_trace
-        with patch("celery.contrib.rdb.Pdb.set_trace") as pset:
-            with patch("celery.contrib.rdb._frame"):
+        with patch('celery.contrib.rdb.Pdb.set_trace') as pset:
+            with patch('celery.contrib.rdb._frame'):
                 rdb.set_trace()
                 rdb.set_trace(Mock())
                 pset.side_effect = socket.error
@@ -69,14 +69,14 @@ class test_Rdb(Case):
         rdb.do_quit(Mock())
         rdb.set_quit.assert_called_with()
 
-    @patch("socket.socket")
+    @patch('socket.socket')
     def test_get_avail_port(self, sock):
         out = WhateverIO()
-        sock.return_value.accept.return_value = (Mock(), ["helu"])
+        sock.return_value.accept.return_value = (Mock(), ['helu'])
         Rdb(out=out)
 
-        with patch("celery.contrib.rdb.current_process") as curproc:
-            curproc.return_value.name = "PoolWorker-10"
+        with patch('celery.contrib.rdb.current_process') as curproc:
+            curproc.return_value.name = 'PoolWorker-10'
             Rdb(out=out)
 
         err = sock.return_value.bind.side_effect = socket.error()

celery/tests/events/test_cursesmon.py

@@ -17,7 +17,7 @@ class test_CursesDisplay(Case):
         try:
             import curses  # noqa
         except ImportError:
-            raise SkipTest("curses monitor requires curses")
+            raise SkipTest('curses monitor requires curses')
 
         from celery.events import cursesmon
         self.monitor = cursesmon.CursesMonitor(object())
@@ -50,8 +50,8 @@ class test_CursesDisplay(Case):
 
     def test_format_title_row(self):
         self.win.x, self.win.y = 80, 24
-        row = self.monitor.format_row("UUID", "TASK",
-                                      "WORKER", "TIME", "STATE")
+        row = self.monitor.format_row('UUID', 'TASK',
+                                      'WORKER', 'TIME', 'STATE')
         self.assertEqual('UUID                      WORKER          '
                          'TASK             TIME     STATE   ',
                          row)

celery/tests/events/test_events.py

@@ -25,7 +25,7 @@ class MockProducer(object):
 
     def has_event(self, kind):
         for event in self.sent:
-            if event["type"] == kind:
+            if event['type'] == kind:
                 return event
         return False
 
@@ -33,9 +33,9 @@ class MockProducer(object):
 class test_Event(AppCase):
 
     def test_constructor(self):
-        event = events.Event("world war II")
-        self.assertEqual(event["type"], "world war II")
-        self.assertTrue(event["timestamp"])
+        event = events.Event('world war II')
+        self.assertEqual(event['type'], 'world war II')
+        self.assertTrue(event['timestamp'])
 
 
 class test_EventDispatcher(AppCase):
@@ -45,18 +45,18 @@ class test_EventDispatcher(AppCase):
         eventer = self.app.events.Dispatcher(object(), enabled=False)
         eventer.publisher = producer
         eventer.enabled = True
-        eventer.send("World War II", ended=True)
-        self.assertTrue(producer.has_event("World War II"))
+        eventer.send('World War II', ended=True)
+        self.assertTrue(producer.has_event('World War II'))
         eventer.enabled = False
-        eventer.send("World War III")
-        self.assertFalse(producer.has_event("World War III"))
+        eventer.send('World War III')
+        self.assertFalse(producer.has_event('World War III'))
 
-        evs = ("Event 1", "Event 2", "Event 3")
+        evs = ('Event 1', 'Event 2', 'Event 3')
         eventer.enabled = True
         eventer.publisher.raise_on_publish = True
         eventer.buffer_while_offline = False
         with self.assertRaises(KeyError):
-            eventer.send("Event X")
+            eventer.send('Event X')
         eventer.buffer_while_offline = True
         for ev in evs:
             eventer.send(ev)
@@ -110,7 +110,7 @@ class test_EventDispatcher(AppCase):
             self.assertFalse(dispatcher.enabled)
             self.assertIsNone(dispatcher.publisher)
             self.assertFalse(dispatcher2.channel.closed,
-                             "does not close manually provided channel")
+                             'does not close manually provided channel')
 
             dispatcher.enable()
             self.assertTrue(dispatcher.enabled)
@@ -125,7 +125,7 @@ class test_EventReceiver(AppCase):
 
     def test_process(self):
 
-        message = {"type": "world-war"}
+        message = {'type': 'world-war'}
 
         got_event = [False]
 
@@ -133,16 +133,16 @@ class test_EventReceiver(AppCase):
             got_event[0] = True
 
         connection = Mock()
-        connection.transport_cls = "memory"
+        connection.transport_cls = 'memory'
         r = events.EventReceiver(connection,
-                                 handlers={"world-war": my_handler},
-                                 node_id="celery.tests")
+                                 handlers={'world-war': my_handler},
+                                 node_id='celery.tests')
         r._receive(message, object())
         self.assertTrue(got_event[0])
 
     def test_catch_all_event(self):
 
-        message = {"type": "world-war"}
+        message = {'type': 'world-war'}
 
         got_event = [False]
 
@@ -150,9 +150,9 @@ class test_EventReceiver(AppCase):
             got_event[0] = True
 
         connection = Mock()
-        connection.transport_cls = "memory"
-        r = events.EventReceiver(connection, node_id="celery.tests")
-        events.EventReceiver.handlers["*"] = my_handler
+        connection.transport_cls = 'memory'
+        r = events.EventReceiver(connection, node_id='celery.tests')
+        events.EventReceiver.handlers['*'] = my_handler
         try:
             r._receive(message, object())
             self.assertTrue(got_event[0])
@@ -162,7 +162,7 @@ class test_EventReceiver(AppCase):
     def test_itercapture(self):
         connection = self.app.broker_connection()
         try:
-            r = self.app.events.Receiver(connection, node_id="celery.tests")
+            r = self.app.events.Receiver(connection, node_id='celery.tests')
             it = r.itercapture(timeout=0.0001, wakeup=False)
             consumer = it.next()
             self.assertTrue(consumer.queues)
@@ -189,9 +189,9 @@ class test_EventReceiver(AppCase):
                                                   enabled=True,
                                                   channel=channel)
             r = self.app.events.Receiver(connection,
-                                         handlers={"*": handler},
-                                         node_id="celery.tests")
-            evs = ["ev1", "ev2", "ev3", "ev4", "ev5"]
+                                         handlers={'*': handler},
+                                         node_id='celery.tests')
+            evs = ['ev1', 'ev2', 'ev3', 'ev4', 'ev5']
             for ev in evs:
                 producer.send(ev)
             it = r.itercapture(limit=4, wakeup=True)

celery/tests/events/test_snapshot.py

@@ -86,7 +86,7 @@ class test_Polaroid(Case):
         self.assertTrue(shutter_signal_sent[0])
 
     def test_shutter_maxrate(self):
-        x = Polaroid(self.state, app=self.app, maxrate="1/h")
+        x = Polaroid(self.state, app=self.app, maxrate='1/h')
         shutter_signal_sent = [0]
 
         def handler(**kwargs):
@@ -124,7 +124,7 @@ class test_evcam(Case):
 
     def test_evcam(self):
         evcam(Polaroid, timer=timer)
-        evcam(Polaroid, timer=timer, loglevel="CRITICAL")
+        evcam(Polaroid, timer=timer, loglevel='CRITICAL')
         self.MockReceiver.raise_keyboard_interrupt = True
         try:
             with self.assertRaises(SystemExit):
@@ -132,7 +132,7 @@ class test_evcam(Case):
         finally:
             self.MockReceiver.raise_keyboard_interrupt = False
 
-    @patch("celery.platforms.create_pidlock")
+    @patch('celery.platforms.create_pidlock')
     def test_evcam_pidfile(self, create_pidlock):
-        evcam(Polaroid, timer=timer, pidfile="/var/pid")
-        create_pidlock.assert_called_with("/var/pid")
+        evcam(Polaroid, timer=timer, pidfile='/var/pid')
+        create_pidlock.assert_called_with('/var/pid')

celery/tests/events/test_state.py

@@ -44,8 +44,8 @@ class ev_worker_online_offline(replay):
 
     def setup(self):
         self.events = [
-            Event("worker-online", hostname="utest1"),
-            Event("worker-offline", hostname="utest1"),
+            Event('worker-online', hostname='utest1'),
+            Event('worker-offline', hostname='utest1'),
         ]
 
 
@@ -53,9 +53,9 @@ class ev_worker_heartbeats(replay):
 
     def setup(self):
         self.events = [
-            Event("worker-heartbeat", hostname="utest1",
+            Event('worker-heartbeat', hostname='utest1',
                 timestamp=time() - HEARTBEAT_EXPIRE_WINDOW * 2),
-            Event("worker-heartbeat", hostname="utest1"),
+            Event('worker-heartbeat', hostname='utest1'),
         ]
 
 
@@ -64,17 +64,17 @@ class ev_task_states(replay):
     def setup(self):
         tid = self.tid = uuid()
         self.events = [
-            Event("task-received", uuid=tid, name="task1",
-                args="(2, 2)", kwargs="{'foo': 'bar'}",
-                retries=0, eta=None, hostname="utest1"),
-            Event("task-started", uuid=tid, hostname="utest1"),
-            Event("task-revoked", uuid=tid, hostname="utest1"),
-            Event("task-retried", uuid=tid, exception="KeyError('bar')",
-                traceback="line 2 at main", hostname="utest1"),
-            Event("task-failed", uuid=tid, exception="KeyError('foo')",
-                traceback="line 1 at main", hostname="utest1"),
-            Event("task-succeeded", uuid=tid, result="4",
-                runtime=0.1234, hostname="utest1"),
+            Event('task-received', uuid=tid, name='task1',
+                args='(2, 2)', kwargs="{'foo': 'bar'}",
+                retries=0, eta=None, hostname='utest1'),
+            Event('task-started', uuid=tid, hostname='utest1'),
+            Event('task-revoked', uuid=tid, hostname='utest1'),
+            Event('task-retried', uuid=tid, exception="KeyError('bar')",
+                traceback='line 2 at main', hostname='utest1'),
+            Event('task-failed', uuid=tid, exception="KeyError('foo')",
+                traceback='line 1 at main', hostname='utest1'),
+            Event('task-succeeded', uuid=tid, result='4',
+                runtime=0.1234, hostname='utest1'),
         ]
 
 
@@ -82,35 +82,35 @@ class ev_snapshot(replay):
 
     def setup(self):
         self.events = [
-            Event("worker-online", hostname="utest1"),
-            Event("worker-online", hostname="utest2"),
-            Event("worker-online", hostname="utest3"),
+            Event('worker-online', hostname='utest1'),
+            Event('worker-online', hostname='utest2'),
+            Event('worker-online', hostname='utest3'),
         ]
         for i in range(20):
-            worker = not i % 2 and "utest2" or "utest1"
-            type = not i % 2 and "task2" or "task1"
-            self.events.append(Event("task-received", name=type,
+            worker = not i % 2 and 'utest2' or 'utest1'
+            type = not i % 2 and 'task2' or 'task1'
+            self.events.append(Event('task-received', name=type,
                           uuid=uuid(), hostname=worker))
 
 
 class test_Worker(Case):
 
     def test_survives_missing_timestamp(self):
-        worker = Worker(hostname="foo")
+        worker = Worker(hostname='foo')
         worker.on_heartbeat(timestamp=None)
         self.assertEqual(worker.heartbeats, [])
 
     def test_repr(self):
-        self.assertTrue(repr(Worker(hostname="foo")))
+        self.assertTrue(repr(Worker(hostname='foo')))
 
 
 class test_Task(Case):
 
     def test_info(self):
-        task = Task(uuid="abcdefg",
-                    name="tasks.add",
-                    args="(2, 2)",
-                    kwargs="{}",
+        task = Task(uuid='abcdefg',
+                    name='tasks.add',
+                    args='(2, 2)',
+                    kwargs='{}',
                     retries=2,
                     result=42,
                     eta=1,
@@ -123,23 +123,23 @@ class test_Task(Case):
         self.assertEqual(sorted(list(task._info_fields)),
                               sorted(task.info().keys()))
 
-        self.assertEqual(sorted(list(task._info_fields + ("received", ))),
-                              sorted(task.info(extra=("received", ))))
+        self.assertEqual(sorted(list(task._info_fields + ('received', ))),
+                              sorted(task.info(extra=('received', ))))
 
-        self.assertEqual(sorted(["args", "kwargs"]),
-                         sorted(task.info(["args", "kwargs"]).keys()))
+        self.assertEqual(sorted(['args', 'kwargs']),
+                         sorted(task.info(['args', 'kwargs']).keys()))
 
     def test_ready(self):
-        task = Task(uuid="abcdefg",
-                    name="tasks.add")
+        task = Task(uuid='abcdefg',
+                    name='tasks.add')
         task.on_received(timestamp=time())
         self.assertFalse(task.ready)
         task.on_succeeded(timestamp=time())
         self.assertTrue(task.ready)
 
     def test_sent(self):
-        task = Task(uuid="abcdefg",
-                    name="tasks.add")
+        task = Task(uuid='abcdefg',
+                    name='tasks.add')
         task.on_sent(timestamp=time())
         self.assertEqual(task.state, states.PENDING)
 
@@ -147,15 +147,15 @@ class test_Task(Case):
         task = Task()
         task.on_failed(timestamp=time())
         task.on_started(timestamp=time())
-        task.on_received(timestamp=time(), name="tasks.add", args=(2, 2))
+        task.on_received(timestamp=time(), name='tasks.add', args=(2, 2))
         self.assertEqual(task.state, states.FAILURE)
-        self.assertEqual(task.name, "tasks.add")
+        self.assertEqual(task.name, 'tasks.add')
         self.assertTupleEqual(task.args, (2, 2))
         task.on_retried(timestamp=time())
         self.assertEqual(task.state, states.RETRY)
 
     def test_repr(self):
-        self.assertTrue(repr(Task(uuid="xxx", name="tasks.add")))
+        self.assertTrue(repr(Task(uuid='xxx', name='tasks.add')))
 
 
 class test_State(Case):
@@ -167,24 +167,24 @@ class test_State(Case):
         r = ev_worker_online_offline(State())
         r.next()
         self.assertTrue(r.state.alive_workers())
-        self.assertTrue(r.state.workers["utest1"].alive)
+        self.assertTrue(r.state.workers['utest1'].alive)
         r.play()
         self.assertFalse(r.state.alive_workers())
-        self.assertFalse(r.state.workers["utest1"].alive)
+        self.assertFalse(r.state.workers['utest1'].alive)
 
     def test_itertasks(self):
         s = State()
-        s.tasks = {"a": "a", "b": "b", "c": "c", "d": "d"}
+        s.tasks = {'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd'}
         self.assertEqual(len(list(s.itertasks(limit=2))), 2)
 
     def test_worker_heartbeat_expire(self):
         r = ev_worker_heartbeats(State())
         r.next()
         self.assertFalse(r.state.alive_workers())
-        self.assertFalse(r.state.workers["utest1"].alive)
+        self.assertFalse(r.state.workers['utest1'].alive)
         r.play()
         self.assertTrue(r.state.alive_workers())
-        self.assertTrue(r.state.workers["utest1"].alive)
+        self.assertTrue(r.state.workers['utest1'].alive)
 
     def test_task_states(self):
         r = ev_task_states(State())
@@ -196,49 +196,49 @@ class test_State(Case):
         self.assertEqual(task.state, states.RECEIVED)
         self.assertTrue(task.received)
         self.assertEqual(task.timestamp, task.received)
-        self.assertEqual(task.worker.hostname, "utest1")
+        self.assertEqual(task.worker.hostname, 'utest1')
 
         # STARTED
         r.next()
-        self.assertTrue(r.state.workers["utest1"].alive,
-                "any task event adds worker heartbeat")
+        self.assertTrue(r.state.workers['utest1'].alive,
+                'any task event adds worker heartbeat')
         self.assertEqual(task.state, states.STARTED)
         self.assertTrue(task.started)
         self.assertEqual(task.timestamp, task.started)
-        self.assertEqual(task.worker.hostname, "utest1")
+        self.assertEqual(task.worker.hostname, 'utest1')
 
         # REVOKED
         r.next()
         self.assertEqual(task.state, states.REVOKED)
         self.assertTrue(task.revoked)
         self.assertEqual(task.timestamp, task.revoked)
-        self.assertEqual(task.worker.hostname, "utest1")
+        self.assertEqual(task.worker.hostname, 'utest1')
 
         # RETRY
         r.next()
         self.assertEqual(task.state, states.RETRY)
         self.assertTrue(task.retried)
         self.assertEqual(task.timestamp, task.retried)
-        self.assertEqual(task.worker.hostname, "utest1")
+        self.assertEqual(task.worker.hostname, 'utest1')
         self.assertEqual(task.exception, "KeyError('bar')")
-        self.assertEqual(task.traceback, "line 2 at main")
+        self.assertEqual(task.traceback, 'line 2 at main')
 
         # FAILURE
         r.next()
         self.assertEqual(task.state, states.FAILURE)
         self.assertTrue(task.failed)
         self.assertEqual(task.timestamp, task.failed)
-        self.assertEqual(task.worker.hostname, "utest1")
+        self.assertEqual(task.worker.hostname, 'utest1')
         self.assertEqual(task.exception, "KeyError('foo')")
-        self.assertEqual(task.traceback, "line 1 at main")
+        self.assertEqual(task.traceback, 'line 1 at main')
 
         # SUCCESS
         r.next()
         self.assertEqual(task.state, states.SUCCESS)
         self.assertTrue(task.succeeded)
         self.assertEqual(task.timestamp, task.succeeded)
-        self.assertEqual(task.worker.hostname, "utest1")
-        self.assertEqual(task.result, "4")
+        self.assertEqual(task.worker.hostname, 'utest1')
+        self.assertEqual(task.result, '4')
         self.assertEqual(task.runtime, 0.1234)
 
     def assertStateEmpty(self, state):
@@ -298,7 +298,7 @@ class test_State(Case):
     def test_task_types(self):
         r = ev_snapshot(State())
         r.play()
-        self.assertEqual(sorted(r.state.task_types()), ["task1", "task2"])
+        self.assertEqual(sorted(r.state.task_types()), ['task1', 'task2'])
 
     def test_tasks_by_timestamp(self):
         r = ev_snapshot(State())
@@ -308,8 +308,8 @@ class test_State(Case):
     def test_tasks_by_type(self):
         r = ev_snapshot(State())
         r.play()
-        self.assertEqual(len(r.state.tasks_by_type("task1")), 10)
-        self.assertEqual(len(r.state.tasks_by_type("task2")), 10)
+        self.assertEqual(len(r.state.tasks_by_type('task1')), 10)
+        self.assertEqual(len(r.state.tasks_by_type('task2')), 10)
 
     def test_alive_workers(self):
         r = ev_snapshot(State())
@@ -319,27 +319,27 @@ class test_State(Case):
     def test_tasks_by_worker(self):
         r = ev_snapshot(State())
         r.play()
-        self.assertEqual(len(r.state.tasks_by_worker("utest1")), 10)
-        self.assertEqual(len(r.state.tasks_by_worker("utest2")), 10)
+        self.assertEqual(len(r.state.tasks_by_worker('utest1')), 10)
+        self.assertEqual(len(r.state.tasks_by_worker('utest2')), 10)
 
     def test_survives_unknown_worker_event(self):
         s = State()
-        s.worker_event("worker-unknown-event-xxx", {"foo": "bar"})
-        s.worker_event("worker-unknown-event-xxx", {"hostname": "xxx",
-                                                    "foo": "bar"})
+        s.worker_event('worker-unknown-event-xxx', {'foo': 'bar'})
+        s.worker_event('worker-unknown-event-xxx', {'hostname': 'xxx',
+                                                    'foo': 'bar'})
 
     def test_survives_unknown_task_event(self):
         s = State()
-        s.task_event("task-unknown-event-xxx", {"foo": "bar",
-                                                "uuid": "x",
-                                                "hostname": "y"})
+        s.task_event('task-unknown-event-xxx', {'foo': 'bar',
+                                                'uuid': 'x',
+                                                'hostname': 'y'})
 
     def test_callback(self):
         scratch = {}
 
         def callback(state, event):
-            scratch["recv"] = True
+            scratch['recv'] = True
 
         s = State(callback=callback)
-        s.event({"type": "worker-online"})
-        self.assertTrue(scratch.get("recv"))
+        s.event({'type': 'worker-online'})
+        self.assertTrue(scratch.get('recv'))

celery/tests/functional/case.py

@@ -21,10 +21,10 @@ HOSTNAME = socket.gethostname()
 
 
 def say(msg):
-    sys.stderr.write("%s\n" % msg)
+    sys.stderr.write('%s\n' % msg)
 
 
-def try_while(fun, reason="Timed out", timeout=10, interval=0.5):
+def try_while(fun, reason='Timed out', timeout=10, interval=0.5):
     time_start = time()
     for iterations in count(0):
         if time() - time_start >= timeout:
@@ -39,7 +39,7 @@ class Worker(object):
     next_worker_id = count(1).next
     _shutdown_called = False
 
-    def __init__(self, hostname, loglevel="error"):
+    def __init__(self, hostname, loglevel='error'):
         self.hostname = hostname
         self.loglevel = loglevel
 
@@ -52,9 +52,9 @@ class Worker(object):
         pid = os.fork()
         if pid == 0:
             from celery import current_app
-            current_app.worker_main(["celeryd", "--loglevel=INFO",
-                                                "-n", self.hostname,
-                                                "-P", "solo"])
+            current_app.worker_main(['celeryd', '--loglevel=INFO',
+                                                '-n', self.hostname,
+                                                '-P', 'solo'])
             os._exit(0)
         self.pid = pid
 
@@ -67,14 +67,14 @@ class Worker(object):
         try_while(lambda: self.is_alive(interval),
                 "Worker won't start (after %s secs.)" % timeout,
                 interval=interval, timeout=timeout)
-        say("--WORKER %s IS ONLINE--" % self.hostname)
+        say('--WORKER %s IS ONLINE--' % self.hostname)
 
     def ensure_shutdown(self, timeout=10, interval=0.5):
         os.kill(self.pid, signal.SIGTERM)
         try_while(lambda: not self.is_alive(interval),
                   "Worker won't shutdown (after %s secs.)" % timeout,
                   timeout=10, interval=0.5)
-        say("--WORKER %s IS SHUTDOWN--" % self.hostname)
+        say('--WORKER %s IS SHUTDOWN--' % self.hostname)
         self._shutdown_called = True
 
     def ensure_started(self):
@@ -85,7 +85,7 @@ class Worker(object):
     def managed(cls, hostname=None, caller=None):
         hostname = hostname or socket.gethostname()
         if caller:
-            hostname = ".".join([qualname(caller), hostname])
+            hostname = '.'.join([qualname(caller), hostname])
         else:
             hostname += str(cls.next_worker_id())
         worker = cls(hostname)
@@ -95,9 +95,9 @@ class Worker(object):
         @atexit.register
         def _ensure_shutdown_once():
             if not worker._shutdown_called:
-                say("-- Found worker not stopped at shutdown: %s\n%s" % (
+                say('-- Found worker not stopped at shutdown: %s\n%s' % (
                         worker.hostname,
-                        "\n".join(stack)))
+                        '\n'.join(stack)))
                 worker.ensure_shutdown()
 
         return worker
@@ -109,7 +109,7 @@ class WorkerCase(Case):
 
     @classmethod
     def setUpClass(cls):
-        logging.getLogger("amqplib").setLevel(logging.ERROR)
+        logging.getLogger('amqplib').setLevel(logging.ERROR)
         cls.worker = Worker.managed(cls.hostname, caller=cls)
 
     @classmethod
@@ -129,7 +129,7 @@ class WorkerCase(Case):
         active = self.inspect(timeout=interval).active()
         if active:
             for task in active[self.worker.hostname]:
-                if task["id"] == task_id:
+                if task['id'] == task_id:
                     return True
         return False
 
@@ -137,7 +137,7 @@ class WorkerCase(Case):
         reserved = self.inspect(timeout=interval).reserved()
         if reserved:
             for task in reserved[self.worker.hostname]:
-                if task["id"] == task_id:
+                if task['id'] == task_id:
                     return True
         return False
 
@@ -145,7 +145,7 @@ class WorkerCase(Case):
         schedule = self.inspect(timeout=interval).scheduled()
         if schedule:
             for item in schedule[self.worker.hostname]:
-                if item["request"]["id"] == task_id:
+                if item['request']['id'] == task_id:
                     return True
         return False
 
@@ -156,15 +156,15 @@ class WorkerCase(Case):
 
     def ensure_accepted(self, task_id, interval=0.5, timeout=10):
         return try_while(lambda: self.is_accepted(task_id, interval),
-                         "Task not accepted within timeout",
+                         'Task not accepted within timeout',
                          interval=0.5, timeout=10)
 
     def ensure_received(self, task_id, interval=0.5, timeout=10):
         return try_while(lambda: self.is_received(task_id, interval),
-                        "Task not receied within timeout",
+                        'Task not receied within timeout',
                         interval=0.5, timeout=10)
 
     def ensure_scheduled(self, task_id, interval=0.5, timeout=10):
         return try_while(lambda: self.is_scheduled(task_id, interval),
-                        "Task not scheduled within timeout",
+                        'Task not scheduled within timeout',
                         interval=0.5, timeout=10)

celery/tests/security/case.py

@@ -11,4 +11,4 @@ class SecurityCase(Case):
         try:
             from OpenSSL import crypto  # noqa
         except ImportError:
-            raise SkipTest("OpenSSL.crypto not installed")
+            raise SkipTest('OpenSSL.crypto not installed')

celery/tests/security/test_certificate.py

@@ -20,8 +20,8 @@ class test_Certificate(SecurityCase):
 
     def test_invalid_certificate(self):
         self.assertRaises(TypeError, Certificate, None)
-        self.assertRaises(SecurityError, Certificate, "")
-        self.assertRaises(SecurityError, Certificate, "foo")
+        self.assertRaises(SecurityError, Certificate, '')
+        self.assertRaises(SecurityError, Certificate, 'foo')
         self.assertRaises(SecurityError, Certificate, CERT1[:20] + CERT1[21:])
         self.assertRaises(SecurityError, Certificate, KEY1)
 
@@ -51,30 +51,30 @@ class test_CertStore(SecurityCase):
 
 class test_FSCertStore(SecurityCase):
 
-    @patch("os.path.isdir")
-    @patch("glob.glob")
-    @patch("celery.security.certificate.Certificate")
+    @patch('os.path.isdir')
+    @patch('glob.glob')
+    @patch('celery.security.certificate.Certificate')
     def test_init(self, Certificate, glob, isdir):
         cert = Certificate.return_value = Mock()
         cert.has_expired.return_value = False
         isdir.return_value = True
-        glob.return_value = ["foo.cert"]
+        glob.return_value = ['foo.cert']
         with mock_open():
             cert.get_id.return_value = 1
-            x = FSCertStore("/var/certs")
+            x = FSCertStore('/var/certs')
             self.assertIn(1, x._certs)
-            glob.assert_called_with("/var/certs/*")
+            glob.assert_called_with('/var/certs/*')
 
             # they both end up with the same id
-            glob.return_value = ["foo.cert", "bar.cert"]
+            glob.return_value = ['foo.cert', 'bar.cert']
             with self.assertRaises(SecurityError):
-                x = FSCertStore("/var/certs")
-            glob.return_value = ["foo.cert"]
+                x = FSCertStore('/var/certs')
+            glob.return_value = ['foo.cert']
 
             cert.has_expired.return_value = True
             with self.assertRaises(SecurityError):
-                x = FSCertStore("/var/certs")
+                x = FSCertStore('/var/certs')
 
             isdir.return_value = False
             with self.assertRaises(SecurityError):
-                x = FSCertStore("/var/certs")
+                x = FSCertStore('/var/certs')

celery/tests/security/test_key.py

@@ -15,8 +15,8 @@ class test_PrivateKey(SecurityCase):
 
     def test_invalid_private_key(self):
         self.assertRaises(TypeError, PrivateKey, None)
-        self.assertRaises(SecurityError, PrivateKey, "")
-        self.assertRaises(SecurityError, PrivateKey, "foo")
+        self.assertRaises(SecurityError, PrivateKey, '')
+        self.assertRaises(SecurityError, PrivateKey, 'foo')
         self.assertRaises(SecurityError, PrivateKey, KEY1[:20] + KEY1[21:])
         self.assertRaises(SecurityError, PrivateKey, CERT1)
 

celery/tests/security/test_security.py

@@ -60,24 +60,24 @@ class test_security(SecurityCase):
         self.assertIn('application/x-python-serialize', disabled)
         disabled.clear()
 
-    @patch("celery.security.register_auth")
-    @patch("celery.security.disable_untrusted_serializers")
-    def test_setup_registry_complete(self, dis, reg, key="KEY", cert="CERT"):
+    @patch('celery.security.register_auth')
+    @patch('celery.security.disable_untrusted_serializers')
+    def test_setup_registry_complete(self, dis, reg, key='KEY', cert='CERT'):
         calls = [0]
 
         def effect(*args):
             try:
                 m = Mock()
-                m.read.return_value = "B" if calls[0] else "A"
+                m.read.return_value = 'B' if calls[0] else 'A'
                 return m
             finally:
                 calls[0] += 1
 
         with mock_open(side_effect=effect):
             store = Mock()
-            setup_security(["json"], key, cert, store)
-            dis.assert_called_with(["json"])
-            reg.assert_called_with("A", "B", store)
+            setup_security(['json'], key, cert, store)
+            dis.assert_called_with(['json'])
+            reg.assert_called_with('A', 'B', store)
 
     def test_security_conf(self):
         current_app.conf.CELERY_TASK_SERIALIZER = 'auth'

celery/tests/security/test_serialization.py

@@ -21,34 +21,34 @@ class test_SecureSerializer(SecurityCase):
 
     def test_serialize(self):
         s = self._get_s(KEY1, CERT1, [CERT1])
-        self.assertEqual(s.deserialize(s.serialize("foo")), "foo")
+        self.assertEqual(s.deserialize(s.serialize('foo')), 'foo')
 
     def test_deserialize(self):
         s = self._get_s(KEY1, CERT1, [CERT1])
-        self.assertRaises(SecurityError, s.deserialize, "bad data")
+        self.assertRaises(SecurityError, s.deserialize, 'bad data')
 
     def test_unmatched_key_cert(self):
         s = self._get_s(KEY1, CERT2, [CERT1, CERT2])
         self.assertRaises(SecurityError,
-                          s.deserialize, s.serialize("foo"))
+                          s.deserialize, s.serialize('foo'))
 
     def test_unknown_source(self):
         s1 = self._get_s(KEY1, CERT1, [CERT2])
         s2 = self._get_s(KEY1, CERT1, [])
         self.assertRaises(SecurityError,
-                          s1.deserialize, s1.serialize("foo"))
+                          s1.deserialize, s1.serialize('foo'))
         self.assertRaises(SecurityError,
-                          s2.deserialize, s2.serialize("foo"))
+                          s2.deserialize, s2.serialize('foo'))
 
     def test_self_send(self):
         s1 = self._get_s(KEY1, CERT1, [CERT1])
         s2 = self._get_s(KEY1, CERT1, [CERT1])
-        self.assertEqual(s2.deserialize(s1.serialize("foo")), "foo")
+        self.assertEqual(s2.deserialize(s1.serialize('foo')), 'foo')
 
     def test_separate_ends(self):
         s1 = self._get_s(KEY1, CERT1, [CERT2])
         s2 = self._get_s(KEY2, CERT2, [CERT1])
-        self.assertEqual(s2.deserialize(s1.serialize("foo")), "foo")
+        self.assertEqual(s2.deserialize(s1.serialize('foo')), 'foo')
 
     def test_register_auth(self):
         register_auth(KEY1, CERT1, '')

celery/tests/slow/test_buckets.py

@@ -18,7 +18,7 @@ from celery.worker import buckets
 
 from celery.tests.utils import Case, skip_if_environ, mock_context
 
-skip_if_disabled = partial(skip_if_environ("SKIP_RLIMITS"))
+skip_if_disabled = partial(skip_if_environ('SKIP_RLIMITS'))
 
 
 class MockJob(object):
@@ -39,7 +39,7 @@ class MockJob(object):
             return self == other
 
     def __repr__(self):
-        return "<MockJob: task:%s id:%s args:%s kwargs:%s" % (
+        return '<MockJob: task:%s id:%s args:%s kwargs:%s' % (
                 self.name, self.id, self.args, self.kwargs)
 
 
@@ -54,12 +54,12 @@ class test_TokenBucketQueue(Case):
     @skip_if_disabled
     def test_bucket__put_get(self):
         x = buckets.TokenBucketQueue(fill_rate=10)
-        x.put("The quick brown fox")
-        self.assertEqual(x.get(), "The quick brown fox")
+        x.put('The quick brown fox')
+        self.assertEqual(x.get(), 'The quick brown fox')
 
-        x.put_nowait("The lazy dog")
+        x.put_nowait('The lazy dog')
         time.sleep(0.2)
-        self.assertEqual(x.get_nowait(), "The lazy dog")
+        self.assertEqual(x.get_nowait(), 'The lazy dog')
 
     @skip_if_disabled
     def test_fill_rate(self):
@@ -68,34 +68,34 @@ class test_TokenBucketQueue(Case):
         time_start = time.time()
         [x.put(str(i)) for i in xrange(20)]
         for i in xrange(20):
-            sys.stderr.write(".")
+            sys.stderr.write('.')
             x.wait()
         self.assertGreater(time.time() - time_start, 1.5)
 
     @skip_if_disabled
     def test_can_consume(self):
         x = buckets.TokenBucketQueue(fill_rate=1)
-        x.put("The quick brown fox")
-        self.assertEqual(x.get(), "The quick brown fox")
+        x.put('The quick brown fox')
+        self.assertEqual(x.get(), 'The quick brown fox')
         time.sleep(0.1)
         # Not yet ready for another token
-        x.put("The lazy dog")
+        x.put('The lazy dog')
         with self.assertRaises(x.RateLimitExceeded):
             x.get()
 
     @skip_if_disabled
     def test_expected_time(self):
         x = buckets.TokenBucketQueue(fill_rate=1)
-        x.put_nowait("The quick brown fox")
-        self.assertEqual(x.get_nowait(), "The quick brown fox")
+        x.put_nowait('The quick brown fox')
+        self.assertEqual(x.get_nowait(), 'The quick brown fox')
         self.assertFalse(x.expected_time())
 
     @skip_if_disabled
     def test_qsize(self):
         x = buckets.TokenBucketQueue(fill_rate=1)
-        x.put("The quick brown fox")
+        x.put('The quick brown fox')
         self.assertEqual(x.qsize(), 1)
-        self.assertEqual(x.get_nowait(), "The quick brown fox")
+        self.assertEqual(x.get_nowait(), 'The quick brown fox')
 
 
 class test_rate_limit_string(Case):
@@ -103,13 +103,13 @@ class test_rate_limit_string(Case):
     @skip_if_disabled
     def test_conversion(self):
         self.assertEqual(timeutils.rate(999), 999)
-        self.assertEqual(timeutils.rate("1456/s"), 1456)
-        self.assertEqual(timeutils.rate("100/m"),
+        self.assertEqual(timeutils.rate('1456/s'), 1456)
+        self.assertEqual(timeutils.rate('100/m'),
                           100 / 60.0)
-        self.assertEqual(timeutils.rate("10/h"),
+        self.assertEqual(timeutils.rate('10/h'),
                           10 / 60.0 / 60.0)
 
-        for zero in (0, None, "0", "0/m", "0/h", "0/s"):
+        for zero in (0, None, '0', '0/m', '0/h', '0/s'):
             self.assertEqual(timeutils.rate(zero), 0)
 
 
@@ -122,11 +122,11 @@ class TaskB(Task):
 
 
 class TaskC(Task):
-    rate_limit = "1/s"
+    rate_limit = '1/s'
 
 
 class TaskD(Task):
-    rate_limit = "1000/m"
+    rate_limit = '1000/m'
 
 
 class test_TaskBucket(Case):
@@ -143,7 +143,7 @@ class test_TaskBucket(Case):
         with self.assertRaises(buckets.Empty):
             x.get_nowait()
 
-    @patch("celery.worker.buckets.sleep")
+    @patch('celery.worker.buckets.sleep')
     def test_get_block(self, sleep):
         x = buckets.TaskBucket(task_registry=self.registry)
         x.not_empty = Mock()
@@ -178,18 +178,18 @@ class test_TaskBucket(Case):
     def test_refresh(self):
         reg = {}
         x = buckets.TaskBucket(task_registry=reg)
-        reg["foo"] = "something"
+        reg['foo'] = 'something'
         x.refresh()
-        self.assertIn("foo", x.buckets)
-        self.assertTrue(x.get_bucket_for_type("foo"))
+        self.assertIn('foo', x.buckets)
+        self.assertTrue(x.get_bucket_for_type('foo'))
 
     @skip_if_disabled
     def test__get_queue_for_type(self):
         x = buckets.TaskBucket(task_registry={})
-        x.buckets["foo"] = buckets.TokenBucketQueue(fill_rate=1)
-        self.assertIs(x._get_queue_for_type("foo"), x.buckets["foo"].queue)
-        x.buckets["bar"] = buckets.FastQueue()
-        self.assertIs(x._get_queue_for_type("bar"), x.buckets["bar"])
+        x.buckets['foo'] = buckets.TokenBucketQueue(fill_rate=1)
+        self.assertIs(x._get_queue_for_type('foo'), x.buckets['foo'].queue)
+        x.buckets['bar'] = buckets.FastQueue()
+        self.assertIs(x._get_queue_for_type('bar'), x.buckets['bar'])
 
     @skip_if_disabled
     def test_update_bucket_for_type(self):
@@ -202,10 +202,10 @@ class test_TaskBucket(Case):
     def test_auto_add_on_missing_put(self):
         reg = {}
         b = buckets.TaskBucket(task_registry=reg)
-        reg["nonexisting.task"] = "foo"
+        reg['nonexisting.task'] = 'foo'
 
-        b.put(MockJob(uuid(), "nonexisting.task", (), {}))
-        self.assertIn("nonexisting.task", b.buckets)
+        b.put(MockJob(uuid(), 'nonexisting.task', (), {}))
+        self.assertIn('nonexisting.task', b.buckets)
 
     @skip_if_disabled
     def test_auto_add_on_missing(self):
@@ -241,7 +241,7 @@ class test_TaskBucket(Case):
     @skip_if_disabled
     def test_put__get(self):
         b = buckets.TaskBucket(task_registry=self.registry)
-        job = MockJob(uuid(), TaskA.name, ["theqbf"], {"foo": "bar"})
+        job = MockJob(uuid(), TaskA.name, ['theqbf'], {'foo': 'bar'})
         b.put(job)
         self.assertEqual(b.get(), job)
 
@@ -258,7 +258,7 @@ class test_TaskBucket(Case):
         # 20 items should take at least one second to complete
         time_start = time.time()
         for i, job in enumerate(jobs):
-            sys.stderr.write(".")
+            sys.stderr.write('.')
             self.assertEqual(b.get(), job)
         self.assertGreater(time.time() - time_start, 1.5)
 
@@ -298,7 +298,7 @@ class test_TaskBucket(Case):
 
             [b.put(job) for job in jobs]
             for i, job in enumerate(jobs):
-                sys.stderr.write(".")
+                sys.stderr.write('.')
                 self.assertTrue(b.get(), job)
             self.assertEqual(i + 1, len(jobs))
         finally:

celery/tests/tasks/test_canvas.py

@@ -9,11 +9,11 @@ from celery.result import EagerResult
 
 from celery.tests.utils import Case
 
-SIG = Signature({"task": "TASK",
-                 "args": ("A1", ),
-                 "kwargs": {"K1": "V1"},
-                 "options": {"task_id": "TASK_ID"},
-                 "subtask_type": ""})
+SIG = Signature({'task': 'TASK',
+                 'args': ('A1', ),
+                 'kwargs': {'K1': 'V1'},
+                 'options': {'task_id': 'TASK_ID'},
+                 'subtask_type': ''})
 
 
 @task()
@@ -41,37 +41,37 @@ class test_Signature(Case):
         self.assertTrue(Signature.subtask_type)
 
     def test_getitem_property(self):
-        self.assertEqual(SIG.task, "TASK")
-        self.assertEqual(SIG.args, ("A1", ))
-        self.assertEqual(SIG.kwargs, {"K1": "V1"})
-        self.assertEqual(SIG.options, {"task_id": "TASK_ID"})
-        self.assertEqual(SIG.subtask_type, "")
+        self.assertEqual(SIG.task, 'TASK')
+        self.assertEqual(SIG.args, ('A1', ))
+        self.assertEqual(SIG.kwargs, {'K1': 'V1'})
+        self.assertEqual(SIG.options, {'task_id': 'TASK_ID'})
+        self.assertEqual(SIG.subtask_type, '')
 
     def test_replace(self):
-        x = Signature("TASK", ("A"), {})
-        self.assertTupleEqual(x.replace(args=("B", )).args, ("B", ))
-        self.assertDictEqual(x.replace(kwargs={"FOO": "BAR"}).kwargs,
-                {"FOO": "BAR"})
-        self.assertDictEqual(x.replace(options={"task_id": "123"}).options,
-                {"task_id": "123"})
+        x = Signature('TASK', ('A'), {})
+        self.assertTupleEqual(x.replace(args=('B', )).args, ('B', ))
+        self.assertDictEqual(x.replace(kwargs={'FOO': 'BAR'}).kwargs,
+                {'FOO': 'BAR'})
+        self.assertDictEqual(x.replace(options={'task_id': '123'}).options,
+                {'task_id': '123'})
 
     def test_set(self):
-        self.assertDictEqual(Signature("TASK", x=1).set(task_id="2").options,
-                {"x": 1, "task_id": "2"})
+        self.assertDictEqual(Signature('TASK', x=1).set(task_id='2').options,
+                {'x': 1, 'task_id': '2'})
 
     def test_link(self):
         x = subtask(SIG)
         x.link(SIG)
         x.link(SIG)
-        self.assertIn(SIG, x.options["link"])
-        self.assertEqual(len(x.options["link"]), 1)
+        self.assertIn(SIG, x.options['link'])
+        self.assertEqual(len(x.options['link']), 1)
 
     def test_link_error(self):
         x = subtask(SIG)
         x.link_error(SIG)
         x.link_error(SIG)
-        self.assertIn(SIG, x.options["link_error"])
-        self.assertEqual(len(x.options["link_error"]), 1)
+        self.assertIn(SIG, x.options['link_error'])
+        self.assertEqual(len(x.options['link_error']), 1)
 
     def test_flatten_links(self):
         tasks = [add.s(2, 2), mul.s(4), div.s(2)]
@@ -151,20 +151,20 @@ class test_chord(Case):
     def test_clone_clones_body(self):
         x = chord([add.s(2, 2), add.s(4, 4)], body=mul.s(4))
         y = x.clone()
-        self.assertIsNot(x.kwargs["body"], y.kwargs["body"])
-        y.kwargs.pop("body")
+        self.assertIsNot(x.kwargs['body'], y.kwargs['body'])
+        y.kwargs.pop('body')
         z = y.clone()
-        self.assertIsNone(z.kwargs.get("body"))
+        self.assertIsNone(z.kwargs.get('body'))
 
     def test_links_to_body(self):
         x = chord([add.s(2, 2), add.s(4, 4)], body=mul.s(4))
         x.link(div.s(2))
-        self.assertFalse(x.options.get("link"))
-        self.assertTrue(x.kwargs["body"].options["link"])
+        self.assertFalse(x.options.get('link'))
+        self.assertTrue(x.kwargs['body'].options['link'])
 
         x.link_error(div.s(2))
-        self.assertFalse(x.options.get("link_error"))
-        self.assertTrue(x.kwargs["body"].options["link_error"])
+        self.assertFalse(x.options.get('link_error'))
+        self.assertTrue(x.kwargs['body'].options['link_error'])
 
         self.assertTrue(x.tasks)
         self.assertTrue(x.body)
@@ -172,5 +172,5 @@ class test_chord(Case):
     def test_repr(self):
         x = chord([add.s(2, 2), add.s(4, 4)], body=mul.s(4))
         self.assertTrue(repr(x))
-        x.kwargs["body"] = None
-        self.assertIn("without body", repr(x))
+        x.kwargs['body'] = None
+        self.assertIn('without body', repr(x))

celery/tests/tasks/test_chord.py

@@ -40,7 +40,7 @@ class TSR(GroupResult):
 
 @contextmanager
 def patch_unlock_retry():
-    unlock = current_app.tasks["celery.chord_unlock"]
+    unlock = current_app.tasks['celery.chord_unlock']
     retry = Mock()
     prev, unlock.retry = unlock.retry, retry
     yield unlock, retry
@@ -49,7 +49,7 @@ def patch_unlock_retry():
 
 class test_unlock_chord_task(AppCase):
 
-    @patch("celery.result.GroupResult")
+    @patch('celery.result.GroupResult')
     def test_unlock_ready(self, GroupResult):
 
         class AlwaysReady(TSR):
@@ -67,7 +67,7 @@ class test_unlock_chord_task(AppCase):
             with patch_unlock_retry() as (unlock, retry):
                 subtask, canvas.maybe_subtask = canvas.maybe_subtask, passthru
                 try:
-                    unlock("group_id", callback_s,
+                    unlock('group_id', callback_s,
                            result=map(AsyncResult, [1, 2, 3]))
                 finally:
                     canvas.maybe_subtask = subtask
@@ -77,7 +77,7 @@ class test_unlock_chord_task(AppCase):
         finally:
             result.GroupResult = pts
 
-    @patch("celery.result.GroupResult")
+    @patch('celery.result.GroupResult')
     def test_when_not_ready(self, GroupResult):
         with patch_unlock_retry() as (unlock, retry):
 
@@ -87,7 +87,7 @@ class test_unlock_chord_task(AppCase):
             pts, result.GroupResult = result.GroupResult, NeverReady
             try:
                 callback = Mock()
-                unlock("group_id", callback, interval=10, max_retries=30,
+                unlock('group_id', callback, interval=10, max_retries=30,
                             result=map(AsyncResult, [1, 2, 3]))
                 self.assertFalse(callback.delay.call_count)
                 # did retry
@@ -96,7 +96,7 @@ class test_unlock_chord_task(AppCase):
                 result.GroupResult = pts
 
     def test_is_in_registry(self):
-        self.assertIn("celery.chord_unlock", current_app.tasks)
+        self.assertIn('celery.chord_unlock', current_app.tasks)
 
 
 class test_chord(AppCase):
@@ -133,7 +133,7 @@ class test_chord(AppCase):
             x = chord(add.s(i, i) for i in xrange(10))
             body = add.s(2)
             result = x(body)
-            self.assertEqual(result.id, body.options["task_id"])
+            self.assertEqual(result.id, body.options['task_id'])
             self.assertTrue(chord.Chord.called)
         finally:
             chord.Chord = prev
@@ -144,9 +144,9 @@ class test_Chord_task(AppCase):
     def test_run(self):
         prev, current_app.backend = current_app.backend, Mock()
         current_app.backend.cleanup = Mock()
-        current_app.backend.cleanup.__name__ = "cleanup"
+        current_app.backend.cleanup.__name__ = 'cleanup'
         try:
-            Chord = current_app.tasks["celery.chord"]
+            Chord = current_app.tasks['celery.chord']
 
             body = dict()
             Chord(TaskSet(add.subtask((i, i)) for i in xrange(5)), body)

celery/tests/tasks/test_context.py

@@ -1,4 +1,4 @@
-# -*- coding: utf-8 -*-"
+# -*- coding: utf-8 -*-'
 from __future__ import absolute_import
 
 from celery.task.base import Context
@@ -10,7 +10,7 @@ from celery.tests.utils import Case
 def get_context_as_dict(ctx, getter=getattr):
     defaults = {}
     for attr_name in dir(ctx):
-        if attr_name.startswith("_"):
+        if attr_name.startswith('_'):
             continue   # Ignore pseudo-private attributes
         attr = getter(ctx, attr_name)
         if callable(attr):
@@ -30,7 +30,7 @@ class test_Context(Case):
 
     def test_updated_context(self):
         expected = dict(default_context)
-        changes = dict(id="unique id", args=["some", 1], wibble="wobble")
+        changes = dict(id='unique id', args=['some', 1], wibble='wobble')
         ctx = Context()
         expected.update(changes)
         ctx.update(changes)
@@ -40,15 +40,15 @@ class test_Context(Case):
     def test_modified_context(self):
         expected = dict(default_context)
         ctx = Context()
-        expected["id"] = "unique id"
-        expected["args"] = ["some", 1]
-        ctx.id = "unique id"
-        ctx.args = ["some", 1]
+        expected['id'] = 'unique id'
+        expected['args'] = ['some', 1]
+        ctx.id = 'unique id'
+        ctx.args = ['some', 1]
         self.assertDictEqual(get_context_as_dict(ctx), expected)
         self.assertDictEqual(get_context_as_dict(Context()), default_context)
 
     def test_cleared_context(self):
-        changes = dict(id="unique id", args=["some", 1], wibble="wobble")
+        changes = dict(id='unique id', args=['some', 1], wibble='wobble')
         ctx = Context()
         ctx.update(changes)
         ctx.clear()
@@ -58,7 +58,7 @@ class test_Context(Case):
 
     def test_context_get(self):
         expected = dict(default_context)
-        changes = dict(id="unique id", args=["some", 1], wibble="wobble")
+        changes = dict(id='unique id', args=['some', 1], wibble='wobble')
         ctx = Context()
         expected.update(changes)
         ctx.update(changes)

celery/tests/tasks/test_http.py

@@ -42,23 +42,23 @@ def _response(res):
 
 
 def success_response(value):
-    return _response(dumps({"status": "success", "retval": value}))
+    return _response(dumps({'status': 'success', 'retval': value}))
 
 
 def fail_response(reason):
-    return _response(dumps({"status": "failure", "reason": reason}))
+    return _response(dumps({'status': 'failure', 'reason': reason}))
 
 
 def unknown_response():
-    return _response(dumps({"status": "u.u.u.u", "retval": True}))
+    return _response(dumps({'status': 'u.u.u.u', 'retval': True}))
 
 
 class test_encodings(Case):
 
     def test_utf8dict(self):
-        uk = "foobar"
-        d = {u"følelser ær langé": u"ærbadægzaååÆØÅ",
-             from_utf8(uk): from_utf8("xuzzybaz")}
+        uk = 'foobar'
+        d = {u'følelser ær langé': u'ærbadægzaååÆØÅ',
+             from_utf8(uk): from_utf8('xuzzybaz')}
 
         for key, value in http.utf8dict(d.items()).items():
             self.assertIsInstance(key, str)
@@ -68,87 +68,87 @@ class test_encodings(Case):
 class test_MutableURL(Case):
 
     def test_url_query(self):
-        url = http.MutableURL("http://example.com?x=10&y=20&z=Foo")
-        self.assertDictContainsSubset({"x": "10",
-                                       "y": "20",
-                                       "z": "Foo"}, url.query)
-        url.query["name"] = "George"
+        url = http.MutableURL('http://example.com?x=10&y=20&z=Foo')
+        self.assertDictContainsSubset({'x': '10',
+                                       'y': '20',
+                                       'z': 'Foo'}, url.query)
+        url.query['name'] = 'George'
         url = http.MutableURL(str(url))
-        self.assertDictContainsSubset({"x": "10",
-                                       "y": "20",
-                                       "z": "Foo",
-                                       "name": "George"}, url.query)
+        self.assertDictContainsSubset({'x': '10',
+                                       'y': '20',
+                                       'z': 'Foo',
+                                       'name': 'George'}, url.query)
 
     def test_url_keeps_everything(self):
-        url = "https://e.com:808/foo/bar#zeta?x=10&y=20"
+        url = 'https://e.com:808/foo/bar#zeta?x=10&y=20'
         url = http.MutableURL(url)
 
-        self.assertEqual(str(url).split("?")[0],
-            "https://e.com:808/foo/bar#zeta")
+        self.assertEqual(str(url).split('?')[0],
+            'https://e.com:808/foo/bar#zeta')
 
     def test___repr__(self):
-        url = http.MutableURL("http://e.com/foo/bar")
-        self.assertTrue(repr(url).startswith("<MutableURL: http://e.com"))
+        url = http.MutableURL('http://e.com/foo/bar')
+        self.assertTrue(repr(url).startswith('<MutableURL: http://e.com'))
 
     def test_set_query(self):
-        url = http.MutableURL("http://e.com/foo/bar/?x=10")
-        url.query = {"zzz": "xxx"}
+        url = http.MutableURL('http://e.com/foo/bar/?x=10')
+        url.query = {'zzz': 'xxx'}
         url = http.MutableURL(str(url))
-        self.assertEqual(url.query, {"zzz": "xxx"})
+        self.assertEqual(url.query, {'zzz': 'xxx'})
 
 
 class test_HttpDispatch(Case):
 
     def test_dispatch_success(self):
-        logger = logging.getLogger("celery.unittest")
+        logger = logging.getLogger('celery.unittest')
 
         with mock_urlopen(success_response(100)):
-            d = http.HttpDispatch("http://example.com/mul", "GET", {
-                                    "x": 10, "y": 10}, logger)
+            d = http.HttpDispatch('http://example.com/mul', 'GET', {
+                                    'x': 10, 'y': 10}, logger)
             self.assertEqual(d.dispatch(), 100)
 
     def test_dispatch_failure(self):
-        logger = logging.getLogger("celery.unittest")
+        logger = logging.getLogger('celery.unittest')
 
-        with mock_urlopen(fail_response("Invalid moon alignment")):
-            d = http.HttpDispatch("http://example.com/mul", "GET", {
-                                    "x": 10, "y": 10}, logger)
+        with mock_urlopen(fail_response('Invalid moon alignment')):
+            d = http.HttpDispatch('http://example.com/mul', 'GET', {
+                                    'x': 10, 'y': 10}, logger)
             with self.assertRaises(http.RemoteExecuteError):
                 d.dispatch()
 
     def test_dispatch_empty_response(self):
-        logger = logging.getLogger("celery.unittest")
+        logger = logging.getLogger('celery.unittest')
 
-        with mock_urlopen(_response("")):
-            d = http.HttpDispatch("http://example.com/mul", "GET", {
-                                    "x": 10, "y": 10}, logger)
+        with mock_urlopen(_response('')):
+            d = http.HttpDispatch('http://example.com/mul', 'GET', {
+                                    'x': 10, 'y': 10}, logger)
             with self.assertRaises(http.InvalidResponseError):
                 d.dispatch()
 
     def test_dispatch_non_json(self):
-        logger = logging.getLogger("celery.unittest")
+        logger = logging.getLogger('celery.unittest')
 
         with mock_urlopen(_response("{'#{:'''")):
-            d = http.HttpDispatch("http://example.com/mul", "GET", {
-                                    "x": 10, "y": 10}, logger)
+            d = http.HttpDispatch('http://example.com/mul', 'GET', {
+                                    'x': 10, 'y': 10}, logger)
             with self.assertRaises(http.InvalidResponseError):
                 d.dispatch()
 
     def test_dispatch_unknown_status(self):
-        logger = logging.getLogger("celery.unittest")
+        logger = logging.getLogger('celery.unittest')
 
         with mock_urlopen(unknown_response()):
-            d = http.HttpDispatch("http://example.com/mul", "GET", {
-                                    "x": 10, "y": 10}, logger)
+            d = http.HttpDispatch('http://example.com/mul', 'GET', {
+                                    'x': 10, 'y': 10}, logger)
             with self.assertRaises(http.UnknownStatusError):
                 d.dispatch()
 
     def test_dispatch_POST(self):
-        logger = logging.getLogger("celery.unittest")
+        logger = logging.getLogger('celery.unittest')
 
         with mock_urlopen(success_response(100)):
-            d = http.HttpDispatch("http://example.com/mul", "POST", {
-                                    "x": 10, "y": 10}, logger)
+            d = http.HttpDispatch('http://example.com/mul', 'POST', {
+                                    'x': 10, 'y': 10}, logger)
             self.assertEqual(d.dispatch(), 100)
 
 
@@ -157,11 +157,11 @@ class test_URL(Case):
     def test_URL_get_async(self):
         with eager_tasks():
             with mock_urlopen(success_response(100)):
-                d = http.URL("http://example.com/mul").get_async(x=10, y=10)
+                d = http.URL('http://example.com/mul').get_async(x=10, y=10)
                 self.assertEqual(d.get(), 100)
 
     def test_URL_post_async(self):
         with eager_tasks():
             with mock_urlopen(success_response(100)):
-                d = http.URL("http://example.com/mul").post_async(x=10, y=10)
+                d = http.URL('http://example.com/mul').post_async(x=10, y=10)
                 self.assertEqual(d.get(), 100)

celery/tests/tasks/test_registry.py

@@ -7,14 +7,14 @@ from celery.tests.utils import Case
 
 
 class MockTask(Task):
-    name = "celery.unittest.test_task"
+    name = 'celery.unittest.test_task'
 
     def run(self, **kwargs):
         return True
 
 
 class MockPeriodicTask(PeriodicTask):
-    name = "celery.unittest.test_periodic_task"
+    name = 'celery.unittest.test_periodic_task'
     run_every = 10
 
     def run(self, **kwargs):
@@ -24,7 +24,7 @@ class MockPeriodicTask(PeriodicTask):
 class test_TaskRegistry(Case):
 
     def test_NotRegistered_str(self):
-        self.assertTrue(repr(TaskRegistry.NotRegistered("tasks.add")))
+        self.assertTrue(repr(TaskRegistry.NotRegistered('tasks.add')))
 
     def assertRegisterUnregisterCls(self, r, task):
         with self.assertRaises(r.NotRegistered):
@@ -41,7 +41,7 @@ class test_TaskRegistry(Case):
     def test_task_registry(self):
         r = TaskRegistry()
         self.assertIsInstance(r, dict,
-                "TaskRegistry is mapping")
+                'TaskRegistry is mapping')
 
         self.assertRegisterUnregisterCls(r, MockTask)
         self.assertRegisterUnregisterCls(r, MockPeriodicTask)

celery/tests/tasks/test_result.py

@@ -36,42 +36,42 @@ def mock_task(name, state, result):
 
 def save_result(task):
     app = app_or_default()
-    traceback = "Some traceback"
-    if task["state"] == states.SUCCESS:
-        app.backend.mark_as_done(task["id"], task["result"])
-    elif task["state"] == states.RETRY:
-        app.backend.mark_as_retry(task["id"], task["result"],
+    traceback = 'Some traceback'
+    if task['state'] == states.SUCCESS:
+        app.backend.mark_as_done(task['id'], task['result'])
+    elif task['state'] == states.RETRY:
+        app.backend.mark_as_retry(task['id'], task['result'],
                 traceback=traceback)
     else:
-        app.backend.mark_as_failure(task["id"], task["result"],
+        app.backend.mark_as_failure(task['id'], task['result'],
                 traceback=traceback)
 
 
 def make_mock_group(size=10):
-    tasks = [mock_task("ts%d" % i, states.SUCCESS, i) for i in xrange(size)]
+    tasks = [mock_task('ts%d' % i, states.SUCCESS, i) for i in xrange(size)]
     [save_result(task) for task in tasks]
-    return [AsyncResult(task["id"]) for task in tasks]
+    return [AsyncResult(task['id']) for task in tasks]
 
 
 class test_AsyncResult(AppCase):
 
     def setup(self):
-        self.task1 = mock_task("task1", states.SUCCESS, "the")
-        self.task2 = mock_task("task2", states.SUCCESS, "quick")
-        self.task3 = mock_task("task3", states.FAILURE, KeyError("brown"))
-        self.task4 = mock_task("task3", states.RETRY, KeyError("red"))
+        self.task1 = mock_task('task1', states.SUCCESS, 'the')
+        self.task2 = mock_task('task2', states.SUCCESS, 'quick')
+        self.task3 = mock_task('task3', states.FAILURE, KeyError('brown'))
+        self.task4 = mock_task('task3', states.RETRY, KeyError('red'))
 
         for task in (self.task1, self.task2, self.task3, self.task4):
             save_result(task)
 
     def test_compat_properties(self):
-        x = AsyncResult("1")
+        x = AsyncResult('1')
         self.assertEqual(x.task_id, x.id)
-        x.task_id = "2"
-        self.assertEqual(x.id, "2")
+        x.task_id = '2'
+        self.assertEqual(x.id, '2')
 
     def test_children(self):
-        x = AsyncResult("1")
+        x = AsyncResult('1')
         children = [EagerResult(str(i), i, states.SUCCESS) for i in range(3)]
         x.backend = Mock()
         x.backend.get_children.return_value = children
@@ -83,16 +83,16 @@ class test_AsyncResult(AppCase):
         tid = uuid()
         x = AsyncResult(tid)
         child = [AsyncResult(uuid()).serializable() for i in xrange(10)]
-        x.backend._cache[tid] = {"children": child}
+        x.backend._cache[tid] = {'children': child}
         self.assertTrue(x.children)
         self.assertEqual(len(x.children), 10)
 
-        x.backend._cache[tid] = {"result": None}
+        x.backend._cache[tid] = {'result': None}
         self.assertIsNone(x.children)
 
     def test_build_graph_get_leaf_collect(self):
-        x = AsyncResult("1")
-        x.backend._cache["1"] = {"status": states.SUCCESS, "result": None}
+        x = AsyncResult('1')
+        x.backend._cache['1'] = {'status': states.SUCCESS, 'result': None}
         c = [EagerResult(str(i), i, states.SUCCESS) for i in range(3)]
         x.iterdeps = Mock()
         x.iterdeps.return_value = (
@@ -115,8 +115,8 @@ class test_AsyncResult(AppCase):
         ])
 
     def test_iterdeps(self):
-        x = AsyncResult("1")
-        x.backend._cache["1"] = {"status": states.SUCCESS, "result": None}
+        x = AsyncResult('1')
+        x.backend._cache['1'] = {'status': states.SUCCESS, 'result': None}
         c = [EagerResult(str(i), i, states.SUCCESS) for i in range(3)]
         for child in c:
             child.backend = Mock()
@@ -130,7 +130,7 @@ class test_AsyncResult(AppCase):
             (x, c[1]),
             (x, c[2]),
         ])
-        x.backend._cache.pop("1")
+        x.backend._cache.pop('1')
         x.ready = Mock()
         x.ready.return_value = False
         with self.assertRaises(IncompleteStream):
@@ -138,21 +138,21 @@ class test_AsyncResult(AppCase):
         list(x.iterdeps(intermediate=True))
 
     def test_eq_not_implemented(self):
-        self.assertFalse(AsyncResult("1") == object())
+        self.assertFalse(AsyncResult('1') == object())
 
     def test_reduce(self):
-        a1 = AsyncResult("uuid", task_name=mytask.name)
+        a1 = AsyncResult('uuid', task_name=mytask.name)
         restored = pickle.loads(pickle.dumps(a1))
-        self.assertEqual(restored.id, "uuid")
+        self.assertEqual(restored.id, 'uuid')
         self.assertEqual(restored.task_name, mytask.name)
 
-        a2 = AsyncResult("uuid")
-        self.assertEqual(pickle.loads(pickle.dumps(a2)).id, "uuid")
+        a2 = AsyncResult('uuid')
+        self.assertEqual(pickle.loads(pickle.dumps(a2)).id, 'uuid')
 
     def test_successful(self):
-        ok_res = AsyncResult(self.task1["id"])
-        nok_res = AsyncResult(self.task3["id"])
-        nok_res2 = AsyncResult(self.task4["id"])
+        ok_res = AsyncResult(self.task1['id'])
+        nok_res = AsyncResult(self.task3['id'])
+        nok_res2 = AsyncResult(self.task4['id'])
 
         self.assertTrue(ok_res.successful())
         self.assertFalse(nok_res.successful())
@@ -162,43 +162,43 @@ class test_AsyncResult(AppCase):
         self.assertFalse(pending_res.successful())
 
     def test_str(self):
-        ok_res = AsyncResult(self.task1["id"])
-        ok2_res = AsyncResult(self.task2["id"])
-        nok_res = AsyncResult(self.task3["id"])
-        self.assertEqual(str(ok_res), self.task1["id"])
-        self.assertEqual(str(ok2_res), self.task2["id"])
-        self.assertEqual(str(nok_res), self.task3["id"])
+        ok_res = AsyncResult(self.task1['id'])
+        ok2_res = AsyncResult(self.task2['id'])
+        nok_res = AsyncResult(self.task3['id'])
+        self.assertEqual(str(ok_res), self.task1['id'])
+        self.assertEqual(str(ok2_res), self.task2['id'])
+        self.assertEqual(str(nok_res), self.task3['id'])
 
         pending_id = uuid()
         pending_res = AsyncResult(pending_id)
         self.assertEqual(str(pending_res), pending_id)
 
     def test_repr(self):
-        ok_res = AsyncResult(self.task1["id"])
-        ok2_res = AsyncResult(self.task2["id"])
-        nok_res = AsyncResult(self.task3["id"])
-        self.assertEqual(repr(ok_res), "<AsyncResult: %s>" % (
-                self.task1["id"]))
-        self.assertEqual(repr(ok2_res), "<AsyncResult: %s>" % (
-                self.task2["id"]))
-        self.assertEqual(repr(nok_res), "<AsyncResult: %s>" % (
-                self.task3["id"]))
+        ok_res = AsyncResult(self.task1['id'])
+        ok2_res = AsyncResult(self.task2['id'])
+        nok_res = AsyncResult(self.task3['id'])
+        self.assertEqual(repr(ok_res), '<AsyncResult: %s>' % (
+                self.task1['id']))
+        self.assertEqual(repr(ok2_res), '<AsyncResult: %s>' % (
+                self.task2['id']))
+        self.assertEqual(repr(nok_res), '<AsyncResult: %s>' % (
+                self.task3['id']))
 
         pending_id = uuid()
         pending_res = AsyncResult(pending_id)
-        self.assertEqual(repr(pending_res), "<AsyncResult: %s>" % (
+        self.assertEqual(repr(pending_res), '<AsyncResult: %s>' % (
                 pending_id))
 
     def test_hash(self):
-        self.assertEqual(hash(AsyncResult("x0w991")),
-                         hash(AsyncResult("x0w991")))
-        self.assertNotEqual(hash(AsyncResult("x0w991")),
-                            hash(AsyncResult("x1w991")))
+        self.assertEqual(hash(AsyncResult('x0w991')),
+                         hash(AsyncResult('x0w991')))
+        self.assertNotEqual(hash(AsyncResult('x0w991')),
+                            hash(AsyncResult('x1w991')))
 
     def test_get_traceback(self):
-        ok_res = AsyncResult(self.task1["id"])
-        nok_res = AsyncResult(self.task3["id"])
-        nok_res2 = AsyncResult(self.task4["id"])
+        ok_res = AsyncResult(self.task1['id'])
+        nok_res = AsyncResult(self.task3['id'])
+        nok_res2 = AsyncResult(self.task4['id'])
         self.assertFalse(ok_res.traceback)
         self.assertTrue(nok_res.traceback)
         self.assertTrue(nok_res2.traceback)
@@ -207,21 +207,21 @@ class test_AsyncResult(AppCase):
         self.assertFalse(pending_res.traceback)
 
     def test_get(self):
-        ok_res = AsyncResult(self.task1["id"])
-        ok2_res = AsyncResult(self.task2["id"])
-        nok_res = AsyncResult(self.task3["id"])
-        nok2_res = AsyncResult(self.task4["id"])
+        ok_res = AsyncResult(self.task1['id'])
+        ok2_res = AsyncResult(self.task2['id'])
+        nok_res = AsyncResult(self.task3['id'])
+        nok2_res = AsyncResult(self.task4['id'])
 
-        self.assertEqual(ok_res.get(), "the")
-        self.assertEqual(ok2_res.get(), "quick")
+        self.assertEqual(ok_res.get(), 'the')
+        self.assertEqual(ok2_res.get(), 'quick')
         with self.assertRaises(KeyError):
             nok_res.get()
         self.assertTrue(nok_res.get(propagate=False))
         self.assertIsInstance(nok2_res.result, KeyError)
-        self.assertEqual(ok_res.info, "the")
+        self.assertEqual(ok_res.info, 'the')
 
     def test_get_timeout(self):
-        res = AsyncResult(self.task4["id"])             # has RETRY state
+        res = AsyncResult(self.task4['id'])             # has RETRY state
         with self.assertRaises(TimeoutError):
             res.get(timeout=0.1)
 
@@ -231,16 +231,16 @@ class test_AsyncResult(AppCase):
 
     @skip_if_quick
     def test_get_timeout_longer(self):
-        res = AsyncResult(self.task4["id"])             # has RETRY state
+        res = AsyncResult(self.task4['id'])             # has RETRY state
         with self.assertRaises(TimeoutError):
             res.get(timeout=1)
 
     def test_ready(self):
-        oks = (AsyncResult(self.task1["id"]),
-               AsyncResult(self.task2["id"]),
-               AsyncResult(self.task3["id"]))
+        oks = (AsyncResult(self.task1['id']),
+               AsyncResult(self.task2['id']),
+               AsyncResult(self.task3['id']))
         self.assertTrue(all(result.ready() for result in oks))
-        self.assertFalse(AsyncResult(self.task4["id"]).ready())
+        self.assertFalse(AsyncResult(self.task4['id']).ready())
 
         self.assertFalse(AsyncResult(uuid()).ready())
 
@@ -275,14 +275,14 @@ class test_ResultSet(AppCase):
 
     def test_add_discard(self):
         x = ResultSet([])
-        x.add(AsyncResult("1"))
-        self.assertIn(AsyncResult("1"), x.results)
-        x.discard(AsyncResult("1"))
-        x.discard(AsyncResult("1"))
-        x.discard("1")
-        self.assertNotIn(AsyncResult("1"), x.results)
+        x.add(AsyncResult('1'))
+        self.assertIn(AsyncResult('1'), x.results)
+        x.discard(AsyncResult('1'))
+        x.discard(AsyncResult('1'))
+        x.discard('1')
+        self.assertNotIn(AsyncResult('1'), x.results)
 
-        x.update([AsyncResult("2")])
+        x.update([AsyncResult('2')])
 
     def test_clear(self):
         x = ResultSet([])
@@ -295,7 +295,7 @@ class MockAsyncResultFailure(AsyncResult):
 
     @property
     def result(self):
-        return KeyError("baz")
+        return KeyError('baz')
 
     @property
     def state(self):
@@ -332,7 +332,7 @@ class SimpleBackend(object):
             self.ids = ids
 
         def get_many(self, *args, **kwargs):
-            return ((id, {"result": i}) for i, id in enumerate(self.ids))
+            return ((id, {'result': i}) for i, id in enumerate(self.ids))
 
 
 class test_TaskSetResult(AppCase):
@@ -346,8 +346,8 @@ class test_TaskSetResult(AppCase):
 
     def test_compat_properties(self):
         self.assertEqual(self.ts.taskset_id, self.ts.id)
-        self.ts.taskset_id = "foo"
-        self.assertEqual(self.ts.taskset_id, "foo")
+        self.ts.taskset_id = 'foo'
+        self.assertEqual(self.ts.taskset_id, 'foo')
 
     def test_compat_subtasks_kwarg(self):
         x = TaskSetResult(uuid(), subtasks=[1, 2, 3])
@@ -490,9 +490,9 @@ class test_failed_AsyncResult(test_GroupResult):
     def setup(self):
         self.size = 11
         subtasks = make_mock_group(10)
-        failed = mock_task("ts11", states.FAILURE, KeyError("Baz"))
+        failed = mock_task('ts11', states.FAILURE, KeyError('Baz'))
         save_result(failed)
-        failed_res = AsyncResult(failed["id"])
+        failed_res = AsyncResult(failed['id'])
         self.ts = GroupResult(uuid(), subtasks + [failed_res])
 
     def test_completed_count(self):
@@ -546,7 +546,7 @@ class test_pending_Group(AppCase):
 class RaisingTask(Task):
 
     def run(self, x, y):
-        raise KeyError("xy")
+        raise KeyError('xy')
 
 
 class test_EagerResult(AppCase):
@@ -558,13 +558,13 @@ class test_EagerResult(AppCase):
         self.assertTrue(res.wait(propagate=False))
 
     def test_wait(self):
-        res = EagerResult("x", "x", states.RETRY)
+        res = EagerResult('x', 'x', states.RETRY)
         res.wait()
         self.assertEqual(res.state, states.RETRY)
         self.assertEqual(res.status, states.RETRY)
 
     def test_forget(self):
-        res = EagerResult("x", "x", states.RETRY)
+        res = EagerResult('x', 'x', states.RETRY)
         res.forget()
 
     def test_revoke(self):

celery/tests/tasks/test_sets.py

@@ -12,7 +12,7 @@ from celery.tests.utils import Case
 
 
 class MockTask(Task):
-    name = "tasks.add"
+    name = 'tasks.add'
 
     def run(self, x, y, **kwargs):
         return x + y
@@ -29,8 +29,8 @@ class MockTask(Task):
 class test_subtask(Case):
 
     def test_behaves_like_type(self):
-        s = subtask("tasks.add", (2, 2), {"cache": True},
-                    {"routing_key": "CPU-bound"})
+        s = subtask('tasks.add', (2, 2), {'cache': True},
+                    {'routing_key': 'CPU-bound'})
         self.assertDictEqual(subtask(s), s)
 
     def test_task_argument_can_be_task_cls(self):
@@ -38,61 +38,61 @@ class test_subtask(Case):
         self.assertEqual(s.task, MockTask.name)
 
     def test_apply_async(self):
-        s = MockTask.subtask((2, 2), {"cache": True},
-                {"routing_key": "CPU-bound"})
+        s = MockTask.subtask((2, 2), {'cache': True},
+                {'routing_key': 'CPU-bound'})
         args, kwargs, options = s.apply_async()
         self.assertTupleEqual(args, (2, 2))
-        self.assertDictEqual(kwargs, {"cache": True})
-        self.assertDictEqual(options, {"routing_key": "CPU-bound"})
+        self.assertDictEqual(kwargs, {'cache': True})
+        self.assertDictEqual(options, {'routing_key': 'CPU-bound'})
 
     def test_delay_argmerge(self):
-        s = MockTask.subtask((2, ), {"cache": True},
-                {"routing_key": "CPU-bound"})
-        args, kwargs, options = s.delay(10, cache=False, other="foo")
+        s = MockTask.subtask((2, ), {'cache': True},
+                {'routing_key': 'CPU-bound'})
+        args, kwargs, options = s.delay(10, cache=False, other='foo')
         self.assertTupleEqual(args, (10, 2))
-        self.assertDictEqual(kwargs, {"cache": False, "other": "foo"})
-        self.assertDictEqual(options, {"routing_key": "CPU-bound"})
+        self.assertDictEqual(kwargs, {'cache': False, 'other': 'foo'})
+        self.assertDictEqual(options, {'routing_key': 'CPU-bound'})
 
     def test_apply_async_argmerge(self):
-        s = MockTask.subtask((2, ), {"cache": True},
-                {"routing_key": "CPU-bound"})
+        s = MockTask.subtask((2, ), {'cache': True},
+                {'routing_key': 'CPU-bound'})
         args, kwargs, options = s.apply_async((10, ),
-                                              {"cache": False, "other": "foo"},
-                                              routing_key="IO-bound",
-                                              exchange="fast")
+                                              {'cache': False, 'other': 'foo'},
+                                              routing_key='IO-bound',
+                                              exchange='fast')
 
         self.assertTupleEqual(args, (10, 2))
-        self.assertDictEqual(kwargs, {"cache": False, "other": "foo"})
-        self.assertDictEqual(options, {"routing_key": "IO-bound",
-                                        "exchange": "fast"})
+        self.assertDictEqual(kwargs, {'cache': False, 'other': 'foo'})
+        self.assertDictEqual(options, {'routing_key': 'IO-bound',
+                                        'exchange': 'fast'})
 
     def test_apply_argmerge(self):
-        s = MockTask.subtask((2, ), {"cache": True},
-                {"routing_key": "CPU-bound"})
+        s = MockTask.subtask((2, ), {'cache': True},
+                {'routing_key': 'CPU-bound'})
         args, kwargs, options = s.apply((10, ),
-                                        {"cache": False, "other": "foo"},
-                                        routing_key="IO-bound",
-                                        exchange="fast")
+                                        {'cache': False, 'other': 'foo'},
+                                        routing_key='IO-bound',
+                                        exchange='fast')
 
         self.assertTupleEqual(args, (10, 2))
-        self.assertDictEqual(kwargs, {"cache": False, "other": "foo"})
-        self.assertDictEqual(options, {"routing_key": "IO-bound",
-                                        "exchange": "fast"})
+        self.assertDictEqual(kwargs, {'cache': False, 'other': 'foo'})
+        self.assertDictEqual(options, {'routing_key': 'IO-bound',
+                                        'exchange': 'fast'})
 
     def test_is_JSON_serializable(self):
-        s = MockTask.subtask((2, ), {"cache": True},
-                {"routing_key": "CPU-bound"})
+        s = MockTask.subtask((2, ), {'cache': True},
+                {'routing_key': 'CPU-bound'})
         s.args = list(s.args)                   # tuples are not preserved
                                                 # but this doesn't matter.
         self.assertEqual(s, subtask(anyjson.loads(anyjson.dumps(s))))
 
     def test_repr(self):
-        s = MockTask.subtask((2, ), {"cache": True})
-        self.assertIn("2", repr(s))
-        self.assertIn("cache=True", repr(s))
+        s = MockTask.subtask((2, ), {'cache': True})
+        self.assertIn('2', repr(s))
+        self.assertIn('cache=True', repr(s))
 
     def test_reduce(self):
-        s = MockTask.subtask((2, ), {"cache": True})
+        s = MockTask.subtask((2, ), {'cache': True})
         cls, args = s.__reduce__()
         self.assertDictEqual(dict(cls(*args)), dict(s))
 

celery/tests/tasks/test_states.py

@@ -15,17 +15,17 @@ class test_state_precedence(Case):
         self.assertGreater(state(states.REVOKED),
                            state(states.STARTED))
         self.assertGreater(state(states.SUCCESS),
-                           state("CRASHED"))
+                           state('CRASHED'))
         self.assertGreater(state(states.FAILURE),
-                           state("CRASHED"))
-        self.assertFalse(state(states.REVOKED) > state("CRASHED"))
+                           state('CRASHED'))
+        self.assertFalse(state(states.REVOKED) > state('CRASHED'))
 
     def test_lt(self):
         self.assertLess(state(states.PENDING), state(states.SUCCESS))
         self.assertLess(state(states.RECEIVED), state(states.FAILURE))
         self.assertLess(state(states.STARTED), state(states.REVOKED))
-        self.assertLess(state("CRASHED"), state(states.SUCCESS))
-        self.assertLess(state("CRASHED"), state(states.FAILURE))
-        self.assertTrue(state(states.REVOKED) < state("CRASHED"))
-        self.assertTrue(state(states.REVOKED) <= state("CRASHED"))
-        self.assertTrue(state("CRASHED") >= state(states.REVOKED))
+        self.assertLess(state('CRASHED'), state(states.SUCCESS))
+        self.assertLess(state('CRASHED'), state(states.FAILURE))
+        self.assertTrue(state(states.REVOKED) < state('CRASHED'))
+        self.assertTrue(state(states.REVOKED) <= state('CRASHED'))
+        self.assertTrue(state('CRASHED') >= state(states.REVOKED))

celery/tests/tasks/test_tasks.py

@@ -29,7 +29,7 @@ return_True_task = task_dec()(return_True)
 
 
 def raise_exception(self, **kwargs):
-    raise Exception("%s error" % self.__class__)
+    raise Exception('%s error' % self.__class__)
 
 
 class MockApplyTask(task.Task):
@@ -43,15 +43,15 @@ class MockApplyTask(task.Task):
         self.applied += 1
 
 
-@task.task(name="c.unittest.increment_counter_task", count=0)
+@task.task(name='c.unittest.increment_counter_task', count=0)
 def increment_counter(increment_by=1):
     increment_counter.count += increment_by or 1
     return increment_counter.count
 
 
-@task.task(name="c.unittest.raising_task")
+@task.task(name='c.unittest.raising_task')
 def raising():
-    raise KeyError("foo")
+    raise KeyError('foo')
 
 
 @task.task(max_retries=3, iterations=0)
@@ -71,7 +71,7 @@ def retry_task(arg1, arg2, kwarg=1, max_retries=None, care=True):
 def retry_task_noargs(**kwargs):
     current.iterations += 1
 
-    retries = kwargs["task_retries"]
+    retries = kwargs['task_retries']
     if retries >= 3:
         return 42
     else:
@@ -82,7 +82,7 @@ def retry_task_noargs(**kwargs):
 def retry_task_mockapply(arg1, arg2, kwarg=1, **kwargs):
     current.iterations += 1
 
-    retries = kwargs["task_retries"]
+    retries = kwargs['task_retries']
     if retries >= 3:
         return arg1
     else:
@@ -98,12 +98,12 @@ class MyCustomException(Exception):
 def retry_task_customexc(arg1, arg2, kwarg=1, **kwargs):
     current.iterations += 1
 
-    retries = kwargs["task_retries"]
+    retries = kwargs['task_retries']
     if retries >= 3:
         return arg1 + kwarg
     else:
         try:
-            raise MyCustomException("Elaine Marie Benes")
+            raise MyCustomException('Elaine Marie Benes')
         except MyCustomException, exc:
             kwargs.update(kwarg=kwarg)
             raise current.retry(countdown=0, exc=exc)
@@ -119,7 +119,7 @@ class test_task_retries(Case):
 
         retry_task.__class__.max_retries = 3
         retry_task.iterations = 0
-        retry_task.apply([0xFF, 0xFFFF], {"max_retries": 10})
+        retry_task.apply([0xFF, 0xFFFF], {'max_retries': 10})
         self.assertEqual(retry_task.iterations, 11)
 
     def test_retry_no_args(self):
@@ -134,9 +134,9 @@ class test_task_retries(Case):
 
     def test_retry_not_eager(self):
         retry_task_mockapply.request.called_directly = False
-        exc = Exception("baz")
+        exc = Exception('baz')
         try:
-            retry_task_mockapply.retry(args=[4, 4], kwargs={"task_retries": 0},
+            retry_task_mockapply.retry(args=[4, 4], kwargs={'task_retries': 0},
                                        exc=exc, throw=False)
             self.assertTrue(retry_task_mockapply.__class__.applied)
         finally:
@@ -145,7 +145,7 @@ class test_task_retries(Case):
         try:
             with self.assertRaises(RetryTaskError):
                 retry_task_mockapply.retry(
-                    args=[4, 4], kwargs={"task_retries": 0},
+                    args=[4, 4], kwargs={'task_retries': 0},
                     exc=exc, throw=True)
             self.assertTrue(retry_task_mockapply.__class__.applied)
         finally:
@@ -154,13 +154,13 @@ class test_task_retries(Case):
     def test_retry_with_kwargs(self):
         retry_task_customexc.__class__.max_retries = 3
         retry_task_customexc.iterations = 0
-        retry_task_customexc.apply([0xFF, 0xFFFF], {"kwarg": 0xF})
+        retry_task_customexc.apply([0xFF, 0xFFFF], {'kwarg': 0xF})
         self.assertEqual(retry_task_customexc.iterations, 4)
 
     def test_retry_with_custom_exception(self):
         retry_task_customexc.__class__.max_retries = 2
         retry_task_customexc.iterations = 0
-        result = retry_task_customexc.apply([0xFF, 0xFFFF], {"kwarg": 0xF})
+        result = retry_task_customexc.apply([0xFF, 0xFFFF], {'kwarg': 0xF})
         with self.assertRaises(MyCustomException):
             result.get()
         self.assertEqual(retry_task_customexc.iterations, 3)
@@ -168,14 +168,14 @@ class test_task_retries(Case):
     def test_max_retries_exceeded(self):
         retry_task.__class__.max_retries = 2
         retry_task.iterations = 0
-        result = retry_task.apply([0xFF, 0xFFFF], {"care": False})
+        result = retry_task.apply([0xFF, 0xFFFF], {'care': False})
         with self.assertRaises(retry_task.MaxRetriesExceededError):
             result.get()
         self.assertEqual(retry_task.iterations, 3)
 
         retry_task.__class__.max_retries = 1
         retry_task.iterations = 0
-        result = retry_task.apply([0xFF, 0xFFFF], {"care": False})
+        result = retry_task.apply([0xFF, 0xFFFF], {'care': False})
         with self.assertRaises(retry_task.MaxRetriesExceededError):
             result.get()
         self.assertEqual(retry_task.iterations, 2)
@@ -224,16 +224,16 @@ class test_tasks(Case):
             test_eta=False, test_expires=False, **kwargs):
         next_task = consumer.queues[0].get()
         task_data = next_task.decode()
-        self.assertEqual(task_data["id"], presult.id)
-        self.assertEqual(task_data["task"], task_name)
-        task_kwargs = task_data.get("kwargs", {})
+        self.assertEqual(task_data['id'], presult.id)
+        self.assertEqual(task_data['task'], task_name)
+        task_kwargs = task_data.get('kwargs', {})
         if test_eta:
-            self.assertIsInstance(task_data.get("eta"), basestring)
-            to_datetime = parse_iso8601(task_data.get("eta"))
+            self.assertIsInstance(task_data.get('eta'), basestring)
+            to_datetime = parse_iso8601(task_data.get('eta'))
             self.assertIsInstance(to_datetime, datetime)
         if test_expires:
-            self.assertIsInstance(task_data.get("expires"), basestring)
-            to_datetime = parse_iso8601(task_data.get("expires"))
+            self.assertIsInstance(task_data.get('expires'), basestring)
+            to_datetime = parse_iso8601(task_data.get('expires'))
             self.assertIsInstance(to_datetime, datetime)
         for arg_name, arg_value in kwargs.items():
             self.assertEqual(task_kwargs.get(arg_name), arg_value)
@@ -241,31 +241,31 @@ class test_tasks(Case):
     def test_incomplete_task_cls(self):
 
         class IncompleteTask(task.Task):
-            name = "c.unittest.t.itask"
+            name = 'c.unittest.t.itask'
 
         with self.assertRaises(NotImplementedError):
             IncompleteTask().run()
 
     def test_task_kwargs_must_be_dictionary(self):
         with self.assertRaises(ValueError):
-            increment_counter.apply_async([], "str")
+            increment_counter.apply_async([], 'str')
 
     def test_task_args_must_be_list(self):
         with self.assertRaises(ValueError):
-            increment_counter.apply_async("str", {})
+            increment_counter.apply_async('str', {})
 
     def test_regular_task(self):
-        T1 = self.createTask("c.unittest.t.t1")
+        T1 = self.createTask('c.unittest.t.t1')
         self.assertIsInstance(T1, task.BaseTask)
         self.assertTrue(T1.run())
         self.assertTrue(callable(T1),
-                "Task class is callable()")
+                'Task class is callable()')
         self.assertTrue(T1(),
-                "Task class runs run() when called")
+                'Task class runs run() when called')
 
         consumer = T1.get_consumer()
         with self.assertRaises(NotImplementedError):
-            consumer.receive("foo", "foo")
+            consumer.receive('foo', 'foo')
         consumer.purge()
         self.assertIsNone(consumer.queues[0].get())
 
@@ -274,27 +274,27 @@ class test_tasks(Case):
         self.assertNextTaskDataEqual(consumer, presult, T1.name)
 
         # With arguments.
-        presult2 = T1.apply_async(kwargs=dict(name="George Costanza"))
+        presult2 = T1.apply_async(kwargs=dict(name='George Costanza'))
         self.assertNextTaskDataEqual(consumer, presult2, T1.name,
-                name="George Costanza")
+                name='George Costanza')
 
         # send_task
-        sresult = send_task(T1.name, kwargs=dict(name="Elaine M. Benes"))
+        sresult = send_task(T1.name, kwargs=dict(name='Elaine M. Benes'))
         self.assertNextTaskDataEqual(consumer, sresult, T1.name,
-                name="Elaine M. Benes")
+                name='Elaine M. Benes')
 
         # With eta.
-        presult2 = T1.apply_async(kwargs=dict(name="George Costanza"),
+        presult2 = T1.apply_async(kwargs=dict(name='George Costanza'),
                             eta=datetime.utcnow() + timedelta(days=1),
                             expires=datetime.utcnow() + timedelta(days=2))
         self.assertNextTaskDataEqual(consumer, presult2, T1.name,
-                name="George Costanza", test_eta=True, test_expires=True)
+                name='George Costanza', test_eta=True, test_expires=True)
 
         # With countdown.
-        presult2 = T1.apply_async(kwargs=dict(name="George Costanza"),
+        presult2 = T1.apply_async(kwargs=dict(name='George Costanza'),
                                   countdown=10, expires=12)
         self.assertNextTaskDataEqual(consumer, presult2, T1.name,
-                name="George Costanza", test_eta=True, test_expires=True)
+                name='George Costanza', test_eta=True, test_expires=True)
 
         # Discarding all tasks.
         consumer.purge()
@@ -310,40 +310,40 @@ class test_tasks(Case):
         self.assertTrue(publisher.exchange)
 
     def test_context_get(self):
-        request = self.createTask("c.unittest.t.c.g").request
+        request = self.createTask('c.unittest.t.c.g').request
         request.foo = 32
-        self.assertEqual(request.get("foo"), 32)
-        self.assertEqual(request.get("bar", 36), 36)
+        self.assertEqual(request.get('foo'), 32)
+        self.assertEqual(request.get('bar', 36), 36)
         request.clear()
 
     def test_task_class_repr(self):
-        task = self.createTask("c.unittest.t.repr")
-        self.assertIn("class Task of", repr(task.app.Task))
+        task = self.createTask('c.unittest.t.repr')
+        self.assertIn('class Task of', repr(task.app.Task))
         prev, task.app.Task._app = task.app.Task._app, None
         try:
-            self.assertIn("unbound", repr(task.app.Task, ))
+            self.assertIn('unbound', repr(task.app.Task, ))
         finally:
             task.app.Task._app = prev
 
     def test_bind_no_magic_kwargs(self):
-        task = self.createTask("c.unittest.t.magic_kwargs")
+        task = self.createTask('c.unittest.t.magic_kwargs')
         task.__class__.accept_magic_kwargs = None
         task.bind(task.app)
 
     def test_annotate(self):
-        with patch("celery.app.task.resolve_all_annotations") as anno:
-            anno.return_value = [{"FOO": "BAR"}]
+        with patch('celery.app.task.resolve_all_annotations') as anno:
+            anno.return_value = [{'FOO': 'BAR'}]
             Task.annotate()
-            self.assertEqual(Task.FOO, "BAR")
+            self.assertEqual(Task.FOO, 'BAR')
 
     def test_after_return(self):
-        task = self.createTask("c.unittest.t.after_return")
+        task = self.createTask('c.unittest.t.after_return')
         task.request.chord = return_True_task.s()
-        task.after_return("SUCCESS", 1.0, "foobar", (), {}, None)
+        task.after_return('SUCCESS', 1.0, 'foobar', (), {}, None)
         task.request.clear()
 
     def test_send_task_sent_event(self):
-        T1 = self.createTask("c.unittest.t.t1")
+        T1 = self.createTask('c.unittest.t.t1')
         app = T1.app
         conn = app.broker_connection()
         chan = conn.channel()
@@ -354,7 +354,7 @@ class test_tasks(Case):
             channel = chan
 
             def delay_task(self, *args, **kwargs):
-                dispatcher[0] = kwargs.get("event_dispatcher")
+                dispatcher[0] = kwargs.get('event_dispatcher')
 
         try:
             T1.apply_async(publisher=Pub())
@@ -368,12 +368,12 @@ class test_tasks(Case):
     def test_get_publisher(self):
         connection = app_or_default().broker_connection()
         p = increment_counter.get_publisher(connection, auto_declare=False,
-                                            exchange="foo")
-        self.assertEqual(p.exchange.name, "foo")
+                                            exchange='foo')
+        self.assertEqual(p.exchange.name, 'foo')
         p = increment_counter.get_publisher(connection, auto_declare=False,
-                                            exchange="foo",
-                                            exchange_type="fanout")
-        self.assertEqual(p.exchange.type, "fanout")
+                                            exchange='foo',
+                                            exchange_type='fanout')
+        self.assertEqual(p.exchange.type, 'fanout')
 
     def test_update_state(self):
 
@@ -382,14 +382,14 @@ class test_tasks(Case):
             pass
 
         tid = uuid()
-        yyy.update_state(tid, "FROBULATING", {"fooz": "baaz"})
-        self.assertEqual(yyy.AsyncResult(tid).status, "FROBULATING")
-        self.assertDictEqual(yyy.AsyncResult(tid).result, {"fooz": "baaz"})
+        yyy.update_state(tid, 'FROBULATING', {'fooz': 'baaz'})
+        self.assertEqual(yyy.AsyncResult(tid).status, 'FROBULATING')
+        self.assertDictEqual(yyy.AsyncResult(tid).result, {'fooz': 'baaz'})
 
         yyy.request.id = tid
-        yyy.update_state(state="FROBUZATING", meta={"fooz": "baaz"})
-        self.assertEqual(yyy.AsyncResult(tid).status, "FROBUZATING")
-        self.assertDictEqual(yyy.AsyncResult(tid).result, {"fooz": "baaz"})
+        yyy.update_state(state='FROBUZATING', meta={'fooz': 'baaz'})
+        self.assertEqual(yyy.AsyncResult(tid).status, 'FROBUZATING')
+        self.assertDictEqual(yyy.AsyncResult(tid).result, {'fooz': 'baaz'})
 
     def test_repr(self):
 
@@ -397,7 +397,7 @@ class test_tasks(Case):
         def task_test_repr():
             pass
 
-        self.assertIn("task_test_repr", repr(task_test_repr))
+        self.assertIn('task_test_repr', repr(task_test_repr))
 
     def test_has___name__(self):
 
@@ -408,7 +408,7 @@ class test_tasks(Case):
         self.assertTrue(yyy2.__name__)
 
     def test_get_logger(self):
-        t1 = self.createTask("c.unittest.t.t1")
+        t1 = self.createTask('c.unittest.t.t1')
         logfh = WhateverIO()
         logger = t1.get_logger(logfile=logfh, loglevel=0)
         self.assertTrue(logger)
@@ -451,15 +451,15 @@ class test_TaskSet(Case):
         consumer = increment_counter.get_consumer()
         for subtask in subtasks:
             m = consumer.queues[0].get().payload
-            self.assertDictContainsSubset({"taskset": taskset_id,
-                                           "task": increment_counter.name,
-                                           "id": subtask.id}, m)
+            self.assertDictContainsSubset({'taskset': taskset_id,
+                                           'task': increment_counter.name,
+                                           'id': subtask.id}, m)
             increment_counter(
-                    increment_by=m.get("kwargs", {}).get("increment_by"))
+                    increment_by=m.get('kwargs', {}).get('increment_by'))
         self.assertEqual(increment_counter.count, sum(xrange(1, 10)))
 
     def test_named_taskset(self):
-        prefix = "test_named_taskset-"
+        prefix = 'test_named_taskset-'
         ts = task.TaskSet([return_True_task.subtask([1])])
         res = ts.apply(taskset_id=prefix + uuid())
         self.assertTrue(res.taskset_id.startswith(prefix))
@@ -496,12 +496,12 @@ class test_apply_task(Case):
         e = increment_counter.apply(args=[1])
         self.assertEqual(e.get(), 2)
 
-        e = increment_counter.apply(kwargs={"increment_by": 4})
+        e = increment_counter.apply(kwargs={'increment_by': 4})
         self.assertEqual(e.get(), 6)
 
         self.assertTrue(e.successful())
         self.assertTrue(e.ready())
-        self.assertTrue(repr(e).startswith("<EagerResult:"))
+        self.assertTrue(repr(e).startswith('<EagerResult:'))
 
         f = raising.apply()
         self.assertTrue(f.ready())
@@ -520,7 +520,7 @@ class test_periodic_tasks(Case):
 
     def test_must_have_run_every(self):
         with self.assertRaises(NotImplementedError):
-            type("Foo", (task.PeriodicTask, ), {"__module__": __name__})
+            type('Foo', (task.PeriodicTask, ), {'__module__': __name__})
 
     def test_remaining_estimate(self):
         self.assertIsInstance(
@@ -552,7 +552,7 @@ def every_minute():
     pass
 
 
-@task.periodic_task(run_every=crontab(minute="*/15"))
+@task.periodic_task(run_every=crontab(minute='*/15'))
 def quarterly():
     pass
 
@@ -568,21 +568,21 @@ def daily():
 
 
 @task.periodic_task(run_every=crontab(hour=7, minute=30,
-                                      day_of_week="thursday"))
+                                      day_of_week='thursday'))
 def weekly():
     pass
 
 
 @task.periodic_task(run_every=crontab(hour=7, minute=30,
-                                      day_of_week="thursday",
-                                      day_of_month="8-14"))
+                                      day_of_week='thursday',
+                                      day_of_month='8-14'))
 def monthly():
     pass
 
 
 @task.periodic_task(run_every=crontab(hour=7, minute=30,
-                                      day_of_week="thursday",
-                                      day_of_month="8-14",
+                                      day_of_week='thursday',
+                                      day_of_month='8-14',
                                       month_of_year=3))
 def yearly():
     pass
@@ -609,7 +609,7 @@ def patch_crontab_nowfun(cls, retval):
 class test_crontab_parser(Case):
 
     def test_crontab_reduce(self):
-        self.assertTrue(loads(dumps(crontab("*"))))
+        self.assertTrue(loads(dumps(crontab('*'))))
 
     def test_range_steps_not_enough(self):
         with self.assertRaises(crontab_parser.ParseException):
@@ -704,22 +704,22 @@ class test_crontab_parser(Case):
             crontab._expand_cronspec(object(), 100)
 
     def test_repr(self):
-        self.assertIn("*", repr(crontab("*")))
+        self.assertIn('*', repr(crontab('*')))
 
     def test_eq(self):
-        self.assertEqual(crontab(day_of_week="1, 2"),
-                         crontab(day_of_week="1-2"))
-        self.assertEqual(crontab(day_of_month="1, 16, 31"),
-                         crontab(day_of_month="*/15"))
-        self.assertEqual(crontab(minute="1", hour="2", day_of_week="5",
-                                 day_of_month="10", month_of_year="5"),
-                         crontab(minute="1", hour="2", day_of_week="5",
-                                 day_of_month="10", month_of_year="5"))
-        self.assertNotEqual(crontab(minute="1"), crontab(minute="2"))
-        self.assertNotEqual(crontab(month_of_year="1"),
-                            crontab(month_of_year="2"))
-        self.assertFalse(object() == crontab(minute="1"))
-        self.assertFalse(crontab(minute="1") == object())
+        self.assertEqual(crontab(day_of_week='1, 2'),
+                         crontab(day_of_week='1-2'))
+        self.assertEqual(crontab(day_of_month='1, 16, 31'),
+                         crontab(day_of_month='*/15'))
+        self.assertEqual(crontab(minute='1', hour='2', day_of_week='5',
+                                 day_of_month='10', month_of_year='5'),
+                         crontab(minute='1', hour='2', day_of_week='5',
+                                 day_of_month='10', month_of_year='5'))
+        self.assertNotEqual(crontab(minute='1'), crontab(minute='2'))
+        self.assertNotEqual(crontab(month_of_year='1'),
+                            crontab(month_of_year='2'))
+        self.assertFalse(object() == crontab(minute='1'))
+        self.assertFalse(crontab(minute='1') == object())
 
 
 class test_crontab_remaining_estimate(Case):
@@ -761,13 +761,13 @@ class test_crontab_remaining_estimate(Case):
     def test_weekday(self):
         next = self.next_ocurrance(crontab(minute=30,
                                            hour=14,
-                                           day_of_week="sat"),
+                                           day_of_week='sat'),
                                    datetime(2010, 9, 11, 14, 30, 15))
         self.assertEqual(next, datetime(2010, 9, 18, 14, 30))
 
     def test_not_weekday(self):
         next = self.next_ocurrance(crontab(minute=[5, 42],
-                                           day_of_week="mon-fri"),
+                                           day_of_week='mon-fri'),
                                    datetime(2010, 9, 11, 14, 30, 15))
         self.assertEqual(next, datetime(2010, 9, 13, 0, 5))
 
@@ -787,28 +787,28 @@ class test_crontab_remaining_estimate(Case):
     def test_weekday_monthday(self):
         next = self.next_ocurrance(crontab(minute=30,
                                            hour=14,
-                                           day_of_week="mon",
+                                           day_of_week='mon',
                                            day_of_month=18),
                                    datetime(2010, 1, 18, 14, 30, 15))
         self.assertEqual(next, datetime(2010, 10, 18, 14, 30))
 
     def test_monthday_not_weekday(self):
         next = self.next_ocurrance(crontab(minute=[5, 42],
-                                           day_of_week="sat",
+                                           day_of_week='sat',
                                            day_of_month=29),
                                    datetime(2010, 1, 29, 0, 5, 15))
         self.assertEqual(next, datetime(2010, 5, 29, 0, 5))
 
     def test_weekday_not_monthday(self):
         next = self.next_ocurrance(crontab(minute=[5, 42],
-                                           day_of_week="mon",
+                                           day_of_week='mon',
                                            day_of_month=18),
                                    datetime(2010, 1, 11, 0, 5, 15))
         self.assertEqual(next, datetime(2010, 1, 18, 0, 5))
 
     def test_not_weekday_not_monthday(self):
         next = self.next_ocurrance(crontab(minute=[5, 42],
-                                           day_of_week="mon",
+                                           day_of_week='mon',
                                            day_of_month=18),
                                    datetime(2010, 1, 10, 0, 5, 15))
         self.assertEqual(next, datetime(2010, 1, 18, 0, 5))
@@ -830,7 +830,7 @@ class test_crontab_remaining_estimate(Case):
     def test_weekmonthdayyear(self):
         next = self.next_ocurrance(crontab(minute=30,
                                            hour=14,
-                                           day_of_week="fri",
+                                           day_of_week='fri',
                                            day_of_month=29,
                                            month_of_year=1),
                                    datetime(2010, 1, 22, 14, 30, 15))
@@ -838,58 +838,58 @@ class test_crontab_remaining_estimate(Case):
 
     def test_monthdayyear_not_week(self):
         next = self.next_ocurrance(crontab(minute=[5, 42],
-                                           day_of_week="wed,thu",
+                                           day_of_week='wed,thu',
                                            day_of_month=29,
-                                           month_of_year="1,4,7"),
+                                           month_of_year='1,4,7'),
                                    datetime(2010, 1, 29, 14, 30, 15))
         self.assertEqual(next, datetime(2010, 4, 29, 0, 5))
 
     def test_weekdaymonthyear_not_monthday(self):
         next = self.next_ocurrance(crontab(minute=30,
                                            hour=14,
-                                           day_of_week="fri",
+                                           day_of_week='fri',
                                            day_of_month=29,
-                                           month_of_year="1-10"),
+                                           month_of_year='1-10'),
                                    datetime(2010, 1, 29, 14, 30, 15))
         self.assertEqual(next, datetime(2010, 10, 29, 14, 30))
 
     def test_weekmonthday_not_monthyear(self):
         next = self.next_ocurrance(crontab(minute=[5, 42],
-                                           day_of_week="fri",
+                                           day_of_week='fri',
                                            day_of_month=29,
-                                           month_of_year="2-10"),
+                                           month_of_year='2-10'),
                                    datetime(2010, 1, 29, 14, 30, 15))
         self.assertEqual(next, datetime(2010, 10, 29, 0, 5))
 
     def test_weekday_not_monthdayyear(self):
         next = self.next_ocurrance(crontab(minute=[5, 42],
-                                           day_of_week="mon",
+                                           day_of_week='mon',
                                            day_of_month=18,
-                                           month_of_year="2-10"),
+                                           month_of_year='2-10'),
                                    datetime(2010, 1, 11, 0, 5, 15))
         self.assertEqual(next, datetime(2010, 10, 18, 0, 5))
 
     def test_monthday_not_weekdaymonthyear(self):
         next = self.next_ocurrance(crontab(minute=[5, 42],
-                                           day_of_week="mon",
+                                           day_of_week='mon',
                                            day_of_month=29,
-                                           month_of_year="2-4"),
+                                           month_of_year='2-4'),
                                    datetime(2010, 1, 29, 0, 5, 15))
         self.assertEqual(next, datetime(2010, 3, 29, 0, 5))
 
     def test_monthyear_not_weekmonthday(self):
         next = self.next_ocurrance(crontab(minute=[5, 42],
-                                           day_of_week="mon",
+                                           day_of_week='mon',
                                            day_of_month=29,
-                                           month_of_year="2-4"),
+                                           month_of_year='2-4'),
                                    datetime(2010, 2, 28, 0, 5, 15))
         self.assertEqual(next, datetime(2010, 3, 29, 0, 5))
 
     def test_not_weekmonthdayyear(self):
         next = self.next_ocurrance(crontab(minute=[5, 42],
-                                           day_of_week="fri,sat",
+                                           day_of_week='fri,sat',
                                            day_of_month=29,
-                                           month_of_year="2-10"),
+                                           month_of_year='2-10'),
                                    datetime(2010, 1, 28, 14, 30, 15))
         self.assertEqual(next, datetime(2010, 5, 29, 0, 5))
 

celery/tests/tasks/test_trace.py

@@ -26,7 +26,7 @@ def raises(exc):
 
 
 def trace(task, args=(), kwargs={}, propagate=False):
-    return eager_trace_task(task, "id-1", args, kwargs,
+    return eager_trace_task(task, 'id-1', args, kwargs,
                       propagate=propagate)
 
 
@@ -42,33 +42,33 @@ class test_trace(Case):
             trace(raises, (SystemExit(), ), {})
 
     def test_trace_RetryTaskError(self):
-        exc = RetryTaskError("foo", "bar")
+        exc = RetryTaskError('foo', 'bar')
         _, info = trace(raises, (exc, ), {})
         self.assertEqual(info.state, states.RETRY)
         self.assertIs(info.retval, exc)
 
     def test_trace_exception(self):
-        exc = KeyError("foo")
+        exc = KeyError('foo')
         _, info = trace(raises, (exc, ), {})
         self.assertEqual(info.state, states.FAILURE)
         self.assertIs(info.retval, exc)
 
     def test_trace_exception_propagate(self):
         with self.assertRaises(KeyError):
-            trace(raises, (KeyError("foo"), ), {}, propagate=True)
+            trace(raises, (KeyError('foo'), ), {}, propagate=True)
 
-    @patch("celery.task.trace.build_tracer")
-    @patch("celery.task.trace.report_internal_error")
+    @patch('celery.task.trace.build_tracer')
+    @patch('celery.task.trace.report_internal_error')
     def test_outside_body_error(self, report_internal_error, build_tracer):
         tracer = Mock()
-        tracer.side_effect = KeyError("foo")
+        tracer.side_effect = KeyError('foo')
         build_tracer.return_value = tracer
 
         @current_app.task
         def xtask():
             pass
 
-        trace_task(xtask, "uuid", (), {})
+        trace_task(xtask, 'uuid', (), {})
         self.assertTrue(report_internal_error.call_count)
         self.assertIs(xtask.__trace__, tracer)
 
@@ -76,7 +76,7 @@ class test_trace(Case):
 class test_TraceInfo(Case):
 
     class TI(TraceInfo):
-        __slots__ = TraceInfo.__slots__ + ("__dict__", )
+        __slots__ = TraceInfo.__slots__ + ('__dict__', )
 
     def test_handle_error_state(self):
         x = self.TI(states.FAILURE)

celery/tests/utilities/test_compat.py

@@ -11,11 +11,11 @@ from celery.tests.utils import Case
 class test_MagicModule(Case):
 
     def test_class_property_set_without_type(self):
-        self.assertTrue(ModernTask.__dict__["app"].__get__(CompatTask()))
+        self.assertTrue(ModernTask.__dict__['app'].__get__(CompatTask()))
 
     def test_class_property_set_on_class(self):
-        self.assertIs(ModernTask.__dict__["app"].__set__(None, None),
-                      ModernTask.__dict__["app"])
+        self.assertIs(ModernTask.__dict__['app'].__set__(None, None),
+                      ModernTask.__dict__['app'])
 
     def test_class_property_set(self):
 
@@ -23,7 +23,7 @@ class test_MagicModule(Case):
             pass
 
         app = celery.Celery(set_as_current=False)
-        ModernTask.__dict__["app"].__set__(X(), app)
+        ModernTask.__dict__['app'].__set__(X(), app)
         self.assertEqual(X.app, app)
 
     def test_dir(self):
@@ -31,14 +31,14 @@ class test_MagicModule(Case):
 
     def test_direct(self):
         import sys
-        prev_celery = sys.modules.pop("celery", None)
-        prev_task = sys.modules.pop("celery.task", None)
+        prev_celery = sys.modules.pop('celery', None)
+        prev_task = sys.modules.pop('celery.task', None)
         try:
             import celery
             self.assertTrue(celery.task)
         finally:
-            sys.modules["celery"] = prev_celery
-            sys.modules["celery.task"] = prev_task
+            sys.modules['celery'] = prev_celery
+            sys.modules['celery.task'] = prev_task
 
     def test_app_attrs(self):
         self.assertEqual(celery.task.control.broadcast,

celery/tests/utilities/test_datastructures.py

@@ -21,30 +21,30 @@ class test_DictAttribute(Case):
 
     def test_get_set(self):
         x = DictAttribute(Object())
-        x["foo"] = "The quick brown fox"
-        self.assertEqual(x["foo"], "The quick brown fox")
-        self.assertEqual(x["foo"], x.obj.foo)
-        self.assertEqual(x.get("foo"), "The quick brown fox")
-        self.assertIsNone(x.get("bar"))
+        x['foo'] = 'The quick brown fox'
+        self.assertEqual(x['foo'], 'The quick brown fox')
+        self.assertEqual(x['foo'], x.obj.foo)
+        self.assertEqual(x.get('foo'), 'The quick brown fox')
+        self.assertIsNone(x.get('bar'))
         with self.assertRaises(KeyError):
-            x["bar"]
+            x['bar']
 
     def test_setdefault(self):
         x = DictAttribute(Object())
-        self.assertEqual(x.setdefault("foo", "NEW"), "NEW")
-        self.assertEqual(x.setdefault("foo", "XYZ"), "NEW")
+        self.assertEqual(x.setdefault('foo', 'NEW'), 'NEW')
+        self.assertEqual(x.setdefault('foo', 'XYZ'), 'NEW')
 
     def test_contains(self):
         x = DictAttribute(Object())
-        x["foo"] = 1
-        self.assertIn("foo", x)
-        self.assertNotIn("bar", x)
+        x['foo'] = 1
+        self.assertIn('foo', x)
+        self.assertNotIn('bar', x)
 
     def test_items(self):
         obj = Object()
         obj.attr1 = 1
         x = DictAttribute(obj)
-        x["attr2"] = 2
+        x['attr2'] = 2
         self.assertDictEqual(dict(x.iteritems()),
                              dict(attr1=1, attr2=2))
         self.assertDictEqual(dict(x.items()),
@@ -54,19 +54,19 @@ class test_DictAttribute(Case):
 class test_ConfigurationView(Case):
 
     def setUp(self):
-        self.view = ConfigurationView({"changed_key": 1,
-                                       "both": 2},
-                                      [{"default_key": 1,
-                                       "both": 1}])
+        self.view = ConfigurationView({'changed_key': 1,
+                                       'both': 2},
+                                      [{'default_key': 1,
+                                       'both': 1}])
 
     def test_setdefault(self):
-        self.assertEqual(self.view.setdefault("both", 36), 2)
-        self.assertEqual(self.view.setdefault("new", 36), 36)
+        self.assertEqual(self.view.setdefault('both', 36), 2)
+        self.assertEqual(self.view.setdefault('new', 36), 36)
 
     def test_get(self):
-        self.assertEqual(self.view.get("both"), 2)
+        self.assertEqual(self.view.get('both'), 2)
         sp = object()
-        self.assertIs(self.view.get("nonexisting", sp), sp)
+        self.assertIs(self.view.get('nonexisting', sp), sp)
 
     def test_update(self):
         changes = dict(self.view.changes)
@@ -75,18 +75,18 @@ class test_ConfigurationView(Case):
                              dict(changes, a=1, b=2, c=3))
 
     def test_contains(self):
-        self.assertIn("changed_key", self.view)
-        self.assertIn("default_key", self.view)
-        self.assertNotIn("new", self.view)
+        self.assertIn('changed_key', self.view)
+        self.assertIn('default_key', self.view)
+        self.assertNotIn('new', self.view)
 
     def test_repr(self):
-        self.assertIn("changed_key", repr(self.view))
-        self.assertIn("default_key", repr(self.view))
+        self.assertIn('changed_key', repr(self.view))
+        self.assertIn('default_key', repr(self.view))
 
     def test_iter(self):
-        expected = {"changed_key": 1,
-                    "default_key": 1,
-                    "both": 2}
+        expected = {'changed_key': 1,
+                    'default_key': 1,
+                    'both': 2}
         self.assertDictEqual(dict(self.view.items()), expected)
         self.assertItemsEqual(list(iter(self.view)),
                               expected.keys())
@@ -99,13 +99,13 @@ class test_ExceptionInfo(Case):
     def test_exception_info(self):
 
         try:
-            raise LookupError("The quick brown fox jumps...")
+            raise LookupError('The quick brown fox jumps...')
         except Exception:
             einfo = ExceptionInfo()
             self.assertEqual(str(einfo), einfo.traceback)
             self.assertIsInstance(einfo.exception, LookupError)
             self.assertTupleEqual(einfo.exception.args,
-                    ("The quick brown fox jumps...", ))
+                    ('The quick brown fox jumps...', ))
             self.assertTrue(einfo.traceback)
 
             r = repr(einfo)
@@ -116,18 +116,18 @@ class test_LimitedSet(Case):
 
     def test_add(self):
         s = LimitedSet(maxlen=2)
-        s.add("foo")
-        s.add("bar")
-        for n in "foo", "bar":
+        s.add('foo')
+        s.add('bar')
+        for n in 'foo', 'bar':
             self.assertIn(n, s)
-        s.add("baz")
-        for n in "bar", "baz":
+        s.add('baz')
+        for n in 'bar', 'baz':
             self.assertIn(n, s)
-        self.assertNotIn("foo", s)
+        self.assertNotIn('foo', s)
 
     def test_iter(self):
         s = LimitedSet(maxlen=2)
-        items = "foo", "bar"
+        items = 'foo', 'bar'
         for item in items:
             s.add(item)
         l = list(iter(s))
@@ -136,37 +136,37 @@ class test_LimitedSet(Case):
 
     def test_repr(self):
         s = LimitedSet(maxlen=2)
-        items = "foo", "bar"
+        items = 'foo', 'bar'
         for item in items:
             s.add(item)
-        self.assertIn("LimitedSet(", repr(s))
+        self.assertIn('LimitedSet(', repr(s))
 
     def test_clear(self):
         s = LimitedSet(maxlen=2)
-        s.add("foo")
-        s.add("bar")
+        s.add('foo')
+        s.add('bar')
         self.assertEqual(len(s), 2)
         s.clear()
         self.assertFalse(s)
 
     def test_update(self):
         s1 = LimitedSet(maxlen=2)
-        s1.add("foo")
-        s1.add("bar")
+        s1.add('foo')
+        s1.add('bar')
 
         s2 = LimitedSet(maxlen=2)
         s2.update(s1)
-        self.assertItemsEqual(list(s2), ["foo", "bar"])
+        self.assertItemsEqual(list(s2), ['foo', 'bar'])
 
-        s2.update(["bla"])
-        self.assertItemsEqual(list(s2), ["bla", "bar"])
+        s2.update(['bla'])
+        self.assertItemsEqual(list(s2), ['bla', 'bar'])
 
-        s2.update(["do", "re"])
-        self.assertItemsEqual(list(s2), ["do", "re"])
+        s2.update(['do', 're'])
+        self.assertItemsEqual(list(s2), ['do', 're'])
 
     def test_as_dict(self):
         s = LimitedSet(maxlen=2)
-        s.add("foo")
+        s.add('foo')
         self.assertIsInstance(s.as_dict(), dict)
 
 
@@ -233,13 +233,13 @@ class test_LRUCache(Case):
             burglar.stop()
 
     def test_safe_to_remove_while_iteritems(self):
-        self.assertSafeIter("iteritems")
+        self.assertSafeIter('iteritems')
 
     def test_safe_to_remove_while_keys(self):
-        self.assertSafeIter("keys")
+        self.assertSafeIter('keys')
 
     def test_safe_to_remove_while_itervalues(self):
-        self.assertSafeIter("itervalues")
+        self.assertSafeIter('itervalues')
 
     def test_items(self):
         c = LRUCache()
@@ -250,22 +250,22 @@ class test_LRUCache(Case):
 class test_AttributeDict(Case):
 
     def test_getattr__setattr(self):
-        x = AttributeDict({"foo": "bar"})
-        self.assertEqual(x["foo"], "bar")
+        x = AttributeDict({'foo': 'bar'})
+        self.assertEqual(x['foo'], 'bar')
         with self.assertRaises(AttributeError):
             x.bar
-        x.bar = "foo"
-        self.assertEqual(x["bar"], "foo")
+        x.bar = 'foo'
+        self.assertEqual(x['bar'], 'foo')
 
 
 class test_DependencyGraph(Case):
 
     def graph1(self):
         return DependencyGraph([
-            ("A", []),
-            ("B", []),
-            ("C", ["A"]),
-            ("D", ["C", "B"]),
+            ('A', []),
+            ('B', []),
+            ('C', ['A']),
+            ('D', ['C', 'B']),
         ])
 
     def test_repr(self):
@@ -274,20 +274,20 @@ class test_DependencyGraph(Case):
     def test_topsort(self):
         order = self.graph1().topsort()
         # C must start before D
-        self.assertLess(order.index("C"), order.index("D"))
+        self.assertLess(order.index('C'), order.index('D'))
         # and B must start before D
-        self.assertLess(order.index("B"), order.index("D"))
+        self.assertLess(order.index('B'), order.index('D'))
         # and A must start before C
-        self.assertLess(order.index("A"), order.index("C"))
+        self.assertLess(order.index('A'), order.index('C'))
 
     def test_edges(self):
         self.assertListEqual(list(self.graph1().edges()),
-                             ["C", "D"])
+                             ['C', 'D'])
 
     def test_items(self):
         self.assertDictEqual(dict(self.graph1().items()),
-                {"A": [], "B": [],
-                 "C": ["A"], "D": ["C", "B"]})
+                {'A': [], 'B': [],
+                 'C': ['A'], 'D': ['C', 'B']})
 
     def test_to_dot(self):
         s = WhateverIO()

celery/tests/utilities/test_dispatcher.py

@@ -18,7 +18,7 @@ if sys.platform.startswith('java'):
         gc.collect()
         time.sleep(0.1)
 
-elif hasattr(sys, "pypy_version_info"):
+elif hasattr(sys, 'pypy_version_info'):
 
     def garbage_collect():  # noqa
         # Collecting weakreferences can take two collections on PyPy.
@@ -42,7 +42,7 @@ class Callable(object):
     def a(self, val, **kwargs):
         return val
 
-a_signal = Signal(providing_args=["val"])
+a_signal = Signal(providing_args=['val'])
 
 
 class DispatcherTests(Case):
@@ -57,16 +57,16 @@ class DispatcherTests(Case):
 
     def testExact(self):
         a_signal.connect(receiver_1_arg, sender=self)
-        expected = [(receiver_1_arg, "test")]
-        result = a_signal.send(sender=self, val="test")
+        expected = [(receiver_1_arg, 'test')]
+        result = a_signal.send(sender=self, val='test')
         self.assertEqual(result, expected)
         a_signal.disconnect(receiver_1_arg, sender=self)
         self._testIsClean(a_signal)
 
     def testIgnoredSender(self):
         a_signal.connect(receiver_1_arg)
-        expected = [(receiver_1_arg, "test")]
-        result = a_signal.send(sender=self, val="test")
+        expected = [(receiver_1_arg, 'test')]
+        result = a_signal.send(sender=self, val='test')
         self.assertEqual(result, expected)
         a_signal.disconnect(receiver_1_arg)
         self._testIsClean(a_signal)
@@ -77,7 +77,7 @@ class DispatcherTests(Case):
         expected = []
         del a
         garbage_collect()
-        result = a_signal.send(sender=self, val="test")
+        result = a_signal.send(sender=self, val='test')
         self.assertEqual(result, expected)
         self._testIsClean(a_signal)
 
@@ -89,7 +89,7 @@ class DispatcherTests(Case):
         a_signal.connect(a)
         a_signal.connect(a)
         a_signal.connect(a)
-        result = a_signal.send(sender=self, val="test")
+        result = a_signal.send(sender=self, val='test')
         self.assertEqual(len(result), 1)
         self.assertEqual(len(a_signal.receivers), 1)
         del a
@@ -105,10 +105,10 @@ class DispatcherTests(Case):
         def uid_based_receiver_2(**kwargs):
             pass
 
-        a_signal.connect(uid_based_receiver_1, dispatch_uid="uid")
-        a_signal.connect(uid_based_receiver_2, dispatch_uid="uid")
+        a_signal.connect(uid_based_receiver_1, dispatch_uid='uid')
+        a_signal.connect(uid_based_receiver_2, dispatch_uid='uid')
         self.assertEqual(len(a_signal.receivers), 1)
-        a_signal.disconnect(dispatch_uid="uid")
+        a_signal.disconnect(dispatch_uid='uid')
         self._testIsClean(a_signal)
 
     def testRobust(self):
@@ -118,7 +118,7 @@ class DispatcherTests(Case):
             raise ValueError('this')
 
         a_signal.connect(fails)
-        result = a_signal.send_robust(sender=self, val="test")
+        result = a_signal.send_robust(sender=self, val='test')
         err = result[0][1]
         self.assertTrue(isinstance(err, ValueError))
         self.assertEqual(err.args, ('this',))

celery/tests/utilities/test_encoding.py

@@ -12,25 +12,25 @@ class test_encoding(Case):
 
     def test_safe_str(self):
         self.assertTrue(encoding.safe_str(object()))
-        self.assertTrue(encoding.safe_str("foo"))
-        self.assertTrue(encoding.safe_str(u"foo"))
+        self.assertTrue(encoding.safe_str('foo'))
+        self.assertTrue(encoding.safe_str(u'foo'))
 
     def test_safe_str_UnicodeDecodeError(self):
         if sys.version_info >= (3, 0):
-            raise SkipTest("py3k: not relevant")
+            raise SkipTest('py3k: not relevant')
 
         class foo(unicode):
 
             def encode(self, *args, **kwargs):
-                raise UnicodeDecodeError("foo")
+                raise UnicodeDecodeError('foo')
 
-        self.assertIn("<Unrepresentable", encoding.safe_str(foo()))
+        self.assertIn('<Unrepresentable', encoding.safe_str(foo()))
 
     def test_safe_repr(self):
         self.assertTrue(encoding.safe_repr(object()))
 
         class foo(object):
             def __repr__(self):
-                raise ValueError("foo")
+                raise ValueError('foo')
 
         self.assertTrue(encoding.safe_repr(foo()))

celery/tests/utilities/test_imports.py

@@ -18,16 +18,16 @@ from celery.tests.utils import Case
 class test_import_utils(Case):
 
     def test_find_module(self):
-        self.assertTrue(find_module("celery"))
+        self.assertTrue(find_module('celery'))
         imp = Mock()
         imp.return_value = None
         with self.assertRaises(NotAPackage):
-            find_module("foo.bar.baz", imp=imp)
+            find_module('foo.bar.baz', imp=imp)
 
     def test_qualname(self):
-        Class = type("Fox", (object, ), {"__module__": "quick.brown"})
-        self.assertEqual(qualname(Class), "quick.brown.Fox")
-        self.assertEqual(qualname(Class()), "quick.brown.Fox")
+        Class = type('Fox', (object, ), {'__module__': 'quick.brown'})
+        self.assertEqual(qualname(Class), 'quick.brown.Fox')
+        self.assertEqual(qualname(Class()), 'quick.brown.Fox')
 
     def test_symbol_by_name__instance_returns_instance(self):
         instance = object()
@@ -35,29 +35,29 @@ class test_import_utils(Case):
 
     def test_symbol_by_name_returns_default(self):
         default = object()
-        self.assertIs(symbol_by_name("xyz.ryx.qedoa.weq:foz",
+        self.assertIs(symbol_by_name('xyz.ryx.qedoa.weq:foz',
                         default=default), default)
 
     def test_symbol_by_name_package(self):
         from celery.worker import WorkController
-        self.assertIs(symbol_by_name(".worker:WorkController",
-                    package="celery"), WorkController)
-        self.assertTrue(symbol_by_name(":group", package="celery"))
+        self.assertIs(symbol_by_name('.worker:WorkController',
+                    package='celery'), WorkController)
+        self.assertTrue(symbol_by_name(':group', package='celery'))
 
-    @patch("celery.utils.imports.reload")
+    @patch('celery.utils.imports.reload')
     def test_reload_from_cwd(self, reload):
-        reload_from_cwd("foo")
+        reload_from_cwd('foo')
         self.assertTrue(reload.called)
 
     def test_reload_from_cwd_custom_reloader(self):
         reload = Mock()
-        reload_from_cwd("foo", reload)
+        reload_from_cwd('foo', reload)
         self.assertTrue(reload.called)
 
     def test_module_file(self):
         m1 = Mock()
-        m1.__file__ = "/opt/foo/xyz.pyc"
-        self.assertEqual(module_file(m1), "/opt/foo/xyz.py")
+        m1.__file__ = '/opt/foo/xyz.pyc'
+        self.assertEqual(module_file(m1), '/opt/foo/xyz.py')
         m2 = Mock()
-        m2.__file__ = "/opt/foo/xyz.py"
-        self.assertEqual(module_file(m1), "/opt/foo/xyz.py")
+        m2.__file__ = '/opt/foo/xyz.py'
+        self.assertEqual(module_file(m1), '/opt/foo/xyz.py')

celery/tests/utilities/test_info.py

@@ -18,14 +18,14 @@ RANDTEXT_RES = """\
     lazy dog\
 """
 
-QUEUES = {"queue1": {
-            "exchange": "exchange1",
-            "exchange_type": "type1",
-            "routing_key": "bind1"},
-         "queue2": {
-            "exchange": "exchange2",
-            "exchange_type": "type2",
-            "routing_key": "bind2"}}
+QUEUES = {'queue1': {
+            'exchange': 'exchange1',
+            'exchange_type': 'type1',
+            'routing_key': 'bind1'},
+         'queue2': {
+            'exchange': 'exchange2',
+            'exchange_type': 'type2',
+            'routing_key': 'bind2'}}
 
 
 QUEUE_FORMAT1 = """. queue1:      exchange:exchange1(type1) binding:bind1"""
@@ -40,5 +40,5 @@ class test_Info(Case):
     def test_format_queues(self):
         celery = Celery(set_as_current=False)
         celery.amqp.queues = celery.amqp.Queues(QUEUES)
-        self.assertEqual(sorted(celery.amqp.queues.format().split("\n")),
+        self.assertEqual(sorted(celery.amqp.queues.format().split('\n')),
                          sorted([QUEUE_FORMAT1, QUEUE_FORMAT2]))

celery/tests/utilities/test_local.py

@@ -17,7 +17,7 @@ class test_try_import(Case):
 
     def test_when_default(self):
         default = object()
-        self.assertIs(try_import("foobar.awqewqe.asdwqewq", default), default)
+        self.assertIs(try_import('foobar.awqewqe.asdwqewq', default), default)
 
 
 class test_Proxy(Case):
@@ -26,15 +26,15 @@ class test_Proxy(Case):
 
         def real():
             """real function"""
-            return "REAL"
+            return 'REAL'
 
-        x = Proxy(lambda: real, name="xyz")
-        self.assertEqual(x.__name__, "xyz")
+        x = Proxy(lambda: real, name='xyz')
+        self.assertEqual(x.__name__, 'xyz')
 
         y = Proxy(lambda: real)
-        self.assertEqual(y.__name__, "real")
+        self.assertEqual(y.__name__, 'real')
 
-        self.assertEqual(x.__doc__, "real function")
+        self.assertEqual(x.__doc__, 'real function')
 
         self.assertEqual(x.__class__, type(real))
         self.assertEqual(x.__dict__, real.__dict__)
@@ -64,27 +64,27 @@ class test_Proxy(Case):
         class X(object):
 
             def __unicode__(self):
-                return u"UNICODE"
+                return u'UNICODE'
 
             def __repr__(self):
-                return "REPR"
+                return 'REPR'
 
         x = Proxy(lambda: X())
-        self.assertEqual(unicode(x), u"UNICODE")
+        self.assertEqual(unicode(x), u'UNICODE')
         del(X.__unicode__)
-        self.assertEqual(unicode(x), "REPR")
+        self.assertEqual(unicode(x), 'REPR')
 
     def test_dir(self):
         if sys.version_info < (2, 6):
-            raise SkipTest("Not relevant for Py2.5")
+            raise SkipTest('Not relevant for Py2.5')
 
         class X(object):
 
             def __dir__(self):
-                return ["a", "b", "c"]
+                return ['a', 'b', 'c']
 
         x = Proxy(lambda: X())
-        self.assertListEqual(dir(x), ["a", "b", "c"])
+        self.assertListEqual(dir(x), ['a', 'b', 'c'])
 
         class Y(object):
 
@@ -95,7 +95,7 @@ class test_Proxy(Case):
 
     def test_getsetdel_attr(self):
         if sys.version_info < (2, 6):
-            raise SkipTest("Not relevant for Py2.5")
+            raise SkipTest('Not relevant for Py2.5')
 
         class X(object):
             a = 1
@@ -103,17 +103,17 @@ class test_Proxy(Case):
             c = 3
 
             def __dir__(self):
-                return ["a", "b", "c"]
+                return ['a', 'b', 'c']
 
         v = X()
 
         x = Proxy(lambda: v)
-        self.assertListEqual(x.__members__, ["a", "b", "c"])
+        self.assertListEqual(x.__members__, ['a', 'b', 'c'])
         self.assertEqual(x.a, 1)
         self.assertEqual(x.b, 2)
         self.assertEqual(x.c, 3)
 
-        setattr(x, "a", 10)
+        setattr(x, 'a', 10)
         self.assertEqual(x.a, 10)
 
         del(x.a)
@@ -122,13 +122,13 @@ class test_Proxy(Case):
     def test_dictproxy(self):
         v = {}
         x = Proxy(lambda: v)
-        x["foo"] = 42
-        self.assertEqual(x["foo"], 42)
+        x['foo'] = 42
+        self.assertEqual(x['foo'], 42)
         self.assertEqual(len(x), 1)
-        self.assertIn("foo", x)
-        del(x["foo"])
+        self.assertIn('foo', x)
+        del(x['foo'])
         with self.assertRaises(KeyError):
-            x["foo"]
+            x['foo']
         self.assertTrue(iter(x))
 
     def test_listproxy(self):

celery/tests/utilities/test_mail.py

@@ -7,8 +7,8 @@ from celery.utils.mail import Message, Mailer
 from celery.tests.utils import Case
 
 
-msg = Message(to="george@vandelay.com", sender="elaine@pendant.com",
-              subject="What's up with Jerry?", body="???!")
+msg = Message(to='george@vandelay.com', sender='elaine@pendant.com',
+              subject="What's up with Jerry?", body='???!')
 
 
 class test_Message(Case):
@@ -29,8 +29,8 @@ class test_Mailer(Case):
         mailer.send(msg)
         mailer._send.assert_called_with(msg, timeout=2)
 
-    @patch("socket.setdefaulttimeout")
-    @patch("socket.getdefaulttimeout")
+    @patch('socket.setdefaulttimeout')
+    @patch('socket.getdefaulttimeout')
     def test_send_no_timeout(self, get, set):
         mailer = Mailer()
         mailer.supports_timeout = False
@@ -43,7 +43,7 @@ class test_Mailer(Case):
         self.assertEqual(sets[1][0], (10, ))
         mailer._send.assert_called_with(msg)
 
-    @patch("smtplib.SMTP_SSL", create=True)
+    @patch('smtplib.SMTP_SSL', create=True)
     def test_send_ssl_tls(self, SMTP_SSL):
         mailer = Mailer(use_ssl=True, use_tls=True)
         client = SMTP_SSL.return_value = Mock()
@@ -52,12 +52,12 @@ class test_Mailer(Case):
         self.assertEqual(client.ehlo.call_count, 2)
         client.quit.assert_called_with()
         client.sendmail.assert_called_with(msg.sender, msg.to, str(msg))
-        mailer = Mailer(use_ssl=True, use_tls=True, user="foo",
-                        password="bar")
+        mailer = Mailer(use_ssl=True, use_tls=True, user='foo',
+                        password='bar')
         mailer._send(msg)
-        client.login.assert_called_with("foo", "bar")
+        client.login.assert_called_with('foo', 'bar')
 
-    @patch("smtplib.SMTP")
+    @patch('smtplib.SMTP')
     def test_send(self, SMTP):
         client = SMTP.return_value = Mock()
         mailer = Mailer(use_ssl=False, use_tls=False)

celery/tests/utilities/test_pickle.py

@@ -20,31 +20,31 @@ class test_Pickle(Case):
     def test_pickle_regular_exception(self):
         exc = None
         try:
-            raise RegularException("RegularException raised")
+            raise RegularException('RegularException raised')
         except RegularException, exc_:
             exc = exc_
 
-        pickled = pickle.dumps({"exception": exc})
+        pickled = pickle.dumps({'exception': exc})
         unpickled = pickle.loads(pickled)
-        exception = unpickled.get("exception")
+        exception = unpickled.get('exception')
         self.assertTrue(exception)
         self.assertIsInstance(exception, RegularException)
-        self.assertTupleEqual(exception.args, ("RegularException raised", ))
+        self.assertTupleEqual(exception.args, ('RegularException raised', ))
 
     def test_pickle_arg_override_exception(self):
 
         exc = None
         try:
-            raise ArgOverrideException("ArgOverrideException raised",
+            raise ArgOverrideException('ArgOverrideException raised',
                     status_code=100)
         except ArgOverrideException, exc_:
             exc = exc_
 
-        pickled = pickle.dumps({"exception": exc})
+        pickled = pickle.dumps({'exception': exc})
         unpickled = pickle.loads(pickled)
-        exception = unpickled.get("exception")
+        exception = unpickled.get('exception')
         self.assertTrue(exception)
         self.assertIsInstance(exception, ArgOverrideException)
         self.assertTupleEqual(exception.args, (
-                              "ArgOverrideException raised", 100))
+                              'ArgOverrideException raised', 100))
         self.assertEqual(exception.status_code, 100)

celery/tests/utilities/test_platforms.py

@@ -56,7 +56,7 @@ class test_shellsplit(Case):
 
     def test_split(self):
         self.assertEqual(shellsplit("the 'quick' brown fox"),
-                ["the", "quick", "brown", "fox"])
+                ['the', 'quick', 'brown', 'fox'])
 
 
 class test_set_process_title(Case):
@@ -64,71 +64,71 @@ class test_set_process_title(Case):
     def when_no_setps(self):
         prev = platforms._setproctitle = platforms._setproctitle, None
         try:
-            set_process_title("foo")
+            set_process_title('foo')
         finally:
             platforms._setproctitle = prev
 
 
 class test_Signals(Case):
 
-    @patch("signal.getsignal")
+    @patch('signal.getsignal')
     def test_getitem(self, getsignal):
-        signals["SIGINT"]
+        signals['SIGINT']
         getsignal.assert_called_with(signal.SIGINT)
 
     def test_supported(self):
-        self.assertTrue(signals.supported("INT"))
-        self.assertFalse(signals.supported("SIGIMAGINARY"))
+        self.assertTrue(signals.supported('INT'))
+        self.assertFalse(signals.supported('SIGIMAGINARY'))
 
     def test_signum(self):
         self.assertEqual(signals.signum(13), 13)
-        self.assertEqual(signals.signum("INT"), signal.SIGINT)
-        self.assertEqual(signals.signum("SIGINT"), signal.SIGINT)
+        self.assertEqual(signals.signum('INT'), signal.SIGINT)
+        self.assertEqual(signals.signum('SIGINT'), signal.SIGINT)
         with self.assertRaises(TypeError):
-            signals.signum("int")
+            signals.signum('int')
             signals.signum(object())
 
-    @patch("signal.signal")
+    @patch('signal.signal')
     def test_ignore(self, set):
-        signals.ignore("SIGINT")
-        set.assert_called_with(signals.signum("INT"), signals.ignored)
-        signals.ignore("SIGTERM")
-        set.assert_called_with(signals.signum("TERM"), signals.ignored)
+        signals.ignore('SIGINT')
+        set.assert_called_with(signals.signum('INT'), signals.ignored)
+        signals.ignore('SIGTERM')
+        set.assert_called_with(signals.signum('TERM'), signals.ignored)
 
-    @patch("signal.signal")
+    @patch('signal.signal')
     def test_setitem(self, set):
         handle = lambda *a: a
-        signals["INT"] = handle
+        signals['INT'] = handle
         set.assert_called_with(signal.SIGINT, handle)
 
-    @patch("signal.signal")
+    @patch('signal.signal')
     def test_setitem_raises(self, set):
         set.side_effect = ValueError()
-        signals["INT"] = lambda *a: a
+        signals['INT'] = lambda *a: a
 
 
 if not current_app.IS_WINDOWS:
 
     class test_get_fdmax(Case):
 
-        @patch("resource.getrlimit")
+        @patch('resource.getrlimit')
         def test_when_infinity(self, getrlimit):
             getrlimit.return_value = [None, resource.RLIM_INFINITY]
             default = object()
             self.assertIs(get_fdmax(default), default)
 
-        @patch("resource.getrlimit")
+        @patch('resource.getrlimit')
         def test_when_actual(self, getrlimit):
             getrlimit.return_value = [None, 13]
             self.assertEqual(get_fdmax(None), 13)
 
     class test_maybe_drop_privileges(Case):
 
-        @patch("celery.platforms.parse_uid")
-        @patch("pwd.getpwuid")
-        @patch("celery.platforms.setgid")
-        @patch("celery.platforms.setuid")
-        @patch("celery.platforms.initgroups")
+        @patch('celery.platforms.parse_uid')
+        @patch('pwd.getpwuid')
+        @patch('celery.platforms.setgid')
+        @patch('celery.platforms.setuid')
+        @patch('celery.platforms.initgroups')
         def test_with_uid(self, initgroups, setuid, setgid,
                 getpwuid, parse_uid):
 
@@ -136,146 +136,146 @@ if not current_app.IS_WINDOWS:
                 pw_gid = 50001
             getpwuid.return_value = pw_struct()
             parse_uid.return_value = 5001
-            maybe_drop_privileges(uid="user")
-            parse_uid.assert_called_with("user")
+            maybe_drop_privileges(uid='user')
+            parse_uid.assert_called_with('user')
             getpwuid.assert_called_with(5001)
             setgid.assert_called_with(50001)
             initgroups.assert_called_with(5001, 50001)
             setuid.assert_called_with(5001)
 
-        @patch("celery.platforms.parse_uid")
-        @patch("celery.platforms.parse_gid")
-        @patch("celery.platforms.setgid")
-        @patch("celery.platforms.setuid")
-        @patch("celery.platforms.initgroups")
+        @patch('celery.platforms.parse_uid')
+        @patch('celery.platforms.parse_gid')
+        @patch('celery.platforms.setgid')
+        @patch('celery.platforms.setuid')
+        @patch('celery.platforms.initgroups')
         def test_with_guid(self, initgroups, setuid, setgid,
                 parse_gid, parse_uid):
             parse_uid.return_value = 5001
             parse_gid.return_value = 50001
-            maybe_drop_privileges(uid="user", gid="group")
-            parse_uid.assert_called_with("user")
-            parse_gid.assert_called_with("group")
+            maybe_drop_privileges(uid='user', gid='group')
+            parse_uid.assert_called_with('user')
+            parse_gid.assert_called_with('group')
             setgid.assert_called_with(50001)
             initgroups.assert_called_with(5001, 50001)
             setuid.assert_called_with(5001)
 
-        @patch("celery.platforms.setuid")
-        @patch("celery.platforms.setgid")
-        @patch("celery.platforms.parse_gid")
+        @patch('celery.platforms.setuid')
+        @patch('celery.platforms.setgid')
+        @patch('celery.platforms.parse_gid')
         def test_only_gid(self, parse_gid, setgid, setuid):
             parse_gid.return_value = 50001
-            maybe_drop_privileges(gid="group")
-            parse_gid.assert_called_with("group")
+            maybe_drop_privileges(gid='group')
+            parse_gid.assert_called_with('group')
             setgid.assert_called_with(50001)
             self.assertFalse(setuid.called)
 
     class test_setget_uid_gid(Case):
 
-        @patch("celery.platforms.parse_uid")
-        @patch("os.setuid")
+        @patch('celery.platforms.parse_uid')
+        @patch('os.setuid')
         def test_setuid(self, _setuid, parse_uid):
             parse_uid.return_value = 5001
-            setuid("user")
-            parse_uid.assert_called_with("user")
+            setuid('user')
+            parse_uid.assert_called_with('user')
             _setuid.assert_called_with(5001)
 
-        @patch("celery.platforms.parse_uid")
-        @patch("os.geteuid")
-        @patch("os.seteuid")
+        @patch('celery.platforms.parse_uid')
+        @patch('os.geteuid')
+        @patch('os.seteuid')
         def test_seteuid(self, _seteuid, _geteuid, parse_uid):
             parse_uid.return_value = 5001
             _geteuid.return_value = 5001
-            seteuid("user")
-            parse_uid.assert_called_with("user")
+            seteuid('user')
+            parse_uid.assert_called_with('user')
             self.assertFalse(_seteuid.called)
 
             _geteuid.return_value = 1
-            seteuid("user")
+            seteuid('user')
             _seteuid.assert_called_with(5001)
 
-        @patch("celery.platforms.parse_gid")
-        @patch("os.setgid")
+        @patch('celery.platforms.parse_gid')
+        @patch('os.setgid')
         def test_setgid(self, _setgid, parse_gid):
             parse_gid.return_value = 50001
-            setgid("group")
-            parse_gid.assert_called_with("group")
+            setgid('group')
+            parse_gid.assert_called_with('group')
             _setgid.assert_called_with(50001)
 
-        @patch("celery.platforms.parse_gid")
-        @patch("os.getegid")
-        @patch("os.setegid")
+        @patch('celery.platforms.parse_gid')
+        @patch('os.getegid')
+        @patch('os.setegid')
         def test_setegid(self, _setegid, _getegid, parse_gid):
             parse_gid.return_value = 50001
             _getegid.return_value = 50001
-            setegid("group")
-            parse_gid.assert_called_with("group")
+            setegid('group')
+            parse_gid.assert_called_with('group')
             self.assertFalse(_setegid.called)
 
             _getegid.return_value = 1
-            setegid("group")
+            setegid('group')
             _setegid.assert_called_with(50001)
 
         def test_parse_uid_when_int(self):
             self.assertEqual(parse_uid(5001), 5001)
 
-        @patch("pwd.getpwnam")
+        @patch('pwd.getpwnam')
         def test_parse_uid_when_existing_name(self, getpwnam):
 
             class pwent(object):
                 pw_uid = 5001
 
             getpwnam.return_value = pwent()
-            self.assertEqual(parse_uid("user"), 5001)
+            self.assertEqual(parse_uid('user'), 5001)
 
-        @patch("pwd.getpwnam")
+        @patch('pwd.getpwnam')
         def test_parse_uid_when_nonexisting_name(self, getpwnam):
-            getpwnam.side_effect = KeyError("user")
+            getpwnam.side_effect = KeyError('user')
 
             with self.assertRaises(KeyError):
-                parse_uid("user")
+                parse_uid('user')
 
         def test_parse_gid_when_int(self):
             self.assertEqual(parse_gid(50001), 50001)
 
-        @patch("grp.getgrnam")
+        @patch('grp.getgrnam')
         def test_parse_gid_when_existing_name(self, getgrnam):
 
             class grent(object):
                 gr_gid = 50001
 
             getgrnam.return_value = grent()
-            self.assertEqual(parse_gid("group"), 50001)
+            self.assertEqual(parse_gid('group'), 50001)
 
-        @patch("grp.getgrnam")
+        @patch('grp.getgrnam')
         def test_parse_gid_when_nonexisting_name(self, getgrnam):
-            getgrnam.side_effect = KeyError("group")
+            getgrnam.side_effect = KeyError('group')
 
             with self.assertRaises(KeyError):
-                parse_gid("group")
+                parse_gid('group')
 
     class test_initgroups(Case):
 
-        @patch("pwd.getpwuid")
-        @patch("os.initgroups", create=True)
+        @patch('pwd.getpwuid')
+        @patch('os.initgroups', create=True)
         def test_with_initgroups(self, initgroups_, getpwuid):
-            getpwuid.return_value = ["user"]
+            getpwuid.return_value = ['user']
             initgroups(5001, 50001)
-            initgroups_.assert_called_with("user", 50001)
+            initgroups_.assert_called_with('user', 50001)
 
-        @patch("celery.platforms.setgroups")
-        @patch("grp.getgrall")
-        @patch("pwd.getpwuid")
+        @patch('celery.platforms.setgroups')
+        @patch('grp.getgrall')
+        @patch('pwd.getpwuid')
         def test_without_initgroups(self, getpwuid, getgrall, setgroups):
-            prev = getattr(os, "initgroups", None)
+            prev = getattr(os, 'initgroups', None)
             try:
-                delattr(os, "initgroups")
+                delattr(os, 'initgroups')
             except AttributeError:
                 pass
             try:
-                getpwuid.return_value = ["user"]
+                getpwuid.return_value = ['user']
 
                 class grent(object):
-                    gr_mem = ["user"]
+                    gr_mem = ['user']
 
                     def __init__(self, gid):
                         self.gr_gid = gid
@@ -297,42 +297,42 @@ if not current_app.IS_WINDOWS:
             finally:
                 platforms.resource = prev
 
-        @patch("celery.platforms.create_pidlock")
-        @patch("celery.platforms.signals")
-        @patch("celery.platforms.maybe_drop_privileges")
-        @patch("os.geteuid")
-        @patch("__builtin__.open")
+        @patch('celery.platforms.create_pidlock')
+        @patch('celery.platforms.signals')
+        @patch('celery.platforms.maybe_drop_privileges')
+        @patch('os.geteuid')
+        @patch('__builtin__.open')
         def test_default(self, open, geteuid, maybe_drop, signals, pidlock):
             geteuid.return_value = 0
-            context = detached(uid="user", gid="group")
+            context = detached(uid='user', gid='group')
             self.assertIsInstance(context, DaemonContext)
-            signals.reset.assert_called_with("SIGCLD")
-            maybe_drop.assert_called_with(uid="user", gid="group")
+            signals.reset.assert_called_with('SIGCLD')
+            maybe_drop.assert_called_with(uid='user', gid='group')
             open.return_value = Mock()
 
             geteuid.return_value = 5001
-            context = detached(uid="user", gid="group", logfile="/foo/bar")
+            context = detached(uid='user', gid='group', logfile='/foo/bar')
             self.assertIsInstance(context, DaemonContext)
-            open.assert_called_with("/foo/bar", "a")
+            open.assert_called_with('/foo/bar', 'a')
             open.return_value.close.assert_called_with()
 
-            context = detached(pidfile="/foo/bar/pid")
+            context = detached(pidfile='/foo/bar/pid')
             self.assertIsInstance(context, DaemonContext)
-            pidlock.assert_called_with("/foo/bar/pid")
+            pidlock.assert_called_with('/foo/bar/pid')
 
     class test_DaemonContext(Case):
 
-        @patch("os.fork")
-        @patch("os.setsid")
-        @patch("os._exit")
-        @patch("os.chdir")
-        @patch("os.umask")
-        @patch("os.close")
-        @patch("os.open")
-        @patch("os.dup2")
+        @patch('os.fork')
+        @patch('os.setsid')
+        @patch('os._exit')
+        @patch('os.chdir')
+        @patch('os.umask')
+        @patch('os.close')
+        @patch('os.open')
+        @patch('os.dup2')
         def test_open(self, dup2, open, close, umask, chdir, _exit, setsid,
                 fork):
-            x = DaemonContext(workdir="/opt/workdir")
+            x = DaemonContext(workdir='/opt/workdir')
 
             fork.return_value = 0
             with x:
@@ -351,13 +351,13 @@ if not current_app.IS_WINDOWS:
 
             fork.reset_mock()
             fork.return_value = 1
-            x = DaemonContext(workdir="/opt/workdir")
+            x = DaemonContext(workdir='/opt/workdir')
             with x:
                 pass
             self.assertEqual(fork.call_count, 1)
             _exit.assert_called_with(0)
 
-            x = DaemonContext(workdir="/opt/workdir", fake=True)
+            x = DaemonContext(workdir='/opt/workdir', fake=True)
             x._detach = Mock()
             with x:
                 pass
@@ -365,20 +365,20 @@ if not current_app.IS_WINDOWS:
 
     class test_PIDFile(Case):
 
-        @patch("celery.platforms.PIDFile")
+        @patch('celery.platforms.PIDFile')
         def test_create_pidlock(self, PIDFile):
             p = PIDFile.return_value = Mock()
             p.is_locked.return_value = True
             p.remove_if_stale.return_value = False
             with self.assertRaises(SystemExit):
-                create_pidlock("/var/pid")
+                create_pidlock('/var/pid')
 
             p.remove_if_stale.return_value = True
-            ret = create_pidlock("/var/pid")
+            ret = create_pidlock('/var/pid')
             self.assertIs(ret, p)
 
         def test_context(self):
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             p.write_pid = Mock()
             p.remove = Mock()
 
@@ -388,7 +388,7 @@ if not current_app.IS_WINDOWS:
             p.remove.assert_called_with()
 
         def test_acquire_raises_LockFailed(self):
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             p.write_pid = Mock()
             p.write_pid.side_effect = OSError()
 
@@ -396,95 +396,95 @@ if not current_app.IS_WINDOWS:
                 with p:
                     pass
 
-        @patch("os.path.exists")
+        @patch('os.path.exists')
         def test_is_locked(self, exists):
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             exists.return_value = True
             self.assertTrue(p.is_locked())
             exists.return_value = False
             self.assertFalse(p.is_locked())
 
-        @patch("__builtin__.open")
+        @patch('__builtin__.open')
         def test_read_pid(self, open_):
             s = open_.return_value = WhateverIO()
-            s.write("1816\n")
+            s.write('1816\n')
             s.seek(0)
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             self.assertEqual(p.read_pid(), 1816)
 
-        @patch("__builtin__.open")
+        @patch('__builtin__.open')
         def test_read_pid_partially_written(self, open_):
             s = open_.return_value = WhateverIO()
-            s.write("1816")
+            s.write('1816')
             s.seek(0)
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             with self.assertRaises(ValueError):
                 p.read_pid()
 
-        @patch("__builtin__.open")
+        @patch('__builtin__.open')
         def test_read_pid_raises_ENOENT(self, open_):
             exc = IOError()
             exc.errno = errno.ENOENT
             open_.side_effect = exc
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             self.assertIsNone(p.read_pid())
 
-        @patch("__builtin__.open")
+        @patch('__builtin__.open')
         def test_read_pid_raises_IOError(self, open_):
             exc = IOError()
             exc.errno = errno.EAGAIN
             open_.side_effect = exc
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             with self.assertRaises(IOError):
                 p.read_pid()
 
-        @patch("__builtin__.open")
+        @patch('__builtin__.open')
         def test_read_pid_bogus_pidfile(self, open_):
             s = open_.return_value = WhateverIO()
-            s.write("eighteensixteen\n")
+            s.write('eighteensixteen\n')
             s.seek(0)
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             with self.assertRaises(ValueError):
                 p.read_pid()
 
-        @patch("os.unlink")
+        @patch('os.unlink')
         def test_remove(self, unlink):
             unlink.return_value = True
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             p.remove()
             unlink.assert_called_with(p.path)
 
-        @patch("os.unlink")
+        @patch('os.unlink')
         def test_remove_ENOENT(self, unlink):
             exc = OSError()
             exc.errno = errno.ENOENT
             unlink.side_effect = exc
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             p.remove()
             unlink.assert_called_with(p.path)
 
-        @patch("os.unlink")
+        @patch('os.unlink')
         def test_remove_EACCES(self, unlink):
             exc = OSError()
             exc.errno = errno.EACCES
             unlink.side_effect = exc
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             p.remove()
             unlink.assert_called_with(p.path)
 
-        @patch("os.unlink")
+        @patch('os.unlink')
         def test_remove_OSError(self, unlink):
             exc = OSError()
             exc.errno = errno.EAGAIN
             unlink.side_effect = exc
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             with self.assertRaises(OSError):
                 p.remove()
             unlink.assert_called_with(p.path)
 
-        @patch("os.kill")
+        @patch('os.kill')
         def test_remove_if_stale_process_alive(self, kill):
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             p.read_pid = Mock()
             p.read_pid.return_value = 1816
             kill.return_value = 0
@@ -496,10 +496,10 @@ if not current_app.IS_WINDOWS:
             kill.side_effect.errno = errno.ENOENT
             self.assertFalse(p.remove_if_stale())
 
-        @patch("os.kill")
+        @patch('os.kill')
         def test_remove_if_stale_process_dead(self, kill):
             with override_stdouts():
-                p = PIDFile("/var/pid")
+                p = PIDFile('/var/pid')
                 p.read_pid = Mock()
                 p.read_pid.return_value = 1816
                 p.remove = Mock()
@@ -512,7 +512,7 @@ if not current_app.IS_WINDOWS:
 
         def test_remove_if_stale_broken_pid(self):
             with override_stdouts():
-                p = PIDFile("/var/pid")
+                p = PIDFile('/var/pid')
                 p.read_pid = Mock()
                 p.read_pid.side_effect = ValueError()
                 p.remove = Mock()
@@ -521,7 +521,7 @@ if not current_app.IS_WINDOWS:
                 p.remove.assert_called_with()
 
         def test_remove_if_stale_no_pidfile(self):
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             p.read_pid = Mock()
             p.read_pid.return_value = None
             p.remove = Mock()
@@ -529,37 +529,37 @@ if not current_app.IS_WINDOWS:
             self.assertTrue(p.remove_if_stale())
             p.remove.assert_called_with()
 
-        @patch("os.fsync")
-        @patch("os.getpid")
-        @patch("os.open")
-        @patch("os.fdopen")
-        @patch("__builtin__.open")
+        @patch('os.fsync')
+        @patch('os.getpid')
+        @patch('os.open')
+        @patch('os.fdopen')
+        @patch('__builtin__.open')
         def test_write_pid(self, open_, fdopen, osopen, getpid, fsync):
             getpid.return_value = 1816
             osopen.return_value = 13
             w = fdopen.return_value = WhateverIO()
             w.close = Mock()
             r = open_.return_value = WhateverIO()
-            r.write("1816\n")
+            r.write('1816\n')
             r.seek(0)
 
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             p.write_pid()
             w.seek(0)
-            self.assertEqual(w.readline(), "1816\n")
+            self.assertEqual(w.readline(), '1816\n')
             self.assertTrue(w.close.called)
             getpid.assert_called_with()
             osopen.assert_called_with(p.path, platforms.PIDFILE_FLAGS,
                                       platforms.PIDFILE_MODE)
-            fdopen.assert_called_with(13, "w")
+            fdopen.assert_called_with(13, 'w')
             fsync.assert_called_with(13)
             open_.assert_called_with(p.path)
 
-        @patch("os.fsync")
-        @patch("os.getpid")
-        @patch("os.open")
-        @patch("os.fdopen")
-        @patch("__builtin__.open")
+        @patch('os.fsync')
+        @patch('os.getpid')
+        @patch('os.open')
+        @patch('os.fdopen')
+        @patch('__builtin__.open')
         def test_write_reread_fails(self, open_, fdopen,
                 osopen, getpid, fsync):
             getpid.return_value = 1816
@@ -567,16 +567,16 @@ if not current_app.IS_WINDOWS:
             w = fdopen.return_value = WhateverIO()
             w.close = Mock()
             r = open_.return_value = WhateverIO()
-            r.write("11816\n")
+            r.write('11816\n')
             r.seek(0)
 
-            p = PIDFile("/var/pid")
+            p = PIDFile('/var/pid')
             with self.assertRaises(LockFailed):
                 p.write_pid()
 
     class test_setgroups(Case):
 
-        @patch("os.setgroups", create=True)
+        @patch('os.setgroups', create=True)
         def test_setgroups_hack_ValueError(self, setgroups):
 
             def on_setgroups(groups):
@@ -591,7 +591,7 @@ if not current_app.IS_WINDOWS:
             with self.assertRaises(ValueError):
                 _setgroups_hack(range(400))
 
-        @patch("os.setgroups", create=True)
+        @patch('os.setgroups', create=True)
         def test_setgroups_hack_OSError(self, setgroups):
             exc = OSError()
             exc.errno = errno.EINVAL
@@ -615,23 +615,23 @@ if not current_app.IS_WINDOWS:
             with self.assertRaises(OSError):
                 _setgroups_hack(range(400))
 
-        @patch("os.sysconf")
-        @patch("celery.platforms._setgroups_hack")
+        @patch('os.sysconf')
+        @patch('celery.platforms._setgroups_hack')
         def test_setgroups(self, hack, sysconf):
             sysconf.return_value = 100
             setgroups(range(400))
             hack.assert_called_with(range(100))
 
-        @patch("os.sysconf")
-        @patch("celery.platforms._setgroups_hack")
+        @patch('os.sysconf')
+        @patch('celery.platforms._setgroups_hack')
         def test_setgroups_sysconf_raises(self, hack, sysconf):
             sysconf.side_effect = ValueError()
             setgroups(range(400))
             hack.assert_called_with(range(400))
 
-        @patch("os.getgroups")
-        @patch("os.sysconf")
-        @patch("celery.platforms._setgroups_hack")
+        @patch('os.getgroups')
+        @patch('os.sysconf')
+        @patch('celery.platforms._setgroups_hack')
         def test_setgroups_raises_ESRCH(self, hack, sysconf, getgroups):
             sysconf.side_effect = ValueError()
             esrch = OSError()
@@ -640,9 +640,9 @@ if not current_app.IS_WINDOWS:
             with self.assertRaises(OSError):
                 setgroups(range(400))
 
-        @patch("os.getgroups")
-        @patch("os.sysconf")
-        @patch("celery.platforms._setgroups_hack")
+        @patch('os.getgroups')
+        @patch('os.sysconf')
+        @patch('celery.platforms._setgroups_hack')
         def test_setgroups_raises_EPERM(self, hack, sysconf, getgroups):
             sysconf.side_effect = ValueError()
             eperm = OSError()

celery/tests/utilities/test_serialization.py

@@ -9,11 +9,11 @@ from celery.tests.utils import Case, mask_modules
 class test_AAPickle(Case):
 
     def test_no_cpickle(self):
-        prev = sys.modules.pop("celery.utils.serialization", None)
+        prev = sys.modules.pop('celery.utils.serialization', None)
         try:
-            with mask_modules("cPickle"):
+            with mask_modules('cPickle'):
                 from celery.utils.serialization import pickle
                 import pickle as orig_pickle
                 self.assertIs(pickle.dumps, orig_pickle.dumps)
         finally:
-            sys.modules["celery.utils.serialization"] = prev
+            sys.modules['celery.utils.serialization'] = prev

celery/tests/utilities/test_term.py

@@ -11,58 +11,58 @@ class test_colored(Case):
 
     def test_colors(self):
         colors = (
-            ("black", term.BLACK),
-            ("red", term.RED),
-            ("green", term.GREEN),
-            ("yellow", term.YELLOW),
-            ("blue", term.BLUE),
-            ("magenta", term.MAGENTA),
-            ("cyan", term.CYAN),
-            ("white", term.WHITE),
+            ('black', term.BLACK),
+            ('red', term.RED),
+            ('green', term.GREEN),
+            ('yellow', term.YELLOW),
+            ('blue', term.BLUE),
+            ('magenta', term.MAGENTA),
+            ('cyan', term.CYAN),
+            ('white', term.WHITE),
         )
 
         for name, key in colors:
-            self.assertIn(fg(30 + key), str(colored().names[name]("foo")))
-
-        self.assertTrue(str(colored().bold("f")))
-        self.assertTrue(str(colored().underline("f")))
-        self.assertTrue(str(colored().blink("f")))
-        self.assertTrue(str(colored().reverse("f")))
-        self.assertTrue(str(colored().bright("f")))
-        self.assertTrue(str(colored().ired("f")))
-        self.assertTrue(str(colored().igreen("f")))
-        self.assertTrue(str(colored().iyellow("f")))
-        self.assertTrue(str(colored().iblue("f")))
-        self.assertTrue(str(colored().imagenta("f")))
-        self.assertTrue(str(colored().icyan("f")))
-        self.assertTrue(str(colored().iwhite("f")))
-        self.assertTrue(str(colored().reset("f")))
-
-        self.assertTrue(str(colored().green(u"∂bar")))
+            self.assertIn(fg(30 + key), str(colored().names[name]('foo')))
+
+        self.assertTrue(str(colored().bold('f')))
+        self.assertTrue(str(colored().underline('f')))
+        self.assertTrue(str(colored().blink('f')))
+        self.assertTrue(str(colored().reverse('f')))
+        self.assertTrue(str(colored().bright('f')))
+        self.assertTrue(str(colored().ired('f')))
+        self.assertTrue(str(colored().igreen('f')))
+        self.assertTrue(str(colored().iyellow('f')))
+        self.assertTrue(str(colored().iblue('f')))
+        self.assertTrue(str(colored().imagenta('f')))
+        self.assertTrue(str(colored().icyan('f')))
+        self.assertTrue(str(colored().iwhite('f')))
+        self.assertTrue(str(colored().reset('f')))
+
+        self.assertTrue(str(colored().green(u'∂bar')))
 
         self.assertTrue(
-            colored().red(u"éefoo") + colored().green(u"∂bar"))
+            colored().red(u'éefoo') + colored().green(u'∂bar'))
 
         self.assertEqual(
-            colored().red("foo").no_color(), "foo")
+            colored().red('foo').no_color(), 'foo')
 
         self.assertTrue(
-            repr(colored().blue(u"åfoo")))
+            repr(colored().blue(u'åfoo')))
 
         self.assertEqual(repr(colored()), "''")
 
         c = colored()
-        s = c.red("foo", c.blue("bar"), c.green("baz"))
+        s = c.red('foo', c.blue('bar'), c.green('baz'))
         self.assertTrue(s.no_color())
 
-        c._fold_no_color(s, u"øfoo")
-        c._fold_no_color(u"fooå", s)
+        c._fold_no_color(s, u'øfoo')
+        c._fold_no_color(u'fooå', s)
 
-        c = colored().red(u"åfoo")
-        self.assertEqual(c._add(c, u"baræ"),
+        c = colored().red(u'åfoo')
+        self.assertEqual(c._add(c, u'baræ'),
             u'\x1b[1;31m\xe5foo\x1b[0mbar\xe6')
 
-        c2 = colored().blue(u"ƒƒz")
+        c2 = colored().blue(u'ƒƒz')
         c3 = c._add(c, c2)
         self.assertEqual(c3,
             u'\x1b[1;31m\xe5foo\x1b[0m\x1b[1;34m\u0192\u0192z\x1b[0m')

celery/tests/utilities/test_timer2.py

@@ -17,13 +17,13 @@ class test_Entry(Case):
     def test_call(self):
         scratch = [None]
 
-        def timed(x, y, moo="foo"):
+        def timed(x, y, moo='foo'):
             scratch[0] = (x, y, moo)
 
-        tref = timer2.Entry(timed, (4, 4), {"moo": "baz"})
+        tref = timer2.Entry(timed, (4, 4), {'moo': 'baz'})
         tref()
 
-        self.assertTupleEqual(scratch[0], (4, 4, "baz"))
+        self.assertTupleEqual(scratch[0], (4, 4, 'baz'))
 
     def test_cancel(self):
         tref = timer2.Entry(lambda x: x, (1, ), {})
@@ -100,7 +100,7 @@ class test_Timer(Case):
             t.schedule.enter_after = Mock()
 
             myfun = Mock()
-            myfun.__name__ = "myfun"
+            myfun.__name__ = 'myfun'
             t.apply_interval(30, myfun)
 
             self.assertEqual(t.schedule.enter_after.call_count, 1)
@@ -120,7 +120,7 @@ class test_Timer(Case):
         finally:
             t.stop()
 
-    @patch("celery.utils.timer2.logger")
+    @patch('celery.utils.timer2.logger')
     def test_apply_entry_error_handled(self, logger):
         t = timer2.Timer()
         t.schedule.on_error = None
@@ -142,7 +142,7 @@ class test_Timer(Case):
         fun.assert_called_with()
         self.assertFalse(stderr.getvalue())
 
-    @patch("os._exit")
+    @patch('os._exit')
     def test_thread_crash(self, _exit):
         t = timer2.Timer()
         t._next_entry = Mock()
@@ -167,13 +167,13 @@ class test_Timer(Case):
         t._do_enter = Mock()
         e = Mock()
         t.enter(e, 13, 0)
-        t._do_enter.assert_called_with("enter", e, 13, priority=0)
+        t._do_enter.assert_called_with('enter', e, 13, priority=0)
 
     def test_test_enter_after(self):
         t = timer2.Timer()
         t._do_enter = Mock()
         t.enter_after()
-        t._do_enter.assert_called_with("enter_after")
+        t._do_enter.assert_called_with('enter_after')
 
     def test_cancel(self):
         t = timer2.Timer()

celery/tests/utilities/test_timeutils.py

@@ -38,22 +38,22 @@ class test_timeutils(Case):
         self.assertEqual(timeutils.timedelta_seconds(delta), 0)
 
     def test_humanize_seconds(self):
-        t = ((4 * 60 * 60 * 24, "4.00 days"),
-             (1 * 60 * 60 * 24, "1.00 day"),
-             (4 * 60 * 60, "4.00 hours"),
-             (1 * 60 * 60, "1.00 hour"),
-             (4 * 60, "4.00 minutes"),
-             (1 * 60, "1.00 minute"),
-             (4, "4.00 seconds"),
-             (1, "1.00 second"),
-             (4.3567631221, "4.36 seconds"),
-             (0, "now"))
+        t = ((4 * 60 * 60 * 24, '4.00 days'),
+             (1 * 60 * 60 * 24, '1.00 day'),
+             (4 * 60 * 60, '4.00 hours'),
+             (1 * 60 * 60, '1.00 hour'),
+             (4 * 60, '4.00 minutes'),
+             (1 * 60, '1.00 minute'),
+             (4, '4.00 seconds'),
+             (1, '1.00 second'),
+             (4.3567631221, '4.36 seconds'),
+             (0, 'now'))
 
         for seconds, human in t:
             self.assertEqual(timeutils.humanize_seconds(seconds), human)
 
-        self.assertEqual(timeutils.humanize_seconds(4, prefix="about "),
-                          "about 4.00 seconds")
+        self.assertEqual(timeutils.humanize_seconds(4, prefix='about '),
+                          'about 4.00 seconds')
 
     def test_maybe_iso8601_datetime(self):
         now = datetime.now()
@@ -77,15 +77,15 @@ class test_timezone(Case):
     def test_get_timezone_with_pytz(self):
         prev, timeutils.pytz = timeutils.pytz, Mock()
         try:
-            self.assertTrue(timezone.get_timezone("UTC"))
+            self.assertTrue(timezone.get_timezone('UTC'))
         finally:
             timeutils.pytz = prev
 
     def test_get_timezone_without_pytz(self):
         prev, timeutils.pytz = timeutils.pytz, None
         try:
-            self.assertTrue(timezone.get_timezone("UTC"))
+            self.assertTrue(timezone.get_timezone('UTC'))
             with self.assertRaises(ImproperlyConfigured):
-                timezone.get_timezone("Europe/Oslo")
+                timezone.get_timezone('Europe/Oslo')
         finally:
             timeutils.pytz = prev

celery/tests/utilities/test_utils.py

@@ -48,23 +48,23 @@ class test_chunks(Case):
 class test_utils(Case):
 
     def test_is_iterable(self):
-        for a in "f", ["f"], ("f", ), {"f": "f"}:
+        for a in 'f', ['f'], ('f', ), {'f': 'f'}:
             self.assertTrue(utils.is_iterable(a))
         for b in object(), 1:
             self.assertFalse(utils.is_iterable(b))
 
     def test_padlist(self):
         self.assertListEqual(functional.padlist(
-                ["George", "Costanza", "NYC"], 3),
-                ["George", "Costanza", "NYC"])
-        self.assertListEqual(functional.padlist(["George", "Costanza"], 3),
-                ["George", "Costanza", None])
+                ['George', 'Costanza', 'NYC'], 3),
+                ['George', 'Costanza', 'NYC'])
+        self.assertListEqual(functional.padlist(['George', 'Costanza'], 3),
+                ['George', 'Costanza', None])
         self.assertListEqual(functional.padlist(
-                ["George", "Costanza", "NYC"], 4, default="Earth"),
-                ["George", "Costanza", "NYC", "Earth"])
+                ['George', 'Costanza', 'NYC'], 4, default='Earth'),
+                ['George', 'Costanza', 'NYC', 'Earth'])
 
     def test_firstmethod_AttributeError(self):
-        self.assertIsNone(functional.firstmethod("foo")([object()]))
+        self.assertIsNone(functional.firstmethod('foo')([object()]))
 
     def test_firstmethod_promises(self):
 
@@ -76,10 +76,10 @@ class test_utils(Case):
             def m(self):
                 return self.value
 
-        self.assertEqual("four", functional.firstmethod("m")([
-            A(), A(), A(), A("four"), A("five")]))
-        self.assertEqual("four", functional.firstmethod("m")([
-            A(), A(), A(), promise(lambda: A("four")), A("five")]))
+        self.assertEqual('four', functional.firstmethod('m')([
+            A(), A(), A(), A('four'), A('five')]))
+        self.assertEqual('four', functional.firstmethod('m')([
+            A(), A(), A(), promise(lambda: A('four')), A('five')]))
 
     def test_first(self):
         iterations = [0]
@@ -98,24 +98,24 @@ class test_utils(Case):
         self.assertEqual(iterations[0], 10)
 
     def test_truncate_text(self):
-        self.assertEqual(text.truncate("ABCDEFGHI", 3), "ABC...")
-        self.assertEqual(text.truncate("ABCDEFGHI", 10), "ABCDEFGHI")
+        self.assertEqual(text.truncate('ABCDEFGHI', 3), 'ABC...')
+        self.assertEqual(text.truncate('ABCDEFGHI', 10), 'ABCDEFGHI')
 
     def test_abbr(self):
-        self.assertEqual(text.abbr(None, 3), "???")
-        self.assertEqual(text.abbr("ABCDEFGHI", 6), "ABC...")
-        self.assertEqual(text.abbr("ABCDEFGHI", 20), "ABCDEFGHI")
-        self.assertEqual(text.abbr("ABCDEFGHI", 6, None), "ABCDEF")
+        self.assertEqual(text.abbr(None, 3), '???')
+        self.assertEqual(text.abbr('ABCDEFGHI', 6), 'ABC...')
+        self.assertEqual(text.abbr('ABCDEFGHI', 20), 'ABCDEFGHI')
+        self.assertEqual(text.abbr('ABCDEFGHI', 6, None), 'ABCDEF')
 
     def test_abbrtask(self):
-        self.assertEqual(text.abbrtask(None, 3), "???")
-        self.assertEqual(text.abbrtask("feeds.tasks.refresh", 10),
-                                        "[.]refresh")
-        self.assertEqual(text.abbrtask("feeds.tasks.refresh", 30),
-                                        "feeds.tasks.refresh")
+        self.assertEqual(text.abbrtask(None, 3), '???')
+        self.assertEqual(text.abbrtask('feeds.tasks.refresh', 10),
+                                        '[.]refresh')
+        self.assertEqual(text.abbrtask('feeds.tasks.refresh', 30),
+                                        'feeds.tasks.refresh')
 
     def test_pretty(self):
-        self.assertTrue(text.pretty(("a", "b", "c")))
+        self.assertTrue(text.pretty(('a', 'b', 'c')))
 
     def test_cached_property(self):
 
@@ -132,9 +132,9 @@ class test_utils(Case):
         self.assertEqual(maybe_list([1]), [1])
         self.assertIsNone(maybe_list(None))
 
-    @patch("warnings.warn")
+    @patch('warnings.warn')
     def test_warn_deprecated(self, warn):
-        utils.warn_deprecated("Foo")
+        utils.warn_deprecated('Foo')
         self.assertTrue(warn.called)
 
 
@@ -147,4 +147,4 @@ class test_mpromise(Case):
         self.assertEqual(p(), 20)
         self.assertTrue(p.evaluated)
         self.assertEqual(p(), 20)
-        self.assertEqual(repr(p), "20")
+        self.assertEqual(repr(p), '20')

celery/tests/utils.py

@@ -41,7 +41,7 @@ from .compat import catch_warnings
 class Mock(mock.Mock):
 
     def __init__(self, *args, **kwargs):
-        attrs = kwargs.pop("attrs", None) or {}
+        attrs = kwargs.pop('attrs', None) or {}
         super(Mock, self).__init__(*args, **kwargs)
         for attr_name, attr_value in attrs.items():
             setattr(self, attr_name, attr_value)
@@ -56,7 +56,7 @@ def skip_unless_module(module):
             try:
                 importlib.import_module(module)
             except ImportError:
-                raise SkipTest("Does not have %s" % (module, ))
+                raise SkipTest('Does not have %s' % (module, ))
 
             return fun(*args, **kwargs)
 
@@ -90,7 +90,7 @@ class _AssertWarnsContext(_AssertRaisesBaseContext):
                 v.__warningregistry__ = {}
         self.warnings_manager = catch_warnings(record=True)
         self.warnings = self.warnings_manager.__enter__()
-        warnings.simplefilter("always", self.expected)
+        warnings.simplefilter('always', self.expected)
         return self
 
     def __exit__(self, exc_type, exc_value, tb):
@@ -122,10 +122,10 @@ class _AssertWarnsContext(_AssertRaisesBaseContext):
             raise self.failureException('%r does not match %r' %
                      (self.expected_regex.pattern, str(first_matching)))
         if self.obj_name:
-            raise self.failureException("%s not triggered by %s"
+            raise self.failureException('%s not triggered by %s'
                 % (exc_name, self.obj_name))
         else:
-            raise self.failureException("%s not triggered"
+            raise self.failureException('%s not triggered'
                 % exc_name)
 
 
@@ -145,21 +145,21 @@ class Case(unittest.TestCase):
             if key not in actual:
                 missing.append(key)
             elif value != actual[key]:
-                mismatched.append("%s, expected: %s, actual: %s" % (
+                mismatched.append('%s, expected: %s, actual: %s' % (
                     safe_repr(key), safe_repr(value),
                     safe_repr(actual[key])))
 
         if not (missing or mismatched):
             return
 
-        standard_msg = ""
+        standard_msg = ''
         if missing:
-            standard_msg = "Missing: %s" % ','.join(map(safe_repr, missing))
+            standard_msg = 'Missing: %s' % ','.join(map(safe_repr, missing))
 
         if mismatched:
             if standard_msg:
-                standard_msg += "; "
-            standard_msg += "Mismatched values: %s" % (
+                standard_msg += '; '
+            standard_msg += 'Mismatched values: %s' % (
                 ','.join(mismatched))
 
         self.fail(self._formatMessage(msg, standard_msg))
@@ -296,7 +296,7 @@ def skip_if_environ(env_var_name):
         @wraps(fun)
         def _skips_if_environ(*args, **kwargs):
             if os.environ.get(env_var_name):
-                raise SkipTest("SKIP %s: %s set\n" % (
+                raise SkipTest('SKIP %s: %s set\n' % (
                     fun.__name__, env_var_name))
             return fun(*args, **kwargs)
 
@@ -306,7 +306,7 @@ def skip_if_environ(env_var_name):
 
 
 def skip_if_quick(fun):
-    return skip_if_environ("QUICKTEST")(fun)
+    return skip_if_environ('QUICKTEST')(fun)
 
 
 def _skip_test(reason, sign):
@@ -315,7 +315,7 @@ def _skip_test(reason, sign):
 
         @wraps(fun)
         def _skipped_test(*args, **kwargs):
-            raise SkipTest("%s: %s" % (sign, reason))
+            raise SkipTest('%s: %s' % (sign, reason))
 
         return _skipped_test
     return _wrap_test
@@ -323,12 +323,12 @@ def _skip_test(reason, sign):
 
 def todo(reason):
     """TODO test decorator."""
-    return _skip_test(reason, "TODO")
+    return _skip_test(reason, 'TODO')
 
 
 def skip(reason):
     """Skip test decorator."""
-    return _skip_test(reason, "SKIP")
+    return _skip_test(reason, 'SKIP')
 
 
 def skip_if(predicate, reason):
@@ -353,11 +353,11 @@ def mask_modules(*modnames):
 
     For example:
 
-        >>> with missing_modules("sys"):
+        >>> with missing_modules('sys'):
         ...     try:
         ...         import sys
         ...     except ImportError:
-        ...         print "sys not found"
+        ...         print 'sys not found'
         sys not found
 
         >>> import sys
@@ -370,7 +370,7 @@ def mask_modules(*modnames):
 
     def myimp(name, *args, **kwargs):
         if name in modnames:
-            raise ImportError("No module named %s" % name)
+            raise ImportError('No module named %s' % name)
         else:
             return realimport(name, *args, **kwargs)
 
@@ -430,10 +430,10 @@ def replace_module_value(module, name, value=None):
         except AttributeError:
             pass
 pypy_version = partial(
-    replace_module_value, sys, "pypy_version_info",
+    replace_module_value, sys, 'pypy_version_info',
 )
 platform_pyimp = partial(
-    replace_module_value, platform, "python_implementation",
+    replace_module_value, platform, 'python_implementation',
 )
 
 
@@ -502,7 +502,7 @@ def mock_context(mock, typ=Mock):
 
 @contextmanager
 def mock_open(typ=WhateverIO, side_effect=None):
-    with mock.patch("__builtin__.open") as open_:
+    with mock.patch('__builtin__.open') as open_:
         with mock_context(open_) as context:
             if side_effect is not None:
                 context.__enter__.side_effect = side_effect

celery/tests/worker/test_autoreload.py

@@ -34,8 +34,8 @@ class test_WorkerComponent(AppCase):
         x.instantiate.assert_called_with(w.autoreloader_cls, w)
         self.assertIs(r, w.autoreloader)
 
-    @patch("select.kevent", create=True)
-    @patch("select.kqueue", create=True)
+    @patch('select.kevent', create=True)
+    @patch('select.kqueue', create=True)
     def test_create_ev(self, kqueue, kevent):
         w = Mock()
         w.use_eventloop = True
@@ -52,39 +52,39 @@ class test_file_hash(Case):
 
     def test_hash(self):
         with mock_open() as a:
-            a.write("the quick brown fox\n")
+            a.write('the quick brown fox\n')
             a.seek(0)
-            A = file_hash("foo")
+            A = file_hash('foo')
         with mock_open() as b:
-            b.write("the quick brown bar\n")
+            b.write('the quick brown bar\n')
             b.seek(0)
-            B = file_hash("bar")
+            B = file_hash('bar')
         self.assertNotEqual(A, B)
 
 
 class test_BaseMonitor(Case):
 
     def test_start_stop_on_change(self):
-        x = BaseMonitor(["a", "b"])
+        x = BaseMonitor(['a', 'b'])
 
         with self.assertRaises(NotImplementedError):
             x.start()
         x.stop()
         x.on_change([])
         x._on_change = Mock()
-        x.on_change("foo")
-        x._on_change.assert_called_with("foo")
+        x.on_change('foo')
+        x._on_change.assert_called_with('foo')
 
 
 class test_StatMonitor(Case):
 
-    @patch("os.stat")
+    @patch('os.stat')
     def test_start(self, stat):
 
         class st(object):
             st_mtime = time()
         stat.return_value = st()
-        x = StatMonitor(["a", "b"])
+        x = StatMonitor(['a', 'b'])
 
         def on_is_set():
             if x.shutdown_event.is_set.call_count > 3:
@@ -101,12 +101,12 @@ class test_StatMonitor(Case):
 
 class test_KQueueMontior(Case):
 
-    @patch("select.kqueue", create=True)
-    @patch("os.close")
+    @patch('select.kqueue', create=True)
+    @patch('os.close')
     def test_stop(self, close, kqueue):
-        x = KQueueMonitor(["a", "b"])
+        x = KQueueMonitor(['a', 'b'])
         x.poller = Mock()
-        x.filemap["a"] = 10
+        x.filemap['a'] = 10
         x.stop()
         x.poller.close.assert_called_with()
         close.assert_called_with(10)
@@ -115,16 +115,16 @@ class test_KQueueMontior(Case):
         close.side_effect.errno = errno.EBADF
         x.stop()
 
-    @patch("kombu.utils.eventio.kqueue", create=True)
-    @patch("kombu.utils.eventio.kevent", create=True)
-    @patch("os.open")
-    @patch("select.kqueue", create=True)
+    @patch('kombu.utils.eventio.kqueue', create=True)
+    @patch('kombu.utils.eventio.kevent', create=True)
+    @patch('os.open')
+    @patch('select.kqueue', create=True)
     def test_start(self, _kq, osopen, kevent, kqueue):
         from kombu.utils import eventio
         prev_poll, eventio.poll = eventio.poll, kqueue
         prev = {}
-        flags = ["KQ_FILTER_VNODE", "KQ_EV_ADD", "KQ_EV_ENABLE",
-                 "KQ_EV_CLEAR", "KQ_NOTE_WRITE", "KQ_NOTE_EXTEND"]
+        flags = ['KQ_FILTER_VNODE', 'KQ_EV_ADD', 'KQ_EV_ENABLE',
+                 'KQ_EV_CLEAR', 'KQ_NOTE_WRITE', 'KQ_NOTE_EXTEND']
         for i, flag in enumerate(flags):
             prev[flag] = getattr(eventio, flag, None)
             if not prev[flag]:
@@ -137,7 +137,7 @@ class test_KQueueMontior(Case):
                 filter = eventio.KQ_FILTER_VNODE
                 fflags = eventio.KQ_NOTE_WRITE
             kq.control.return_value = [ev()]
-            x = KQueueMonitor(["a"])
+            x = KQueueMonitor(['a'])
             osopen.return_value = 10
             calls = [0]
 
@@ -160,9 +160,9 @@ class test_KQueueMontior(Case):
 
 class test_InotifyMonitor(Case):
 
-    @patch("celery.worker.autoreload.pyinotify")
+    @patch('celery.worker.autoreload.pyinotify')
     def test_start(self, inotify):
-            x = InotifyMonitor(["a"])
+            x = InotifyMonitor(['a'])
             inotify.IN_MODIFY = 1
             inotify.IN_ATTRIB = 2
             x.start()
@@ -181,23 +181,23 @@ class test_InotifyMonitor(Case):
 
 class test_default_implementation(Case):
 
-    @patch("select.kqueue", create=True)
+    @patch('select.kqueue', create=True)
     def test_kqueue(self, kqueue):
-        self.assertEqual(default_implementation(), "kqueue")
+        self.assertEqual(default_implementation(), 'kqueue')
 
-    @patch("celery.worker.autoreload.pyinotify")
+    @patch('celery.worker.autoreload.pyinotify')
     def test_inotify(self, pyinotify):
-        kq = getattr(select, "kqueue", None)
+        kq = getattr(select, 'kqueue', None)
         try:
-            delattr(select, "kqueue")
+            delattr(select, 'kqueue')
         except AttributeError:
             pass
-        platform, sys.platform = sys.platform, "linux"
+        platform, sys.platform = sys.platform, 'linux'
         try:
-            self.assertEqual(default_implementation(), "inotify")
+            self.assertEqual(default_implementation(), 'inotify')
             ino, autoreload.pyinotify = autoreload.pyinotify, None
             try:
-                self.assertEqual(default_implementation(), "stat")
+                self.assertEqual(default_implementation(), 'stat')
             finally:
                 autoreload.pyinotify = ino
         finally:
@@ -208,7 +208,7 @@ class test_default_implementation(Case):
 
 class test_Autoreloader(AppCase):
 
-    @patch("celery.worker.autoreload.file_hash")
+    @patch('celery.worker.autoreload.file_hash')
     def test_start(self, fhash):
         x = Autoreloader(Mock(), modules=[__name__])
         x.Monitor = Mock()
@@ -222,14 +222,14 @@ class test_Autoreloader(AppCase):
         mon.start.side_effect = None
         x.body()
 
-    @patch("celery.worker.autoreload.file_hash")
+    @patch('celery.worker.autoreload.file_hash')
     def test_maybe_modified(self, fhash):
-        fhash.return_value = "abcd"
+        fhash.return_value = 'abcd'
         x = Autoreloader(Mock(), modules=[__name__])
         x._hashes = {}
-        x._hashes[__name__] = "dcba"
+        x._hashes[__name__] = 'dcba'
         self.assertTrue(x._maybe_modified(__name__))
-        x._hashes[__name__] = "abcd"
+        x._hashes[__name__] = 'abcd'
         self.assertFalse(x._maybe_modified(__name__))
 
     def test_on_change(self):
@@ -258,4 +258,4 @@ class test_Autoreloader(AppCase):
 
     def test_module_name(self):
         x = Autoreloader(Mock(), modules=[__name__])
-        self.assertEqual(x._module_name("foo/bar/baz.py"), "baz")
+        self.assertEqual(x._module_name('foo/bar/baz.py'), 'baz')

celery/tests/worker/test_autoscale.py

@@ -30,9 +30,9 @@ class MockPool(BasePool):
 
     def shrink(self, n=1):
         if self.shrink_raises_exception:
-            raise KeyError("foo")
+            raise KeyError('foo')
         if self.shrink_raises_ValueError:
-            raise ValueError("foo")
+            raise ValueError('foo')
         self._pool._processes -= n
 
     @property
@@ -105,7 +105,7 @@ class test_Autoscaler(Case):
         x.pool.shrink_raises_exception = True
         x.scale_down(1)
 
-    @patch("celery.worker.autoscale.debug")
+    @patch('celery.worker.autoscale.debug')
     def test_shrink_raises_ValueError(self, debug):
         x = autoscale.Autoscaler(self.pool, 10, 3)
         x.scale_up(3)
@@ -143,14 +143,14 @@ class test_Autoscaler(Case):
         self.assertEqual(info['min'], 3)
         self.assertEqual(info['current'], 3)
 
-    @patch("os._exit")
+    @patch('os._exit')
     def test_thread_crash(self, _exit):
 
         class _Autoscaler(autoscale.Autoscaler):
 
             def body(self):
                 self._is_shutdown.set()
-                raise OSError("foo")
+                raise OSError('foo')
         x = _Autoscaler(self.pool, 10, 3)
 
         stderr = Mock()

celery/tests/worker/test_bootsteps.py

@@ -11,7 +11,7 @@ from celery.tests.utils import AppCase, Case
 class test_Component(Case):
 
     class Def(bootsteps.Component):
-        name = "test_Component.Def"
+        name = 'test_Component.Def'
 
     def test_components_must_be_named(self):
         with self.assertRaises(NotImplementedError):
@@ -22,18 +22,18 @@ class test_Component(Case):
         class Y(bootsteps.Component):
             bootsteps = True
 
-    def test_namespace_name(self, ns="test_namespace_name"):
+    def test_namespace_name(self, ns='test_namespace_name'):
 
         class X(bootsteps.Component):
             namespace = ns
-            name = "X"
+            name = 'X'
         self.assertEqual(X.namespace, ns)
-        self.assertEqual(X.name, "X")
+        self.assertEqual(X.name, 'X')
 
         class Y(bootsteps.Component):
-            name = "%s.Y" % (ns, )
+            name = '%s.Y' % (ns, )
         self.assertEqual(Y.namespace, ns)
-        self.assertEqual(Y.name, "Y")
+        self.assertEqual(Y.name, 'Y')
 
     def test_init(self):
         self.assertTrue(self.Def(self))
@@ -56,10 +56,10 @@ class test_Component(Case):
     def test_include_when_enabled(self):
         x = self.Def(self)
         x.create = Mock()
-        x.create.return_value = "George"
+        x.create.return_value = 'George'
         self.assertTrue(x.include(self))
 
-        self.assertEqual(x.obj, "George")
+        self.assertEqual(x.obj, 'George')
         x.create.assert_called_with(self)
 
     def test_include_when_disabled(self):
@@ -74,7 +74,7 @@ class test_Component(Case):
 class test_StartStopComponent(Case):
 
     class Def(bootsteps.StartStopComponent):
-        name = "test_StartStopComponent.Def"
+        name = 'test_StartStopComponent.Def'
 
     def setUp(self):
         self.components = []
@@ -126,7 +126,7 @@ class test_StartStopComponent(Case):
 class test_Namespace(AppCase):
 
     class NS(bootsteps.Namespace):
-        name = "test_Namespace"
+        name = 'test_Namespace'
 
     class ImportingNS(bootsteps.Namespace):
 
@@ -135,7 +135,7 @@ class test_Namespace(AppCase):
             self.imported = []
 
         def modules(self):
-            return ["A", "B", "C"]
+            return ['A', 'B', 'C']
 
         def import_module(self, module):
             self.imported.append(module)
@@ -143,23 +143,23 @@ class test_Namespace(AppCase):
     def test_components_added_to_unclaimed(self):
 
         class tnA(bootsteps.Component):
-            name = "test_Namespace.A"
+            name = 'test_Namespace.A'
 
         class tnB(bootsteps.Component):
-            name = "test_Namespace.B"
+            name = 'test_Namespace.B'
 
         class xxA(bootsteps.Component):
-            name = "xx.A"
+            name = 'xx.A'
 
-        self.assertIn("A", self.NS._unclaimed["test_Namespace"])
-        self.assertIn("B", self.NS._unclaimed["test_Namespace"])
-        self.assertIn("A", self.NS._unclaimed["xx"])
-        self.assertNotIn("B", self.NS._unclaimed["xx"])
+        self.assertIn('A', self.NS._unclaimed['test_Namespace'])
+        self.assertIn('B', self.NS._unclaimed['test_Namespace'])
+        self.assertIn('A', self.NS._unclaimed['xx'])
+        self.assertNotIn('B', self.NS._unclaimed['xx'])
 
     def test_init(self):
         ns = self.NS(app=self.app)
         self.assertIs(ns.app, self.app)
-        self.assertEqual(ns.name, "test_Namespace")
+        self.assertEqual(ns.name, 'test_Namespace')
         self.assertFalse(ns.services)
 
     def test_interface_modules(self):
@@ -168,29 +168,29 @@ class test_Namespace(AppCase):
     def test_load_modules(self):
         x = self.ImportingNS(app=self.app)
         x.load_modules()
-        self.assertListEqual(x.imported, ["A", "B", "C"])
+        self.assertListEqual(x.imported, ['A', 'B', 'C'])
 
     def test_apply(self):
 
         class MyNS(bootsteps.Namespace):
-            name = "test_apply"
+            name = 'test_apply'
 
             def modules(self):
-                return ["A", "B"]
+                return ['A', 'B']
 
         class A(bootsteps.Component):
-            name = "test_apply.A"
-            requires = ["C"]
+            name = 'test_apply.A'
+            requires = ['C']
 
         class B(bootsteps.Component):
-            name = "test_apply.B"
+            name = 'test_apply.B'
 
         class C(bootsteps.Component):
-            name = "test_apply.C"
-            requires = ["B"]
+            name = 'test_apply.C'
+            requires = ['B']
 
         class D(bootsteps.Component):
-            name = "test_apply.D"
+            name = 'test_apply.D'
             last = True
 
         x = MyNS(app=self.app)
@@ -208,17 +208,17 @@ class test_Namespace(AppCase):
         self.assertIsInstance(x.boot_steps[2], A)
         self.assertIsInstance(x.boot_steps[3], D)
 
-        self.assertIs(x["A"], A)
+        self.assertIs(x['A'], A)
 
     def test_import_module(self):
         x = self.NS(app=self.app)
         import os
-        self.assertIs(x.import_module("os"), os)
+        self.assertIs(x.import_module('os'), os)
 
     def test_find_last_but_no_components(self):
 
         class MyNS(bootsteps.Namespace):
-            name = "qwejwioqjewoqiej"
+            name = 'qwejwioqjewoqiej'
 
         x = MyNS(app=self.app)
         x.apply(self)

celery/tests/worker/test_control.py

@@ -53,7 +53,7 @@ class Consumer(object):
 
     @property
     def info(self):
-        return {"xyz": "XYZ"}
+        return {'xyz': 'XYZ'}
 
 
 class test_ControlPanel(Case):
@@ -63,7 +63,7 @@ class test_ControlPanel(Case):
         self.panel = self.create_panel(consumer=Consumer())
 
     def create_state(self, **kwargs):
-        kwargs.setdefault("app", self.app)
+        kwargs.setdefault('app', self.app)
         return AttributeDict(kwargs)
 
     def create_panel(self, **kwargs):
@@ -75,50 +75,50 @@ class test_ControlPanel(Case):
         consumer = Consumer()
         panel = self.create_panel(consumer=consumer)
         consumer.event_dispatcher.enabled = False
-        panel.handle("enable_events")
+        panel.handle('enable_events')
         self.assertTrue(consumer.event_dispatcher.enable.call_count)
-        self.assertIn(("worker-online", ),
+        self.assertIn(('worker-online', ),
                 consumer.event_dispatcher.send.call_args)
         consumer.event_dispatcher.enabled = True
-        self.assertIn("already enabled", panel.handle("enable_events")["ok"])
+        self.assertIn('already enabled', panel.handle('enable_events')['ok'])
 
     def test_disable_events(self):
         consumer = Consumer()
         panel = self.create_panel(consumer=consumer)
         consumer.event_dispatcher.enabled = True
-        panel.handle("disable_events")
+        panel.handle('disable_events')
         self.assertTrue(consumer.event_dispatcher.disable.call_count)
-        self.assertIn(("worker-offline", ),
+        self.assertIn(('worker-offline', ),
                       consumer.event_dispatcher.send.call_args)
         consumer.event_dispatcher.enabled = False
-        self.assertIn("already disabled", panel.handle("disable_events")["ok"])
+        self.assertIn('already disabled', panel.handle('disable_events')['ok'])
 
     def test_heartbeat(self):
         consumer = Consumer()
         panel = self.create_panel(consumer=consumer)
         consumer.event_dispatcher.enabled = True
-        panel.handle("heartbeat")
-        self.assertIn(("worker-heartbeat", ),
+        panel.handle('heartbeat')
+        self.assertIn(('worker-heartbeat', ),
                       consumer.event_dispatcher.send.call_args)
 
     def test_time_limit(self):
         panel = self.create_panel(consumer=Mock())
         th, ts = mytask.time_limit, mytask.soft_time_limit
         try:
-            r = panel.handle("time_limit", arguments=dict(
+            r = panel.handle('time_limit', arguments=dict(
                 task_name=mytask.name, hard=30, soft=10))
             self.assertEqual((mytask.time_limit, mytask.soft_time_limit),
                              (30, 10))
-            self.assertIn("ok", r)
-            r = panel.handle("time_limit", arguments=dict(
+            self.assertIn('ok', r)
+            r = panel.handle('time_limit', arguments=dict(
                 task_name=mytask.name, hard=None, soft=None))
             self.assertEqual((mytask.time_limit, mytask.soft_time_limit),
                              (None, None))
-            self.assertIn("ok", r)
+            self.assertIn('ok', r)
 
-            r = panel.handle("time_limit", arguments=dict(
-                task_name="248e8afya9s8dh921eh928", hard=30))
-            self.assertIn("error", r)
+            r = panel.handle('time_limit', arguments=dict(
+                task_name='248e8afya9s8dh921eh928', hard=30))
+            self.assertIn('error', r)
         finally:
             mytask.time_limit, mytask.soft_time_limit = th, ts
 
@@ -126,44 +126,44 @@ class test_ControlPanel(Case):
         import kombu
 
         x = kombu.Consumer(current_app.broker_connection(),
-                           [kombu.Queue("foo", kombu.Exchange("foo"), "foo"),
-                            kombu.Queue("bar", kombu.Exchange("bar"), "bar")],
+                           [kombu.Queue('foo', kombu.Exchange('foo'), 'foo'),
+                            kombu.Queue('bar', kombu.Exchange('bar'), 'bar')],
                            auto_declare=False)
         consumer = Mock()
         consumer.task_consumer = x
         panel = self.create_panel(consumer=consumer)
-        r = panel.handle("active_queues")
-        self.assertListEqual(list(sorted(q["name"] for q in r)),
-                             ["bar", "foo"])
+        r = panel.handle('active_queues')
+        self.assertListEqual(list(sorted(q['name'] for q in r)),
+                             ['bar', 'foo'])
 
     def test_dump_tasks(self):
-        info = "\n".join(self.panel.handle("dump_tasks"))
-        self.assertIn("mytask", info)
-        self.assertIn("rate_limit=200", info)
+        info = '\n'.join(self.panel.handle('dump_tasks'))
+        self.assertIn('mytask', info)
+        self.assertIn('rate_limit=200', info)
 
     def test_stats(self):
         prev_count, state.total_count = state.total_count, 100
         try:
-            self.assertDictContainsSubset({"total": 100,
-                                           "consumer": {"xyz": "XYZ"}},
-                                          self.panel.handle("stats"))
+            self.assertDictContainsSubset({'total': 100,
+                                           'consumer': {'xyz': 'XYZ'}},
+                                          self.panel.handle('stats'))
             self.panel.state.consumer = Mock()
-            self.panel.handle("stats")
+            self.panel.handle('stats')
             self.assertTrue(
                 self.panel.state.consumer.controller.autoscaler.info.called)
         finally:
             state.total_count = prev_count
 
     def test_report(self):
-        self.panel.handle("report")
+        self.panel.handle('report')
 
     def test_active(self):
         from celery.worker.job import TaskRequest
 
-        r = TaskRequest(mytask.name, "do re mi", (), {})
+        r = TaskRequest(mytask.name, 'do re mi', (), {})
         state.active_requests.add(r)
         try:
-            self.assertTrue(self.panel.handle("dump_active"))
+            self.assertTrue(self.panel.handle('dump_active'))
         finally:
             state.active_requests.discard(r)
 
@@ -184,17 +184,17 @@ class test_ControlPanel(Case):
         consumer.pool = MockPool()
         panel = self.create_panel(consumer=consumer)
 
-        panel.handle("pool_grow")
+        panel.handle('pool_grow')
         self.assertEqual(consumer.pool.size, 2)
-        panel.handle("pool_shrink")
+        panel.handle('pool_shrink')
         self.assertEqual(consumer.pool.size, 1)
 
         panel.state.consumer = Mock()
         panel.state.consumer.controller = Mock()
         sc = panel.state.consumer.controller.autoscaler = Mock()
-        panel.handle("pool_grow")
+        panel.handle('pool_grow')
         self.assertTrue(sc.force_scale_up.called)
-        panel.handle("pool_shrink")
+        panel.handle('pool_shrink')
         self.assertTrue(sc.force_scale_down.called)
 
     def test_add__cancel_consumer(self):
@@ -220,60 +220,60 @@ class test_ControlPanel(Case):
         consumer.task_consumer = MockConsumer()
         panel = self.create_panel(consumer=consumer)
 
-        panel.handle("add_consumer", {"queue": "MyQueue"})
-        self.assertIn("MyQueue", consumer.task_consumer.queues)
+        panel.handle('add_consumer', {'queue': 'MyQueue'})
+        self.assertIn('MyQueue', consumer.task_consumer.queues)
         self.assertTrue(consumer.task_consumer.consuming)
-        panel.handle("add_consumer", {"queue": "MyQueue"})
-        panel.handle("cancel_consumer", {"queue": "MyQueue"})
-        self.assertIn("MyQueue", consumer.task_consumer.cancelled)
+        panel.handle('add_consumer', {'queue': 'MyQueue'})
+        panel.handle('cancel_consumer', {'queue': 'MyQueue'})
+        self.assertIn('MyQueue', consumer.task_consumer.cancelled)
 
     def test_revoked(self):
         state.revoked.clear()
-        state.revoked.add("a1")
-        state.revoked.add("a2")
+        state.revoked.add('a1')
+        state.revoked.add('a2')
 
         try:
-            self.assertEqual(sorted(self.panel.handle("dump_revoked")),
-                             ["a1", "a2"])
+            self.assertEqual(sorted(self.panel.handle('dump_revoked')),
+                             ['a1', 'a2'])
         finally:
             state.revoked.clear()
 
     def test_dump_schedule(self):
         consumer = Consumer()
         panel = self.create_panel(consumer=consumer)
-        self.assertFalse(panel.handle("dump_schedule"))
-        r = TaskRequest(mytask.name, "CAFEBABE", (), {})
+        self.assertFalse(panel.handle('dump_schedule'))
+        r = TaskRequest(mytask.name, 'CAFEBABE', (), {})
         consumer.timer.schedule.enter(
                 consumer.timer.Entry(lambda x: x, (r, )),
                     datetime.now() + timedelta(seconds=10))
-        self.assertTrue(panel.handle("dump_schedule"))
+        self.assertTrue(panel.handle('dump_schedule'))
 
     def test_dump_reserved(self):
         consumer = Consumer()
         panel = self.create_panel(consumer=consumer)
-        response = panel.handle("dump_reserved", {"safe": True})
-        self.assertDictContainsSubset({"name": mytask.name,
-                                       "args": (2, 2),
-                                       "kwargs": {},
-                                       "hostname": socket.gethostname()},
+        response = panel.handle('dump_reserved', {'safe': True})
+        self.assertDictContainsSubset({'name': mytask.name,
+                                       'args': (2, 2),
+                                       'kwargs': {},
+                                       'hostname': socket.gethostname()},
                                        response[0])
         consumer.ready_queue = FastQueue()
-        self.assertFalse(panel.handle("dump_reserved"))
+        self.assertFalse(panel.handle('dump_reserved'))
 
     def test_rate_limit_when_disabled(self):
         app = current_app
         app.conf.CELERY_DISABLE_RATE_LIMITS = True
         try:
-            e = self.panel.handle("rate_limit", arguments=dict(
-                 task_name=mytask.name, rate_limit="100/m"))
-            self.assertIn("rate limits disabled", e.get("error"))
+            e = self.panel.handle('rate_limit', arguments=dict(
+                 task_name=mytask.name, rate_limit='100/m'))
+            self.assertIn('rate limits disabled', e.get('error'))
         finally:
             app.conf.CELERY_DISABLE_RATE_LIMITS = False
 
     def test_rate_limit_invalid_rate_limit_string(self):
-        e = self.panel.handle("rate_limit", arguments=dict(
-            task_name="tasks.add", rate_limit="x1240301#%!"))
-        self.assertIn("Invalid rate limit string", e.get("error"))
+        e = self.panel.handle('rate_limit', arguments=dict(
+            task_name='tasks.add', rate_limit='x1240301#%!'))
+        self.assertIn('Invalid rate limit string', e.get('error'))
 
     def test_rate_limit(self):
 
@@ -294,12 +294,12 @@ class test_ControlPanel(Case):
         task = current_app.tasks[mytask.name]
         old_rate_limit = task.rate_limit
         try:
-            panel.handle("rate_limit", arguments=dict(task_name=task.name,
-                                                      rate_limit="100/m"))
-            self.assertEqual(task.rate_limit, "100/m")
+            panel.handle('rate_limit', arguments=dict(task_name=task.name,
+                                                      rate_limit='100/m'))
+            self.assertEqual(task.rate_limit, '100/m')
             self.assertTrue(consumer.ready_queue.fresh)
             consumer.ready_queue.fresh = False
-            panel.handle("rate_limit", arguments=dict(task_name=task.name,
+            panel.handle('rate_limit', arguments=dict(task_name=task.name,
                                                       rate_limit=0))
             self.assertEqual(task.rate_limit, 0)
             self.assertTrue(consumer.ready_queue.fresh)
@@ -307,45 +307,45 @@ class test_ControlPanel(Case):
             task.rate_limit = old_rate_limit
 
     def test_rate_limit_nonexistant_task(self):
-        self.panel.handle("rate_limit", arguments={
-                                "task_name": "xxxx.does.not.exist",
-                                "rate_limit": "1000/s"})
+        self.panel.handle('rate_limit', arguments={
+                                'task_name': 'xxxx.does.not.exist',
+                                'rate_limit': '1000/s'})
 
     def test_unexposed_command(self):
         with self.assertRaises(KeyError):
-            self.panel.handle("foo", arguments={})
+            self.panel.handle('foo', arguments={})
 
     def test_revoke_with_name(self):
         tid = uuid()
-        m = {"method": "revoke",
-             "destination": hostname,
-             "arguments": {"task_id": tid,
-                           "task_name": mytask.name}}
+        m = {'method': 'revoke',
+             'destination': hostname,
+             'arguments': {'task_id': tid,
+                           'task_name': mytask.name}}
         self.panel.dispatch_from_message(m)
         self.assertIn(tid, revoked)
 
     def test_revoke_with_name_not_in_registry(self):
         tid = uuid()
-        m = {"method": "revoke",
-             "destination": hostname,
-             "arguments": {"task_id": tid,
-                           "task_name": "xxxxxxxxx33333333388888"}}
+        m = {'method': 'revoke',
+             'destination': hostname,
+             'arguments': {'task_id': tid,
+                           'task_name': 'xxxxxxxxx33333333388888'}}
         self.panel.dispatch_from_message(m)
         self.assertIn(tid, revoked)
 
     def test_revoke(self):
         tid = uuid()
-        m = {"method": "revoke",
-             "destination": hostname,
-             "arguments": {"task_id": tid}}
+        m = {'method': 'revoke',
+             'destination': hostname,
+             'arguments': {'task_id': tid}}
         self.panel.dispatch_from_message(m)
         self.assertIn(tid, revoked)
 
-        m = {"method": "revoke",
-             "destination": "does.not.exist",
-             "arguments": {"task_id": tid + "xxx"}}
+        m = {'method': 'revoke',
+             'destination': 'does.not.exist',
+             'arguments': {'task_id': tid + 'xxx'}}
         self.panel.dispatch_from_message(m)
-        self.assertNotIn(tid + "xxx", revoked)
+        self.assertNotIn(tid + 'xxx', revoked)
 
     def test_revoke_terminate(self):
         request = Mock()
@@ -355,10 +355,10 @@ class test_ControlPanel(Case):
             r = control.revoke(Mock(), tid, terminate=True)
             self.assertIn(tid, revoked)
             self.assertTrue(request.terminate.call_count)
-            self.assertIn("terminated", r["ok"])
+            self.assertIn('terminated', r['ok'])
             # unknown task id only revokes
             r = control.revoke(Mock(), uuid(), terminate=True)
-            self.assertIn("revoked", r["ok"])
+            self.assertIn('revoked', r['ok'])
         finally:
             state.active_requests.discard(request)
 
@@ -367,25 +367,25 @@ class test_ControlPanel(Case):
         self.panel.state.consumer.controller = Mock()
         sc = self.panel.state.consumer.controller.autoscaler = Mock()
         sc.update.return_value = 10, 2
-        m = {"method": "autoscale",
-             "destination": hostname,
-             "arguments": {"max": "10", "min": "2"}}
+        m = {'method': 'autoscale',
+             'destination': hostname,
+             'arguments': {'max': '10', 'min': '2'}}
         r = self.panel.dispatch_from_message(m)
-        self.assertIn("ok", r)
+        self.assertIn('ok', r)
 
         self.panel.state.consumer.controller.autoscaler = None
         r = self.panel.dispatch_from_message(m)
-        self.assertIn("error", r)
+        self.assertIn('error', r)
 
     def test_ping(self):
-        m = {"method": "ping",
-             "destination": hostname}
+        m = {'method': 'ping',
+             'destination': hostname}
         r = self.panel.dispatch_from_message(m)
-        self.assertEqual(r, "pong")
+        self.assertEqual(r, 'pong')
 
     def test_shutdown(self):
-        m = {"method": "shutdown",
-             "destination": hostname}
+        m = {'method': 'shutdown',
+             'destination': hostname}
         with self.assertRaises(SystemExit):
             self.panel.dispatch_from_message(m)
 
@@ -402,10 +402,10 @@ class test_ControlPanel(Case):
                       state=self.create_state(consumer=Consumer()),
                       handlers=Panel.data,
                       mailbox=self.app.control.mailbox)
-        r = panel.dispatch("ping", reply_to={"exchange": "x",
-                                             "routing_key": "x"})
-        self.assertEqual(r, "pong")
-        self.assertDictEqual(replies[0], {panel.hostname: "pong"})
+        r = panel.dispatch('ping', reply_to={'exchange': 'x',
+                                             'routing_key': 'x'})
+        self.assertEqual(r, 'pong')
+        self.assertDictEqual(replies[0], {panel.hostname: 'pong'})
 
     def test_pool_restart(self):
         consumer = Consumer()
@@ -416,7 +416,7 @@ class test_ControlPanel(Case):
         _import = panel.app.loader.import_from_cwd = Mock()
         _reload = Mock()
 
-        panel.handle("pool_restart", {"reloader": _reload})
+        panel.handle('pool_restart', {'reloader': _reload})
         self.assertTrue(consumer.controller.pool.restart.called)
         self.assertFalse(_reload.called)
         self.assertFalse(_import.called)
@@ -430,12 +430,12 @@ class test_ControlPanel(Case):
         _import = consumer.controller.app.loader.import_from_cwd = Mock()
         _reload = Mock()
 
-        panel.handle("pool_restart", {"modules": ["foo", "bar"],
-                                      "reloader": _reload})
+        panel.handle('pool_restart', {'modules': ['foo', 'bar'],
+                                      'reloader': _reload})
 
         self.assertTrue(consumer.controller.pool.restart.called)
         self.assertFalse(_reload.called)
-        self.assertEqual([(("foo",), {}), (("bar",), {})],
+        self.assertEqual([(('foo',), {}), (('bar',), {})],
                           _import.call_args_list)
 
     def test_pool_restart_relaod_modules(self):
@@ -447,10 +447,10 @@ class test_ControlPanel(Case):
         _import = panel.app.loader.import_from_cwd = Mock()
         _reload = Mock()
 
-        with patch.dict(sys.modules, {"foo": None}):
-            panel.handle("pool_restart", {"modules": ["foo"],
-                                          "reload": False,
-                                          "reloader": _reload})
+        with patch.dict(sys.modules, {'foo': None}):
+            panel.handle('pool_restart', {'modules': ['foo'],
+                                          'reload': False,
+                                          'reloader': _reload})
 
             self.assertTrue(consumer.controller.pool.restart.called)
             self.assertFalse(_reload.called)
@@ -460,9 +460,9 @@ class test_ControlPanel(Case):
             _reload.reset_mock()
             consumer.controller.pool.restart.reset_mock()
 
-            panel.handle("pool_restart", {"modules": ["foo"],
-                                          "reload": True,
-                                          "reloader": _reload})
+            panel.handle('pool_restart', {'modules': ['foo'],
+                                          'reload': True,
+                                          'reloader': _reload})
 
             self.assertTrue(consumer.controller.pool.restart.called)
             self.assertTrue(_reload.called)

celery/tests/worker/test_heartbeat.py

@@ -25,8 +25,8 @@ class MockDispatcher(object):
 class MockDispatcherRaising(object):
 
     def send(self, msg):
-        if msg == "worker-offline":
-            raise Exception("foo")
+        if msg == 'worker-offline':
+            raise Exception('foo')
 
 
 class MockTimer(object):

celery/tests/worker/test_hub.py

@@ -118,7 +118,7 @@ class test_BoundedSemaphore(Case):
 
 class test_Hub(Case):
 
-    @patch("kombu.utils.eventio.poll")
+    @patch('kombu.utils.eventio.poll')
     def test_start_stop(self, poll):
         hub = Hub()
         hub.start()

celery/tests/worker/test_mediator.py

@@ -13,9 +13,9 @@ from celery.tests.utils import Case
 
 
 class MockTask(object):
-    hostname = "harness.com"
+    hostname = 'harness.com'
     id = 1234
-    name = "mocktask"
+    name = 'mocktask'
 
     def __init__(self, value, **kwargs):
         self.value = value
@@ -47,21 +47,21 @@ class test_Mediator(Case):
         got = {}
 
         def mycallback(value):
-            got["value"] = value.value
+            got['value'] = value.value
 
         m = Mediator(ready_queue, mycallback)
-        ready_queue.put(MockTask("George Costanza"))
+        ready_queue.put(MockTask('George Costanza'))
 
         m.body()
 
-        self.assertEqual(got["value"], "George Costanza")
+        self.assertEqual(got['value'], 'George Costanza')
 
-        ready_queue.put(MockTask("Jerry Seinfeld"))
+        ready_queue.put(MockTask('Jerry Seinfeld'))
         m._does_debug = False
         m.body()
-        self.assertEqual(got["value"], "Jerry Seinfeld")
+        self.assertEqual(got['value'], 'Jerry Seinfeld')
 
-    @patch("os._exit")
+    @patch('os._exit')
     def test_mediator_crash(self, _exit):
         ms = [None]
 
@@ -69,13 +69,13 @@ class test_Mediator(Case):
 
             def body(self):
                 try:
-                    raise KeyError("foo")
+                    raise KeyError('foo')
                 finally:
                     ms[0]._is_shutdown.set()
 
         ready_queue = Queue()
         ms[0] = m = _Mediator(ready_queue, None)
-        ready_queue.put(MockTask("George Constanza"))
+        ready_queue.put(MockTask('George Constanza'))
 
         stderr = Mock()
         p, sys.stderr = sys.stderr, stderr
@@ -90,10 +90,10 @@ class test_Mediator(Case):
         ready_queue = Queue()
 
         def mycallback(value):
-            raise KeyError("foo")
+            raise KeyError('foo')
 
         m = Mediator(ready_queue, mycallback)
-        ready_queue.put(MockTask("Elaine M. Benes"))
+        ready_queue.put(MockTask('Elaine M. Benes'))
 
         m.body()
 
@@ -107,7 +107,7 @@ class test_Mediator(Case):
 
         m = Mediator(ready_queue, mycallback)
         condition[0] = m._is_shutdown
-        ready_queue.put(MockTask("Elaine M. Benes"))
+        ready_queue.put(MockTask('Elaine M. Benes'))
 
         m.run()
         self.assertTrue(m._is_shutdown.isSet())
@@ -118,15 +118,15 @@ class test_Mediator(Case):
         got = {}
 
         def mycallback(value):
-            got["value"] = value.value
+            got['value'] = value.value
 
         m = Mediator(ready_queue, mycallback)
-        t = MockTask("Jerry Seinfeld")
+        t = MockTask('Jerry Seinfeld')
         t.id = uuid()
         revoked_tasks.add(t.id)
         ready_queue.put(t)
 
         m.body()
 
-        self.assertNotIn("value", got)
+        self.assertNotIn('value', got)
         self.assertTrue(t.on_ack.call_count)

celery/tests/worker/test_request.py

@@ -38,7 +38,7 @@ from celery.worker.state import revoked
 
 from celery.tests.utils import Case
 
-scratch = {"ACK": False}
+scratch = {'ACK': False}
 some_kwargs_scratchpad = {}
 
 
@@ -62,17 +62,17 @@ class test_mro_lookup(Case):
                 return ()
 
         A.x = 10
-        self.assertEqual(mro_lookup(C, "x"), A)
-        self.assertIsNone(mro_lookup(C, "x", stop=(A, )))
+        self.assertEqual(mro_lookup(C, 'x'), A)
+        self.assertIsNone(mro_lookup(C, 'x', stop=(A, )))
         B.x = 10
-        self.assertEqual(mro_lookup(C, "x"), B)
+        self.assertEqual(mro_lookup(C, 'x'), B)
         C.x = 10
-        self.assertEqual(mro_lookup(C, "x"), C)
-        self.assertIsNone(mro_lookup(D, "x"))
+        self.assertEqual(mro_lookup(C, 'x'), C)
+        self.assertIsNone(mro_lookup(D, 'x'))
 
 
 def jail(task_id, name, args, kwargs):
-    request = {"id": task_id}
+    request = {'id': task_id}
     task = current_app.tasks[name]
     task.__trace__ = None  # rebuild
     return trace_task(task,
@@ -80,7 +80,7 @@ def jail(task_id, name, args, kwargs):
 
 
 def on_ack(*args, **kwargs):
-    scratch["ACK"] = True
+    scratch['ACK'] = True
 
 
 @task_dec(accept_magic_kwargs=False)
@@ -102,7 +102,7 @@ class MyTaskIgnoreResult(Task):
 
 @task_dec(accept_magic_kwargs=True)
 def mytask_some_kwargs(i, task_id):
-    some_kwargs_scratchpad["task_id"] = task_id
+    some_kwargs_scratchpad['task_id'] = task_id
     return i ** i
 
 
@@ -115,21 +115,21 @@ class test_default_encode(Case):
 
     def setUp(self):
         if sys.version_info >= (3, 0):
-            raise SkipTest("py3k: not relevant")
+            raise SkipTest('py3k: not relevant')
 
     def test_jython(self):
-        prev, sys.platform = sys.platform, "java 1.6.1"
+        prev, sys.platform = sys.platform, 'java 1.6.1'
         try:
-            self.assertEqual(default_encode("foo"), "foo")
+            self.assertEqual(default_encode('foo'), 'foo')
         finally:
             sys.platform = prev
 
     def test_cython(self):
-        prev, sys.platform = sys.platform, "darwin"
+        prev, sys.platform = sys.platform, 'darwin'
         gfe, sys.getfilesystemencoding = sys.getfilesystemencoding, \
-                                         lambda: "utf-8"
+                                         lambda: 'utf-8'
         try:
-            self.assertEqual(default_encode("foo"), "foo")
+            self.assertEqual(default_encode('foo'), 'foo')
         finally:
             sys.platform = prev
             sys.getfilesystemencoding = gfe
@@ -139,15 +139,15 @@ class test_RetryTaskError(Case):
 
     def test_retry_task_error(self):
         try:
-            raise Exception("foo")
+            raise Exception('foo')
         except Exception, exc:
-            ret = RetryTaskError("Retrying task", exc)
+            ret = RetryTaskError('Retrying task', exc)
             self.assertEqual(ret.exc, exc)
 
 
 class test_trace_task(Case):
 
-    @patch("celery.task.trace._logger")
+    @patch('celery.task.trace._logger')
     def test_process_cleanup_fails(self, _logger):
         backend = mytask.backend
         mytask.backend = Mock()
@@ -158,7 +158,7 @@ class test_trace_task(Case):
             self.assertEqual(ret, 4)
             mytask.backend.store_result.assert_called_with(tid, 4,
                                                            states.SUCCESS)
-            self.assertIn("Process cleanup failed",
+            self.assertIn('Process cleanup failed',
                           _logger.error.call_args[0][0])
         finally:
             mytask.backend = backend
@@ -229,15 +229,15 @@ class MockEventDispatcher(object):
 class test_TaskRequest(Case):
 
     def test_task_wrapper_repr(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         self.assertTrue(repr(tw))
 
-    @patch("celery.worker.job.kwdict")
+    @patch('celery.worker.job.kwdict')
     def test_kwdict(self, kwdict):
 
         prev, module.NEEDS_KWDICT = module.NEEDS_KWDICT, True
         try:
-            TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+            TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
             self.assertTrue(kwdict.called)
         finally:
             module.NEEDS_KWDICT = prev
@@ -245,30 +245,30 @@ class test_TaskRequest(Case):
     def test_sets_store_errors(self):
         mytask.ignore_result = True
         try:
-            tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+            tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
             self.assertFalse(tw.store_errors)
             mytask.store_errors_even_if_ignored = True
-            tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+            tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
             self.assertTrue(tw.store_errors)
         finally:
             mytask.ignore_result = False
             mytask.store_errors_even_if_ignored = False
 
     def test_send_event(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.eventer = MockEventDispatcher()
-        tw.send_event("task-frobulated")
-        self.assertIn("task-frobulated", tw.eventer.sent)
+        tw.send_event('task-frobulated')
+        self.assertIn('task-frobulated', tw.eventer.sent)
 
     def test_on_retry(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.eventer = MockEventDispatcher()
         try:
-            raise RetryTaskError("foo", KeyError("moofoobar"))
+            raise RetryTaskError('foo', KeyError('moofoobar'))
         except:
             einfo = ExceptionInfo()
             tw.on_failure(einfo)
-            self.assertIn("task-retried", tw.eventer.sent)
+            self.assertIn('task-retried', tw.eventer.sent)
             prev, module._does_info = module._does_info, False
             try:
                 tw.on_failure(einfo)
@@ -278,33 +278,33 @@ class test_TaskRequest(Case):
             tw.on_failure(einfo)
 
     def test_compat_properties(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         self.assertEqual(tw.task_id, tw.id)
         self.assertEqual(tw.task_name, tw.name)
-        tw.task_id = "ID"
-        self.assertEqual(tw.id, "ID")
-        tw.task_name = "NAME"
-        self.assertEqual(tw.name, "NAME")
+        tw.task_id = 'ID'
+        self.assertEqual(tw.id, 'ID')
+        tw.task_name = 'NAME'
+        self.assertEqual(tw.name, 'NAME')
 
     def test_terminate__task_started(self):
         pool = Mock()
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.time_start = time.time()
         tw.worker_pid = 313
-        tw.terminate(pool, signal="KILL")
-        pool.terminate_job.assert_called_with(tw.worker_pid, "KILL")
+        tw.terminate(pool, signal='KILL')
+        pool.terminate_job.assert_called_with(tw.worker_pid, 'KILL')
 
     def test_terminate__task_reserved(self):
         pool = Mock()
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.time_start = None
-        tw.terminate(pool, signal="KILL")
+        tw.terminate(pool, signal='KILL')
         self.assertFalse(pool.terminate_job.call_count)
-        self.assertTupleEqual(tw._terminate_on_ack, (True, pool, "KILL"))
-        tw.terminate(pool, signal="KILL")
+        self.assertTupleEqual(tw._terminate_on_ack, (True, pool, 'KILL'))
+        tw.terminate(pool, signal='KILL')
 
     def test_revoked_expires_expired(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"},
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'},
                          expires=datetime.utcnow() - timedelta(days=1))
         tw.revoked()
         self.assertIn(tw.id, revoked)
@@ -312,7 +312,7 @@ class test_TaskRequest(Case):
                          states.REVOKED)
 
     def test_revoked_expires_not_expired(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"},
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'},
                          expires=datetime.utcnow() + timedelta(days=1))
         tw.revoked()
         self.assertNotIn(tw.id, revoked)
@@ -321,7 +321,7 @@ class test_TaskRequest(Case):
 
     def test_revoked_expires_ignore_result(self):
         mytask.ignore_result = True
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"},
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'},
                          expires=datetime.utcnow() - timedelta(days=1))
         try:
             tw.revoked()
@@ -343,14 +343,14 @@ class test_TaskRequest(Case):
 
         def get_ei():
             try:
-                raise KeyError("moofoobar")
+                raise KeyError('moofoobar')
             except:
                 return ExceptionInfo()
 
         app.mail_admins = mock_mail_admins
         mytask.send_error_emails = True
         try:
-            tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+            tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
 
             einfo = get_ei()
             tw.on_failure(einfo)
@@ -382,19 +382,19 @@ class test_TaskRequest(Case):
             mytask.error_whitelist = ()
 
     def test_already_revoked(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw._already_revoked = True
         self.assertTrue(tw.revoked())
 
     def test_revoked(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         revoked.add(tw.id)
         self.assertTrue(tw.revoked())
         self.assertTrue(tw._already_revoked)
         self.assertTrue(tw.acknowledged)
 
     def test_execute_does_not_execute_revoked(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         revoked.add(tw.id)
         tw.execute()
 
@@ -410,12 +410,12 @@ class test_TaskRequest(Case):
             mytask_raising.acks_late = False
 
     def test_execute_using_pool_does_not_execute_revoked(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         revoked.add(tw.id)
         tw.execute_using_pool(None)
 
     def test_on_accepted_acks_early(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.on_accepted(pid=os.getpid(), time_accepted=time.time())
         self.assertTrue(tw.acknowledged)
         prev, module._does_debug = module._does_debug, False
@@ -425,7 +425,7 @@ class test_TaskRequest(Case):
             module._does_debug = prev
 
     def test_on_accepted_acks_late(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         mytask.acks_late = True
         try:
             tw.on_accepted(pid=os.getpid(), time_accepted=time.time())
@@ -434,15 +434,15 @@ class test_TaskRequest(Case):
             mytask.acks_late = False
 
     def test_on_accepted_terminates(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         pool = Mock()
-        tw.terminate(pool, signal="KILL")
+        tw.terminate(pool, signal='KILL')
         self.assertFalse(pool.terminate_job.call_count)
         tw.on_accepted(pid=314, time_accepted=time.time())
-        pool.terminate_job.assert_called_with(314, "KILL")
+        pool.terminate_job.assert_called_with(314, 'KILL')
 
     def test_on_success_acks_early(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.time_start = 1
         tw.on_success(42)
         prev, module._does_info = module._does_info, False
@@ -453,7 +453,7 @@ class test_TaskRequest(Case):
             module._does_info = prev
 
     def test_on_success_BaseException(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.time_start = 1
         with self.assertRaises(SystemExit):
             try:
@@ -464,7 +464,7 @@ class test_TaskRequest(Case):
                 assert False
 
     def test_on_success_eventer(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.time_start = 1
         tw.eventer = Mock()
         tw.send_event = Mock()
@@ -472,17 +472,17 @@ class test_TaskRequest(Case):
         self.assertTrue(tw.send_event.called)
 
     def test_on_success_when_failure(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.time_start = 1
         tw.on_failure = Mock()
         try:
-            raise KeyError("foo")
+            raise KeyError('foo')
         except Exception:
             tw.on_success(ExceptionInfo())
             self.assertTrue(tw.on_failure.called)
 
     def test_on_success_acks_late(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.time_start = 1
         mytask.acks_late = True
         try:
@@ -495,11 +495,11 @@ class test_TaskRequest(Case):
 
         def get_ei():
             try:
-                raise WorkerLostError("do re mi")
+                raise WorkerLostError('do re mi')
             except WorkerLostError:
                 return ExceptionInfo()
 
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         exc_info = get_ei()
         tw.on_failure(exc_info)
         self.assertEqual(mytask.backend.get_status(tw.id),
@@ -508,7 +508,7 @@ class test_TaskRequest(Case):
         mytask.ignore_result = True
         try:
             exc_info = get_ei()
-            tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+            tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
             tw.on_failure(exc_info)
             self.assertEqual(mytask.backend.get_status(tw.id),
                              states.PENDING)
@@ -516,12 +516,12 @@ class test_TaskRequest(Case):
             mytask.ignore_result = False
 
     def test_on_failure_acks_late(self):
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.time_start = 1
         mytask.acks_late = True
         try:
             try:
-                raise KeyError("foo")
+                raise KeyError('foo')
             except KeyError:
                 exc_info = ExceptionInfo()
                 tw.on_failure(exc_info)
@@ -530,25 +530,25 @@ class test_TaskRequest(Case):
             mytask.acks_late = False
 
     def test_from_message_invalid_kwargs(self):
-        body = dict(task=mytask.name, id=1, args=(), kwargs="foo")
+        body = dict(task=mytask.name, id=1, args=(), kwargs='foo')
         with self.assertRaises(InvalidTaskError):
             TaskRequest.from_message(None, body)
 
-    @patch("celery.worker.job.error")
-    @patch("celery.worker.job.warn")
+    @patch('celery.worker.job.error')
+    @patch('celery.worker.job.warn')
     def test_on_timeout(self, warn, error):
 
-        tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+        tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
         tw.on_timeout(soft=True, timeout=1337)
-        self.assertIn("Soft time limit", warn.call_args[0][0])
+        self.assertIn('Soft time limit', warn.call_args[0][0])
         tw.on_timeout(soft=False, timeout=1337)
-        self.assertIn("Hard time limit", error.call_args[0][0])
+        self.assertIn('Hard time limit', error.call_args[0][0])
         self.assertEqual(mytask.backend.get_status(tw.id),
                          states.FAILURE)
 
         mytask.ignore_result = True
         try:
-            tw = TaskRequest(mytask.name, uuid(), [1], {"f": "x"})
+            tw = TaskRequest(mytask.name, uuid(), [1], {'f': 'x'})
             tw.on_timeout(soft=True, timeout=1336)
             self.assertEqual(mytask.backend.get_status(tw.id),
                              states.PENDING)
@@ -557,18 +557,18 @@ class test_TaskRequest(Case):
 
     def test_trace_task_ret(self):
         mytask.__trace__ = build_tracer(mytask.name, mytask,
-                                        current_app.loader, "test")
+                                        current_app.loader, 'test')
         res = trace_task_ret(mytask.name, uuid(), [4], {})
         self.assertEqual(res, 4 ** 4)
 
     def test_execute_safe_catches_exception(self):
 
         def _error_exec(self, *args, **kwargs):
-            raise KeyError("baz")
+            raise KeyError('baz')
 
         @task_dec(request=None)
         def raising():
-            raise KeyError("baz")
+            raise KeyError('baz')
 
         with self.assertWarnsRegex(RuntimeWarning,
                 r'Exception raised outside'):
@@ -578,9 +578,9 @@ class test_TaskRequest(Case):
     def test_worker_task_trace_handle_retry(self):
         from celery.exceptions import RetryTaskError
         tid = uuid()
-        mytask.request.update({"id": tid})
+        mytask.request.update({'id': tid})
         try:
-            raise ValueError("foo")
+            raise ValueError('foo')
         except Exception, exc:
             try:
                 raise RetryTaskError(str(exc), exc=exc)
@@ -597,10 +597,10 @@ class test_TaskRequest(Case):
 
     def test_worker_task_trace_handle_failure(self):
         tid = uuid()
-        mytask.request.update({"id": tid})
+        mytask.request.update({'id': tid})
         try:
             try:
-                raise ValueError("foo")
+                raise ValueError('foo')
             except Exception, exc:
                 w = TraceInfo(states.FAILURE, exc)
                 w.handle_failure(mytask, store_errors=False)
@@ -614,39 +614,39 @@ class test_TaskRequest(Case):
 
     def test_task_wrapper_mail_attrs(self):
         tw = TaskRequest(mytask.name, uuid(), [], {})
-        x = tw.success_msg % {"name": tw.name,
-                              "id": tw.id,
-                              "return_value": 10,
-                              "runtime": 0.3641}
+        x = tw.success_msg % {'name': tw.name,
+                              'id': tw.id,
+                              'return_value': 10,
+                              'runtime': 0.3641}
         self.assertTrue(x)
-        x = tw.error_msg % {"name": tw.name,
-                           "id": tw.id,
-                           "exc": "FOOBARBAZ",
-                           "traceback": "foobarbaz"}
+        x = tw.error_msg % {'name': tw.name,
+                           'id': tw.id,
+                           'exc': 'FOOBARBAZ',
+                           'traceback': 'foobarbaz'}
         self.assertTrue(x)
 
     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")
+        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"])
+        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)
 
     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")
+        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, [])
@@ -654,67 +654,67 @@ class test_TaskRequest(Case):
 
     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")
+        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())
 
     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")
+        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())
 
     def test_execute(self):
         tid = uuid()
-        tw = TaskRequest(mytask.name, tid, [4], {"f": "x"})
+        tw = TaskRequest(mytask.name, tid, [4], {'f': 'x'})
         self.assertEqual(tw.execute(), 256)
         meta = mytask.backend.get_task_meta(tid)
-        self.assertEqual(meta["result"], 256)
-        self.assertEqual(meta["status"], states.SUCCESS)
+        self.assertEqual(meta['result'], 256)
+        self.assertEqual(meta['status'], states.SUCCESS)
 
     def test_execute_success_no_kwargs(self):
         tid = uuid()
         tw = TaskRequest(mytask_no_kwargs.name, tid, [4], {})
         self.assertEqual(tw.execute(), 256)
         meta = mytask_no_kwargs.backend.get_task_meta(tid)
-        self.assertEqual(meta["result"], 256)
-        self.assertEqual(meta["status"], states.SUCCESS)
+        self.assertEqual(meta['result'], 256)
+        self.assertEqual(meta['status'], states.SUCCESS)
 
     def test_execute_success_some_kwargs(self):
         tid = uuid()
         tw = TaskRequest(mytask_some_kwargs.name, tid, [4], {})
         self.assertEqual(tw.execute(), 256)
         meta = mytask_some_kwargs.backend.get_task_meta(tid)
-        self.assertEqual(some_kwargs_scratchpad.get("task_id"), tid)
-        self.assertEqual(meta["result"], 256)
-        self.assertEqual(meta["status"], states.SUCCESS)
+        self.assertEqual(some_kwargs_scratchpad.get('task_id'), tid)
+        self.assertEqual(meta['result'], 256)
+        self.assertEqual(meta['status'], states.SUCCESS)
 
     def test_execute_ack(self):
         tid = uuid()
-        tw = TaskRequest(mytask.name, tid, [4], {"f": "x"},
+        tw = TaskRequest(mytask.name, tid, [4], {'f': 'x'},
                         on_ack=on_ack)
         self.assertEqual(tw.execute(), 256)
         meta = mytask.backend.get_task_meta(tid)
-        self.assertTrue(scratch["ACK"])
-        self.assertEqual(meta["result"], 256)
-        self.assertEqual(meta["status"], states.SUCCESS)
+        self.assertTrue(scratch['ACK'])
+        self.assertEqual(meta['result'], 256)
+        self.assertEqual(meta['status'], states.SUCCESS)
 
     def test_execute_fail(self):
         tid = uuid()
         tw = TaskRequest(mytask_raising.name, tid, [4])
         self.assertIsInstance(tw.execute(), ExceptionInfo)
         meta = mytask_raising.backend.get_task_meta(tid)
-        self.assertEqual(meta["status"], states.FAILURE)
-        self.assertIsInstance(meta["result"], KeyError)
+        self.assertEqual(meta['status'], states.FAILURE)
+        self.assertIsInstance(meta['result'], KeyError)
 
     def test_execute_using_pool(self):
         tid = uuid()
-        tw = TaskRequest(mytask.name, tid, [4], {"f": "x"})
+        tw = TaskRequest(mytask.name, tid, [4], {'f': 'x'})
 
         class MockPool(BasePool):
             target = None
@@ -736,7 +736,7 @@ class test_TaskRequest(Case):
         self.assertEqual(p.args[0], mytask.name)
         self.assertEqual(p.args[1], tid)
         self.assertEqual(p.args[2], [4])
-        self.assertIn("f", p.args[3])
+        self.assertIn('f', p.args[3])
         self.assertIn([4], p.args)
 
         tw.task.accept_magic_kwargs = False
@@ -744,23 +744,23 @@ class test_TaskRequest(Case):
 
     def test_default_kwargs(self):
         tid = uuid()
-        tw = TaskRequest(mytask.name, tid, [4], {"f": "x"})
+        tw = TaskRequest(mytask.name, tid, [4], {'f': 'x'})
         self.assertDictEqual(
                 tw.extend_with_default_kwargs(), {
-                    "f": "x",
-                    "logfile": None,
-                    "loglevel": None,
-                    "task_id": tw.id,
-                    "task_retries": 0,
-                    "task_is_eager": False,
-                    "delivery_info": {"exchange": None, "routing_key": None},
-                    "task_name": tw.name})
-
-    @patch("celery.worker.job.logger")
+                    'f': 'x',
+                    'logfile': None,
+                    'loglevel': None,
+                    'task_id': tw.id,
+                    'task_retries': 0,
+                    'task_is_eager': False,
+                    'delivery_info': {'exchange': None, 'routing_key': None},
+                    'task_name': tw.name})
+
+    @patch('celery.worker.job.logger')
     def _test_on_failure(self, exception, logger):
         app = app_or_default()
         tid = uuid()
-        tw = TaskRequest(mytask.name, tid, [4], {"f": "x"})
+        tw = TaskRequest(mytask.name, tid, [4], {'f': 'x'})
         try:
             raise exception
         except Exception:
@@ -770,17 +770,17 @@ class test_TaskRequest(Case):
                 tw.on_failure(exc_info)
                 self.assertTrue(logger.log.called)
                 context = logger.log.call_args[0][2]
-                self.assertEqual(mytask.name, context["name"])
-                self.assertIn(tid, context["id"])
+                self.assertEqual(mytask.name, context['name'])
+                self.assertIn(tid, context['id'])
             finally:
                 app.conf.CELERY_SEND_TASK_ERROR_EMAILS = False
 
     def test_on_failure(self):
-        self._test_on_failure(Exception("Inside unit tests"))
+        self._test_on_failure(Exception('Inside unit tests'))
 
     def test_on_failure_unicode_exception(self):
-        self._test_on_failure(Exception(u"Бобры атакуют"))
+        self._test_on_failure(Exception(u'Бобры атакуют'))
 
     def test_on_failure_utf8_exception(self):
         self._test_on_failure(Exception(
-            from_utf8(u"Бобры атакуют")))
+            from_utf8(u'Бобры атакуют')))

celery/tests/worker/test_revoke.py

@@ -7,7 +7,7 @@ from celery.tests.utils import Case
 class test_revoked(Case):
 
     def test_is_working(self):
-        state.revoked.add("foo")
-        self.assertIn("foo", state.revoked)
-        state.revoked.pop_value("foo")
-        self.assertNotIn("foo", state.revoked)
+        state.revoked.add('foo')
+        self.assertIn('foo', state.revoked)
+        state.revoked.pop_value('foo')
+        self.assertNotIn('foo', state.revoked)

celery/tests/worker/test_state.py

@@ -50,7 +50,7 @@ class MyPersistent(state.Persistent):
 class test_Persistent(StateResetCase):
 
     def on_setup(self):
-        self.p = MyPersistent(filename="celery-state")
+        self.p = MyPersistent(filename='celery-state')
 
     def test_close_twice(self):
         self.p._is_open = False
@@ -61,30 +61,30 @@ class test_Persistent(StateResetCase):
         self.assertEqual(self.p.db.filename, self.p.filename)
 
     def test_save(self):
-        self.p.db["foo"] = "bar"
+        self.p.db['foo'] = 'bar'
         self.p.save()
         self.assertTrue(self.p.db.in_sync)
         self.assertTrue(self.p.db.closed)
 
     def add_revoked(self, *ids):
         for id in ids:
-            self.p.db.setdefault("revoked", LimitedSet()).add(id)
+            self.p.db.setdefault('revoked', LimitedSet()).add(id)
 
-    def test_merge(self, data=["foo", "bar", "baz"]):
+    def test_merge(self, data=['foo', 'bar', 'baz']):
         self.add_revoked(*data)
         self.p.merge(self.p.db)
         for item in data:
             self.assertIn(item, state.revoked)
 
-    def test_sync(self, data1=["foo", "bar", "baz"],
-                        data2=["baz", "ini", "koz"]):
+    def test_sync(self, data1=['foo', 'bar', 'baz'],
+                        data2=['baz', 'ini', 'koz']):
         self.add_revoked(*data1)
         for item in data2:
             state.revoked.add(item)
         self.p.sync(self.p.db)
 
         for item in data2:
-            self.assertIn(item, self.p.db["revoked"])
+            self.assertIn(item, self.p.db['revoked'])
 
 
 class SimpleReq(object):
@@ -95,20 +95,20 @@ class SimpleReq(object):
 
 class test_state(StateResetCase):
 
-    def test_accepted(self, requests=[SimpleReq("foo"),
-                                      SimpleReq("bar"),
-                                      SimpleReq("baz"),
-                                      SimpleReq("baz")]):
+    def test_accepted(self, requests=[SimpleReq('foo'),
+                                      SimpleReq('bar'),
+                                      SimpleReq('baz'),
+                                      SimpleReq('baz')]):
         for request in requests:
             state.task_accepted(request)
         for req in requests:
             self.assertIn(req, state.active_requests)
-        self.assertEqual(state.total_count["foo"], 1)
-        self.assertEqual(state.total_count["bar"], 1)
-        self.assertEqual(state.total_count["baz"], 2)
+        self.assertEqual(state.total_count['foo'], 1)
+        self.assertEqual(state.total_count['bar'], 1)
+        self.assertEqual(state.total_count['baz'], 2)
 
-    def test_ready(self, requests=[SimpleReq("foo"),
-                                   SimpleReq("bar")]):
+    def test_ready(self, requests=[SimpleReq('foo'),
+                                   SimpleReq('bar')]):
         for request in requests:
             state.task_accepted(request)
         self.assertEqual(len(state.active_requests), 2)

celery/tests/worker/test_worker.py

@@ -43,7 +43,7 @@ class MyKombuConsumer(BlockingConsumer):
     task_consumer = Mock()
 
     def __init__(self, *args, **kwargs):
-        kwargs.setdefault("pool", BasePool(2))
+        kwargs.setdefault('pool', BasePool(2))
         super(MyKombuConsumer, self).__init__(*args, **kwargs)
 
     def restart_heartbeat(self):
@@ -54,7 +54,7 @@ class MockNode(object):
     commands = []
 
     def handle_message(self, body, message):
-        self.commands.append(body.pop("command", None))
+        self.commands.append(body.pop('command', None))
 
 
 class MockEventDispatcher(object):
@@ -87,16 +87,16 @@ def foo_task(x, y, z, **kwargs):
 
 @periodic_task_dec(run_every=60)
 def foo_periodic_task():
-    return "foo"
+    return 'foo'
 
 
 def create_message(channel, **data):
-    data.setdefault("id", uuid())
+    data.setdefault('id', uuid())
     channel.no_ack_consumers = set()
     return Message(channel, body=pickle.dumps(dict(**data)),
-                   content_type="application/x-python-serialize",
-                   content_encoding="binary",
-                   delivery_info={"consumer_tag": "mock"})
+                   content_type='application/x-python-serialize',
+                   content_encoding='binary',
+                   delivery_info={'consumer_tag': 'mock'})
 
 
 class test_QoS(Case):
@@ -179,7 +179,7 @@ class test_QoS(Case):
         qos.decrement_eventually()
         self.assertEqual(qos.value, 8)
         consumer.qos.assert_called_with(prefetch_count=9)
-        self.assertIn({"prefetch_count": 9}, consumer.qos.call_args)
+        self.assertIn({'prefetch_count': 9}, consumer.qos.call_args)
 
         # Does not decrement 0 value
         qos.value = 0
@@ -218,12 +218,12 @@ class test_Consumer(Case):
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
         l.qos = QoS(l.task_consumer, 10)
         info = l.info
-        self.assertEqual(info["prefetch_count"], 10)
-        self.assertFalse(info["broker"])
+        self.assertEqual(info['prefetch_count'], 10)
+        self.assertFalse(info['broker'])
 
         l.connection = current_app.broker_connection()
         info = l.info
-        self.assertTrue(info["broker"])
+        self.assertTrue(info['broker'])
 
     def test_start_when_closed(self):
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
@@ -269,23 +269,23 @@ class test_Consumer(Case):
         self.assertTrue(eventer.close.call_count)
         self.assertTrue(heart.closed)
 
-    @patch("celery.worker.consumer.warn")
+    @patch('celery.worker.consumer.warn')
     def test_receive_message_unknown(self, warn):
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
         backend = Mock()
-        m = create_message(backend, unknown={"baz": "!!!"})
+        m = create_message(backend, unknown={'baz': '!!!'})
         l.event_dispatcher = Mock()
         l.pidbox_node = MockNode()
 
         l.receive_message(m.decode(), m)
         self.assertTrue(warn.call_count)
 
-    @patch("celery.utils.timer2.to_timestamp")
+    @patch('celery.utils.timer2.to_timestamp')
     def test_receive_message_eta_OverflowError(self, to_timestamp):
         to_timestamp.side_effect = OverflowError()
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
         m = create_message(Mock(), task=foo_task.name,
-                                   args=("2, 2"),
+                                   args=('2, 2'),
                                    kwargs={},
                                    eta=datetime.now().isoformat())
         l.event_dispatcher = Mock()
@@ -296,29 +296,29 @@ class test_Consumer(Case):
         self.assertTrue(m.acknowledged)
         self.assertTrue(to_timestamp.call_count)
 
-    @patch("celery.worker.consumer.error")
+    @patch('celery.worker.consumer.error')
     def test_receive_message_InvalidTaskError(self, error):
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
         m = create_message(Mock(), task=foo_task.name,
-                           args=(1, 2), kwargs="foobarbaz", id=1)
+                           args=(1, 2), kwargs='foobarbaz', id=1)
         l.update_strategies()
         l.event_dispatcher = Mock()
         l.pidbox_node = MockNode()
 
         l.receive_message(m.decode(), m)
-        self.assertIn("Received invalid task message", error.call_args[0][0])
+        self.assertIn('Received invalid task message', error.call_args[0][0])
 
-    @patch("celery.worker.consumer.crit")
+    @patch('celery.worker.consumer.crit')
     def test_on_decode_error(self, crit):
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
 
         class MockMessage(Mock):
-            content_type = "application/x-msgpack"
-            content_encoding = "binary"
-            body = "foobarbaz"
+            content_type = 'application/x-msgpack'
+            content_encoding = 'binary'
+            body = 'foobarbaz'
 
         message = MockMessage()
-        l.on_decode_error(message, KeyError("foo"))
+        l.on_decode_error(message, KeyError('foo'))
         self.assertTrue(message.ack.call_count)
         self.assertIn("Can't decode message body", crit.call_args[0][0])
 
@@ -345,8 +345,8 @@ class test_Consumer(Case):
             def consume_messages(self):
                 if not self.iterations:
                     self.iterations = 1
-                    raise KeyError("foo")
-                raise SyntaxError("bar")
+                    raise KeyError('foo')
+                raise SyntaxError('bar')
 
         l = MockConsumer(self.ready_queue, timer=self.timer,
                              send_events=False, pool=BasePool())
@@ -366,8 +366,8 @@ class test_Consumer(Case):
             def consume_messages(self):
                 if not self.iterations:
                     self.iterations = 1
-                    raise KeyError("foo")
-                raise SyntaxError("bar")
+                    raise KeyError('foo')
+                raise SyntaxError('bar')
 
         l = MockConsumer(self.ready_queue, timer=self.timer,
                              send_events=False, pool=BasePool())
@@ -400,7 +400,7 @@ class test_Consumer(Case):
 
             def drain_events(self, **kwargs):
                 self.obj.connection = None
-                raise socket.error("foo")
+                raise socket.error('foo')
 
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
         l._state = RUN
@@ -441,11 +441,11 @@ class test_Consumer(Case):
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
         l.connection_errors = (KeyError, )
         l.channel_errors = (SyntaxError, )
-        l.maybe_conn_error(Mock(side_effect=AttributeError("foo")))
-        l.maybe_conn_error(Mock(side_effect=KeyError("foo")))
-        l.maybe_conn_error(Mock(side_effect=SyntaxError("foo")))
+        l.maybe_conn_error(Mock(side_effect=AttributeError('foo')))
+        l.maybe_conn_error(Mock(side_effect=KeyError('foo')))
+        l.maybe_conn_error(Mock(side_effect=SyntaxError('foo')))
         with self.assertRaises(IndexError):
-            l.maybe_conn_error(Mock(side_effect=IndexError("foo")))
+            l.maybe_conn_error(Mock(side_effect=IndexError('foo')))
 
     def test_apply_eta_task(self):
         from celery.worker import state
@@ -487,18 +487,18 @@ class test_Consumer(Case):
         l.pidbox_node = Mock()
         l.reset_pidbox_node = Mock()
 
-        l.on_control("foo", "bar")
-        l.pidbox_node.handle_message.assert_called_with("foo", "bar")
+        l.on_control('foo', 'bar')
+        l.pidbox_node.handle_message.assert_called_with('foo', 'bar')
 
         l.pidbox_node = Mock()
-        l.pidbox_node.handle_message.side_effect = KeyError("foo")
-        l.on_control("foo", "bar")
-        l.pidbox_node.handle_message.assert_called_with("foo", "bar")
+        l.pidbox_node.handle_message.side_effect = KeyError('foo')
+        l.on_control('foo', 'bar')
+        l.pidbox_node.handle_message.assert_called_with('foo', 'bar')
 
         l.pidbox_node = Mock()
-        l.pidbox_node.handle_message.side_effect = ValueError("foo")
-        l.on_control("foo", "bar")
-        l.pidbox_node.handle_message.assert_called_with("foo", "bar")
+        l.pidbox_node.handle_message.side_effect = ValueError('foo')
+        l.on_control('foo', 'bar')
+        l.pidbox_node.handle_message.assert_called_with('foo', 'bar')
         l.reset_pidbox_node.assert_called_with()
 
     def test_revoke(self):
@@ -517,7 +517,7 @@ class test_Consumer(Case):
     def test_receieve_message_not_registered(self):
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
         backend = Mock()
-        m = create_message(backend, task="x.X.31x", args=[2, 4, 8], kwargs={})
+        m = create_message(backend, task='x.X.31x', args=[2, 4, 8], kwargs={})
 
         l.event_dispatcher = Mock()
         self.assertFalse(l.receive_message(m.decode(), m))
@@ -525,8 +525,8 @@ class test_Consumer(Case):
             self.ready_queue.get_nowait()
         self.assertTrue(self.timer.empty())
 
-    @patch("celery.worker.consumer.warn")
-    @patch("celery.worker.consumer.logger")
+    @patch('celery.worker.consumer.warn')
+    @patch('celery.worker.consumer.logger')
     def test_receieve_message_ack_raises(self, logger, warn):
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
         backend = Mock()
@@ -535,7 +535,7 @@ class test_Consumer(Case):
         l.event_dispatcher = Mock()
         l.connection_errors = (socket.error, )
         m.reject = Mock()
-        m.reject.side_effect = socket.error("foo")
+        m.reject.side_effect = socket.error('foo')
         self.assertFalse(l.receive_message(m.decode(), m))
         self.assertTrue(warn.call_count)
         with self.assertRaises(Empty):
@@ -580,7 +580,7 @@ class test_Consumer(Case):
         l.pidbox_node = Mock()
         chan = l.pidbox_node.channel = Mock()
         l.connection = Mock()
-        chan.close.side_effect = socket.error("foo")
+        chan.close.side_effect = socket.error('foo')
         l.connection_errors = (socket.error, )
         l.reset_pidbox_node()
         chan.close.assert_called_with()
@@ -647,8 +647,8 @@ class test_Consumer(Case):
         self.assertIsNone(l.connection)
         self.assertTrue(connections[0].closed)
 
-    @patch("kombu.connection.BrokerConnection._establish_connection")
-    @patch("kombu.utils.sleep")
+    @patch('kombu.connection.BrokerConnection._establish_connection')
+    @patch('kombu.utils.sleep')
     def test_open_connection_errback(self, sleep, connect):
         l = MyKombuConsumer(self.ready_queue, timer=self.timer)
         from kombu.transport.memory import Transport
@@ -683,7 +683,7 @@ class test_Consumer(Case):
 
             def reset_connection(self):
                 if self.iterations >= 1:
-                    raise KeyError("foo")
+                    raise KeyError('foo')
 
         init_callback = Mock()
         l = _Consumer(self.ready_queue, timer=self.timer,
@@ -699,7 +699,7 @@ class test_Consumer(Case):
             if l.qos.prev != l.qos.value:
                 l.qos.update()
             if l.iterations >= 2:
-                raise KeyError("foo")
+                raise KeyError('foo')
 
         l.consume_messages = raises_KeyError
         with self.assertRaises(KeyError):
@@ -715,7 +715,7 @@ class test_Consumer(Case):
         l.task_consumer = Mock()
         l.broadcast_consumer = Mock()
         l.connection = BrokerConnection()
-        l.consume_messages = Mock(side_effect=socket.error("foo"))
+        l.consume_messages = Mock(side_effect=socket.error('foo'))
         with self.assertRaises(socket.error):
             l.start()
         self.assertTrue(init_callback.call_count)
@@ -760,18 +760,18 @@ class test_WorkController(AppCase):
         worker._shutdown_complete.set()
         return worker
 
-    @patch("celery.platforms.create_pidlock")
+    @patch('celery.platforms.create_pidlock')
     def test_use_pidfile(self, create_pidlock):
         create_pidlock.return_value = Mock()
-        worker = self.create_worker(pidfile="pidfilelockfilepid")
+        worker = self.create_worker(pidfile='pidfilelockfilepid')
         worker.components = []
         worker.start()
         self.assertTrue(create_pidlock.called)
         worker.stop()
         self.assertTrue(worker.pidlock.release.called)
 
-    @patch("celery.platforms.signals")
-    @patch("celery.platforms.set_mp_process_title")
+    @patch('celery.platforms.signals')
+    @patch('celery.platforms.set_mp_process_title')
     def test_process_initializer(self, set_mp_process_title, _signals):
         from celery import Celery
         from celery import signals
@@ -790,19 +790,19 @@ class test_WorkController(AppCase):
         app = Celery(loader=loader, set_as_current=False)
         app.loader = loader
         app.conf = AttributeDict(DEFAULTS)
-        process_initializer(app, "awesome.worker.com")
+        process_initializer(app, 'awesome.worker.com')
         _signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
         _signals.reset.assert_any_call(*WORKER_SIGRESET)
         self.assertTrue(app.loader.init_worker.call_count)
         self.assertTrue(on_worker_process_init.called)
         self.assertIs(_tls.current_app, app)
-        set_mp_process_title.assert_called_with("celery",
-                        hostname="awesome.worker.com")
+        set_mp_process_title.assert_called_with('celery',
+                        hostname='awesome.worker.com')
 
     def test_with_rate_limits_disabled(self):
         worker = WorkController(concurrency=1, loglevel=0,
                                 disable_rate_limits=True)
-        self.assertTrue(hasattr(worker.ready_queue, "put"))
+        self.assertTrue(hasattr(worker.ready_queue, 'put'))
 
     def test_attrs(self):
         worker = self.worker
@@ -820,7 +820,7 @@ class test_WorkController(AppCase):
 
     def test_with_autoscaler(self):
         worker = self.create_worker(autoscale=[10, 3], send_events=False,
-                                timer_cls="celery.utils.timer2.Timer")
+                                timer_cls='celery.utils.timer2.Timer')
         self.assertTrue(worker.autoscaler)
 
     def test_dont_stop_or_terminate(self):
@@ -844,11 +844,11 @@ class test_WorkController(AppCase):
         worker = WorkController(concurrency=1, loglevel=0)
 
         try:
-            raise KeyError("foo")
+            raise KeyError('foo')
         except KeyError, exc:
             Timers(worker).on_timer_error(exc)
             msg, args = self.logger.error.call_args[0]
-            self.assertIn("KeyError", msg % args)
+            self.assertIn('KeyError', msg % args)
 
     def test_on_timer_tick(self):
         worker = WorkController(concurrency=1, loglevel=10)
@@ -857,7 +857,7 @@ class test_WorkController(AppCase):
         xargs = self.logger.debug.call_args[0]
         fmt, arg = xargs[0], xargs[1]
         self.assertEqual(30.0, arg)
-        self.assertIn("Next eta %s secs", fmt)
+        self.assertIn('Next eta %s secs', fmt)
 
     def test_process_task(self):
         worker = self.worker
@@ -873,7 +873,7 @@ class test_WorkController(AppCase):
     def test_process_task_raise_base(self):
         worker = self.worker
         worker.pool = Mock()
-        worker.pool.apply_async.side_effect = KeyboardInterrupt("Ctrl+C")
+        worker.pool.apply_async.side_effect = KeyboardInterrupt('Ctrl+C')
         backend = Mock()
         m = create_message(backend, task=foo_task.name, args=[4, 8, 10],
                            kwargs={})
@@ -901,7 +901,7 @@ class test_WorkController(AppCase):
     def test_process_task_raise_regular(self):
         worker = self.worker
         worker.pool = Mock()
-        worker.pool.apply_async.side_effect = KeyError("some exception")
+        worker.pool.apply_async.side_effect = KeyError('some exception')
         backend = Mock()
         m = create_message(backend, task=foo_task.name, args=[4, 8, 10],
                            kwargs={})
@@ -931,14 +931,14 @@ class test_WorkController(AppCase):
 
         state.Persistent = Mock()
         try:
-            worker = self.create_worker(state_db="statefilename")
+            worker = self.create_worker(state_db='statefilename')
             self.assertTrue(worker._persistence)
         finally:
             state.Persistent = Persistent
 
     def test_disable_rate_limits_solo(self):
         worker = self.create_worker(disable_rate_limits=True,
-                                    pool_cls="solo")
+                                    pool_cls='solo')
         self.assertIsInstance(worker.ready_queue, FastQueue)
         self.assertIsNone(worker.mediator)
         self.assertEqual(worker.ready_queue.put, worker.process_task)
@@ -946,9 +946,9 @@ class test_WorkController(AppCase):
     def test_disable_rate_limits_processes(self):
         try:
             worker = self.create_worker(disable_rate_limits=True,
-                                        pool_cls="processes")
+                                        pool_cls='processes')
         except ImportError:
-            raise SkipTest("multiprocessing not supported")
+            raise SkipTest('multiprocessing not supported')
         self.assertIsInstance(worker.ready_queue, FastQueue)
         self.assertTrue(worker.mediator)
         self.assertNotEqual(worker.ready_queue.put, worker.process_task)
@@ -1067,28 +1067,28 @@ class test_WorkController(AppCase):
 
         cbs = w.pool.init_callbacks.call_args[1]
         w = Mock()
-        cbs["on_process_up"](w)
+        cbs['on_process_up'](w)
         hub.add_reader.assert_called_with(w.sentinel, P.maintain_pool)
 
-        cbs["on_process_down"](w)
+        cbs['on_process_down'](w)
         hub.remove.assert_called_with(w.sentinel)
 
         result = Mock()
         tref = result._tref
 
-        cbs["on_timeout_cancel"](result)
+        cbs['on_timeout_cancel'](result)
         tref.cancel.assert_called_with()
-        cbs["on_timeout_cancel"](result)  # no more tref
+        cbs['on_timeout_cancel'](result)  # no more tref
 
-        cbs["on_timeout_set"](result, 10, 20)
+        cbs['on_timeout_set'](result, 10, 20)
         tsoft, callback = hub.timer.apply_after.call_args[0]
         callback()
 
-        cbs["on_timeout_set"](result, 10, None)
+        cbs['on_timeout_set'](result, 10, None)
         tsoft, callback = hub.timer.apply_after.call_args[0]
         callback()
-        cbs["on_timeout_set"](result, None, 10)
-        cbs["on_timeout_set"](result, None, None)
+        cbs['on_timeout_set'](result, None, 10)
+        cbs['on_timeout_set'](result, None, None)
 
         P.did_start_ok.return_value = False
         with self.assertRaises(WorkerLostError):

celery/worker/control.py

@@ -143,7 +143,7 @@ def time_limit(panel, task_name=None, hard=None, soft=None, **kwargs):
 def dump_schedule(panel, safe=False, **kwargs):
     schedule = panel.consumer.timer.schedule
     if not schedule.queue:
-        logger.info('--Empty schedule--')
+        logger.debug('--Empty schedule--')
         return []
 
     formatitem = lambda (i, item): '%s. %s pri%s %r' % (i,
@@ -166,7 +166,7 @@ def dump_reserved(panel, safe=False, **kwargs):
     ready_queue = panel.consumer.ready_queue
     reserved = ready_queue.items
     if not reserved:
-        logger.info('--Empty queue--')
+        logger.debug('--Empty queue--')
         return []
     logger.debug('* Dump of currently reserved tasks:\n%s',
                  '\n'.join(map(safe_repr, reserved)))

contrib/bundles/generate.py

@@ -1,34 +0,0 @@
-import os
-import sys
-
-sys.path.insert(0, os.path.abspath(
-    os.path.join(__file__, os.pardir, os.pardir)))
-
-from celery import VERSION
-
-from bundle import Bundle
-
-series = "{}.{}".format(*VERSION[:2])
-
-defaults = {"version": series,
-            "author": "Celery Project",
-            "author_email": "bundles@celeryproject.org",
-            "url": "http://celeryproject.org",
-            "license": "BSD"}
-
-
-bundles = [
-    Bundle("celery-with-redis",
-        "Bundle that installs the dependencies for Celery and Redis",
-        requires=["celery>=%s,<3.0" % (series, ), "redis>=2.4.4"],
-        **defaults),
-]
-
-
-def main():
-    for bundle in bundles:
-        bundle.bump_if_exists()
-        print(bundle.render_readme())
-
-if __name__ == "__main__":
-    main()

contrib/requirements

@@ -1 +0,0 @@
-../requirements

docs/slidesource/slide-example1-result.py

@@ -1,10 +0,0 @@
-from myapp.tasks import MyTask
-
-res = MyTask.delay(2, 4)
-res.get()
-#8
-
-res = MyTask.apply_async(args=[8, 4],
-                         countdown=5)
-res.get()                               # Is executed after 5 seconds.
-#32

docs/slidesource/slide-example1.py

@@ -1,7 +0,0 @@
-from celery.task import Task
-
-
-class MyTask(Task):
-
-    def run(self, x, y):
-        return x * y

docs/tutorials/task-cookbook.rst

@@ -28,39 +28,36 @@ The cache key expires after some time in case something unexpected happens
 
 .. code-block:: python
 
-    from celery.task import Task
+    from celery import task
+    from celery.utils.log import get_task_logger
     from django.core.cache import cache
     from django.utils.hashcompat import md5_constructor as md5
     from djangofeeds.models import Feed
 
+    logger = get_task_logger(__name__)
+
     LOCK_EXPIRE = 60 * 5 # Lock expires in 5 minutes
 
-    class FeedImporter(Task):
-        name = "feed.import"
-
-        def run(self, feed_url, **kwargs):
-            logger = self.get_logger(**kwargs)
-
-            # The cache key consists of the task name and the MD5 digest
-            # of the feed URL.
-            feed_url_digest = md5(feed_url).hexdigest()
-            lock_id = "%s-lock-%s" % (self.name, feed_url_hexdigest)
-
-            # cache.add fails if if the key already exists
-            acquire_lock = lambda: cache.add(lock_id, "true", LOCK_EXPIRE)
-            # memcache delete is very slow, but we have to use it to take
-            # advantage of using add() for atomic locking
-            release_lock = lambda: cache.delete(lock_id)
-
-            logger.debug("Importing feed: %s" % feed_url)
-            if acquire_lock():
-                try:
-                    feed = Feed.objects.import_feed(feed_url)
-                finally:
-                    release_lock()
-                return feed.url
-
-            logger.debug(
-                "Feed %s is already being imported by another worker" % (
-                    feed_url))
-            return
+    @task
+    def import_feed(feed_url):
+        # The cache key consists of the task name and the MD5 digest
+        # of the feed URL.
+        feed_url_digest = md5(feed_url).hexdigest()
+        lock_id = '%s-lock-%s' % (self.name, feed_url_hexdigest)
+
+        # cache.add fails if if the key already exists
+        acquire_lock = lambda: cache.add(lock_id, 'true', LOCK_EXPIRE)
+        # memcache delete is very slow, but we have to use it to take
+        # advantage of using add() for atomic locking
+        release_lock = lambda: cache.delete(lock_id)
+
+        logger.debug('Importing feed: %s' % feed_url)
+        if acquire_lock():
+            try:
+                feed = Feed.objects.import_feed(feed_url)
+            finally:
+                release_lock()
+            return feed.url
+
+        logger.debug(
+            'Feed %s is already being imported by another worker' % feed_url)

docs/userguide/workers.rst

@@ -173,7 +173,6 @@ Some remote control commands also have higher-level interfaces using
 
 Sending the :control:`rate_limit` command and keyword arguments::
 
-    >>> from celery.task.control import broadcast
     >>> celery.control.broadcast("rate_limit",
     ...                          arguments={"task_name": "myapp.mytask",
     ...                                     "rate_limit": "200/m"})
@@ -465,7 +464,6 @@ being imported by the worker processes:
 
 .. code-block:: python
 
-    >>> from celery.task.control import broadcast
     >>> celery.control.broadcast("pool_restart",
     ...                          arguments={"modules": ["foo", "bar"]})