Moved some django specific tests to django-celery

celery/tests/test_backends/__init__.py

@@ -4,14 +4,11 @@ from celery import backends
 from celery.backends.amqp import AMQPBackend
 from celery.backends.pyredis import RedisBackend
 
-from djcelery.backends.database import DatabaseBackend
-
 
 class TestBackends(unittest.TestCase):
 
     def test_get_backend_aliases(self):
         expects = [("amqp", AMQPBackend),
-                   ("database", DatabaseBackend),
                    ("redis", RedisBackend)]
         for expect_name, expect_cls in expects:
             self.assertIsInstance(backends.get_backend_cls(expect_name)(),

celery/tests/test_backends/test_cache.py

@@ -1,127 +0,0 @@
-import sys
-import unittest2 as unittest
-
-from billiard.serialization import pickle
-from django.core.cache.backends.base import InvalidCacheBackendError
-
-from celery import result
-from celery import states
-from celery.utils import gen_unique_id
-from celery.datastructures import ExceptionInfo
-
-from djcelery.backends.cache import CacheBackend
-
-class SomeClass(object):
-
-    def __init__(self, data):
-        self.data = data
-
-
-class TestCacheBackend(unittest.TestCase):
-
-    def test_mark_as_done(self):
-        cb = CacheBackend()
-
-        tid = gen_unique_id()
-
-        self.assertFalse(cb.is_successful(tid))
-        self.assertEqual(cb.get_status(tid), states.PENDING)
-        self.assertIsNone(cb.get_result(tid))
-
-        cb.mark_as_done(tid, 42)
-        self.assertTrue(cb.is_successful(tid))
-        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):
-        backend = CacheBackend()
-        taskset_id = gen_unique_id()
-        subtask_ids = [gen_unique_id() for i in range(10)]
-        subtasks = map(result.AsyncResult, subtask_ids)
-        res = result.TaskSetResult(taskset_id, subtasks)
-        res.save(backend=backend)
-        saved = result.TaskSetResult.restore(taskset_id, backend=backend)
-        self.assertListEqual(saved.subtasks, subtasks)
-        self.assertEqual(saved.taskset_id, taskset_id)
-
-    def test_is_pickled(self):
-        cb = CacheBackend()
-
-        tid2 = gen_unique_id()
-        result = {"foo": "baz", "bar": SomeClass(12345)}
-        cb.mark_as_done(tid2, result)
-        # is serialized properly.
-        rindb = cb.get_result(tid2)
-        self.assertEqual(rindb.get("foo"), "baz")
-        self.assertEqual(rindb.get("bar").data, 12345)
-
-    def test_mark_as_failure(self):
-        cb = CacheBackend()
-
-        einfo = None
-        tid3 = gen_unique_id()
-        try:
-            raise KeyError("foo")
-        except KeyError, exception:
-            einfo = ExceptionInfo(sys.exc_info())
-            pass
-        cb.mark_as_failure(tid3, exception, traceback=einfo.traceback)
-        self.assertFalse(cb.is_successful(tid3))
-        self.assertEqual(cb.get_status(tid3), states.FAILURE)
-        self.assertIsInstance(cb.get_result(tid3), KeyError)
-        self.assertEqual(cb.get_traceback(tid3), einfo.traceback)
-
-    def test_process_cleanup(self):
-        cb = CacheBackend()
-        cb.process_cleanup()
-
-
-class TestCustomCacheBackend(unittest.TestCase):
-
-    def test_custom_cache_backend(self):
-        from celery import conf
-        prev_backend = conf.CELERY_CACHE_BACKEND
-        prev_module = sys.modules["djcelery.backends.cache"]
-        conf.CELERY_CACHE_BACKEND = "dummy://"
-        sys.modules.pop("djcelery.backends.cache")
-        try:
-            from djcelery.backends.cache import cache
-            from django.core.cache import cache as django_cache
-            self.assertEqual(cache.__class__.__module__,
-                              "django.core.cache.backends.dummy")
-            self.assertIsNot(cache, django_cache)
-        finally:
-            conf.CELERY_CACHE_BACKEND = prev_backend
-            sys.modules["djcelery.backends.cache"] = prev_module
-
-
-class TestMemcacheWrapper(unittest.TestCase):
-
-    def test_memcache_wrapper(self):
-
-        try:
-            from django.core.cache.backends import memcached
-            from django.core.cache.backends import locmem
-        except InvalidCacheBackendError:
-            sys.stderr.write(
-                "\n* Memcache library is not installed. Skipping test.\n")
-            return
-        prev_cache_cls = memcached.CacheClass
-        memcached.CacheClass = locmem.CacheClass
-        prev_backend_module = sys.modules.pop("djcelery.backends.cache")
-        try:
-            from djcelery.backends.cache import cache, DjangoMemcacheWrapper
-            self.assertIsInstance(cache, DjangoMemcacheWrapper)
-
-            key = "cu.test_memcache_wrapper"
-            val = "The quick brown fox."
-            default = "The lazy dog."
-
-            self.assertEqual(cache.get(key, default=default), default)
-            cache.set(key, val)
-            self.assertEqual(pickle.loads(cache.get(key, default=default)),
-                              val)
-        finally:
-            memcached.CacheClass = prev_cache_cls
-            sys.modules["djcelery.backends.cache"] = prev_backend_module

