diff --git a/taskflow/tests/test_examples.py b/taskflow/tests/test_examples.py
index ce795dd0..62142909 100644
--- a/taskflow/tests/test_examples.py
+++ b/taskflow/tests/test_examples.py
@@ -132,7 +132,7 @@ class ExamplesTestCase(test.TestCase):
             # replace them with some constant string
             output = UUID_RE.sub('<SOME UUID>', output)
             expected_output = UUID_RE.sub('<SOME UUID>', expected_output)
-            self.assertEqual(output, expected_output)
+            self.assertEqual(expected_output, output)
 
 
 def make_output_files():
diff --git a/taskflow/tests/unit/test_arguments_passing.py b/taskflow/tests/unit/test_arguments_passing.py
index 2cde1dea..8676412d 100644
--- a/taskflow/tests/unit/test_arguments_passing.py
+++ b/taskflow/tests/unit/test_arguments_passing.py
@@ -30,24 +30,24 @@ class ArgumentsPassingTest(utils.EngineTestBase):
         flow = utils.TaskOneReturn(name='task1', provides='first_data')
         engine = self._make_engine(flow)
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'first_data': 1})
+        self.assertEqual({'first_data': 1}, engine.storage.fetch_all())
 
     def test_save_all_in_one(self):
         flow = utils.TaskMultiReturn(provides='all_data')
         engine = self._make_engine(flow)
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(),
-                         {'all_data': (1, 3, 5)})
+        self.assertEqual({'all_data': (1, 3, 5)},
+                         engine.storage.fetch_all())
 
     def test_save_several_values(self):
         flow = utils.TaskMultiReturn(provides=('badger', 'mushroom', 'snake'))
         engine = self._make_engine(flow)
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {
+        self.assertEqual({
             'badger': 1,
             'mushroom': 3,
             'snake': 5
-        })
+        }, engine.storage.fetch_all())
 
     def test_save_dict(self):
         flow = utils.TaskMultiDict(provides=set(['badger',
@@ -55,11 +55,11 @@ class ArgumentsPassingTest(utils.EngineTestBase):
                                                  'snake']))
         engine = self._make_engine(flow)
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {
+        self.assertEqual({
             'badger': 0,
             'mushroom': 1,
             'snake': 2,
-        })
+        }, engine.storage.fetch_all())
 
     def test_bad_save_as_value(self):
         self.assertRaises(TypeError,
@@ -71,10 +71,10 @@ class ArgumentsPassingTest(utils.EngineTestBase):
         engine = self._make_engine(flow)
         engine.storage.inject({'x': 1, 'y': 4, 'z': 9, 'a': 17})
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {
+        self.assertEqual({
             'x': 1, 'y': 4, 'z': 9, 'a': 17,
             'result': 14,
-        })
+        }, engine.storage.fetch_all())
 
     def test_arguments_missing(self):
         flow = utils.TaskMultiArg()
@@ -88,19 +88,19 @@ class ArgumentsPassingTest(utils.EngineTestBase):
         engine = self._make_engine(flow)
         engine.storage.inject({'x': 1, 'y': 4, 'z': 9, 'a': 17})
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {
+        self.assertEqual({
             'x': 1, 'y': 4, 'z': 9, 'a': 17,
             'result': 30,
-        })
+        }, engine.storage.fetch_all())
 
     def test_argument_injection(self):
         flow = utils.TaskMultiArgOneReturn(provides='result',
                                            inject={'x': 1, 'y': 4, 'z': 9})
         engine = self._make_engine(flow)
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {
+        self.assertEqual({
             'result': 14,
-        })
+        }, engine.storage.fetch_all())
 
     def test_argument_injection_rebind(self):
         flow = utils.TaskMultiArgOneReturn(provides='result',
@@ -108,9 +108,9 @@ class ArgumentsPassingTest(utils.EngineTestBase):
                                            inject={'a': 1, 'b': 4, 'c': 9})
         engine = self._make_engine(flow)
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {
+        self.assertEqual({
             'result': 14,
-        })
+        }, engine.storage.fetch_all())
 
     def test_argument_injection_required(self):
         flow = utils.TaskMultiArgOneReturn(provides='result',
@@ -119,9 +119,9 @@ class ArgumentsPassingTest(utils.EngineTestBase):
                                                    'a': 0, 'b': 0, 'c': 0})
         engine = self._make_engine(flow)
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {
+        self.assertEqual({
             'result': 14,
-        })
+        }, engine.storage.fetch_all())
 
     def test_all_arguments_mapping(self):
         flow = utils.TaskMultiArgOneReturn(provides='result',
@@ -131,10 +131,10 @@ class ArgumentsPassingTest(utils.EngineTestBase):
             'a': 1, 'b': 2, 'c': 3, 'x': 4, 'y': 5, 'z': 6
         })
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {
+        self.assertEqual({
             'a': 1, 'b': 2, 'c': 3, 'x': 4, 'y': 5, 'z': 6,
             'result': 6,
-        })
+        }, engine.storage.fetch_all())
 
     def test_invalid_argument_name_map(self):
         flow = utils.TaskMultiArg(rebind={'z': 'b'})
@@ -159,9 +159,9 @@ class ArgumentsPassingTest(utils.EngineTestBase):
         engine = self._make_engine(flow)
         engine.storage.inject({'long_arg_name': 1})
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {
+        self.assertEqual({
             'long_arg_name': 1, 'result': 1
-        })
+        }, engine.storage.fetch_all())
 
 
 class SerialEngineTest(ArgumentsPassingTest, test.TestCase):
diff --git a/taskflow/tests/unit/test_engine_helpers.py b/taskflow/tests/unit/test_engine_helpers.py
index 64be04b6..60fa7558 100644
--- a/taskflow/tests/unit/test_engine_helpers.py
+++ b/taskflow/tests/unit/test_engine_helpers.py
@@ -85,7 +85,7 @@ class FlowFromDetailTestCase(test.TestCase):
                         return_value=lambda: 'RESULT') as mock_import:
             result = taskflow.engines.flow_from_detail(flow_detail)
             mock_import.assert_called_once_with(name)
-        self.assertEqual(result, 'RESULT')
+        self.assertEqual('RESULT', result)
 
     def test_factory_with_arg(self):
         name = 'some.test.factory'
@@ -96,7 +96,7 @@ class FlowFromDetailTestCase(test.TestCase):
                         return_value=lambda x: 'RESULT %s' % x) as mock_import:
             result = taskflow.engines.flow_from_detail(flow_detail)
             mock_import.assert_called_once_with(name)
-        self.assertEqual(result, 'RESULT foo')
+        self.assertEqual('RESULT foo', result)
 
 
 def my_flow_factory(task_name):
@@ -121,12 +121,12 @@ class LoadFromFactoryTestCase(test.TestCase):
         self.assertIsInstance(engine._flow, test_utils.DummyTask)
 
         fd = engine.storage._flowdetail
-        self.assertEqual(fd.name, 'test1')
-        self.assertEqual(fd.meta.get('factory'), {
+        self.assertEqual('test1', fd.name)
+        self.assertEqual({
             'name': '%s.my_flow_factory' % __name__,
             'args': [],
             'kwargs': {'task_name': 'test1'},
-        })
+        }, fd.meta.get('factory'))
 
     def test_it_works_by_name(self):
         factory_name = '%s.my_flow_factory' % __name__
@@ -135,9 +135,9 @@ class LoadFromFactoryTestCase(test.TestCase):
         self.assertIsInstance(engine._flow, test_utils.DummyTask)
 
         fd = engine.storage._flowdetail
-        self.assertEqual(fd.name, 'test1')
-        self.assertEqual(fd.meta.get('factory'), {
+        self.assertEqual('test1', fd.name)
+        self.assertEqual({
             'name': factory_name,
             'args': [],
             'kwargs': {'task_name': 'test1'},
-        })
+        }, fd.meta.get('factory'))
diff --git a/taskflow/tests/unit/test_engines.py b/taskflow/tests/unit/test_engines.py
index c56d7569..ba003aec 100644
--- a/taskflow/tests/unit/test_engines.py
+++ b/taskflow/tests/unit/test_engines.py
@@ -72,14 +72,14 @@ class EngineTaskTest(object):
         with utils.CaptureListener(engine, values=values) as capturer:
             self.assertFailuresRegexp(RuntimeError, '^Woot', engine.run)
         self.assertEqual(expected, capturer.values)
-        self.assertEqual(engine.storage.get_flow_state(), states.REVERTED)
+        self.assertEqual(states.REVERTED, engine.storage.get_flow_state())
         with utils.CaptureListener(engine, values=values) as capturer:
             self.assertFailuresRegexp(RuntimeError, '^Woot', engine.run)
         now_expected = list(expected)
         now_expected.extend(['fail.t PENDING', 'fail.f PENDING'])
         now_expected.extend(expected)
         self.assertEqual(now_expected, values)
-        self.assertEqual(engine.storage.get_flow_state(), states.REVERTED)
+        self.assertEqual(states.REVERTED, engine.storage.get_flow_state())
 
     def test_invalid_flow_raises(self):
 
@@ -123,33 +123,33 @@ class EngineOptionalRequirementsTest(utils.EngineTestBase):
         engine = self._make_engine(flow_no_inject, store={'a': 3})
         engine.run()
         result = engine.storage.fetch_all()
