-Refactor failure backend tests

-Actually make them pass this time

Author: chawco

tests/__init__.py

@@ -4,7 +4,7 @@
 
 class Basic(object):
     queue = 'basic'
-    
+
     @staticmethod
     def perform(name):
         s = "name:%s" % name
@@ -15,7 +15,7 @@ class BasicMulti(object):
     @staticmethod
     def perform(name, age):
         print 'name: %s, age: %s' % (name, age)
-    
+
 
 class ReturnAllArgsJob(object):
     queue = 'basic'
@@ -40,24 +40,24 @@ def perform(fail_until):
 
 class TestProcess(object):
     queue = 'high'
-    
+
     @staticmethod
     def perform():
         import time
         time.sleep(.5)
         return 'Done Sleeping'
-        
-    
+
+
 class ErrorObject(object):
     queue = 'basic'
-    
+
     @staticmethod
     def perform():
         raise Exception("Could not finish job")
 
 class LongObject(object):
     queue = 'long_runnning'
-    
+
     @staticmethod
     def perform(sleep_time):
         import time
@@ -76,14 +76,14 @@ def test_safe_str_to_class(self):
         assert safe_str_to_class('tests.Basic') == Basic
         self.assertRaises(ImportError, safe_str_to_class, 'test.Mine')
         self.assertRaises(ImportError, safe_str_to_class, 'tests.World')
-    
+
 
 class PyResTests(unittest.TestCase):
     def setUp(self):
         self.resq = ResQ()
         self.redis = self.resq.redis
         self.redis.flushall()
-    
+
     def tearDown(self):
         self.redis.flushall()
         del self.redis

tests/test_failure.py

@@ -1,69 +1,57 @@
-from tests import PyResTests, Basic, TestProcess, ErrorObject
+from tests import PyResTests, Basic
 from pyres import failure
-from pyres.failure.base import BaseBackend
-from pyres.failure.multiple import MultipleBackend
-from pyres.failure.redis import RedisBackend
 from pyres.job import Job
 
 class FailureTests(PyResTests):
+    def setUp(self):
+        PyResTests.setUp(self)
+        self.queue_name = 'basic'
+        self.job_class = Basic
+
     def test_count(self):
-        self.resq.enqueue(Basic,"test1")
-        job = Job.reserve('basic',self.resq)
+        self.resq.enqueue(self.job_class,"test1")
+        job = Job.reserve(self.queue_name,self.resq)
         job.fail("problem")
         assert failure.count(self.resq) == 1
         assert self.redis.llen('resque:failed') == 1
 
     def test_create(self):
-        self.resq.enqueue(Basic,"test1")
-        job = Job.reserve('basic',self.resq)
+        self.resq.enqueue(self.job_class,"test1")
+        job = Job.reserve(self.queue_name,self.resq)
         e = Exception('test')
-        fail = failure.create(e, 'basic', job._payload)
+        fail = failure.create(e, self.queue_name, job._payload)
         assert isinstance(fail._payload, dict)
         fail.save(self.resq)
         assert failure.count(self.resq) == 1
         assert self.redis.llen('resque:failed') == 1
 
     def test_all(self):
-        self.resq.enqueue(Basic,"test1")
-        job = Job.reserve('basic',self.resq)
+        self.resq.enqueue(self.job_class,"test1")
+        job = Job.reserve(self.queue_name,self.resq)
         e = Exception('problem')
         job.fail(e)
         assert len(failure.all(self.resq, 0, 20)) == 1
 
     def test_clear(self):
-        self.resq.enqueue(Basic,"test1")
-        job = Job.reserve('basic',self.resq)
+        self.resq.enqueue(self.job_class,"test1")
+        job = Job.reserve(self.queue_name,self.resq)
         e = Exception('problem')
         job.fail(e)
         assert self.redis.llen('resque:failed') == 1
         failure.clear(self.resq)
         assert self.redis.llen('resque:failed') == 0
 
     def test_requeue(self):
-        self.resq.enqueue(Basic,"test1")
-        job = Job.reserve('basic',self.resq)
+        self.resq.enqueue(self.job_class,"test1")
+        job = Job.reserve(self.queue_name,self.resq)
         e = Exception('problem')
         fail_object = job.fail(e)
-        assert self.resq.size('basic') == 0
+        assert self.resq.size(self.queue_name) == 0
         failure.requeue(self.resq, fail_object)
-        assert self.resq.size('basic') == 1
-        job = Job.reserve('basic',self.resq)
-        assert job._queue == 'basic'
-        assert job._payload == {'class':'tests.Basic','args':['test1']}
-
-# Test the MultipleBackend, basically just repeat the above tests, ensuring that
-# we've delegated to the methods appropriately
-
-class TestBackend(BaseBackend):
-    def save(self, resq):
-        resq.redis.set('testbackend:called', 1)
-
-failure.backend = MultipleBackend
-failure.backend.classes = [RedisBackend, TestBackend]
-
-class MultipleFailureTests(FailureTests):
-    def test_create(self):
-        # Run the parent test
-        FailureTests.test_create(self)
-        # But also ensure the other backends were called
-        assert int(self.redis.get('testbackend:called')) == 1
+        assert self.resq.size(self.queue_name) == 1
+        job = Job.reserve(self.queue_name,self.resq)
+        assert job._queue == self.queue_name
+        mod_with_class = '{module}.{klass}'.format(
+            module=self.job_class.__module__,
+            klass=self.job_class.__name__)
+        assert job._payload == {'class':mod_with_class,'args':['test1']}

tests/test_failure_multi.py

@@ -0,0 +1,24 @@
+from tests import Basic
+from tests.test_failure import FailureTests
+
+from pyres import failure
+from pyres.failure.base import BaseBackend
+from pyres.failure.multiple import MultipleBackend
+from pyres.failure.redis import RedisBackend
+
+# Inner class for the failure backend
+class TestBackend(BaseBackend):
+    def save(self, resq):
+        resq.redis.set('testbackend:called', 1)
+
+failure.backend = MultipleBackend
+failure.backend.classes = [RedisBackend, TestBackend]
+
+class BasicMultiBackend(Basic):
+    queue = 'basicmultibackend'
+
+class MultipleFailureTests(FailureTests):
+    def setUp(self):
+        FailureTests.setUp(self)
+        self.job_class = BasicMultiBackend
+        self.queue_name = 'basicmultibackend'