celery/tests/test_backends/test_database.py

@@ -1,69 +0,0 @@
-import unittest2 as unittest
-from datetime import timedelta
-
-from celery import states
-from celery.task import PeriodicTask
-from celery.utils import gen_unique_id
-
-from djcelery.backends.database import DatabaseBackend
-
-
-class SomeClass(object):
-
-    def __init__(self, data):
-        self.data = data
-
-
-class MyPeriodicTask(PeriodicTask):
-    name = "c.u.my-periodic-task-244"
-    run_every = timedelta(seconds=1)
-
-    def run(self, **kwargs):
-        return 42
-
-
-class TestDatabaseBackend(unittest.TestCase):
-
-    def test_backend(self):
-        b = DatabaseBackend()
-        tid = gen_unique_id()
-
-        self.assertFalse(b.is_successful(tid))
-        self.assertEqual(b.get_status(tid), states.PENDING)
-        self.assertIsNone(b.get_result(tid))
-
-        b.mark_as_done(tid, 42)
-        self.assertTrue(b.is_successful(tid))
-        self.assertEqual(b.get_status(tid), states.SUCCESS)
-        self.assertEqual(b.get_result(tid), 42)
-
-        tid2 = gen_unique_id()
-        result = {"foo": "baz", "bar": SomeClass(12345)}
-        b.mark_as_done(tid2, result)
-        # is serialized properly.
-        rindb = b.get_result(tid2)
-        self.assertEqual(rindb.get("foo"), "baz")
-        self.assertEqual(rindb.get("bar").data, 12345)
-
-        tid3 = gen_unique_id()
-        try:
-            raise KeyError("foo")
-        except KeyError, exception:
-            pass
-        b.mark_as_failure(tid3, exception)
-        self.assertFalse(b.is_successful(tid3))
-        self.assertEqual(b.get_status(tid3), states.FAILURE)
-        self.assertIsInstance(b.get_result(tid3), KeyError)
-
-    def test_taskset_store(self):
-        b = DatabaseBackend()
-        tid = gen_unique_id()
-
-        self.assertIsNone(b.restore_taskset(tid))
-
-        result = {"foo": "baz", "bar": SomeClass(12345)}
-        b.save_taskset(tid, result)
-        rindb = b.restore_taskset(tid)
-        self.assertIsNotNone(rindb)
-        self.assertEqual(rindb.get("foo"), "baz")
-        self.assertEqual(rindb.get("bar").data, 12345)

celery/tests/test_conf.py

@@ -1,36 +0,0 @@
-import unittest2 as unittest
-
-from django.conf import settings
-
-from celery import conf
-
-
-SETTING_VARS = (
-    ("CELERY_DEFAULT_QUEUE", "DEFAULT_QUEUE"),
-    ("CELERY_DEFAULT_ROUTING_KEY", "DEFAULT_ROUTING_KEY"),
-    ("CELERY_DEFAULT_EXCHANGE_TYPE", "DEFAULT_EXCHANGE_TYPE"),
-    ("CELERY_DEFAULT_EXCHANGE", "DEFAULT_EXCHANGE"),
-    ("CELERYD_CONCURRENCY", "CELERYD_CONCURRENCY"),
-    ("CELERYD_LOG_FILE", "CELERYD_LOG_FILE"),
-    ("CELERYD_LOG_FORMAT", "CELERYD_LOG_FORMAT"),
-)
-
-
-class TestConf(unittest.TestCase):
-
-    def assertDefaultSetting(self, setting_name, result_var):
-        if hasattr(settings, setting_name):
-            self.assertEqual(getattr(conf, result_var),
-                              getattr(settings, setting_name),
-                              "Overwritten setting %s is written to %s" % (
-                                  setting_name, result_var))
-        else:
-            self.assertEqual(conf._DEFAULTS.get(setting_name),
-                             getattr(conf, result_var),
-                             "Default setting %s is written to %s" % (
-                                 setting_name, result_var))
-
-    def test_configuration_cls(self):
-        for setting_name, result_var in SETTING_VARS:
-            self.assertDefaultSetting(setting_name, result_var)
-        self.assertIsInstance(conf.CELERYD_LOG_LEVEL, int)