-        self.assertEqual(result, {'a': 3, 'result': 15})
+        self.assertEqual({'a': 3, 'result': 15}, result)
 
         engine = self._make_engine(flow_no_inject,
                                    store={'a': 3, 'b': 7})
         engine.run()
         result = engine.storage.fetch_all()
-        self.assertEqual(result, {'a': 3, 'b': 7, 'result': 21})
+        self.assertEqual({'a': 3, 'b': 7, 'result': 21}, result)
 
         engine = self._make_engine(flow_inject_a, store={'a': 3})
         engine.run()
         result = engine.storage.fetch_all()
-        self.assertEqual(result, {'a': 3, 'result': 50})
+        self.assertEqual({'a': 3, 'result': 50}, result)
 
         engine = self._make_engine(flow_inject_a, store={'a': 3, 'b': 7})
         engine.run()
         result = engine.storage.fetch_all()
-        self.assertEqual(result, {'a': 3, 'b': 7, 'result': 70})
+        self.assertEqual({'a': 3, 'b': 7, 'result': 70}, result)
 
         engine = self._make_engine(flow_inject_b, store={'a': 3})
         engine.run()
         result = engine.storage.fetch_all()
-        self.assertEqual(result, {'a': 3, 'result': 3000})
+        self.assertEqual({'a': 3, 'result': 3000}, result)
 
         engine = self._make_engine(flow_inject_b, store={'a': 3, 'b': 7})
         engine.run()
         result = engine.storage.fetch_all()
-        self.assertEqual(result, {'a': 3, 'b': 7, 'result': 3000})
+        self.assertEqual({'a': 3, 'b': 7, 'result': 3000}, result)
 
 
 class EngineMultipleResultsTest(utils.EngineTestBase):
@@ -160,7 +160,7 @@ class EngineMultipleResultsTest(utils.EngineTestBase):
         engine = self._make_engine(flow)
         engine.run()
         result = engine.storage.fetch('x')
-        self.assertEqual(result, 1)
+        self.assertEqual(1, result)
 
     def test_many_results_visible_to(self):
         flow = lf.Flow("flow")
@@ -223,7 +223,7 @@ class EngineMultipleResultsTest(utils.EngineTestBase):
         engine = self._make_engine(flow, store={'x': 0})
         engine.run()
         result = engine.storage.fetch('x')
-        self.assertEqual(result, 0)
+        self.assertEqual(0, result)
 
     def test_fetch_all_with_a_single_result(self):
         flow = lf.Flow("flow")
@@ -232,7 +232,7 @@ class EngineMultipleResultsTest(utils.EngineTestBase):
         engine = self._make_engine(flow)
         engine.run()
         result = engine.storage.fetch_all()
-        self.assertEqual(result, {'x': 1})
+        self.assertEqual({'x': 1}, result)
 
     def test_fetch_all_with_two_results(self):
         flow = lf.Flow("flow")
@@ -241,7 +241,7 @@ class EngineMultipleResultsTest(utils.EngineTestBase):
         engine = self._make_engine(flow, store={'x': 0})
         engine.run()
         result = engine.storage.fetch_all()
-        self.assertEqual(result, {'x': [0, 1]})
+        self.assertEqual({'x': [0, 1]}, result)
 
     def test_task_can_update_value(self):
         flow = lf.Flow("flow")
@@ -250,7 +250,7 @@ class EngineMultipleResultsTest(utils.EngineTestBase):
         engine = self._make_engine(flow, store={'x': 0})
         engine.run()
         result = engine.storage.fetch_all()
-        self.assertEqual(result, {'x': [0, 1]})
+        self.assertEqual({'x': [0, 1]}, result)
 
 
 class EngineLinearFlowTest(utils.EngineTestBase):
@@ -315,7 +315,7 @@ class EngineLinearFlowTest(utils.EngineTestBase):
         expected = ['task1.t RUNNING', 'task1.t SUCCESS(5)',
                     'task2.t RUNNING', 'task2.t SUCCESS(5)']
         self.assertEqual(expected, capturer.values)
