Use assertEqual instead of assertEquals for unittest2 compatibility.

celery/tests/test_backends/test_amqp.py

@@ -29,8 +29,8 @@ class TestRedisBackend(unittest.TestCase):
 
         tb.mark_as_done(tid, 42)
         self.assertTrue(tb.is_successful(tid))
-        self.assertEquals(tb.get_status(tid), states.SUCCESS)
-        self.assertEquals(tb.get_result(tid), 42)
+        self.assertEqual(tb.get_status(tid), states.SUCCESS)
+        self.assertEqual(tb.get_result(tid), 42)
         self.assertTrue(tb._cache.get(tid))
         self.assertTrue(tb.get_result(tid), 42)
 
@@ -42,8 +42,8 @@ class TestRedisBackend(unittest.TestCase):
         tb.mark_as_done(tid2, result)
         # is serialized properly.
         rindb = tb.get_result(tid2)
-        self.assertEquals(rindb.get("foo"), "baz")
-        self.assertEquals(rindb.get("bar").data, 12345)
+        self.assertEqual(rindb.get("foo"), "baz")
+        self.assertEqual(rindb.get("bar").data, 12345)
 
     def test_mark_as_failure(self):
         tb = self.backend
@@ -55,9 +55,9 @@ class TestRedisBackend(unittest.TestCase):
             einfo = ExceptionInfo(sys.exc_info())
         tb.mark_as_failure(tid3, exception, traceback=einfo.traceback)
         self.assertFalse(tb.is_successful(tid3))
-        self.assertEquals(tb.get_status(tid3), states.FAILURE)
+        self.assertEqual(tb.get_status(tid3), states.FAILURE)
         self.assertTrue(isinstance(tb.get_result(tid3), KeyError))
-        self.assertEquals(tb.get_traceback(tid3), einfo.traceback)
+        self.assertEqual(tb.get_traceback(tid3), einfo.traceback)
 
     def test_process_cleanup(self):
         self.backend.process_cleanup()

celery/tests/test_backends/test_base.py

@@ -61,11 +61,11 @@ class TestPickleException(unittest.TestCase):
 
     def test_get_pickleable_exception(self):
         exc = Exception("foo")
-        self.assertEquals(gpe(exc), exc)
+        self.assertEqual(gpe(exc), exc)
 
     def test_unpickleable(self):
         self.assertTrue(isinstance(fnpe(Unpickleable()), KeyError))
-        self.assertEquals(fnpe(Impossible()), None)
+        self.assertEqual(fnpe(Impossible()), None)
 
 
 class TestPrepareException(unittest.TestCase):
@@ -80,11 +80,11 @@ class TestPrepareException(unittest.TestCase):
         x = b.prepare_exception(Impossible())
         self.assertTrue(isinstance(x, UnpickleableExceptionWrapper))
         y = b.exception_to_python(x)
-        self.assertEquals(y.__class__.__name__, "Impossible")
+        self.assertEqual(y.__class__.__name__, "Impossible")
         if sys.version_info < (2, 5):
             self.assertTrue(y.__class__.__module__)
         else:
-            self.assertEquals(y.__class__.__module__, "foo.module")
+            self.assertEqual(y.__class__.__module__, "foo.module")
 
     def test_regular(self):
         x = b.prepare_exception(KeyError("baz"))

celery/tests/test_backends/test_cache.py

@@ -25,13 +25,13 @@ class TestCacheBackend(unittest.TestCase):
         tid = gen_unique_id()
 
         self.assertFalse(cb.is_successful(tid))
-        self.assertEquals(cb.get_status(tid), states.PENDING)
-        self.assertEquals(cb.get_result(tid), None)
+        self.assertEqual(cb.get_status(tid), states.PENDING)
+        self.assertEqual(cb.get_result(tid), None)
 
         cb.mark_as_done(tid, 42)
         self.assertTrue(cb.is_successful(tid))
-        self.assertEquals(cb.get_status(tid), states.SUCCESS)
-        self.assertEquals(cb.get_result(tid), 42)
+        self.assertEqual(cb.get_status(tid), states.SUCCESS)
+        self.assertEqual(cb.get_result(tid), 42)
         self.assertTrue(cb.get_result(tid), 42)
 
     def test_save_restore_taskset(self):
@@ -42,8 +42,8 @@ class TestCacheBackend(unittest.TestCase):
         res = result.TaskSetResult(taskset_id, subtasks)
         res.save(backend=backend)
         saved = result.TaskSetResult.restore(taskset_id, backend=backend)
-        self.assertEquals(saved.subtasks, subtasks)
-        self.assertEquals(saved.taskset_id, taskset_id)
+        self.assertEqual(saved.subtasks, subtasks)
+        self.assertEqual(saved.taskset_id, taskset_id)
 
     def test_is_pickled(self):
         cb = CacheBackend()
@@ -53,8 +53,8 @@ class TestCacheBackend(unittest.TestCase):
         cb.mark_as_done(tid2, result)
         # is serialized properly.
         rindb = cb.get_result(tid2)
-        self.assertEquals(rindb.get("foo"), "baz")
-        self.assertEquals(rindb.get("bar").data, 12345)
+        self.assertEqual(rindb.get("foo"), "baz")
+        self.assertEqual(rindb.get("bar").data, 12345)
 
     def test_mark_as_failure(self):
         cb = CacheBackend()
@@ -68,9 +68,9 @@ class TestCacheBackend(unittest.TestCase):
             pass
         cb.mark_as_failure(tid3, exception, traceback=einfo.traceback)
         self.assertFalse(cb.is_successful(tid3))
-        self.assertEquals(cb.get_status(tid3), states.FAILURE)
+        self.assertEqual(cb.get_status(tid3), states.FAILURE)
         self.assertTrue(isinstance(cb.get_result(tid3), KeyError))
-        self.assertEquals(cb.get_traceback(tid3), einfo.traceback)
+        self.assertEqual(cb.get_traceback(tid3), einfo.traceback)
 
     def test_process_cleanup(self):
         cb = CacheBackend()
@@ -89,7 +89,7 @@ class TestCustomCacheBackend(unittest.TestCase):
         try:
             from celery.backends.cache import cache
             from django.core.cache import cache as django_cache