celery/tests/test_discovery.py

@@ -1,29 +0,0 @@
-import unittest2 as unittest
-
-from django.conf import settings
-
-from celery.task import tasks
-
-from djcelery.loaders.djangoapp import autodiscover
-
-
-class TestDiscovery(unittest.TestCase):
-
-    def assertDiscovery(self):
-        apps = autodiscover()
-        self.assertTrue(apps)
-        self.assertIn("c.unittest.SomeAppTask", tasks)
-        self.assertEqual(tasks["c.unittest.SomeAppTask"].run(), 42)
-
-    def test_discovery(self):
-        if "someapp" in settings.INSTALLED_APPS:
-            self.assertDiscovery()
-
-    def test_discovery_with_broken(self):
-        if "someapp" in settings.INSTALLED_APPS:
-            installed_apps = list(settings.INSTALLED_APPS)
-            settings.INSTALLED_APPS = installed_apps + ["xxxnot.aexist"]
-            try:
-                self.assertRaises(ImportError, autodiscover)
-            finally:
-                settings.INSTALLED_APPS = installed_apps

celery/tests/test_models.py

@@ -1,75 +0,0 @@
-import unittest2 as unittest
-from datetime import datetime, timedelta
-
-from celery import states
-from celery.utils import gen_unique_id
-
-from djcelery.models import TaskMeta, TaskSetMeta
-
-
-class TestModels(unittest.TestCase):
-
-    def createTaskMeta(self):
-        id = gen_unique_id()
-        taskmeta, created = TaskMeta.objects.get_or_create(task_id=id)
-        return taskmeta
-
-    def createTaskSetMeta(self):
-        id = gen_unique_id()
-        tasksetmeta, created = TaskSetMeta.objects.get_or_create(taskset_id=id)
-        return tasksetmeta
-
-    def test_taskmeta(self):
-        m1 = self.createTaskMeta()
-        m2 = self.createTaskMeta()
-        m3 = self.createTaskMeta()
-        self.assertTrue(unicode(m1).startswith("<Task:"))
-        self.assertTrue(m1.task_id)
-        self.assertIsInstance(m1.date_done, datetime)
-
-        self.assertEqual(TaskMeta.objects.get_task(m1.task_id).task_id,
-                m1.task_id)
-        self.assertNotEqual(TaskMeta.objects.get_task(m1.task_id).status,
-                            states.SUCCESS)
-        TaskMeta.objects.store_result(m1.task_id, True, status=states.SUCCESS)
-        TaskMeta.objects.store_result(m2.task_id, True, status=states.SUCCESS)
-        self.assertEqual(TaskMeta.objects.get_task(m1.task_id).status,
-                         states.SUCCESS)
-        self.assertEqual(TaskMeta.objects.get_task(m2.task_id).status,
-                         states.SUCCESS)
-
-        # Have to avoid save() because it applies the auto_now=True.
-        TaskMeta.objects.filter(task_id=m1.task_id).update(
-                date_done=datetime.now() - timedelta(days=10))
-
-        expired = TaskMeta.objects.get_all_expired()
-        self.assertIn(m1, expired)
-        self.assertNotIn(m2, expired)
-        self.assertNotIn(m3, expired)
-
-        TaskMeta.objects.delete_expired()
-        self.assertNotIn(m1, TaskMeta.objects.all())
-
-    def test_tasksetmeta(self):
-        m1 = self.createTaskSetMeta()
-        m2 = self.createTaskSetMeta()
-        m3 = self.createTaskSetMeta()
-        self.assertTrue(unicode(m1).startswith("<TaskSet:"))
-        self.assertTrue(m1.taskset_id)
-        self.assertIsInstance(m1.date_done, datetime)
-
-        self.assertEqual(
-                TaskSetMeta.objects.restore_taskset(m1.taskset_id).taskset_id,
-                m1.taskset_id)
-
-        # Have to avoid save() because it applies the auto_now=True.
-        TaskSetMeta.objects.filter(taskset_id=m1.taskset_id).update(
-                date_done=datetime.now() - timedelta(days=10))
-
-        expired = TaskSetMeta.objects.get_all_expired()
-        self.assertIn(m1, expired)
-        self.assertNotIn(m2, expired)
-        self.assertNotIn(m3, expired)
-
-        TaskSetMeta.objects.delete_expired()
-        self.assertNotIn(m1, TaskSetMeta.objects.all())