-        self.assertEqual(len(flow), 2)
+        self.assertEqual(2, len(flow))
 
     def test_sequential_flow_two_tasks_iter(self):
         flow = lf.Flow('flow-2').add(
@@ -329,7 +329,7 @@ class EngineLinearFlowTest(utils.EngineTestBase):
         expected = ['task1.t RUNNING', 'task1.t SUCCESS(5)',
                     'task2.t RUNNING', 'task2.t SUCCESS(5)']
         self.assertEqual(expected, capturer.values)
-        self.assertEqual(len(flow), 2)
+        self.assertEqual(2, len(flow))
 
     def test_sequential_flow_iter_suspend_resume(self):
         flow = lf.Flow('flow-2').add(
@@ -373,7 +373,7 @@ class EngineLinearFlowTest(utils.EngineTestBase):
         )
         engine = self._make_engine(flow)
         self.assertFailuresRegexp(RuntimeError, '^Woot', engine.run)
-        self.assertEqual(engine.storage.fetch_all(), {})
+        self.assertEqual({}, engine.storage.fetch_all())
 
     def test_revert_provided(self):
         flow = lf.Flow('revert').add(
@@ -382,7 +382,7 @@ class EngineLinearFlowTest(utils.EngineTestBase):
         )
         engine = self._make_engine(flow, store={'value': 0})
         self.assertFailuresRegexp(RuntimeError, '^Woot', engine.run)
-        self.assertEqual(engine.storage.get_revert_result('giver'), 2)
+        self.assertEqual(2, engine.storage.get_revert_result('giver'))
 
     def test_nasty_revert(self):
         flow = lf.Flow('revert').add(
@@ -470,7 +470,7 @@ class EngineParallelFlowTest(utils.EngineTestBase):
             engine.run()
         expected = ['task1.t RUNNING', 'task1.t SUCCESS(5)']
         self.assertEqual(expected, capturer.values)
-        self.assertEqual(engine.storage.fetch_all(), {'a': 5})
+        self.assertEqual({'a': 5}, engine.storage.fetch_all())
 
     def test_parallel_flow_two_tasks(self):
         flow = uf.Flow('p-2').add(
@@ -533,8 +533,8 @@ class EngineParallelFlowTest(utils.EngineTestBase):
             engine.run()
         expected = ['task2.t RUNNING', 'task2.t SUCCESS(5)']
         self.assertEqual(expected, capturer.values)
-        self.assertEqual(engine.storage.fetch_all(),
-                         {'x1': 17, 'x2': 5})
+        self.assertEqual({'x1': 17, 'x2': 5},
+                         engine.storage.fetch_all())
 
 
 class EngineLinearAndUnorderedExceptionsTest(utils.EngineTestBase):
@@ -670,7 +670,7 @@ class EngineGraphFlowTest(utils.EngineTestBase):
         expected = set(['task2.t SUCCESS(5)', 'task2.t RUNNING',
                         'task1.t RUNNING', 'task1.t SUCCESS(5)'])
         self.assertEqual(expected, set(capturer.values))
-        self.assertEqual(len(flow), 2)
+        self.assertEqual(2, len(flow))
 
     def test_graph_flow_two_tasks(self):
         flow = gf.Flow('g-1-1').add(
@@ -728,7 +728,7 @@ class EngineGraphFlowTest(utils.EngineTestBase):
                     'task1.t REVERTING',
                     'task1.t REVERTED(None)']
         self.assertEqual(expected, capturer.values)
-        self.assertEqual(engine.storage.get_flow_state(), states.REVERTED)
+        self.assertEqual(states.REVERTED, engine.storage.get_flow_state())
 
     def test_graph_flow_four_tasks_revert_failure(self):
         flow = gf.Flow('g-3-nasty').add(
@@ -738,7 +738,7 @@ class EngineGraphFlowTest(utils.EngineTestBase):
 
         engine = self._make_engine(flow)
         self.assertFailuresRegexp(RuntimeError, '^Gotcha', engine.run)
-        self.assertEqual(engine.storage.get_flow_state(), states.FAILURE)
+        self.assertEqual(states.FAILURE, engine.storage.get_flow_state())
 
     def test_graph_flow_with_multireturn_and_multiargs_tasks(self):
         flow = gf.Flow('g-3-multi').add(
@@ -751,14 +751,14 @@ class EngineGraphFlowTest(utils.EngineTestBase):
         engine = self._make_engine(flow)
         engine.storage.inject({'x': 30})
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {
+        self.assertEqual({
             'a': 1,
             'b': 3,
             'c': 5,
             'x': 30,
             'y': 38,
             'z': 42
-        })
+        }, engine.storage.fetch_all())
 
     def test_task_graph_property(self):
         flow = gf.Flow('test').add(
@@ -1110,11 +1110,11 @@ class EngineCheckingTaskTest(utils.EngineTestBase):
                 return 'RESULT'
 
             def revert(m_self, result, flow_failures):
-                self.assertEqual(result, 'RESULT')
-                self.assertEqual(list(flow_failures.keys()), ['fail1'])
+                self.assertEqual('RESULT', result)
+                self.assertEqual(['fail1'], list(flow_failures.keys()))
                 fail = flow_failures['fail1']
                 self.assertIsInstance(fail, failure.Failure)
-                self.assertEqual(str(fail), 'Failure: RuntimeError: Woot!')
+                self.assertEqual('Failure: RuntimeError: Woot!', str(fail))
 
         flow = lf.Flow('test').add(
             CheckingTask(),
diff --git a/taskflow/tests/unit/test_failure.py b/taskflow/tests/unit/test_failure.py
index 9e5b4f79..4ecfa5c5 100644
--- a/taskflow/tests/unit/test_failure.py
+++ b/taskflow/tests/unit/test_failure.py
@@ -44,15 +44,15 @@ def _make_exc_info(msg):
 class GeneralFailureObjTestsMixin(object):
 
     def test_captures_message(self):
-        self.assertEqual(self.fail_obj.exception_str, 'Woot!')
+        self.assertEqual('Woot!', self.fail_obj.exception_str)
 
     def test_str(self):
-        self.assertEqual(str(self.fail_obj),
-                         'Failure: RuntimeError: Woot!')
+        self.assertEqual('Failure: RuntimeError: Woot!',
+                         str(self.fail_obj))
 
     def test_exception_types(self):
-        self.assertEqual(list(self.fail_obj),
-                         test_utils.RUNTIME_ERROR_CLASSES[:-2])
+        self.assertEqual(test_utils.RUNTIME_ERROR_CLASSES[:-2],
+                         list(self.fail_obj))
 
     def test_pformat_no_traceback(self):
         text = self.fail_obj.pformat()
@@ -60,11 +60,11 @@ class GeneralFailureObjTestsMixin(object):
 
     def test_check_str(self):
         val = 'Exception'
-        self.assertEqual(self.fail_obj.check(val), val)
+        self.assertEqual(val, self.fail_obj.check(val))
 
     def test_check_str_not_there(self):
         val = 'ValueError'
-        self.assertEqual(self.fail_obj.check(val), None)
+        self.assertEqual(None, self.fail_obj.check(val))
 
     def test_check_type(self):
         self.assertIs(self.fail_obj.check(RuntimeError), RuntimeError)
@@ -84,8 +84,8 @@ class CaptureFailureTestCase(test.TestCase, GeneralFailureObjTestsMixin):
 
     def test_captures_exc_info(self):
         exc_info = self.fail_obj.exc_info
-        self.assertEqual(len(exc_info), 3)
-        self.assertEqual(exc_info[0], RuntimeError)
+        self.assertEqual(3, len(exc_info))
+        self.assertEqual(RuntimeError, exc_info[0])
         self.assertIs(exc_info[1], self.fail_obj.exception)
 
     def test_reraises(self):
@@ -181,7 +181,7 @@ class FailureObjectTestCase(test.TestCase):
                                 exc_type_names=['Exception'],
                                 hi='hi there')
         expected = "Failure.__init__ got unexpected keyword argument(s): hi"
-        self.assertEqual(str(exc), expected)
+        self.assertEqual(expected, str(exc))
 
     def test_empty_does_not_reraise(self):
         self.assertIs(failure.Failure.reraise_if_any([]), None)
@@ -198,7 +198,7 @@ class FailureObjectTestCase(test.TestCase):
         ]
         exc = self.assertRaises(exceptions.WrappedFailure,
                                 failure.Failure.reraise_if_any, fls)
-        self.assertEqual(list(exc), fls)
+        self.assertEqual(fls, list(exc))
 
     def test_failure_copy(self):
         fail_obj = _captured_failure('Woot!')
@@ -267,14 +267,14 @@ class WrappedFailureTestCase(test.TestCase):
     def test_simple_iter(self):
         fail_obj = _captured_failure('Woot!')
         wf = exceptions.WrappedFailure([fail_obj])
-        self.assertEqual(len(wf), 1)
-        self.assertEqual(list(wf), [fail_obj])
+        self.assertEqual(1, len(wf))
+        self.assertEqual([fail_obj], list(wf))
 
     def test_simple_check(self):
         fail_obj = _captured_failure('Woot!')
         wf = exceptions.WrappedFailure([fail_obj])
-        self.assertEqual(wf.check(RuntimeError), RuntimeError)
-        self.assertEqual(wf.check(ValueError), None)
+        self.assertEqual(RuntimeError, wf.check(RuntimeError))
+        self.assertEqual(None, wf.check(ValueError))
 
     def test_two_failures(self):
         fls = [
@@ -282,8 +282,8 @@ class WrappedFailureTestCase(test.TestCase):
             _captured_failure('Oh, not again!')
         ]
         wf = exceptions.WrappedFailure(fls)
-        self.assertEqual(len(wf), 2)
-        self.assertEqual(list(wf), fls)
+        self.assertEqual(2, len(wf))
+        self.assertEqual(fls, list(wf))
 
     def test_flattening(self):
         f1 = _captured_failure('Wrap me')
@@ -295,7 +295,7 @@ class WrappedFailureTestCase(test.TestCase):
             fail_obj = failure.Failure()
 
         wf = exceptions.WrappedFailure([fail_obj, f3])
-        self.assertEqual(list(wf), [f1, f2, f3])
+        self.assertEqual([f1, f2, f3], list(wf))
 
 
 class NonAsciiExceptionsTestCase(test.TestCase):
@@ -304,8 +304,8 @@ class NonAsciiExceptionsTestCase(test.TestCase):
         bad_string = chr(200)
         excp = ValueError(bad_string)
         fail = failure.Failure.from_exception(excp)
-        self.assertEqual(fail.exception_str,
-                         encodeutils.exception_to_unicode(excp))
+        self.assertEqual(encodeutils.exception_to_unicode(excp),
+                         fail.exception_str)
         # This is slightly different on py2 vs py3... due to how
         # __str__ or __unicode__ is called and what is expected from
         # both...
@@ -314,15 +314,15 @@ class NonAsciiExceptionsTestCase(test.TestCase):
             expected = 'Failure: ValueError: %s' % msg.encode('utf-8')
         else:
             expected = u'Failure: ValueError: \xc8'
-        self.assertEqual(str(fail), expected)
+        self.assertEqual(expected, str(fail))
 
     def test_exception_non_ascii_unicode(self):
         hi_ru = u'привет'
         fail = failure.Failure.from_exception(ValueError(hi_ru))
-        self.assertEqual(fail.exception_str, hi_ru)
+        self.assertEqual(hi_ru, fail.exception_str)
         self.assertIsInstance(fail.exception_str, six.text_type)
-        self.assertEqual(six.text_type(fail),
-                         u'Failure: ValueError: %s' % hi_ru)
+        self.assertEqual(u'Failure: ValueError: %s' % hi_ru,
+                         six.text_type(fail))
 
     def test_wrapped_failure_non_ascii_unicode(self):
         hi_cn = u'嗨'
diff --git a/taskflow/tests/unit/test_flow_dependencies.py b/taskflow/tests/unit/test_flow_dependencies.py
index bdb427d9..54f857bf 100644
--- a/taskflow/tests/unit/test_flow_dependencies.py
+++ b/taskflow/tests/unit/test_flow_dependencies.py
@@ -66,29 +66,29 @@ class FlowDependenciesTest(test.TestCase):
         flow = lf.Flow('lf').add(
             utils.TaskOneArg('task1'),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(flow.requires, set(['x', 'y', 'z']))
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(['x', 'y', 'z']), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_linear_flow_requires_rebind_values(self):
         flow = lf.Flow('lf').add(
             utils.TaskOneArg('task1', rebind=['q']),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(flow.requires, set(['x', 'y', 'z', 'q']))
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(['x', 'y', 'z', 'q']), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_linear_flow_provides_values(self):
         flow = lf.Flow('lf').add(
             utils.TaskOneReturn('task1', provides='x'),
             utils.TaskMultiReturn('task2', provides=['a', 'b', 'c']))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set(['x', 'a', 'b', 'c']))
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(['x', 'a', 'b', 'c']), flow.provides)
 
     def test_linear_flow_provides_required_values(self):
         flow = lf.Flow('lf').add(
             utils.TaskOneReturn('task1', provides='x'),
             utils.TaskOneArg('task2'))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set(['x']))
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(['x']), flow.provides)
 
     def test_linear_flow_multi_provides_and_requires_values(self):
         flow = lf.Flow('lf').add(
@@ -97,36 +97,36 @@ class FlowDependenciesTest(test.TestCase):
                                           provides=['x', 'y', 'q']),
             utils.TaskMultiArgMultiReturn('task2',
                                           provides=['i', 'j', 'k']))
-        self.assertEqual(flow.requires, set(['a', 'b', 'c', 'z']))
-        self.assertEqual(flow.provides, set(['x', 'y', 'q', 'i', 'j', 'k']))
+        self.assertEqual(set(['a', 'b', 'c', 'z']), flow.requires)
+        self.assertEqual(set(['x', 'y', 'q', 'i', 'j', 'k']), flow.provides)
 
     def test_unordered_flow_without_dependencies(self):
         flow = uf.Flow('uf').add(
             utils.TaskNoRequiresNoReturns('task1'),
             utils.TaskNoRequiresNoReturns('task2'))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_unordered_flow_requires_values(self):
         flow = uf.Flow('uf').add(
             utils.TaskOneArg('task1'),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(flow.requires, set(['x', 'y', 'z']))
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(['x', 'y', 'z']), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_unordered_flow_requires_rebind_values(self):
         flow = uf.Flow('uf').add(
             utils.TaskOneArg('task1', rebind=['q']),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(flow.requires, set(['x', 'y', 'z', 'q']))
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(['x', 'y', 'z', 'q']), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_unordered_flow_provides_values(self):
         flow = uf.Flow('uf').add(
             utils.TaskOneReturn('task1', provides='x'),
             utils.TaskMultiReturn('task2', provides=['a', 'b', 'c']))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set(['x', 'a', 'b', 'c']))
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(['x', 'a', 'b', 'c']), flow.provides)
 
     def test_unordered_flow_provides_required_values(self):
         flow = uf.Flow('uf')
@@ -159,8 +159,8 @@ class FlowDependenciesTest(test.TestCase):
                                           provides=['d', 'e', 'f']),
             utils.TaskMultiArgMultiReturn('task2',
                                           provides=['i', 'j', 'k']))