-            self.assertEquals(cache.__class__.__module__,
+            self.assertEqual(cache.__class__.__module__,
                               "django.core.cache.backends.dummy")
             self.assertTrue(cache is not django_cache)
         finally:
@@ -119,9 +119,9 @@ class TestMemcacheWrapper(unittest.TestCase):
             val = "The quick brown fox."
             default = "The lazy dog."
 
-            self.assertEquals(cache.get(key, default=default), default)
+            self.assertEqual(cache.get(key, default=default), default)
             cache.set(key, val)
-            self.assertEquals(pickle.loads(cache.get(key, default=default)),
+            self.assertEqual(pickle.loads(cache.get(key, default=default)),
                               val)
         finally:
             memcached.CacheClass = prev_cache_cls

celery/tests/test_backends/test_database.py

@@ -28,13 +28,13 @@ class TestDatabaseBackend(unittest.TestCase):
         tid = gen_unique_id()
 
         self.assertFalse(b.is_successful(tid))
-        self.assertEquals(b.get_status(tid), states.PENDING)
+        self.assertEqual(b.get_status(tid), states.PENDING)
         self.assertTrue(b.get_result(tid) is None)
 
         b.mark_as_done(tid, 42)
         self.assertTrue(b.is_successful(tid))
-        self.assertEquals(b.get_status(tid), states.SUCCESS)
-        self.assertEquals(b.get_result(tid), 42)
+        self.assertEqual(b.get_status(tid), states.SUCCESS)
+        self.assertEqual(b.get_result(tid), 42)
         self.assertTrue(b.get_result(tid), 42)
 
         tid2 = gen_unique_id()
@@ -42,8 +42,8 @@ class TestDatabaseBackend(unittest.TestCase):
         b.mark_as_done(tid2, result)
         # is serialized properly.
         rindb = b.get_result(tid2)
-        self.assertEquals(rindb.get("foo"), "baz")
-        self.assertEquals(rindb.get("bar").data, 12345)
+        self.assertEqual(rindb.get("foo"), "baz")
+        self.assertEqual(rindb.get("bar").data, 12345)
 
         tid3 = gen_unique_id()
         try:
@@ -52,7 +52,7 @@ class TestDatabaseBackend(unittest.TestCase):
             pass
         b.mark_as_failure(tid3, exception)
         self.assertFalse(b.is_successful(tid3))
-        self.assertEquals(b.get_status(tid3), states.FAILURE)
+        self.assertEqual(b.get_status(tid3), states.FAILURE)
         self.assertTrue(isinstance(b.get_result(tid3), KeyError))
 
     def test_taskset_store(self):
@@ -65,5 +65,5 @@ class TestDatabaseBackend(unittest.TestCase):
         b.save_taskset(tid, result)
         rindb = b.restore_taskset(tid)
         self.assertTrue(rindb is not None)
-        self.assertEquals(rindb.get("foo"), "baz")
-        self.assertEquals(rindb.get("bar").data, 12345)
+        self.assertEqual(rindb.get("foo"), "baz")
+        self.assertEqual(rindb.get("bar").data, 12345)

celery/tests/test_backends/test_redis.py

@@ -74,13 +74,13 @@ class TestRedisBackend(unittest.TestCase):
         tid = gen_unique_id()
 
         self.assertFalse(tb.is_successful(tid))
-        self.assertEquals(tb.get_status(tid), states.PENDING)
-        self.assertEquals(tb.get_result(tid), None)
+        self.assertEqual(tb.get_status(tid), states.PENDING)
+        self.assertEqual(tb.get_result(tid), None)
 
         tb.mark_as_done(tid, 42)
         self.assertTrue(tb.is_successful(tid))
-        self.assertEquals(tb.get_status(tid), states.SUCCESS)
-        self.assertEquals(tb.get_result(tid), 42)
+        self.assertEqual(tb.get_status(tid), states.SUCCESS)
+        self.assertEqual(tb.get_result(tid), 42)
         self.assertTrue(tb.get_result(tid), 42)
 
     def test_is_pickled(self):
@@ -93,8 +93,8 @@ class TestRedisBackend(unittest.TestCase):
         tb.mark_as_done(tid2, result)
         # is serialized properly.
         rindb = tb.get_result(tid2)
-        self.assertEquals(rindb.get("foo"), "baz")
-        self.assertEquals(rindb.get("bar").data, 12345)
+        self.assertEqual(rindb.get("foo"), "baz")
+        self.assertEqual(rindb.get("bar").data, 12345)
 
     def test_mark_as_failure(self):
         tb = get_redis_or_None()
@@ -108,7 +108,7 @@ class TestRedisBackend(unittest.TestCase):
             pass
         tb.mark_as_failure(tid3, exception)
         self.assertFalse(tb.is_successful(tid3))
-        self.assertEquals(tb.get_status(tid3), states.FAILURE)
+        self.assertEqual(tb.get_status(tid3), states.FAILURE)
         self.assertTrue(isinstance(tb.get_result(tid3), KeyError))
 
     def test_process_cleanup(self):

celery/tests/test_backends/test_tyrant.py

@@ -64,13 +64,13 @@ class TestTyrantBackend(unittest.TestCase):
         tid = gen_unique_id()
 
         self.assertFalse(tb.is_successful(tid))
-        self.assertEquals(tb.get_status(tid), states.PENDING)
-        self.assertEquals(tb.get_result(tid), None)
+        self.assertEqual(tb.get_status(tid), states.PENDING)
+        self.assertEqual(tb.get_result(tid), None)
 
         tb.mark_as_done(tid, 42)
         self.assertTrue(tb.is_successful(tid))
-        self.assertEquals(tb.get_status(tid), states.SUCCESS)
-        self.assertEquals(tb.get_result(tid), 42)
+        self.assertEqual(tb.get_status(tid), states.SUCCESS)
+        self.assertEqual(tb.get_result(tid), 42)
         self.assertTrue(tb.get_result(tid), 42)
 
     def test_is_pickled(self):
@@ -83,8 +83,8 @@ class TestTyrantBackend(unittest.TestCase):
         tb.mark_as_done(tid2, result)
         # is serialized properly.
         rindb = tb.get_result(tid2)
-        self.assertEquals(rindb.get("foo"), "baz")
-        self.assertEquals(rindb.get("bar").data, 12345)
+        self.assertEqual(rindb.get("foo"), "baz")
+        self.assertEqual(rindb.get("bar").data, 12345)
 
     def test_mark_as_failure(self):
         tb = get_tyrant_or_None()
@@ -98,7 +98,7 @@ class TestTyrantBackend(unittest.TestCase):
             pass
         tb.mark_as_failure(tid3, exception)
         self.assertFalse(tb.is_successful(tid3))
-        self.assertEquals(tb.get_status(tid3), states.FAILURE)
+        self.assertEqual(tb.get_status(tid3), states.FAILURE)
         self.assertTrue(isinstance(tb.get_result(tid3), KeyError))
 
     def test_process_cleanup(self):

celery/tests/test_beat.py

@@ -86,21 +86,21 @@ class TestScheduleEntry(unittest.TestCase):
 
     def test_constructor(self):
         s = beat.ScheduleEntry(DuePeriodicTask.name)
-        self.assertEquals(s.name, DuePeriodicTask.name)
+        self.assertEqual(s.name, DuePeriodicTask.name)
         self.assertTrue(isinstance(s.last_run_at, datetime))
-        self.assertEquals(s.total_run_count, 0)
+        self.assertEqual(s.total_run_count, 0)
 
         now = datetime.now()
         s = beat.ScheduleEntry(DuePeriodicTask.name, now, 300)
-        self.assertEquals(s.name, DuePeriodicTask.name)
-        self.assertEquals(s.last_run_at, now)
-        self.assertEquals(s.total_run_count, 300)
+        self.assertEqual(s.name, DuePeriodicTask.name)
+        self.assertEqual(s.last_run_at, now)
+        self.assertEqual(s.total_run_count, 300)
 
     def test_next(self):
         s = beat.ScheduleEntry(DuePeriodicTask.name, None, 300)
         n = s.next()
-        self.assertEquals(n.name, s.name)
-        self.assertEquals(n.total_run_count, 301)
+        self.assertEqual(n.name, s.name)
+        self.assertEqual(n.total_run_count, 301)
         self.assertTrue(n.last_run_at > s.last_run_at)
 
     def test_is_due(self):
@@ -126,7 +126,7 @@ class TestScheduler(unittest.TestCase):
         self.assertTrue(isinstance(s.registry, TaskRegistry))
         self.assertTrue(isinstance(s.schedule, dict))
         self.assertTrue(isinstance(s.logger, logging.Logger))
-        self.assertEquals(s.max_interval, conf.CELERYBEAT_MAX_LOOP_INTERVAL)
+        self.assertEqual(s.max_interval, conf.CELERYBEAT_MAX_LOOP_INTERVAL)
 
     def test_cleanup(self):
         self.scheduler.schedule["fbz"] = beat.ScheduleEntry("fbz")
@@ -161,13 +161,13 @@ class TestScheduler(unittest.TestCase):
     def test_tick(self):
         self.scheduler.schedule.pop(DuePeriodicTaskRaising.name, None)
         self.registry.pop(DuePeriodicTaskRaising.name, None)
-        self.assertEquals(self.scheduler.tick(),
+        self.assertEqual(self.scheduler.tick(),
                             self.scheduler.max_interval)
 
     def test_quick_schedulingerror(self):
         self.registry.register(DuePeriodicTaskRaising)
         self.scheduler.schedule_registry()
-        self.assertEquals(self.scheduler.tick(),
+        self.assertEqual(self.scheduler.tick(),
                             self.scheduler.max_interval)
 
 

celery/tests/test_buckets.py

@@ -51,11 +51,11 @@ class TestTokenBucketQueue(unittest.TestCase):
     def test_bucket__put_get(self):
         x = buckets.TokenBucketQueue(fill_rate=10)
         x.put("The quick brown fox")
-        self.assertEquals(x.get(), "The quick brown fox")
+        self.assertEqual(x.get(), "The quick brown fox")
 
         x.put_nowait("The lazy dog")
         time.sleep(0.2)
-        self.assertEquals(x.get_nowait(), "The lazy dog")
+        self.assertEqual(x.get_nowait(), "The lazy dog")
 
     @skip_if_disabled
     def test_fill_rate(self):
@@ -97,15 +97,15 @@ class TestRateLimitString(unittest.TestCase):
 
     @skip_if_disabled
     def test_conversion(self):
-        self.assertEquals(buckets.parse_ratelimit_string(999), 999)
-        self.assertEquals(buckets.parse_ratelimit_string("1456/s"), 1456)
-        self.assertEquals(buckets.parse_ratelimit_string("100/m"),
+        self.assertEqual(buckets.parse_ratelimit_string(999), 999)
+        self.assertEqual(buckets.parse_ratelimit_string("1456/s"), 1456)
+        self.assertEqual(buckets.parse_ratelimit_string("100/m"),
                           100 / 60.0)
-        self.assertEquals(buckets.parse_ratelimit_string("10/h"),
+        self.assertEqual(buckets.parse_ratelimit_string("10/h"),
                           10 / 60.0 / 60.0)
 
         for zero in (0, None, "0", "0/m", "0/h", "0/s"):
-            self.assertEquals(buckets.parse_ratelimit_string(zero), 0)
+            self.assertEqual(buckets.parse_ratelimit_string(zero), 0)
 
 
 class TaskA(Task):
@@ -166,7 +166,7 @@ class TestTaskBuckets(unittest.TestCase):
         b = buckets.TaskBucket(task_registry=self.registry)
         job = MockJob(gen_unique_id(), TaskA.name, ["theqbf"], {"foo": "bar"})
         b.put(job)
-        self.assertEquals(b.get(), job)
+        self.assertEqual(b.get(), job)
 
     @skip_if_disabled
     def test_fill_rate(self):

celery/tests/test_celery.py

@@ -6,10 +6,10 @@ class TestInitFile(unittest.TestCase):
 
     def test_version(self):
         self.assertTrue(celery.VERSION)
-        self.assertEquals(len(celery.VERSION), 3)
+        self.assertEqual(len(celery.VERSION), 3)
         celery.VERSION = (0, 3, 0)
         self.assertFalse(celery.is_stable_release())
-        self.assertEquals(celery.__version__.count("."), 2)
+        self.assertEqual(celery.__version__.count("."), 2)
         self.assertTrue("(unstable)" in celery.version_with_meta())
         celery.VERSION = (0, 4, 0)
         self.assertTrue(celery.is_stable_release())

celery/tests/test_conf.py

@@ -18,7 +18,7 @@ class TestConf(unittest.TestCase):
 
     def assertDefaultSetting(self, setting_name, result_var):
         if hasattr(settings, setting_name):
-            self.assertEquals(getattr(conf, result_var),
+            self.assertEqual(getattr(conf, result_var),
                               getattr(settings, setting_name),
                               "Overwritten setting %s is written to %s" % (
                                   setting_name, result_var))

celery/tests/test_datastructures.py

@@ -13,8 +13,8 @@ class TestPositionQueue(unittest.TestCase):
         for position in q.data:
             self.assertTrue(isinstance(position, q.UnfilledPosition))
 
-        self.assertEquals(q.filled, [])
-        self.assertEquals(len(q), 0)
+        self.assertEqual(q.filled, [])
+        self.assertEqual(len(q), 0)
         self.assertFalse(q.full())
 
     def test_position_queue_almost(self):
@@ -23,16 +23,16 @@ class TestPositionQueue(unittest.TestCase):
         q[6] = 6
         q[9] = 9
 
-        self.assertEquals(q.filled, [3, 6, 9])
-        self.assertEquals(len(q), 3)
+        self.assertEqual(q.filled, [3, 6, 9])
+        self.assertEqual(len(q), 3)
         self.assertFalse(q.full())
 
     def test_position_queue_full(self):
         q = PositionQueue(length=10)
         for i in xrange(10):
             q[i] = i
-        self.assertEquals(q.filled, list(xrange(10)))
-        self.assertEquals(len(q), 10)
+        self.assertEqual(q.filled, list(xrange(10)))
+        self.assertEqual(len(q), 10)
         self.assertTrue(q.full())
 
 
@@ -46,9 +46,9 @@ class TestExceptionInfo(unittest.TestCase):
             exc_info = sys.exc_info()
 
         einfo = ExceptionInfo(exc_info)
-        self.assertEquals(str(einfo), einfo.traceback)
+        self.assertEqual(str(einfo), einfo.traceback)
         self.assertTrue(isinstance(einfo.exception, LookupError))
-        self.assertEquals(einfo.exception.args,
+        self.assertEqual(einfo.exception.args,
                 ("The quick brown fox jumps...", ))
         self.assertTrue(einfo.traceback)
 
@@ -64,38 +64,38 @@ class TestUtilities(unittest.TestCase):
         self.assertRaises(StopIteration, it.next)
         x.put("foo")
         it = consume_queue(x)
-        self.assertEquals(it.next(), "foo")
+        self.assertEqual(it.next(), "foo")
         self.assertRaises(StopIteration, it.next)
 
 
 class TestSharedCounter(unittest.TestCase):
 
     def test_initial_value(self):
-        self.assertEquals(int(SharedCounter(10)), 10)
+        self.assertEqual(int(SharedCounter(10)), 10)
 
     def test_increment(self):
         c = SharedCounter(10)
         c.increment()
-        self.assertEquals(int(c), 11)
+        self.assertEqual(int(c), 11)
         c.increment(2)
-        self.assertEquals(int(c), 13)
+        self.assertEqual(int(c), 13)
 
     def test_decrement(self):
         c = SharedCounter(10)
         c.decrement()
-        self.assertEquals(int(c), 9)
+        self.assertEqual(int(c), 9)
         c.decrement(2)
-        self.assertEquals(int(c), 7)
+        self.assertEqual(int(c), 7)
 
     def test_iadd(self):
         c = SharedCounter(10)
         c += 10
-        self.assertEquals(int(c), 20)
+        self.assertEqual(int(c), 20)
 
     def test_isub(self):
         c = SharedCounter(10)
         c -= 20
-        self.assertEquals(int(c), -10)
+        self.assertEqual(int(c), -10)
 
     def test_repr(self):
         self.assertTrue(repr(SharedCounter(10)).startswith("<SharedCounter:"))
@@ -137,4 +137,4 @@ class TestLocalCache(unittest.TestCase):
         slots = list(range(limit * 2))
         for i in slots:
             x[i] = i
-        self.assertEquals(x.keys(), slots[limit:])
+        self.assertEqual(x.keys(), slots[limit:])

celery/tests/test_discovery.py

@@ -10,7 +10,7 @@ class TestDiscovery(unittest.TestCase):
         apps = autodiscover()
         self.assertTrue(apps)
         self.assertTrue("c.unittest.SomeAppTask" in tasks)
-        self.assertEquals(tasks["c.unittest.SomeAppTask"].run(), 42)
+        self.assertEqual(tasks["c.unittest.SomeAppTask"].run(), 42)
 
     def test_discovery(self):
         if "someapp" in settings.INSTALLED_APPS:

celery/tests/test_events.py

@@ -25,7 +25,7 @@ class TestEvent(unittest.TestCase):
 
     def test_constructor(self):
         event = events.Event("world war II")
-        self.assertEquals(event["type"], "world war II")
+        self.assertEqual(event["type"], "world war II")
         self.assertTrue(event["timestamp"])
 
 

celery/tests/test_loaders.py

@@ -16,19 +16,19 @@ class TestLoaders(unittest.TestCase):
 
     def test_get_loader_cls(self):
 
-        self.assertEquals(loaders.get_loader_cls("django"),
+        self.assertEqual(loaders.get_loader_cls("django"),
                           loaders.DjangoLoader)
-        self.assertEquals(loaders.get_loader_cls("default"),
+        self.assertEqual(loaders.get_loader_cls("default"),
                           loaders.DefaultLoader)
         # Execute cached branch.
-        self.assertEquals(loaders.get_loader_cls("django"),
+        self.assertEqual(loaders.get_loader_cls("django"),
                           loaders.DjangoLoader)
-        self.assertEquals(loaders.get_loader_cls("default"),
+        self.assertEqual(loaders.get_loader_cls("default"),
                           loaders.DefaultLoader)
 
     @with_environ("CELERY_LOADER", "default")
     def test_detect_loader_CELERY_LOADER(self):
-        self.assertEquals(loaders.detect_loader(), loaders.DefaultLoader)
+        self.assertEqual(loaders.detect_loader(), loaders.DefaultLoader)
 
 
 class DummyLoader(base.BaseLoader):
@@ -54,17 +54,17 @@ class TestLoaderBase(unittest.TestCase):
 
     def test_import_task_module(self):
         import sys
-        self.assertEquals(sys, self.loader.import_task_module("sys"))
+        self.assertEqual(sys, self.loader.import_task_module("sys"))
 
     def test_conf_property(self):
-        self.assertEquals(self.loader.conf.foo, "bar")
-        self.assertEquals(self.loader._conf_cache.foo, "bar")
-        self.assertEquals(self.loader.conf.foo, "bar")
+        self.assertEqual(self.loader.conf.foo, "bar")
+        self.assertEqual(self.loader._conf_cache.foo, "bar")
+        self.assertEqual(self.loader.conf.foo, "bar")
 
     def test_import_default_modules(self):
         import os
         import sys
-        self.assertEquals(self.loader.import_default_modules(), [os, sys])
+        self.assertEqual(self.loader.import_default_modules(), [os, sys])
 
 
 class TestDjangoLoader(unittest.TestCase):
@@ -117,11 +117,11 @@ class TestDefaultLoader(unittest.TestCase):
         try:
             l = default.Loader()
             settings = l.read_configuration()
-            self.assertEquals(settings.CELERY_IMPORTS, ("os", "sys"))
+            self.assertEqual(settings.CELERY_IMPORTS, ("os", "sys"))
             from django.conf import settings
             settings.configured = False
             settings = l.read_configuration()
-            self.assertEquals(settings.CELERY_IMPORTS, ("os", "sys"))
+            self.assertEqual(settings.CELERY_IMPORTS, ("os", "sys"))
             self.assertTrue(settings.configured)
             l.on_worker_init()
         finally:

celery/tests/test_log.py

@@ -68,7 +68,7 @@ class TestLog(unittest.TestCase):
     def test_emergency_error(self):
         sio = StringIO()
         emergency_error(sio, "Testing emergency error facility")
-        self.assertEquals(rpartition(sio.getvalue(), ":")[2].strip(),
+        self.assertEqual(rpartition(sio.getvalue(), ":")[2].strip(),
                              "Testing emergency error facility")
 
     def test_setup_logger_no_handlers_stream(self):

celery/tests/test_messaging.py

@@ -10,5 +10,5 @@ class TestMsgOptions(unittest.TestCase):
     def test_extract_msg_options(self):
         testing = {"mandatory": True, "routing_key": "foo.xuzzy"}
         result = extract_msg_options(testing)
-        self.assertEquals(result["mandatory"], True)
-        self.assertEquals(result["routing_key"], "foo.xuzzy")
+        self.assertEqual(result["mandatory"], True)
+        self.assertEqual(result["routing_key"], "foo.xuzzy")

celery/tests/test_models.py

@@ -26,7 +26,7 @@ class TestModels(unittest.TestCase):
         self.assertTrue(m1.task_id)
         self.assertTrue(isinstance(m1.date_done, datetime))
 
-        self.assertEquals(TaskMeta.objects.get_task(m1.task_id).task_id,
+        self.assertEqual(TaskMeta.objects.get_task(m1.task_id).task_id,
                 m1.task_id)
         self.assertFalse(
                 TaskMeta.objects.get_task(m1.task_id).status == states.SUCCESS)
@@ -57,7 +57,7 @@ class TestModels(unittest.TestCase):
         self.assertTrue(m1.taskset_id)
         self.assertTrue(isinstance(m1.date_done, datetime))
 
-        self.assertEquals(
+        self.assertEqual(
                 TaskSetMeta.objects.restore_taskset(m1.taskset_id).taskset_id,
                 m1.taskset_id)
 

celery/tests/test_pickle.py

@@ -28,7 +28,7 @@ class TestPickle(unittest.TestCase):
         exception = unpickled.get("exception")
         self.assertTrue(exception)
         self.assertTrue(isinstance(exception, RegularException))
-        self.assertEquals(exception.args, ("RegularException raised", ))
+        self.assertEqual(exception.args, ("RegularException raised", ))
 
     def test_pickle_arg_override_exception(self):
 
@@ -44,6 +44,6 @@ class TestPickle(unittest.TestCase):
         exception = unpickled.get("exception")
         self.assertTrue(exception)
         self.assertTrue(isinstance(exception, ArgOverrideException))
-        self.assertEquals(exception.args, ("ArgOverrideException raised",
+        self.assertEqual(exception.args, ("ArgOverrideException raised",
                                           100))
-        self.assertEquals(exception.status_code, 100)
+        self.assertEqual(exception.status_code, 100)

celery/tests/test_pool.py

@@ -26,7 +26,7 @@ class TestTaskPool(unittest.TestCase):
 
     def test_attrs(self):
         p = TaskPool(limit=2)
-        self.assertEquals(p.limit, 2)
+        self.assertEqual(p.limit, 2)
         self.assertTrue(isinstance(p.logger, logging.Logger))
         self.assertTrue(p._pool is None)
 
@@ -58,35 +58,35 @@ class TestTaskPool(unittest.TestCase):
         res3 = p.apply_async(do_something, args=[20], callbacks=[mycallback],
                             meta={"foo3": "bar3"})
 
-        self.assertEquals(res.get(), 100)
+        self.assertEqual(res.get(), 100)
         time.sleep(0.5)
         self.assertTrue(scratchpad.get(0))
-        self.assertEquals(scratchpad[0]["ret_value"], 100)
-        self.assertEquals(scratchpad[0]["meta"], {"foo": "bar"})
+        self.assertEqual(scratchpad[0]["ret_value"], 100)
+        self.assertEqual(scratchpad[0]["meta"], {"foo": "bar"})
 
         self.assertTrue(isinstance(res2.get(), ExceptionInfo))
         self.assertTrue(scratchpad.get(1))
         time.sleep(1)
-        #self.assertEquals(scratchpad[1]["ret_value"], "FOO")
+        #self.assertEqual(scratchpad[1]["ret_value"], "FOO")
         self.assertTrue(isinstance(scratchpad[1]["ret_value"],
                           ExceptionInfo))
-        self.assertEquals(scratchpad[1]["ret_value"].exception.args,
+        self.assertEqual(scratchpad[1]["ret_value"].exception.args,
                           ("FOO EXCEPTION", ))
-        self.assertEquals(scratchpad[1]["meta"], {"foo2": "bar2"})
+        self.assertEqual(scratchpad[1]["meta"], {"foo2": "bar2"})
 
-        self.assertEquals(res3.get(), 400)
+        self.assertEqual(res3.get(), 400)
         time.sleep(0.5)
         self.assertTrue(scratchpad.get(2))
-        self.assertEquals(scratchpad[2]["ret_value"], 400)
-        self.assertEquals(scratchpad[2]["meta"], {"foo3": "bar3"})
+        self.assertEqual(scratchpad[2]["ret_value"], 400)
+        self.assertEqual(scratchpad[2]["meta"], {"foo3": "bar3"})
 
         res3 = p.apply_async(do_something, args=[30], callbacks=[mycallback],
                             meta={"foo4": "bar4"})
 
-        self.assertEquals(res3.get(), 900)
+        self.assertEqual(res3.get(), 900)
         time.sleep(0.5)
         self.assertTrue(scratchpad.get(3))
-        self.assertEquals(scratchpad[3]["ret_value"], 900)
-        self.assertEquals(scratchpad[3]["meta"], {"foo4": "bar4"})
+        self.assertEqual(scratchpad[3]["ret_value"], 900)
+        self.assertEqual(scratchpad[3]["meta"], {"foo4": "bar4"})
 
         p.stop()

celery/tests/test_result.py

@@ -58,19 +58,19 @@ class TestAsyncResult(unittest.TestCase):
         ok_res = AsyncResult(self.task1["id"])
         ok2_res = AsyncResult(self.task2["id"])
         nok_res = AsyncResult(self.task3["id"])
-        self.assertEquals(str(ok_res), self.task1["id"])
-        self.assertEquals(str(ok2_res), self.task2["id"])
-        self.assertEquals(str(nok_res), 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"])
 
     def test_repr(self):
         ok_res = AsyncResult(self.task1["id"])
         ok2_res = AsyncResult(self.task2["id"])
         nok_res = AsyncResult(self.task3["id"])
-        self.assertEquals(repr(ok_res), "<AsyncResult: %s>" % (
+        self.assertEqual(repr(ok_res), "<AsyncResult: %s>" % (
                 self.task1["id"]))
-        self.assertEquals(repr(ok2_res), "<AsyncResult: %s>" % (
+        self.assertEqual(repr(ok2_res), "<AsyncResult: %s>" % (
                 self.task2["id"]))
-        self.assertEquals(repr(nok_res), "<AsyncResult: %s>" % (
+        self.assertEqual(repr(nok_res), "<AsyncResult: %s>" % (
                 self.task3["id"]))
 
     def test_get_traceback(self):
@@ -87,8 +87,8 @@ class TestAsyncResult(unittest.TestCase):
         nok_res = AsyncResult(self.task3["id"])
         nok2_res = AsyncResult(self.task4["id"])
 
-        self.assertEquals(ok_res.get(), "the")
-        self.assertEquals(ok2_res.get(), "quick")
+        self.assertEqual(ok_res.get(), "the")
+        self.assertEqual(ok2_res.get(), "quick")
         self.assertRaises(KeyError, nok_res.get)
         self.assertTrue(isinstance(nok2_res.result, KeyError))
 
@@ -138,7 +138,7 @@ class TestTaskSetResult(unittest.TestCase):
         self.ts = TaskSetResult(gen_unique_id(), make_mock_taskset(self.size))
 
     def test_total(self):
-        self.assertEquals(self.ts.total, self.size)
+        self.assertEqual(self.ts.total, self.size)
 
     def test_iterate_raises(self):
         ar = MockAsyncResultFailure(gen_unique_id())
@@ -151,8 +151,8 @@ class TestTaskSetResult(unittest.TestCase):
         ar2 = MockAsyncResultSuccess(gen_unique_id())
         ts = TaskSetResult(gen_unique_id(), [ar, ar2])
         it = iter(ts)
-        self.assertEquals(it.next(), 42)
-        self.assertEquals(it.next(), 42)
+        self.assertEqual(it.next(), 42)
+        self.assertEqual(it.next(), 42)
 
     def test_join_timeout(self):
         ar = MockAsyncResultSuccess(gen_unique_id())
@@ -166,18 +166,18 @@ class TestTaskSetResult(unittest.TestCase):
         it = self.ts.itersubtasks()
 
         for i, t in enumerate(it):
-            self.assertEquals(t.get(), i)
+            self.assertEqual(t.get(), i)
 
     def test___iter__(self):
 
         it = iter(self.ts)
 
         results = sorted(list(it))
-        self.assertEquals(results, list(xrange(self.size)))
+        self.assertEqual(results, list(xrange(self.size)))
 
     def test_join(self):
         joined = self.ts.join()
-        self.assertEquals(joined, list(xrange(self.size)))
+        self.assertEqual(joined, list(xrange(self.size)))
 
     def test_successful(self):
         self.assertTrue(self.ts.successful())
@@ -192,7 +192,7 @@ class TestTaskSetResult(unittest.TestCase):
         self.assertTrue(self.ts.ready())
 
     def test_completed_count(self):
-        self.assertEquals(self.ts.completed_count(), self.ts.total)
+        self.assertEqual(self.ts.completed_count(), self.ts.total)
 
 
 class TestPendingAsyncResult(unittest.TestCase):
@@ -220,11 +220,11 @@ class TestFailedTaskSetResult(TestTaskSetResult):
 
         for i in xrange(self.size - 1):
             t = it.next()
-            self.assertEquals(t.get(), i)
+            self.assertEqual(t.get(), i)
         self.assertRaises(KeyError, it.next().get)
 
     def test_completed_count(self):
-        self.assertEquals(self.ts.completed_count(), self.ts.total - 1)
+        self.assertEqual(self.ts.completed_count(), self.ts.total - 1)
 
     def test___iter__(self):
         it = iter(self.ts)
@@ -252,7 +252,7 @@ class TestTaskSetPending(unittest.TestCase):
                                         AsyncResult(gen_unique_id())])
 
     def test_completed_count(self):
-        self.assertEquals(self.ts.completed_count(), 0)
+        self.assertEqual(self.ts.completed_count(), 0)
 
     def test_ready(self):
         self.assertFalse(self.ts.ready())

celery/tests/test_task.py

@@ -128,15 +128,15 @@ class TestTaskRetries(unittest.TestCase):
         RetryTask.max_retries = 3
         RetryTask.iterations = 0
         result = RetryTask.apply([0xFF, 0xFFFF])
-        self.assertEquals(result.get(), 0xFF)
-        self.assertEquals(RetryTask.iterations, 4)
+        self.assertEqual(result.get(), 0xFF)
+        self.assertEqual(RetryTask.iterations, 4)
 
     def test_retry_no_args(self):
         RetryTaskNoArgs.max_retries = 3
         RetryTaskNoArgs.iterations = 0
         result = RetryTaskNoArgs.apply()
-        self.assertEquals(result.get(), 42)
-        self.assertEquals(RetryTaskNoArgs.iterations, 4)
+        self.assertEqual(result.get(), 42)
+        self.assertEqual(RetryTaskNoArgs.iterations, 4)
 
     def test_retry_not_eager(self):
         exc = Exception("baz")
@@ -158,8 +158,8 @@ class TestTaskRetries(unittest.TestCase):
         RetryTaskCustomExc.max_retries = 3
         RetryTaskCustomExc.iterations = 0
         result = RetryTaskCustomExc.apply([0xFF, 0xFFFF], {"kwarg": 0xF})
-        self.assertEquals(result.get(), 0xFF + 0xF)
-        self.assertEquals(RetryTaskCustomExc.iterations, 4)
+        self.assertEqual(result.get(), 0xFF + 0xF)
+        self.assertEqual(RetryTaskCustomExc.iterations, 4)
 
     def test_retry_with_custom_exception(self):
         RetryTaskCustomExc.max_retries = 2
@@ -167,7 +167,7 @@ class TestTaskRetries(unittest.TestCase):
         result = RetryTaskCustomExc.apply([0xFF, 0xFFFF], {"kwarg": 0xF})
         self.assertRaises(MyCustomException,
                           result.get)
-        self.assertEquals(RetryTaskCustomExc.iterations, 3)
+        self.assertEqual(RetryTaskCustomExc.iterations, 3)
 
     def test_max_retries_exceeded(self):
         RetryTask.max_retries = 2
@@ -175,14 +175,14 @@ class TestTaskRetries(unittest.TestCase):
         result = RetryTask.apply([0xFF, 0xFFFF])
         self.assertRaises(RetryTask.MaxRetriesExceededError,
                           result.get)
-        self.assertEquals(RetryTask.iterations, 3)
+        self.assertEqual(RetryTask.iterations, 3)
 
         RetryTask.max_retries = 1
         RetryTask.iterations = 0
         result = RetryTask.apply([0xFF, 0xFFFF])
         self.assertRaises(RetryTask.MaxRetriesExceededError,
                           result.get)
-        self.assertEquals(RetryTask.iterations, 2)
+        self.assertEqual(RetryTask.iterations, 2)
 
 
 class MockPublisher(object):
@@ -205,13 +205,13 @@ class TestCeleryTasks(unittest.TestCase):
     def test_ping(self):
         from celery import conf
         conf.ALWAYS_EAGER = True
-        self.assertEquals(task.ping(), 'pong')
+        self.assertEqual(task.ping(), 'pong')
         conf.ALWAYS_EAGER = False
 
     def test_execute_remote(self):
         from celery import conf
         conf.ALWAYS_EAGER = True
-        self.assertEquals(task.execute_remote(return_True, ["foo"]).get(),
+        self.assertEqual(task.execute_remote(return_True, ["foo"]).get(),
                           True)
         conf.ALWAYS_EAGER = False
 
@@ -237,15 +237,15 @@ class TestCeleryTasks(unittest.TestCase):
             test_eta=False, **kwargs):
         next_task = consumer.fetch()
         task_data = next_task.decode()
-        self.assertEquals(task_data["id"], presult.task_id)
-        self.assertEquals(task_data["task"], task_name)
+        self.assertEqual(task_data["id"], presult.task_id)
+        self.assertEqual(task_data["task"], task_name)
         task_kwargs = task_data.get("kwargs", {})
         if test_eta:
             self.assertTrue(isinstance(task_data.get("eta"), basestring))
             to_datetime = parse_iso8601(task_data.get("eta"))
             self.assertTrue(isinstance(to_datetime, datetime))
         for arg_name, arg_value in kwargs.items():
-            self.assertEquals(task_kwargs.get(arg_name), arg_value)
+            self.assertEqual(task_kwargs.get(arg_name), arg_value)
 
     def test_incomplete_task_cls(self):
 
@@ -302,7 +302,7 @@ class TestCeleryTasks(unittest.TestCase):
         # Discarding all tasks.
         consumer.discard_all()
         task.apply_async(t1)
-        self.assertEquals(consumer.discard_all(), 1)
+        self.assertEqual(consumer.discard_all(), 1)
         self.assertTrue(consumer.fetch() is None)
 
         self.assertFalse(presult.successful())
@@ -319,7 +319,7 @@ class TestCeleryTasks(unittest.TestCase):
         try:
             p = IncrementCounterTask.get_publisher(exchange="foo",
                                                    connection="bar")
-            self.assertEquals(p.kwargs["exchange"], "foo")
+            self.assertEqual(p.kwargs["exchange"], "foo")
         finally:
             base.TaskPublisher = old_pub
 
@@ -339,7 +339,7 @@ class TestTaskSet(unittest.TestCase):
         ts = task.TaskSet(return_True_task.name, [
             [[1], {}], [[2], {}], [[3], {}], [[4], {}], [[5], {}]])
         res = ts.apply_async()
-        self.assertEquals(res.join(), [True, True, True, True, True])
+        self.assertEqual(res.join(), [True, True, True, True, True])
 
         conf.ALWAYS_EAGER = False
 
@@ -356,8 +356,8 @@ class TestTaskSet(unittest.TestCase):
             [[], {"increment_by": 8}],
             [[], {"increment_by": 9}],
         ])
-        self.assertEquals(ts.task_name, IncrementCounterTask.name)
-        self.assertEquals(ts.total, 9)
+        self.assertEqual(ts.task_name, IncrementCounterTask.name)
+        self.assertEqual(ts.total, 9)
 
 
         consumer = IncrementCounterTask().get_consumer()
@@ -367,12 +367,12 @@ class TestTaskSet(unittest.TestCase):
         taskset_id = taskset_res.taskset_id
         for subtask in subtasks:
             m = consumer.fetch().payload
-            self.assertEquals(m.get("taskset"), taskset_id)
-            self.assertEquals(m.get("task"), IncrementCounterTask.name)
-            self.assertEquals(m.get("id"), subtask.task_id)
+            self.assertEqual(m.get("taskset"), taskset_id)
+            self.assertEqual(m.get("task"), IncrementCounterTask.name)
+            self.assertEqual(m.get("id"), subtask.task_id)
             IncrementCounterTask().run(
                     increment_by=m.get("kwargs", {}).get("increment_by"))
-        self.assertEquals(IncrementCounterTask.count, sum(xrange(1, 10)))
+        self.assertEqual(IncrementCounterTask.count, sum(xrange(1, 10)))
 
 
 class TestTaskApply(unittest.TestCase):
@@ -382,13 +382,13 @@ class TestTaskApply(unittest.TestCase):
 
         e = IncrementCounterTask.apply()
         self.assertTrue(isinstance(e, EagerResult))
-        self.assertEquals(e.get(), 1)
+        self.assertEqual(e.get(), 1)
 
         e = IncrementCounterTask.apply(args=[1])
-        self.assertEquals(e.get(), 2)
+        self.assertEqual(e.get(), 2)
 
         e = IncrementCounterTask.apply(kwargs={"increment_by": 4})
-        self.assertEquals(e.get(), 6)
+        self.assertEqual(e.get(), 6)
 
         self.assertTrue(e.successful())
         self.assertTrue(e.ready())
@@ -418,7 +418,7 @@ class TestPeriodicTask(unittest.TestCase):
 
     def test_timedelta_seconds_returns_0_on_negative_time(self):
         delta = timedelta(days=-2)
-        self.assertEquals(MyPeriodic().timedelta_seconds(delta), 0)
+        self.assertEqual(MyPeriodic().timedelta_seconds(delta), 0)
 
     def test_timedelta_seconds(self):
         deltamap = ((timedelta(seconds=1), 1),
@@ -427,7 +427,7 @@ class TestPeriodicTask(unittest.TestCase):
                     (timedelta(hours=4), 4 * 60 * 60),
                     (timedelta(days=3), 3 * 86400))
         for delta, seconds in deltamap:
-            self.assertEquals(MyPeriodic().timedelta_seconds(delta), seconds)
+            self.assertEqual(MyPeriodic().timedelta_seconds(delta), seconds)
 
     def test_is_due_not_due(self):
         due, remaining = MyPeriodic().is_due(datetime.now())
@@ -438,4 +438,4 @@ class TestPeriodicTask(unittest.TestCase):
         p = MyPeriodic()
         due, remaining = p.is_due(datetime.now() - p.run_every)
         self.assertTrue(due)
-        self.assertEquals(remaining, p.timedelta_seconds(p.run_every))
+        self.assertEqual(remaining, p.timedelta_seconds(p.run_every))

celery/tests/test_task_builtins.py

@@ -13,13 +13,13 @@ def some_func(i):
 class TestPingTask(unittest.TestCase):
 
     def test_ping(self):
-        self.assertEquals(PingTask.apply().get(), 'pong')
+        self.assertEqual(PingTask.apply().get(), 'pong')
 
 
 class TestRemoteExecuteTask(unittest.TestCase):
 
     def test_execute_remote(self):
-        self.assertEquals(ExecuteRemoteTask.apply(
+        self.assertEqual(ExecuteRemoteTask.apply(
                             args=[pickle.dumps(some_func), [10], {}]).get(),
                           100)
 

celery/tests/test_task_http.py

@@ -71,21 +71,21 @@ class TestMutableURL(unittest.TestCase):
 
     def test_url_query(self):
         url = http.MutableURL("http://example.com?x=10&y=20&z=Foo")
-        self.assertEquals(url.query.get("x"), "10")
-        self.assertEquals(url.query.get("y"), "20")
-        self.assertEquals(url.query.get("z"), "Foo")
+        self.assertEqual(url.query.get("x"), "10")
+        self.assertEqual(url.query.get("y"), "20")
+        self.assertEqual(url.query.get("z"), "Foo")
         url.query["name"] = "George"
         url = http.MutableURL(str(url))
-        self.assertEquals(url.query.get("x"), "10")
-        self.assertEquals(url.query.get("y"), "20")
-        self.assertEquals(url.query.get("z"), "Foo")
-        self.assertEquals(url.query.get("name"), "George")
+        self.assertEqual(url.query.get("x"), "10")
+        self.assertEqual(url.query.get("y"), "20")
+        self.assertEqual(url.query.get("z"), "Foo")
+        self.assertEqual(url.query.get("name"), "George")
 
     def test_url_keeps_everything(self):
         url = "https://e.com:808/foo/bar#zeta?x=10&y=20"
         url = http.MutableURL(url)
 
-        self.assertEquals(str(url).split("?")[0],
+        self.assertEqual(str(url).split("?")[0],
             "https://e.com:808/foo/bar#zeta")
 
     def test___repr__(self):
@@ -96,7 +96,7 @@ class TestMutableURL(unittest.TestCase):
         url = http.MutableURL("http://e.com/foo/bar/?x=10")
         url.query = {"zzz": "xxx"}
         url = http.MutableURL(str(url))
-        self.assertEquals(url.query, {"zzz": "xxx"})
+        self.assertEqual(url.query, {"zzz": "xxx"})
 
 
 class TestHttpDispatch(unittest.TestCase):
@@ -107,7 +107,7 @@ class TestHttpDispatch(unittest.TestCase):
         def with_mock_urlopen(_val):
             d = http.HttpDispatch("http://example.com/mul", "GET", {
                                     "x": 10, "y": 10}, logger)
-            self.assertEquals(d.dispatch(), 100)
+            self.assertEqual(d.dispatch(), 100)
 
         context = mock_urlopen(success_response(100))
         execute_context(context, with_mock_urlopen)
@@ -162,7 +162,7 @@ class TestHttpDispatch(unittest.TestCase):
         def with_mock_urlopen(_val):
             d = http.HttpDispatch("http://example.com/mul", "POST", {
                                     "x": 10, "y": 10}, logger)
-            self.assertEquals(d.dispatch(), 100)
+            self.assertEqual(d.dispatch(), 100)
 
         context = mock_urlopen(success_response(100))
         execute_context(context, with_mock_urlopen)
@@ -175,7 +175,7 @@ class TestURL(unittest.TestCase):
 
             def with_mock_urlopen(_val):
                 d = http.URL("http://example.com/mul").get_async(x=10, y=10)
-                self.assertEquals(d.get(), 100)
+                self.assertEqual(d.get(), 100)
 
             context = mock_urlopen(success_response(100))
             execute_context(context, with_mock_urlopen)
@@ -187,7 +187,7 @@ class TestURL(unittest.TestCase):
 
             def with_mock_urlopen(_val):
                 d = http.URL("http://example.com/mul").post_async(x=10, y=10)
-                self.assertEquals(d.get(), 100)
+                self.assertEqual(d.get(), 100)
 
             context = mock_urlopen(success_response(100))
             execute_context(context, with_mock_urlopen)

celery/tests/test_utils.py

@@ -15,17 +15,17 @@ class TestChunks(unittest.TestCase):
 
         # n == 2
         x = utils.chunks(iter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 2)
-        self.assertEquals(list(x),
+        self.assertEqual(list(x),
             [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9], [10]])
 
         # n == 3
         x = utils.chunks(iter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 3)
-        self.assertEquals(list(x),
+        self.assertEqual(list(x),
             [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]])
 
         # n == 2 (exact)
         x = utils.chunks(iter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 2)
-        self.assertEquals(list(x),
+        self.assertEqual(list(x),
             [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]])
 
 
@@ -55,9 +55,9 @@ class TestDivUtils(unittest.TestCase):
         items = range(6)
         it = utils.repeatlast(items)
         for i in items:
-            self.assertEquals(it.next(), i)
+            self.assertEqual(it.next(), i)
         for j in items:
-            self.assertEquals(it.next(), i)
+            self.assertEqual(it.next(), i)
 
 
 class TestRetryOverTime(unittest.TestCase):
@@ -70,7 +70,7 @@ class TestRetryOverTime(unittest.TestCase):
         ret = utils.retry_over_time(_fun, (socket.error, ), args=[16, 16],
                                     max_retries=3)
 
-        self.assertEquals(ret, 256)
+        self.assertEqual(ret, 256)
 
     @sleepdeprived
     def test_raises_on_unlisted_exception(self):
@@ -95,8 +95,8 @@ class TestRetryOverTime(unittest.TestCase):
         ret = utils.retry_over_time(_fun, (socket.error, ), args=[32, 32],
                                     max_retries=None)
 
-        self.assertEquals(iterations[0], 3)
-        self.assertEquals(ret, 1024)
+        self.assertEqual(iterations[0], 3)
+        self.assertEqual(ret, 1024)
 
         self.assertRaises(socket.error, utils.retry_over_time,
                         _fun, (socket.error, ), args=[32, 32], max_retries=1)

celery/tests/test_utils_info.py

@@ -47,16 +47,16 @@ class TestInfo(unittest.TestCase):
              (0, "now"))
 
         for seconds, human in t:
-            self.assertEquals(info.humanize_seconds(seconds), human)
+            self.assertEqual(info.humanize_seconds(seconds), human)
 
-        self.assertEquals(info.humanize_seconds(4, prefix="about "),
+        self.assertEqual(info.humanize_seconds(4, prefix="about "),
                           "about 4.00 seconds")
 
     def test_textindent(self):
-        self.assertEquals(info.textindent(RANDTEXT, 4), RANDTEXT_RES)
+        self.assertEqual(info.textindent(RANDTEXT, 4), RANDTEXT_RES)
 
     def test_format_routing_table(self):
-        self.assertEquals(info.format_routing_table(ROUTE), ROUTE_FORMAT)
+        self.assertEqual(info.format_routing_table(ROUTE), ROUTE_FORMAT)
 
     def test_broker_info(self):
         info.format_broker_info()

celery/tests/test_views.py

@@ -49,7 +49,7 @@ class ViewTestCase(DjangoTestCase):
     def assertJSONEquals(self, json, py):
         json = isinstance(json, HttpResponse) and json.content or json
         try:
-            self.assertEquals(JSON_load(json), py)
+            self.assertEqual(JSON_load(json), py)
         except TypeError, exc:
             raise TypeError("%s: %s" % (exc, json))
 
@@ -61,7 +61,7 @@ class TestTaskApply(ViewTestCase):
         try:
             ret = self.client.get(task_apply(kwargs={"task_name":
                 mytask.name}) + "?x=4&y=4")
-            self.assertEquals(scratch["result"], 16)
+            self.assertEqual(scratch["result"], 16)
         finally:
             conf.ALWAYS_EAGER = False
 
@@ -86,7 +86,7 @@ class TestTaskStatus(ViewTestCase):
         expect = dict(id=uuid, status=status, result=res)
         if status in default_backend.EXCEPTION_STATES:
             instore = default_backend.get_result(uuid)
-            self.assertEquals(str(instore.args), str(res.args))
+            self.assertEqual(str(instore.args), str(res.args))
             expect["result"] = str(res.args[0])
             expect["exc"] = get_full_cls_name(res.__class__)
             expect["traceback"] = traceback

celery/tests/test_worker.py

@@ -161,7 +161,7 @@ class TestCarrotListener(unittest.TestCase):
         l.task_consumer.add_consumer = create_recorder("consumer_add")
 
         records.clear()
-        self.assertEquals(l._detect_wait_method(), l._mainloop)
+        self.assertEqual(l._detect_wait_method(), l._mainloop)
         self.assertTrue(records.get("broadcast_callback"))
         self.assertTrue(records.get("consume_broadcast"))
         self.assertTrue(records.get("consume_tasks"))
@@ -243,8 +243,8 @@ class TestCarrotListener(unittest.TestCase):
 
         in_bucket = self.ready_queue.get_nowait()
         self.assertTrue(isinstance(in_bucket, TaskWrapper))
-        self.assertEquals(in_bucket.task_name, foo_task.name)
-        self.assertEquals(in_bucket.execute(), 2 * 4 * 8)
+        self.assertEqual(in_bucket.task_name, foo_task.name)
+        self.assertEqual(in_bucket.execute(), 2 * 4 * 8)
         self.assertTrue(self.eta_schedule.empty())
 
     def test_receieve_message_eta_isoformat(self):
@@ -312,12 +312,12 @@ class TestCarrotListener(unittest.TestCase):
         l.receive_message(m.decode(), m)
 
         in_hold = self.eta_schedule.queue[0]
-        self.assertEquals(len(in_hold), 4)
+        self.assertEqual(len(in_hold), 4)
         eta, priority, task, on_accept = in_hold
         self.assertTrue(isinstance(task, TaskWrapper))
         self.assertTrue(callable(on_accept))
-        self.assertEquals(task.task_name, foo_task.name)
-        self.assertEquals(task.execute(), 2 * 4 * 8)
+        self.assertEqual(task.task_name, foo_task.name)
+        self.assertEqual(task.execute(), 2 * 4 * 8)
         self.assertRaises(Empty, self.ready_queue.get_nowait)
 
 

celery/tests/test_worker_control.py

@@ -27,11 +27,11 @@ class TestControlPanel(unittest.TestCase):
             self.panel.execute("rate_limit", kwargs=dict(
                                                 task_name=task.name,
                                                 rate_limit="100/m"))
-            self.assertEquals(task.rate_limit, "100/m")
+            self.assertEqual(task.rate_limit, "100/m")
             self.panel.execute("rate_limit", kwargs=dict(
                                                 task_name=task.name,
                                                 rate_limit=0))
-            self.assertEquals(task.rate_limit, 0)
+            self.assertEqual(task.rate_limit, 0)
         finally:
             task.rate_limit = old_rate_limit
 

celery/tests/test_worker_controllers.py

@@ -72,7 +72,7 @@ class TestMediator(unittest.TestCase):
 
         m.on_iteration()
 
-        self.assertEquals(got["value"], "George Constanza")
+        self.assertEqual(got["value"], "George Constanza")
 
     def test_mediator_on_iteration_revoked(self):
         ready_queue = Queue()
@@ -112,6 +112,6 @@ class TestScheduleController(unittest.TestCase):
             for i in times:
                 c.on_iteration()
                 res = i is None and 1 or i
-                self.assertEquals(slept[0], res)
+                self.assertEqual(slept[0], res)
         finally:
             time.sleep = old_sleep

celery/tests/test_worker_job.py

@@ -78,20 +78,20 @@ class TestRetryTaskError(unittest.TestCase):
         except Exception, exc:
             ret = RetryTaskError("Retrying task", exc)
 
-        self.assertEquals(ret.exc, exc)
+        self.assertEqual(ret.exc, exc)
 
 
 class TestJail(unittest.TestCase):
 
     def test_execute_jail_success(self):
         ret = jail(gen_unique_id(), mytask.name, [2], {})
-        self.assertEquals(ret, 4)
+        self.assertEqual(ret, 4)
 
     def test_execute_jail_failure(self):
         ret = jail(gen_unique_id(), mytask_raising.name,
                    [4], {})
         self.assertTrue(isinstance(ret, ExceptionInfo))
-        self.assertEquals(ret.exception.args, (4, ))
+        self.assertEqual(ret.exception.args, (4, ))
 
     def test_execute_ignore_result(self):
         task_id = gen_unique_id()
@@ -215,7 +215,7 @@ class TestTaskWrapper(unittest.TestCase):
     def test_execute_and_trace(self):
         from celery.worker.job import execute_and_trace
         res = execute_and_trace(mytask.name, gen_unique_id(), [4], {})
-        self.assertEquals(res, 4 ** 4)
+        self.assertEqual(res, 4 ** 4)
 
     def test_execute_safe_catches_exception(self):
         from celery.worker.job import execute_and_trace, WorkerTaskTrace
@@ -254,10 +254,10 @@ class TestTaskWrapper(unittest.TestCase):
                                                                   exc=value_))
         w._store_errors = False
         w.handle_retry(value_, type_, tb_, "")
-        self.assertEquals(mytask.backend.get_status(uuid), states.PENDING)
+        self.assertEqual(mytask.backend.get_status(uuid), states.PENDING)
         w._store_errors = True
         w.handle_retry(value_, type_, tb_, "")
-        self.assertEquals(mytask.backend.get_status(uuid), states.RETRY)
+        self.assertEqual(mytask.backend.get_status(uuid), states.RETRY)
 
     def test_worker_task_trace_handle_failure(self):
         from celery.worker.job import WorkerTaskTrace
@@ -266,10 +266,10 @@ class TestTaskWrapper(unittest.TestCase):
         type_, value_, tb_ = self.create_exception(ValueError("foo"))
         w._store_errors = False
         w.handle_failure(value_, type_, tb_, "")
-        self.assertEquals(mytask.backend.get_status(uuid), states.PENDING)
+        self.assertEqual(mytask.backend.get_status(uuid), states.PENDING)
         w._store_errors = True
         w.handle_failure(value_, type_, tb_, "")
-        self.assertEquals(mytask.backend.get_status(uuid), states.FAILURE)
+        self.assertEqual(mytask.backend.get_status(uuid), states.FAILURE)
 
     def test_executed_bit(self):
         from celery.worker.job import AlreadyExecutedError
@@ -304,10 +304,10 @@ class TestTaskWrapper(unittest.TestCase):
                         content_encoding="utf-8")
         tw = TaskWrapper.from_message(m, m.decode())
         self.assertTrue(isinstance(tw, TaskWrapper))
-        self.assertEquals(tw.task_name, body["task"])
-        self.assertEquals(tw.task_id, body["id"])
-        self.assertEquals(tw.args, body["args"])
-        self.assertEquals(tw.kwargs.keys()[0],
+        self.assertEqual(tw.task_name, body["task"])
+        self.assertEqual(tw.task_id, body["id"])
+        self.assertEqual(tw.args, body["args"])
+        self.assertEqual(tw.kwargs.keys()[0],
                           u"æØåveéðƒeæ".encode("utf-8"))
         self.assertFalse(isinstance(tw.kwargs.keys()[0], unicode))
         self.assertTrue(tw.logger)
@@ -324,44 +324,44 @@ class TestTaskWrapper(unittest.TestCase):
     def test_execute(self):
         tid = gen_unique_id()
         tw = TaskWrapper(mytask.name, tid, [4], {"f": "x"})
-        self.assertEquals(tw.execute(), 256)
+        self.assertEqual(tw.execute(), 256)
         meta = TaskMeta.objects.get(task_id=tid)
-        self.assertEquals(meta.result, 256)
-        self.assertEquals(meta.status, states.SUCCESS)
+        self.assertEqual(meta.result, 256)
+        self.assertEqual(meta.status, states.SUCCESS)
 
     def test_execute_success_no_kwargs(self):
         tid = gen_unique_id()
         tw = TaskWrapper(mytask_no_kwargs.name, tid, [4], {})
-        self.assertEquals(tw.execute(), 256)
+        self.assertEqual(tw.execute(), 256)
         meta = TaskMeta.objects.get(task_id=tid)
-        self.assertEquals(meta.result, 256)
-        self.assertEquals(meta.status, states.SUCCESS)
+        self.assertEqual(meta.result, 256)
+        self.assertEqual(meta.status, states.SUCCESS)
 
     def test_execute_success_some_kwargs(self):
         tid = gen_unique_id()
         tw = TaskWrapper(mytask_some_kwargs.name, tid, [4], {})
-        self.assertEquals(tw.execute(logfile="foobaz.log"), 256)
+        self.assertEqual(tw.execute(logfile="foobaz.log"), 256)
         meta = TaskMeta.objects.get(task_id=tid)
-        self.assertEquals(some_kwargs_scratchpad.get("logfile"), "foobaz.log")
-        self.assertEquals(meta.result, 256)
-        self.assertEquals(meta.status, states.SUCCESS)
+        self.assertEqual(some_kwargs_scratchpad.get("logfile"), "foobaz.log")
+        self.assertEqual(meta.result, 256)
+        self.assertEqual(meta.status, states.SUCCESS)
 
     def test_execute_ack(self):
         tid = gen_unique_id()
         tw = TaskWrapper(mytask.name, tid, [4], {"f": "x"},
                         on_ack=on_ack)
-        self.assertEquals(tw.execute(), 256)
+        self.assertEqual(tw.execute(), 256)
         meta = TaskMeta.objects.get(task_id=tid)
         self.assertTrue(scratch["ACK"])
-        self.assertEquals(meta.result, 256)
-        self.assertEquals(meta.status, states.SUCCESS)
+        self.assertEqual(meta.result, 256)
+        self.assertEqual(meta.status, states.SUCCESS)
 
     def test_execute_fail(self):
         tid = gen_unique_id()
         tw = TaskWrapper(mytask_raising.name, tid, [4], {"f": "x"})
         self.assertTrue(isinstance(tw.execute(), ExceptionInfo))
         meta = TaskMeta.objects.get(task_id=tid)
-        self.assertEquals(meta.status, states.FAILURE)
+        self.assertEqual(meta.status, states.FAILURE)
         self.assertTrue(isinstance(meta.result, KeyError))
 
     def test_execute_using_pool(self):
@@ -376,7 +376,7 @@ class TestTaskWrapper(unittest.TestCase):
     def test_default_kwargs(self):
         tid = gen_unique_id()
         tw = TaskWrapper(mytask.name, tid, [4], {"f": "x"})
-        self.assertEquals(tw.extend_with_default_kwargs(10, "some_logfile"), {
+        self.assertEqual(tw.extend_with_default_kwargs(10, "some_logfile"), {
             "f": "x",
             "logfile": "some_logfile",
             "loglevel": 10,

celery/tests/test_worker_scheduler.py

@@ -26,9 +26,9 @@ class TestScheduler(unittest.TestCase):
         sched.enter(MockItem("foo"), eta=now, callback=callback)
 
         remaining = iter(sched).next()
-        self.assertEquals(remaining, 0)
+        self.assertEqual(remaining, 0)
         self.assertTrue(callback_called[0])
-        self.assertEquals(ready_queue.get_nowait().task_id, "foo")
+        self.assertEqual(ready_queue.get_nowait().task_id, "foo")
 
     def test_sched_run_later(self):
         ready_queue = Queue()