celery/tests/test_views.py

@@ -1,127 +0,0 @@
-import sys
-
-from django.http import HttpResponse
-from django.test.testcases import TestCase as DjangoTestCase
-from django.core.urlresolvers import reverse
-from django.template import TemplateDoesNotExist
-
-from anyjson import deserialize as JSON_load
-from billiard.utils.functional import curry
-
-from celery import conf
-from celery import states
-from celery.utils import gen_unique_id, get_full_cls_name
-from celery.backends import default_backend
-from celery.exceptions import RetryTaskError
-from celery.decorators import task
-from celery.datastructures import ExceptionInfo
-
-def reversestar(name, **kwargs):
-    return reverse(name, kwargs=kwargs)
-
-task_is_successful = curry(reversestar, "celery-is_task_successful")
-task_status = curry(reversestar, "celery-task_status")
-task_apply = curry(reverse, "celery-apply")
-
-scratch = {}
-@task()
-def mytask(x, y):
-    ret = scratch["result"] = int(x) * int(y)
-    return ret
-
-
-def create_exception(name, base=Exception):
-    return type(name, (base, ), {})
-
-
-def catch_exception(exception):
-    try:
-        raise exception
-    except exception.__class__, exc:
-        exc = default_backend.prepare_exception(exc)
-        return exc, ExceptionInfo(sys.exc_info()).traceback
-
-
-class ViewTestCase(DjangoTestCase):
-
-    def assertJSONEqual(self, json, py):
-        json = isinstance(json, HttpResponse) and json.content or json
-        try:
-            self.assertEqual(JSON_load(json), py)
-        except TypeError, exc:
-            raise TypeError("%s: %s" % (exc, json))
-
-
-class TestTaskApply(ViewTestCase):
-
-    def test_apply(self):
-        conf.ALWAYS_EAGER = True
-        try:
-            self.client.get(task_apply(kwargs={"task_name":
-                mytask.name}) + "?x=4&y=4")
-            self.assertEqual(scratch["result"], 16)
-        finally:
-            conf.ALWAYS_EAGER = False
-
-    def test_apply_raises_404_on_unregistered_task(self):
-        conf.ALWAYS_EAGER = True
-        try:
-            name = "xxx.does.not.exist"
-            action = curry(self.client.get, task_apply(kwargs={
-                        "task_name": name}) + "?x=4&y=4")
-            self.assertRaises(TemplateDoesNotExist, action)
-        finally:
-            conf.ALWAYS_EAGER = False
-
-
-class TestTaskStatus(ViewTestCase):
-
-    def assertStatusForIs(self, status, res, traceback=None):
-        uuid = gen_unique_id()
-        default_backend.store_result(uuid, res, status,
-                                     traceback=traceback)
-        json = self.client.get(task_status(task_id=uuid))
-        expect = dict(id=uuid, status=status, result=res)
-        if status in default_backend.EXCEPTION_STATES:
-            instore = default_backend.get_result(uuid)
-            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
-
-        self.assertJSONEqual(json, dict(task=expect))
-
-    def test_task_status_success(self):
-        self.assertStatusForIs(states.SUCCESS, "The quick brown fox")
-
-    def test_task_status_failure(self):
-        exc, tb = catch_exception(KeyError("foo"))
-        self.assertStatusForIs(states.FAILURE, exc, tb)
-
-    def test_task_status_retry(self):
-        oexc, _ = catch_exception(KeyError("Resource not available"))
-        exc, tb = catch_exception(RetryTaskError(str(oexc), oexc))
-        self.assertStatusForIs(states.RETRY, exc, tb)
-
-
-class TestTaskIsSuccessful(ViewTestCase):
-
-    def assertStatusForIs(self, status, outcome):
-        uuid = gen_unique_id()
-        result = gen_unique_id()
-        default_backend.store_result(uuid, result, status)
-        json = self.client.get(task_is_successful(task_id=uuid))
-        self.assertJSONEqual(json, {"task": {"id": uuid,
-                                             "executed": outcome}})
-
-    def test_is_successful_success(self):
-        self.assertStatusForIs(states.SUCCESS, True)
-
-    def test_is_successful_pending(self):
-        self.assertStatusForIs(states.PENDING, False)
-
-    def test_is_successful_failure(self):
-        self.assertStatusForIs(states.FAILURE, False)
-
-    def test_is_successful_retry(self):
-        self.assertStatusForIs(states.RETRY, False)