-        self.assertEqual(flow.requires, set(['a', 'b', 'c', 'x', 'y', 'z']))
-        self.assertEqual(flow.provides, set(['d', 'e', 'f', 'i', 'j', 'k']))
+        self.assertEqual(set(['a', 'b', 'c', 'x', 'y', 'z']), flow.requires)
+        self.assertEqual(set(['d', 'e', 'f', 'i', 'j', 'k']), flow.provides)
 
     def test_unordered_flow_provides_same_values(self):
         flow = uf.Flow('uf').add(utils.TaskOneReturn(provides='x'))
@@ -184,36 +184,36 @@ class FlowDependenciesTest(test.TestCase):
                                           rebind=['b'], provides=['z']),
                 utils.TaskOneArgOneReturn('task4', rebind=['c'],
                                           provides=['q'])))
-        self.assertEqual(flow.requires, set(['a', 'b', 'c']))
-        self.assertEqual(flow.provides, set(['x', 'y', 'z', 'q']))
+        self.assertEqual(set(['a', 'b', 'c']), flow.requires)
+        self.assertEqual(set(['x', 'y', 'z', 'q']), flow.provides)
 
     def test_graph_flow_requires_values(self):
         flow = gf.Flow('gf').add(
             utils.TaskOneArg('task1'),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(flow.requires, set(['x', 'y', 'z']))
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(['x', 'y', 'z']), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_graph_flow_requires_rebind_values(self):
         flow = gf.Flow('gf').add(
             utils.TaskOneArg('task1', rebind=['q']),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(flow.requires, set(['x', 'y', 'z', 'q']))
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(['x', 'y', 'z', 'q']), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_graph_flow_provides_values(self):
         flow = gf.Flow('gf').add(
             utils.TaskOneReturn('task1', provides='x'),
             utils.TaskMultiReturn('task2', provides=['a', 'b', 'c']))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set(['x', 'a', 'b', 'c']))
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(['x', 'a', 'b', 'c']), flow.provides)
 
     def test_graph_flow_provides_required_values(self):
         flow = gf.Flow('gf').add(
             utils.TaskOneReturn('task1', provides='x'),
             utils.TaskOneArg('task2'))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set(['x']))
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(['x']), flow.provides)
 
     def test_graph_flow_provides_provided_value_other_call(self):
         flow = gf.Flow('gf')
@@ -228,8 +228,8 @@ class FlowDependenciesTest(test.TestCase):
                                           provides=['d', 'e', 'f']),
             utils.TaskMultiArgMultiReturn('task2',
                                           provides=['i', 'j', 'k']))
-        self.assertEqual(flow.requires, set(['a', 'b', 'c', 'x', 'y', 'z']))
-        self.assertEqual(flow.provides, set(['d', 'e', 'f', 'i', 'j', 'k']))
+        self.assertEqual(set(['a', 'b', 'c', 'x', 'y', 'z']), flow.requires)
+        self.assertEqual(set(['d', 'e', 'f', 'i', 'j', 'k']), flow.provides)
 
     def test_graph_cyclic_dependency(self):
         flow = gf.Flow('g-3-cyclic')
@@ -245,81 +245,81 @@ class FlowDependenciesTest(test.TestCase):
     def test_task_requires_and_provides_same_values(self):
         flow = lf.Flow('lf', utils.TaskOneArgOneReturn('rt', requires='x',
                                                        provides='x'))
-        self.assertEqual(flow.requires, set('x'))
-        self.assertEqual(flow.provides, set('x'))
+        self.assertEqual(set('x'), flow.requires)
+        self.assertEqual(set('x'), flow.provides)
 
     def test_retry_in_linear_flow_no_requirements_no_provides(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt'))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_retry_in_linear_flow_with_requirements(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt', requires=['x', 'y']))
-        self.assertEqual(flow.requires, set(['x', 'y']))
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(['x', 'y']), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_retry_in_linear_flow_with_provides(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt', provides=['x', 'y']))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set(['x', 'y']))
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(['x', 'y']), flow.provides)
 
     def test_retry_in_linear_flow_requires_and_provides(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt',
                                                 requires=['x', 'y'],
                                                 provides=['a', 'b']))
-        self.assertEqual(flow.requires, set(['x', 'y']))
-        self.assertEqual(flow.provides, set(['a', 'b']))
+        self.assertEqual(set(['x', 'y']), flow.requires)
+        self.assertEqual(set(['a', 'b']), flow.provides)
 
     def test_retry_requires_and_provides_same_value(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt',
                                                 requires=['x', 'y'],
                                                 provides=['x', 'y']))
-        self.assertEqual(flow.requires, set(['x', 'y']))
-        self.assertEqual(flow.provides, set(['x', 'y']))
+        self.assertEqual(set(['x', 'y']), flow.requires)
+        self.assertEqual(set(['x', 'y']), flow.provides)
 
     def test_retry_in_unordered_flow_no_requirements_no_provides(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt'))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_retry_in_unordered_flow_with_requirements(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt', requires=['x', 'y']))
-        self.assertEqual(flow.requires, set(['x', 'y']))
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(['x', 'y']), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_retry_in_unordered_flow_with_provides(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt', provides=['x', 'y']))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set(['x', 'y']))
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(['x', 'y']), flow.provides)
 
     def test_retry_in_unordered_flow_requires_and_provides(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt',
                                                 requires=['x', 'y'],
                                                 provides=['a', 'b']))
-        self.assertEqual(flow.requires, set(['x', 'y']))
-        self.assertEqual(flow.provides, set(['a', 'b']))
+        self.assertEqual(set(['x', 'y']), flow.requires)
+        self.assertEqual(set(['a', 'b']), flow.provides)
 
     def test_retry_in_graph_flow_no_requirements_no_provides(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt'))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_retry_in_graph_flow_with_requirements(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt', requires=['x', 'y']))
-        self.assertEqual(flow.requires, set(['x', 'y']))
-        self.assertEqual(flow.provides, set())
+        self.assertEqual(set(['x', 'y']), flow.requires)
+        self.assertEqual(set(), flow.provides)
 
     def test_retry_in_graph_flow_with_provides(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt', provides=['x', 'y']))
-        self.assertEqual(flow.requires, set())
-        self.assertEqual(flow.provides, set(['x', 'y']))
+        self.assertEqual(set(), flow.requires)
+        self.assertEqual(set(['x', 'y']), flow.provides)
 
     def test_retry_in_graph_flow_requires_and_provides(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt',
                                                 requires=['x', 'y'],
                                                 provides=['a', 'b']))
