Use assertIn, asertGreater, etc

celery/tests/app/test_schedules.py

@@ -249,8 +249,8 @@ class test_crontab_parser(AppCase):
             self.crontab(month_of_year='1'),
             self.crontab(month_of_year='2'),
         )
-        self.assertFalse(object() == self.crontab(minute='1'))
-        self.assertFalse(self.crontab(minute='1') == object())
+        self.assertNotEqual(object(), self.crontab(minute='1'))
+        self.assertNotEqual(self.crontab(minute='1'), object())
         self.assertNotEqual(crontab(month_of_year='1'), schedule(10))
 
 

celery/tests/bin/test_multi.py

@@ -83,7 +83,7 @@ class test_multi_args(AppCase):
         names = list(it)
 
         def assert_line_in(name, args):
-            self.assertIn(name, [tup[0] for tup in names])
+            self.assertIn(name, {tup[0] for tup in names})
             argv = None
             for item in names:
                 if item[0] == name:
@@ -352,11 +352,11 @@ class test_MultiTool(AppCase):
         self.assertEqual(len(sigs), 2)
         self.assertIn(
             ('foo@e.com', 10, signal.SIGTERM),
-            [tup[0] for tup in sigs],
+            {tup[0] for tup in sigs},
         )
         self.assertIn(
             ('bar@e.com', 11, signal.SIGTERM),
-            [tup[0] for tup in sigs],
+            {tup[0] for tup in sigs},
         )
         self.t.signal_node.return_value = False
         self.assertTrue(callback.called)

celery/tests/bin/test_worker.py

@@ -50,7 +50,7 @@ class test_Worker(WorkerAppCase):
     def test_queues_string(self):
         w = self.app.Worker()
         w.setup_queues('foo,bar,baz')
-        self.assertTrue('foo' in self.app.amqp.queues)
+        self.assertIn('foo', self.app.amqp.queues)
 
     @disable_stdouts
     def test_cpu_count(self):

celery/tests/concurrency/test_prefork.py

@@ -339,7 +339,7 @@ class test_TaskPool(PoolCase):
         pool = TaskPool(10)
         pool.start()
         self.assertTrue(pool._pool.started)
-        self.assertTrue(pool._pool._state == asynpool.RUN)
+        self.assertEqual(pool._pool._state, asynpool.RUN)
 
         _pool = pool._pool
         pool.stop()

celery/tests/events/test_state.py

@@ -455,7 +455,7 @@ class test_State(AppCase):
 
         # RECEIVED
         next(r)
-        self.assertTrue(r.tid in r.state.tasks)
+        self.assertIn(r.tid, r.state.tasks)
         task = r.state.tasks[r.tid]
         self.assertEqual(task.state, states.RECEIVED)
         self.assertTrue(task.received)

celery/tests/tasks/test_result.py

@@ -170,7 +170,7 @@ class test_AsyncResult(AppCase):
         list(x.iterdeps(intermediate=True))
 
     def test_eq_not_implemented(self):
-        self.assertFalse(self.app.AsyncResult('1') == object())
+        self.assertNotEqual(self.app.AsyncResult('1'), object())
 
     @depends_on_current_app
     def test_reduce(self):
@@ -320,11 +320,14 @@ class test_ResultSet(AppCase):
             [self.app.AsyncResult(t) for t in ['1', '2', '3']])))
 
     def test_eq_other(self):
-        self.assertFalse(self.app.ResultSet(
-            [self.app.AsyncResult(t) for t in [1, 3, 3]]) == 1)
+        self.assertNotEqual(
+            self.app.ResultSet([self.app.AsyncResult(t)
+                               for t in [1, 3, 3]]),
+            1,
+        )
         rs1 = self.app.ResultSet([self.app.AsyncResult(1)])
         rs2 = self.app.ResultSet([self.app.AsyncResult(1)])
-        self.assertTrue(rs1 == rs2)
+        self.assertEqual(rs1, rs2)
 
     def test_get(self):
         x = self.app.ResultSet([self.app.AsyncResult(t) for t in [1, 2, 3]])
@@ -530,7 +533,7 @@ class test_GroupResult(AppCase):
         self.assertEqual(len(self.ts), self.size)
 
     def test_eq_other(self):
-        self.assertFalse(self.ts == 1)
+        self.assertNotEqual(self.ts, 1)
 
     @depends_on_current_app
     def test_pickleable(self):

celery/tests/tasks/test_states.py

@@ -1,31 +1,54 @@
 from __future__ import absolute_import, unicode_literals
 
-from celery.states import state
 from celery import states
+
 from celery.tests.case import Case
 
 
 class test_state_precedence(Case):
 
     def test_gt(self):
-        self.assertGreater(state(states.SUCCESS),
-                           state(states.PENDING))
-        self.assertGreater(state(states.FAILURE),
-                           state(states.RECEIVED))
-        self.assertGreater(state(states.REVOKED),
-                           state(states.STARTED))
-        self.assertGreater(state(states.SUCCESS),
-                           state('CRASHED'))
-        self.assertGreater(state(states.FAILURE),
-                           state('CRASHED'))
-        self.assertFalse(state(states.REVOKED) > state('CRASHED'))
+        self.assertGreater(
+            states.state(states.SUCCESS), states.state(states.PENDING),
+        )
+        self.assertGreater(
+            states.state(states.FAILURE), states.state(states.RECEIVED),
+        )
+        self.assertGreater(
+            states.state(states.REVOKED), states.state(states.STARTED),
+        )
+        self.assertGreater(
+            states.state(states.SUCCESS), states.state('CRASHED'),
+        )
+        self.assertGreater(
+            states.state(states.FAILURE), states.state('CRASHED'),
+        )
+        self.assertLessEqual(
+            states.state(states.REVOKED), states.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(
+            states.state(states.PENDING), states.state(states.SUCCESS),
+        )
+        self.assertLess(
+            states.state(states.RECEIVED), states.state(states.FAILURE),
+        )
+        self.assertLess(
+            states.state(states.STARTED), states.state(states.REVOKED),
+        )
+        self.assertLess(
+            states.state('CRASHED'), states.state(states.SUCCESS),
+        )
+        self.assertLess(
+            states.state('CRASHED'), states.state(states.FAILURE),
+        )
+        self.assertLess(
+            states.state(states.REVOKED), states.state('CRASHED'),
+        )
+        self.assertLessEqual(
+            states.state(states.REVOKED), states.state('CRASHED'),
+        )
+        self.assertGreaterEqual(
+            states.state('CRASHED'), states.state(states.REVOKED),
+        )

celery/tests/utils/test_saferef.py

@@ -53,7 +53,7 @@ class SaferefTests(Case):
 
         """
         for t in self.ts[:50]:
-            self.assertTrue(safe_ref(t.x) in self.ss)
+            self.assertIn(safe_ref(t.x), self.ss)
 
     def test_valid(self):
         """test_value