-        self.assertEqual(flow.requires, set(['x', 'y']))
-        self.assertEqual(flow.provides, set(['a', 'b']))
+        self.assertEqual(set(['x', 'y']), flow.requires)
+        self.assertEqual(set(['a', 'b']), flow.provides)
 
     def test_linear_flow_retry_and_task(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt',
@@ -328,8 +328,8 @@ class FlowDependenciesTest(test.TestCase):
         flow.add(utils.TaskMultiArgOneReturn(rebind=['a', 'x', 'c'],
                                              provides=['z']))
 
-        self.assertEqual(flow.requires, set(['x', 'y', 'c']))
-        self.assertEqual(flow.provides, set(['a', 'b', 'z']))
+        self.assertEqual(set(['x', 'y', 'c']), flow.requires)
+        self.assertEqual(set(['a', 'b', 'z']), flow.provides)
 
     def test_unordered_flow_retry_and_task(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt',
@@ -338,8 +338,8 @@ class FlowDependenciesTest(test.TestCase):
         flow.add(utils.TaskMultiArgOneReturn(rebind=['a', 'x', 'c'],
                                              provides=['z']))
 
-        self.assertEqual(flow.requires, set(['x', 'y', 'c']))
-        self.assertEqual(flow.provides, set(['a', 'b', 'z']))
+        self.assertEqual(set(['x', 'y', 'c']), flow.requires)
+        self.assertEqual(set(['a', 'b', 'z']), flow.provides)
 
     def test_unordered_flow_retry_and_task_same_requires_provides(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt', requires=['x']))
@@ -365,8 +365,8 @@ class FlowDependenciesTest(test.TestCase):
         flow.add(utils.TaskMultiArgOneReturn(rebind=['a', 'x', 'c'],
                                              provides=['z']))
 
-        self.assertEqual(flow.requires, set(['x', 'y', 'c']))
-        self.assertEqual(flow.provides, set(['a', 'b', 'z']))
+        self.assertEqual(set(['x', 'y', 'c']), flow.requires)
+        self.assertEqual(set(['a', 'b', 'z']), flow.provides)
 
     def test_graph_flow_retry_and_task_dependency_provide_require(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt', requires=['x']))
@@ -389,4 +389,4 @@ class FlowDependenciesTest(test.TestCase):
                 pass
 
         flow = lf.Flow('lf', retry=FullArgsRetry(requires='a'))
-        self.assertEqual(flow.requires, set(['a']))
+        self.assertEqual(set(['a']), flow.requires)
diff --git a/taskflow/tests/unit/test_functor_task.py b/taskflow/tests/unit/test_functor_task.py
index 2deed5fe..cc45720d 100644
--- a/taskflow/tests/unit/test_functor_task.py
+++ b/taskflow/tests/unit/test_functor_task.py
@@ -49,11 +49,11 @@ class FunctorTaskTest(test.TestCase):
 
     def test_simple(self):
         task = base.FunctorTask(add)
-        self.assertEqual(task.name, __name__ + '.add')
+        self.assertEqual(__name__ + '.add', task.name)
 
     def test_other_name(self):
         task = base.FunctorTask(add, name='my task')
-        self.assertEqual(task.name, 'my task')
+        self.assertEqual('my task', task.name)
 
     def test_it_runs(self):
         values = []
@@ -67,7 +67,7 @@ class FunctorTaskTest(test.TestCase):
         )
         self.assertRaisesRegexp(RuntimeError, '^Woot',
                                 taskflow.engines.run, flow)
-        self.assertEqual(values, ['one', 'fail', 'revert one'])
+        self.assertEqual(['one', 'fail', 'revert one'], values)
 
     def test_lambda_functors(self):
         t = base.FunctorTask
diff --git a/taskflow/tests/unit/test_progress.py b/taskflow/tests/unit/test_progress.py
index 943f93c0..7486c02b 100644
--- a/taskflow/tests/unit/test_progress.py
+++ b/taskflow/tests/unit/test_progress.py
@@ -117,11 +117,11 @@ class TestProgress(test.TestCase):
         end_progress = e.storage.get_task_progress("test")
         self.assertEqual(1.0, end_progress)
         end_details = e.storage.get_task_progress_details("test")
-        self.assertEqual(end_details.get('at_progress'), 0.5)
-        self.assertEqual(end_details.get('details'), {
+        self.assertEqual(0.5, end_details.get('at_progress'))
+        self.assertEqual({
             'test': 'test data',
             'foo': 'bar'
-        })
+        }, end_details.get('details'))
 
     def test_dual_storage_progress(self):
         fired_events = []
diff --git a/taskflow/tests/unit/test_retries.py b/taskflow/tests/unit/test_retries.py
index ce957b3a..6dc01851 100644
--- a/taskflow/tests/unit/test_retries.py
+++ b/taskflow/tests/unit/test_retries.py
@@ -53,19 +53,19 @@ class RetryTest(utils.EngineTestBase):
         flow = lf.Flow('flow-1', utils.OneReturnRetry(provides='x'))
         engine = self._make_engine(flow)
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'x': 1})
+        self.assertEqual({'x': 1}, engine.storage.fetch_all())
 
     def test_run_empty_unordered_flow(self):
         flow = uf.Flow('flow-1', utils.OneReturnRetry(provides='x'))
         engine = self._make_engine(flow)
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'x': 1})
+        self.assertEqual({'x': 1}, engine.storage.fetch_all())
 
     def test_run_empty_graph_flow(self):
         flow = gf.Flow('flow-1', utils.OneReturnRetry(provides='x'))
         engine = self._make_engine(flow)
         engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'x': 1})
+        self.assertEqual({'x': 1}, engine.storage.fetch_all())
 
     def test_states_retry_success_linear_flow(self):
         flow = lf.Flow('flow-1', retry.Times(4, 'r1', provides='x')).add(
@@ -76,7 +76,7 @@ class RetryTest(utils.EngineTestBase):
         engine.storage.inject({'y': 2})
         with utils.CaptureListener(engine) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2})
+        self.assertEqual({'y': 2, 'x': 2}, engine.storage.fetch_all())
         expected = ['flow-1.f RUNNING',
                     'r1.r RUNNING', 'r1.r SUCCESS(1)',
                     'task1.t RUNNING', 'task1.t SUCCESS(5)',
@@ -105,7 +105,7 @@ class RetryTest(utils.EngineTestBase):
         engine.storage.inject({'y': 4})
         with utils.CaptureListener(engine) as capturer:
             self.assertRaisesRegexp(RuntimeError, '^Woot', engine.run)
-        self.assertEqual(engine.storage.fetch_all(), {'y': 4})
+        self.assertEqual({'y': 4}, engine.storage.fetch_all())
         expected = ['flow-1.f RUNNING',
                     'r1.r RUNNING',
                     'r1.r SUCCESS(1)',
@@ -144,7 +144,7 @@ class RetryTest(utils.EngineTestBase):
         engine.storage.inject({'y': 4})
         with utils.CaptureListener(engine) as capturer:
             self.assertRaisesRegexp(RuntimeError, '^Gotcha', engine.run)
-        self.assertEqual(engine.storage.fetch_all(), {'y': 4, 'x': 1})
+        self.assertEqual({'y': 4, 'x': 1}, engine.storage.fetch_all())
         expected = ['flow-1.f RUNNING',
                     'r1.r RUNNING',
                     'r1.r SUCCESS(1)',
@@ -172,7 +172,7 @@ class RetryTest(utils.EngineTestBase):
         engine.storage.inject({'y': 2})
         with utils.CaptureListener(engine) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2})
+        self.assertEqual({'y': 2, 'x': 2}, engine.storage.fetch_all())
         expected = ['flow-1.f RUNNING',
                     'r1.r RUNNING',
                     'r1.r SUCCESS(None)',
@@ -215,8 +215,9 @@ class RetryTest(utils.EngineTestBase):
         engine.storage.inject({'y': 2})
         with utils.CaptureListener(engine) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x1': 2,
-                                                      'x2': 1})
+        self.assertEqual({'y': 2, 'x1': 2,
+                          'x2': 1},
+                         engine.storage.fetch_all())
         expected = ['flow-1.f RUNNING',
                     'r1.r RUNNING',
                     'r1.r SUCCESS(1)',
@@ -270,7 +271,7 @@ class RetryTest(utils.EngineTestBase):
         engine.storage.inject({'y': 2})
         with utils.CaptureListener(engine) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2})
+        self.assertEqual({'y': 2, 'x': 2}, engine.storage.fetch_all())
         expected = ['flow-1.f RUNNING',
                     'r.r RUNNING',
                     'r.r SUCCESS(1)',
@@ -305,7 +306,7 @@ class RetryTest(utils.EngineTestBase):
         engine.storage.inject({'y': 2})
         with utils.CaptureListener(engine) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2, 'x2': 1})
+        self.assertEqual({'y': 2, 'x': 2, 'x2': 1}, engine.storage.fetch_all())
         expected = ['flow-1.f RUNNING',
                     'r1.r RUNNING',
                     'r1.r SUCCESS(1)',
@@ -350,7 +351,7 @@ class RetryTest(utils.EngineTestBase):
                 engine.run()
             except Exception:
                 pass
-        self.assertEqual(engine.storage.fetch_all(), {'y': 2})
+        self.assertEqual({'y': 2}, engine.storage.fetch_all())
         expected = ['flow-1.f RUNNING',
                     'task1.t RUNNING',
                     'task1.t SUCCESS(5)',
@@ -379,7 +380,7 @@ class RetryTest(utils.EngineTestBase):
                 engine.run()
             except Exception:
                 pass
-        self.assertEqual(engine.storage.fetch_all(), {'y': 2})
+        self.assertEqual({'y': 2}, engine.storage.fetch_all())
         expected = ['flow-1.f RUNNING',
                     'task1.t RUNNING',
                     'task1.t SUCCESS(5)',
@@ -406,7 +407,7 @@ class RetryTest(utils.EngineTestBase):
         engine.storage.inject({'y': 2})
         with utils.CaptureListener(engine) as capturer:
             self.assertRaisesRegexp(RuntimeError, '^Woot', engine.run)
-        self.assertEqual(engine.storage.fetch_all(), {'y': 2})
+        self.assertEqual({'y': 2}, engine.storage.fetch_all())
         expected = ['flow-1.f RUNNING',
                     'r1.r RUNNING',
                     'r1.r SUCCESS(1)',
@@ -471,7 +472,7 @@ class RetryTest(utils.EngineTestBase):
                     't3.t RUNNING',
                     't3.t SUCCESS(5)',
                     'flow-1.f SUCCESS']
-        self.assertEqual(capturer.values, expected)
+        self.assertEqual(expected, capturer.values)
 
     def test_resume_flow_that_should_be_retried(self):
         flow = lf.Flow('flow-1', retry.Times(3, 'r1')).add(
@@ -525,7 +526,7 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t SUCCESS(5)',
                     'flow-1.f SUCCESS']
-        self.assertEqual(capturer.values, expected)
+        self.assertEqual(expected, capturer.values)
 
     def test_default_times_retry(self):
         flow = lf.Flow('flow-1', retry.Times(3, 'r1')).add(
@@ -1040,7 +1041,7 @@ class RetryTest(utils.EngineTestBase):
                     'task1.t RUNNING',
                     'task1.t SUCCESS(5)',
                     'flow-1.f SUCCESS']
-        self.assertEqual(capturer.values, expected)
+        self.assertEqual(expected, capturer.values)
 
     def test_retry_fails(self):
         r = FailingRetry()
@@ -1048,7 +1049,7 @@ class RetryTest(utils.EngineTestBase):
         engine = self._make_engine(flow)
         self.assertRaisesRegexp(ValueError, '^OMG', engine.run)
         self.assertEqual(1, len(engine.storage.get_retry_histories()))
-        self.assertEqual(len(r.history), 0)
+        self.assertEqual(0, len(r.history))
         self.assertEqual([], list(r.history.outcomes_iter()))
         self.assertIsNotNone(r.history.failure)
         self.assertTrue(r.history.caused_by(ValueError, include_retry=True))
@@ -1088,7 +1089,7 @@ class RetryTest(utils.EngineTestBase):
             'c.t FAILURE(Failure: RuntimeError: Woot!)',
             'b.t REVERTED(None)',
         ])
-        self.assertEqual(engine.storage.get_flow_state(), st.REVERTED)
+        self.assertEqual(st.REVERTED, engine.storage.get_flow_state())
 
     def test_nested_provides_graph_retried_correctly(self):
         flow = gf.Flow("test").add(
@@ -1123,7 +1124,7 @@ class RetryTest(utils.EngineTestBase):
                     'a.t SUCCESS(5)',
                     'c.t SUCCESS(5)']
         self.assertItemsEqual(expected, capturer.values[4:])
-        self.assertEqual(engine.storage.get_flow_state(), st.SUCCESS)
+        self.assertEqual(st.SUCCESS, engine.storage.get_flow_state())
 
 
 class RetryParallelExecutionTest(utils.EngineTestBase):
@@ -1142,7 +1143,7 @@ class RetryParallelExecutionTest(utils.EngineTestBase):
         engine.storage.inject({'y': 2})
         with utils.CaptureListener(engine, capture_flow=False) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2})
+        self.assertEqual({'y': 2, 'x': 2}, engine.storage.fetch_all())
         expected = ['r.r RUNNING',
                     'r.r SUCCESS(1)',
                     'task1.t RUNNING',
@@ -1178,7 +1179,7 @@ class RetryParallelExecutionTest(utils.EngineTestBase):
         engine.storage.inject({'y': 2})
         with utils.CaptureListener(engine, capture_flow=False) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2})
+        self.assertEqual({'y': 2, 'x': 2}, engine.storage.fetch_all())
         expected = ['r.r RUNNING',
                     'r.r SUCCESS(1)',
                     'task1.t RUNNING',
diff --git a/taskflow/tests/unit/test_storage.py b/taskflow/tests/unit/test_storage.py
index 0e1c47fc..53ca2106 100644
--- a/taskflow/tests/unit/test_storage.py
+++ b/taskflow/tests/unit/test_storage.py
@@ -63,13 +63,13 @@ class StorageTestMixin(object):
     def test_flow_name_and_uuid(self):
         flow_detail = models.FlowDetail(name='test-fd', uuid='aaaa')
         s = self._get_storage(flow_detail)
-        self.assertEqual(s.flow_name, 'test-fd')
-        self.assertEqual(s.flow_uuid, 'aaaa')
+        self.assertEqual('test-fd', s.flow_name)
+        self.assertEqual('aaaa', s.flow_uuid)
 
     def test_ensure_task(self):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task'))
-        self.assertEqual(s.get_atom_state('my task'), states.PENDING)
+        self.assertEqual(states.PENDING, s.get_atom_state('my task'))
         self.assertTrue(uuidutils.is_uuid_like(s.get_atom_uuid('my task')))
 
     def test_get_tasks_states(self):
@@ -81,7 +81,7 @@ class StorageTestMixin(object):
             'my task': (states.SUCCESS, states.EXECUTE),
             'my task2': (states.PENDING, states.EXECUTE),
         }
-        self.assertEqual(s.get_atoms_states(['my task', 'my task2']), expected)
+        self.assertEqual(expected, s.get_atoms_states(['my task', 'my task2']))
 
     def test_ensure_task_flow_detail(self):
         _lb, flow_detail = p_utils.temporary_flow_detail(self.backend)
@@ -91,9 +91,9 @@ class StorageTestMixin(object):
         s.ensure_atom(t)
         td = flow_detail.find(s.get_atom_uuid('my task'))
         self.assertIsNotNone(td)
-        self.assertEqual(td.name, 'my task')
-        self.assertEqual(td.version, '3.11')
-        self.assertEqual(td.state, states.PENDING)
+        self.assertEqual('my task', td.name)
+        self.assertEqual('3.11', td.version)
+        self.assertEqual(states.PENDING, td.state)
 
     def test_get_without_save(self):
         _lb, flow_detail = p_utils.temporary_flow_detail(self.backend)
@@ -114,26 +114,26 @@ class StorageTestMixin(object):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task'))
         s.save('my task', 5)
-        self.assertEqual(s.get('my task'), 5)
-        self.assertEqual(s.fetch_all(), {})
-        self.assertEqual(s.get_atom_state('my task'), states.SUCCESS)
+        self.assertEqual(5, s.get('my task'))
+        self.assertEqual({}, s.fetch_all())
+        self.assertEqual(states.SUCCESS, s.get_atom_state('my task'))
 
     def test_save_and_get_cached_failure(self):
         a_failure = failure.Failure.from_exception(RuntimeError('Woot!'))
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task'))
         s.save('my task', a_failure, states.FAILURE)
-        self.assertEqual(s.get('my task'), a_failure)
-        self.assertEqual(s.get_atom_state('my task'), states.FAILURE)
+        self.assertEqual(a_failure, s.get('my task'))
+        self.assertEqual(states.FAILURE, s.get_atom_state('my task'))
         self.assertTrue(s.has_failures())
-        self.assertEqual(s.get_failures(), {'my task': a_failure})
+        self.assertEqual({'my task': a_failure}, s.get_failures())
 
     def test_save_and_get_non_cached_failure(self):
         a_failure = failure.Failure.from_exception(RuntimeError('Woot!'))
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task'))
         s.save('my task', a_failure, states.FAILURE)
-        self.assertEqual(s.get('my task'), a_failure)
+        self.assertEqual(a_failure, s.get('my task'))
         s._failures['my task'] = {}
         self.assertTrue(a_failure.matches(s.get('my task')))
 
@@ -145,10 +145,10 @@ class StorageTestMixin(object):
         s.save('my task', a_failure, states.FAILURE)
 
         s.set_atom_state('my task', states.REVERTING)
-        self.assertEqual(s.get('my task'), a_failure)
+        self.assertEqual(a_failure, s.get('my task'))
 
         s.set_atom_state('my task', states.REVERTED)
-        self.assertEqual(s.get('my task'), a_failure)
+        self.assertEqual(a_failure, s.get('my task'))
 
     def test_get_failure_after_reload(self):
         a_failure = failure.Failure.from_exception(RuntimeError('Woot!'))
@@ -159,7 +159,7 @@ class StorageTestMixin(object):
         self.assertTrue(s2.has_failures())
         self.assertEqual(1, len(s2.get_failures()))
         self.assertTrue(a_failure.matches(s2.get('my task')))
-        self.assertEqual(s2.get_atom_state('my task'), states.FAILURE)
+        self.assertEqual(states.FAILURE, s2.get_atom_state('my task'))
 
     def test_get_non_existing_var(self):
         s = self._get_storage()
@@ -171,21 +171,21 @@ class StorageTestMixin(object):
         s.ensure_atom(test_utils.NoopTask('my task'))
         s.save('my task', 5)
         s.reset('my task')
-        self.assertEqual(s.get_atom_state('my task'), states.PENDING)
+        self.assertEqual(states.PENDING, s.get_atom_state('my task'))
         self.assertRaises(exceptions.NotFound, s.get, 'my task')
 
     def test_reset_unknown_task(self):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task'))
-        self.assertEqual(s.reset('my task'), None)
+        self.assertEqual(None, s.reset('my task'))
 
     def test_fetch_by_name(self):
         s = self._get_storage()
         name = 'my result'
         s.ensure_atom(test_utils.NoopTask('my task', provides=name))
         s.save('my task', 5)
-        self.assertEqual(s.fetch(name), 5)
-        self.assertEqual(s.fetch_all(), {name: 5})
+        self.assertEqual(5, s.fetch(name))
+        self.assertEqual({name: 5}, s.fetch_all())
 
     def test_fetch_unknown_name(self):
         s = self._get_storage()
@@ -203,108 +203,108 @@ class StorageTestMixin(object):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task'))
         s.update_atom_metadata('my task', None)
-        self.assertEqual(s.get_task_progress('my task'), 0.0)
+        self.assertEqual(0.0, s.get_task_progress('my task'))
         s.set_task_progress('my task', 0.5)
-        self.assertEqual(s.get_task_progress('my task'), 0.5)
+        self.assertEqual(0.5, s.get_task_progress('my task'))
         s.update_atom_metadata('my task', None)
-        self.assertEqual(s.get_task_progress('my task'), 0.5)
+        self.assertEqual(0.5, s.get_task_progress('my task'))
 
     def test_default_task_progress(self):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task'))
-        self.assertEqual(s.get_task_progress('my task'), 0.0)
-        self.assertEqual(s.get_task_progress_details('my task'), None)
+        self.assertEqual(0.0, s.get_task_progress('my task'))
+        self.assertEqual(None, s.get_task_progress_details('my task'))
 
     def test_task_progress(self):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task'))
 
         s.set_task_progress('my task', 0.5, {'test_data': 11})
-        self.assertEqual(s.get_task_progress('my task'), 0.5)
-        self.assertEqual(s.get_task_progress_details('my task'), {
+        self.assertEqual(0.5, s.get_task_progress('my task'))
+        self.assertEqual({
             'at_progress': 0.5,
             'details': {'test_data': 11}
-        })
+        }, s.get_task_progress_details('my task'))
 
         s.set_task_progress('my task', 0.7, {'test_data': 17})
-        self.assertEqual(s.get_task_progress('my task'), 0.7)
-        self.assertEqual(s.get_task_progress_details('my task'), {
+        self.assertEqual(0.7, s.get_task_progress('my task'))
+        self.assertEqual({
             'at_progress': 0.7,
             'details': {'test_data': 17}
-        })
+        }, s.get_task_progress_details('my task'))
 
         s.set_task_progress('my task', 0.99)
-        self.assertEqual(s.get_task_progress('my task'), 0.99)
-        self.assertEqual(s.get_task_progress_details('my task'), {
+        self.assertEqual(0.99, s.get_task_progress('my task'))
+        self.assertEqual({
             'at_progress': 0.7,
             'details': {'test_data': 17}
-        })
+        }, s.get_task_progress_details('my task'))
 
     def test_task_progress_erase(self):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task'))
 
         s.set_task_progress('my task', 0.8, {})
-        self.assertEqual(s.get_task_progress('my task'), 0.8)
-        self.assertEqual(s.get_task_progress_details('my task'), None)
+        self.assertEqual(0.8, s.get_task_progress('my task'))
+        self.assertEqual(None, s.get_task_progress_details('my task'))
 
     def test_fetch_result_not_ready(self):
         s = self._get_storage()
         name = 'my result'
         s.ensure_atom(test_utils.NoopTask('my task', provides=name))
         self.assertRaises(exceptions.NotFound, s.get, name)
-        self.assertEqual(s.fetch_all(), {})
+        self.assertEqual({}, s.fetch_all())
 
     def test_save_multiple_results(self):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task', provides=['foo', 'bar']))
         s.save('my task', ('spam', 'eggs'))
-        self.assertEqual(s.fetch_all(), {
+        self.assertEqual({
             'foo': 'spam',
             'bar': 'eggs',
-        })
+        }, s.fetch_all())
 
     def test_mapping_none(self):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task'))
         s.save('my task', 5)
-        self.assertEqual(s.fetch_all(), {})
+        self.assertEqual({}, s.fetch_all())
 
     def test_inject(self):
         s = self._get_storage()
         s.inject({'foo': 'bar', 'spam': 'eggs'})
-        self.assertEqual(s.fetch('spam'), 'eggs')
-        self.assertEqual(s.fetch_all(), {
+        self.assertEqual('eggs', s.fetch('spam'))
+        self.assertEqual({
             'foo': 'bar',
             'spam': 'eggs',
-        })
+        }, s.fetch_all())
 
     def test_inject_twice(self):
         s = self._get_storage()
         s.inject({'foo': 'bar'})
-        self.assertEqual(s.fetch_all(), {'foo': 'bar'})
+        self.assertEqual({'foo': 'bar'}, s.fetch_all())
         s.inject({'spam': 'eggs'})
-        self.assertEqual(s.fetch_all(), {
+        self.assertEqual({
             'foo': 'bar',
             'spam': 'eggs',
-        })
+        }, s.fetch_all())
 
     def test_inject_resumed(self):
         s = self._get_storage()
         s.inject({'foo': 'bar', 'spam': 'eggs'})
         # verify it's there
-        self.assertEqual(s.fetch_all(), {
+        self.assertEqual({
             'foo': 'bar',
             'spam': 'eggs',
-        })
+        }, s.fetch_all())
         # imagine we are resuming, so we need to make new
         # storage from same flow details
         s2 = self._get_storage(s._flowdetail)
         # injected data should still be there:
-        self.assertEqual(s2.fetch_all(), {
+        self.assertEqual({
             'foo': 'bar',
             'spam': 'eggs',
-        })
+        }, s2.fetch_all())
 
     def test_many_thread_ensure_same_task(self):
         s = self._get_storage()
@@ -341,8 +341,8 @@ class StorageTestMixin(object):
     def test_fetch_mapped_args(self):
         s = self._get_storage()
         s.inject({'foo': 'bar', 'spam': 'eggs'})
-        self.assertEqual(s.fetch_mapped_args({'viking': 'spam'}),
-                         {'viking': 'eggs'})
+        self.assertEqual({'viking': 'eggs'},
+                         s.fetch_mapped_args({'viking': 'spam'}))
 
     def test_fetch_not_found_args(self):
         s = self._get_storage()
@@ -353,23 +353,23 @@ class StorageTestMixin(object):
     def test_fetch_optional_args_found(self):
         s = self._get_storage()
         s.inject({'foo': 'bar', 'spam': 'eggs'})
-        self.assertEqual(s.fetch_mapped_args({'viking': 'spam'},
-                                             optional_args=set(['viking'])),
-                         {'viking': 'eggs'})
+        self.assertEqual({'viking': 'eggs'},
+                         s.fetch_mapped_args({'viking': 'spam'},
+                                             optional_args=set(['viking'])))
 
     def test_fetch_optional_args_not_found(self):
         s = self._get_storage()
         s.inject({'foo': 'bar', 'spam': 'eggs'})
-        self.assertEqual(s.fetch_mapped_args({'viking': 'helmet'},
-                                             optional_args=set(['viking'])),
-                         {})
+        self.assertEqual({},
+                         s.fetch_mapped_args({'viking': 'helmet'},
+                                             optional_args=set(['viking'])))
 
     def test_set_and_get_task_state(self):
         s = self._get_storage()
         state = states.PENDING
         s.ensure_atom(test_utils.NoopTask('my task'))
         s.set_atom_state('my task', state)
-        self.assertEqual(s.get_atom_state('my task'), state)
+        self.assertEqual(state, s.get_atom_state('my task'))
 
     def test_get_state_of_unknown_task(self):
         s = self._get_storage()
@@ -418,7 +418,7 @@ class StorageTestMixin(object):
 
     def test_initial_flow_state(self):
         s = self._get_storage()
-        self.assertEqual(s.get_flow_state(), states.PENDING)
+        self.assertEqual(states.PENDING, s.get_flow_state())
 
     def test_get_flow_state(self):
         _lb, flow_detail = p_utils.temporary_flow_detail(backend=self.backend)
@@ -426,12 +426,12 @@ class StorageTestMixin(object):
         with contextlib.closing(self.backend.get_connection()) as conn:
             flow_detail.update(conn.update_flow_details(flow_detail))
         s = self._get_storage(flow_detail)
-        self.assertEqual(s.get_flow_state(), states.FAILURE)
+        self.assertEqual(states.FAILURE, s.get_flow_state())
 
     def test_set_and_get_flow_state(self):
         s = self._get_storage()
         s.set_flow_state(states.SUCCESS)
-        self.assertEqual(s.get_flow_state(), states.SUCCESS)
+        self.assertEqual(states.SUCCESS, s.get_flow_state())
 
     def test_result_is_checked(self):
         s = self._get_storage()
@@ -451,7 +451,7 @@ class StorageTestMixin(object):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my task', provides=['a', 'b']))
         s.save('my task', ['result'])
-        self.assertEqual(s.fetch('a'), 'result')
+        self.assertEqual('result', s.fetch('a'))
         self.assertRaisesRegexp(exceptions.NotFound,
                                 '^Unable to find result', s.fetch, 'b')
 
@@ -495,9 +495,9 @@ class StorageTestMixin(object):
         s.save('my retry', 'b')
         s.cleanup_retry_history('my retry', states.REVERTED)
         history = s.get_retry_history('my retry')
-        self.assertEqual(list(history), [])
+        self.assertEqual([], list(history))
         self.assertEqual(0, len(history))
-        self.assertEqual(s.fetch_all(), {})
+        self.assertEqual({}, s.fetch_all())
 
     def test_cached_retry_failure(self):
         a_failure = failure.Failure.from_exception(RuntimeError('Woot!'))
@@ -511,7 +511,7 @@ class StorageTestMixin(object):
         self.assertIsNotNone(history.failure)
         self.assertEqual(1, len(history))
         self.assertTrue(s.has_failures())
-        self.assertEqual(s.get_failures(), {'my retry': a_failure})
+        self.assertEqual({'my retry': a_failure}, s.get_failures())
 
     def test_logbook_get_unknown_atom_type(self):
         self.assertRaisesRegexp(TypeError,
@@ -523,14 +523,14 @@ class StorageTestMixin(object):
         s.ensure_atom(test_utils.NoopTask('my task'))
         s.set_atom_intention('my task', states.REVERT)
         intention = s.get_atom_intention('my task')
-        self.assertEqual(intention, states.REVERT)
+        self.assertEqual(states.REVERT, intention)
 
     def test_save_retry_intention(self):
         s = self._get_storage()
         s.ensure_atom(test_utils.NoopTask('my retry'))
         s.set_atom_intention('my retry', states.RETRY)
         intention = s.get_atom_intention('my retry')
-        self.assertEqual(intention, states.RETRY)
+        self.assertEqual(states.RETRY, intention)
 
     def test_inject_persistent_missing(self):
         t = test_utils.ProgressingTask('my retry', requires=['x'])
diff --git a/taskflow/tests/unit/test_suspend.py b/taskflow/tests/unit/test_suspend.py
index 07c96923..6559bfc2 100644
--- a/taskflow/tests/unit/test_suspend.py
+++ b/taskflow/tests/unit/test_suspend.py
@@ -49,13 +49,13 @@ class SuspendTest(utils.EngineTestBase):
         with SuspendingListener(engine, task_name='b',
                                 task_state=states.SUCCESS) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.get_flow_state(), states.SUCCESS)
+        self.assertEqual(states.SUCCESS, engine.storage.get_flow_state())
         expected = ['a.t RUNNING', 'a.t SUCCESS(5)']
         self.assertEqual(expected, capturer.values)
         with SuspendingListener(engine, task_name='b',
                                 task_state=states.SUCCESS) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.get_flow_state(), states.SUCCESS)
+        self.assertEqual(states.SUCCESS, engine.storage.get_flow_state())
         expected = []
         self.assertEqual(expected, capturer.values)
 
@@ -69,13 +69,13 @@ class SuspendTest(utils.EngineTestBase):
         with SuspendingListener(engine, task_name='b',
                                 task_state=states.SUCCESS) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.get_flow_state(), states.SUSPENDED)
+        self.assertEqual(states.SUSPENDED, engine.storage.get_flow_state())
         expected = ['a.t RUNNING', 'a.t SUCCESS(5)',
                     'b.t RUNNING', 'b.t SUCCESS(5)']
         self.assertEqual(expected, capturer.values)
         with utils.CaptureListener(engine, capture_flow=False) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.get_flow_state(), states.SUCCESS)
+        self.assertEqual(states.SUCCESS, engine.storage.get_flow_state())
         expected = ['c.t RUNNING', 'c.t SUCCESS(5)']
         self.assertEqual(expected, capturer.values)
 
@@ -89,7 +89,7 @@ class SuspendTest(utils.EngineTestBase):
         with SuspendingListener(engine, task_name='b',
                                 task_state=states.REVERTED) as capturer:
             engine.run()
-        self.assertEqual(engine.storage.get_flow_state(), states.SUSPENDED)
+        self.assertEqual(states.SUSPENDED, engine.storage.get_flow_state())
         expected = ['a.t RUNNING',
                     'a.t SUCCESS(5)',
                     'b.t RUNNING',
@@ -103,7 +103,7 @@ class SuspendTest(utils.EngineTestBase):
         self.assertEqual(expected, capturer.values)
         with utils.CaptureListener(engine, capture_flow=False) as capturer:
             self.assertRaisesRegexp(RuntimeError, '^Woot', engine.run)
-        self.assertEqual(engine.storage.get_flow_state(), states.REVERTED)
+        self.assertEqual(states.REVERTED, engine.storage.get_flow_state())
         expected = ['a.t REVERTING', 'a.t REVERTED(None)']
         self.assertEqual(expected, capturer.values)
 
@@ -133,7 +133,7 @@ class SuspendTest(utils.EngineTestBase):
         engine2 = self._make_engine(flow, engine.storage._flowdetail)
         with utils.CaptureListener(engine2, capture_flow=False) as capturer2:
             self.assertRaisesRegexp(RuntimeError, '^Woot', engine2.run)
-        self.assertEqual(engine2.storage.get_flow_state(), states.REVERTED)
+        self.assertEqual(states.REVERTED, engine2.storage.get_flow_state())
         expected = ['a.t REVERTING',
                     'a.t REVERTED(None)']
         self.assertEqual(expected, capturer2.values)
@@ -170,9 +170,9 @@ class SuspendTest(utils.EngineTestBase):
         engine2 = self._make_engine(flow2, engine.storage._flowdetail)
         with utils.CaptureListener(engine2, capture_flow=False) as capturer2:
             self.assertRaisesRegexp(RuntimeError, '^Woot', engine2.run)
-        self.assertEqual(engine2.storage.get_flow_state(), states.REVERTED)
+        self.assertEqual(states.REVERTED, engine2.storage.get_flow_state())
         expected = ['a.t REVERTING', 'a.t REVERTED(None)']
-        self.assertEqual(capturer2.values, expected)
+        self.assertEqual(expected, capturer2.values)
 
     def test_storage_is_rechecked(self):
         flow = lf.Flow('linear').add(
@@ -184,7 +184,7 @@ class SuspendTest(utils.EngineTestBase):
         with SuspendingListener(engine, task_name='b',
                                 task_state=states.SUCCESS):
             engine.run()
-        self.assertEqual(engine.storage.get_flow_state(), states.SUSPENDED)
+        self.assertEqual(states.SUSPENDED, engine.storage.get_flow_state())
         # uninject everything:
         engine.storage.save(engine.storage.injector_name,
                             {}, states.SUCCESS)
diff --git a/taskflow/tests/unit/test_utils.py b/taskflow/tests/unit/test_utils.py
index c136cb7c..64bb2330 100644
--- a/taskflow/tests/unit/test_utils.py
+++ b/taskflow/tests/unit/test_utils.py
@@ -179,19 +179,19 @@ class TestSequenceMinus(test.TestCase):
 
     def test_simple_case(self):
         result = misc.sequence_minus([1, 2, 3, 4], [2, 3])
-        self.assertEqual(result, [1, 4])
+        self.assertEqual([1, 4], result)
 
     def test_subtrahend_has_extra_elements(self):
         result = misc.sequence_minus([1, 2, 3, 4], [2, 3, 5, 7, 13])
-        self.assertEqual(result, [1, 4])
+        self.assertEqual([1, 4], result)
 
     def test_some_items_are_equal(self):
         result = misc.sequence_minus([1, 1, 1, 1], [1, 1, 3])
-        self.assertEqual(result, [1, 1])
+        self.assertEqual([1, 1], result)
 
     def test_equal_items_not_continious(self):
         result = misc.sequence_minus([1, 2, 3, 1], [1, 3])
-        self.assertEqual(result, [2, 1])
+        self.assertEqual([2, 1], result)
 
 
 class TestReversedEnumerate(testscenarios.TestWithScenarios, test.TestCase):
@@ -301,11 +301,11 @@ class TestMergeUri(test.TestCase):
 class TestClamping(test.TestCase):
     def test_simple_clamp(self):
         result = misc.clamp(1.0, 2.0, 3.0)
-        self.assertEqual(result, 2.0)
+        self.assertEqual(2.0, result)
         result = misc.clamp(4.0, 2.0, 3.0)
-        self.assertEqual(result, 3.0)
+        self.assertEqual(3.0, result)
         result = misc.clamp(3.0, 4.0, 4.0)
-        self.assertEqual(result, 4.0)
+        self.assertEqual(4.0, result)
 
     def test_invalid_clamp(self):
         self.assertRaises(ValueError, misc.clamp, 0.0, 2.0, 1.0)
diff --git a/taskflow/tests/unit/test_utils_binary.py b/taskflow/tests/unit/test_utils_binary.py
index 92c496a2..773f3893 100644
--- a/taskflow/tests/unit/test_utils_binary.py
+++ b/taskflow/tests/unit/test_utils_binary.py
@@ -32,7 +32,7 @@ class BinaryEncodeTest(test.TestCase):
     def _check(self, data, expected_result):
         result = misc.binary_encode(data)
         self.assertIsInstance(result, six.binary_type)
-        self.assertEqual(result, expected_result)
+        self.assertEqual(expected_result, result)
 
     def test_simple_binary(self):
         data = _bytes('hello')
@@ -51,7 +51,7 @@ class BinaryEncodeTest(test.TestCase):
     def test_unicode_other_encoding(self):
         result = misc.binary_encode(u'mañana', 'latin-1')
         self.assertIsInstance(result, six.binary_type)
-        self.assertEqual(result, u'mañana'.encode('latin-1'))
+        self.assertEqual(u'mañana'.encode('latin-1'), result)
 
 
 class BinaryDecodeTest(test.TestCase):
@@ -59,7 +59,7 @@ class BinaryDecodeTest(test.TestCase):
     def _check(self, data, expected_result):
         result = misc.binary_decode(data)
         self.assertIsInstance(result, six.text_type)
-        self.assertEqual(result, expected_result)
+        self.assertEqual(expected_result, result)
 
     def test_simple_text(self):
         data = u'hello'
@@ -79,18 +79,18 @@ class BinaryDecodeTest(test.TestCase):
         data = u'mañana'.encode('latin-1')
         result = misc.binary_decode(data, 'latin-1')
         self.assertIsInstance(result, six.text_type)
-        self.assertEqual(result, u'mañana')
+        self.assertEqual(u'mañana', result)
 
 
 class DecodeJsonTest(test.TestCase):
 
     def test_it_works(self):
-        self.assertEqual(misc.decode_json(_bytes('{"foo": 1}')),
-                         {"foo": 1})
+        self.assertEqual({"foo": 1},
+                         misc.decode_json(_bytes('{"foo": 1}')))
 
     def test_it_works_with_unicode(self):
         data = _bytes('{"foo": "фуу"}')
-        self.assertEqual(misc.decode_json(data), {"foo": u'фуу'})
+        self.assertEqual({"foo": u'фуу'}, misc.decode_json(data))
 
     def test_handles_invalid_unicode(self):
         self.assertRaises(ValueError, misc.decode_json,