Retain atom 'revert' result (or failure)

When a atom is reverted it can be useful to retain the
result of that 'revert' method being called, so that it
can be later analyzed (or used for various purposes) so
adjust the storage, and actions to enable it to be stored.

Change-Id: I38a9a5f3bf7550e924468bb4a86652cb8beb306c

7 files changed, 180 insertions, 129 deletions

diff --git a/taskflow/tests/unit/action_engine/test_runner.py b/taskflow/tests/unit/action_engine/test_runner.py
index 401cf50..9d43f31 100644
--- a/taskflow/tests/unit/action_engine/test_runner.py
+++ b/taskflow/tests/unit/action_engine/test_runner.py
@@ -126,7 +126,8 @@ class RunnerTest(test.TestCase, _RunnerTestMixin):
         failure = failures[0]
         self.assertTrue(failure.check(RuntimeError))
 
-        self.assertEqual(st.FAILURE, rt.storage.get_atom_state(tasks[0].name))
+        self.assertEqual(st.REVERT_FAILURE,
+                         rt.storage.get_atom_state(tasks[0].name))
 
     def test_run_iterations_suspended(self):
         flow = lf.Flow("root")
diff --git a/taskflow/tests/unit/test_check_transition.py b/taskflow/tests/unit/test_check_transition.py
index 7c820fd..a8b5a7c 100644
--- a/taskflow/tests/unit/test_check_transition.py
+++ b/taskflow/tests/unit/test_check_transition.py
@@ -21,11 +21,16 @@ from taskflow import test
 
 class TransitionTest(test.TestCase):
 
+    _DISALLOWED_TPL = "Transition from '%s' to '%s' was found to be disallowed"
+    _NOT_IGNORED_TPL = "Transition from '%s' to '%s' was not ignored"
+
     def assertTransitionAllowed(self, from_state, to_state):
-        self.assertTrue(self.check_transition(from_state, to_state))
+        msg = self._DISALLOWED_TPL % (from_state, to_state)
+        self.assertTrue(self.check_transition(from_state, to_state), msg=msg)
 
     def assertTransitionIgnored(self, from_state, to_state):
-        self.assertFalse(self.check_transition(from_state, to_state))
+        msg = self._NOT_IGNORED_TPL % (from_state, to_state)
+        self.assertFalse(self.check_transition(from_state, to_state), msg=msg)
 
     def assertTransitionForbidden(self, from_state, to_state):
         self.assertRaisesRegexp(exc.InvalidState,
@@ -101,7 +106,8 @@ class CheckTaskTransitionTest(TransitionTest):
 
     def test_from_reverting_state(self):
         self.assertTransitions(from_state=states.REVERTING,
-                               allowed=(states.FAILURE, states.REVERTED),
+                               allowed=(states.REVERT_FAILURE,
+                                        states.REVERTED),
                                ignored=(states.RUNNING, states.REVERTING,
                                         states.PENDING, states.SUCCESS))
 
diff --git a/taskflow/tests/unit/test_engines.py b/taskflow/tests/unit/test_engines.py
index 255ac4f..5cc242c 100644
--- a/taskflow/tests/unit/test_engines.py
+++ b/taskflow/tests/unit/test_engines.py
@@ -66,7 +66,7 @@ class EngineTaskTest(object):
         engine = self._make_engine(flow)
         expected = ['fail.f RUNNING', 'fail.t RUNNING',
                     'fail.t FAILURE(Failure: RuntimeError: Woot!)',
-                    'fail.t REVERTING', 'fail.t REVERTED',
+                    'fail.t REVERTING', 'fail.t REVERTED(None)',
                     'fail.f REVERTED']
         with utils.CaptureListener(engine, values=values) as capturer:
             self.assertFailuresRegexp(RuntimeError, '^Woot', engine.run)
@@ -374,6 +374,29 @@ class EngineLinearFlowTest(utils.EngineTestBase):
         self.assertFailuresRegexp(RuntimeError, '^Woot', engine.run)
         self.assertEqual(engine.storage.fetch_all(), {})
 
+    def test_revert_provided(self):
+        flow = lf.Flow('revert').add(
+            utils.GiveBackRevert('giver'),
+            utils.FailingTask(name='fail')
+        )
+        engine = self._make_engine(flow, store={'value': 0})
+        self.assertFailuresRegexp(RuntimeError, '^Woot', engine.run)
+        self.assertEqual(engine.storage.get_revert_result('giver'), 2)
+
+    def test_nasty_revert(self):
+        flow = lf.Flow('revert').add(
+            utils.NastyTask('nasty'),
+            utils.FailingTask(name='fail')
+        )
+        engine = self._make_engine(flow)
+        self.assertFailuresRegexp(RuntimeError, '^Gotcha', engine.run)
+        fail = engine.storage.get_revert_result('nasty')
+        self.assertIsNotNone(fail.check(RuntimeError))
+        exec_failures = engine.storage.get_execute_failures()
+        self.assertIn('fail', exec_failures)
+        rev_failures = engine.storage.get_revert_failures()
+        self.assertIn('nasty', rev_failures)
+
     def test_sequential_flow_nested_blocks(self):
         flow = lf.Flow('nested-1').add(
             utils.ProgressingTask('task1'),
@@ -406,7 +429,7 @@ class EngineLinearFlowTest(utils.EngineTestBase):
             self.assertFailuresRegexp(RuntimeError, '^Woot', engine.run)
         expected = ['fail.t RUNNING',
                     'fail.t FAILURE(Failure: RuntimeError: Woot!)',
-                    'fail.t REVERTING', 'fail.t REVERTED']
+                    'fail.t REVERTING', 'fail.t REVERTED(None)']
         self.assertEqual(expected, capturer.values)
 
     def test_correctly_reverts_children(self):
@@ -424,9 +447,9 @@ class EngineLinearFlowTest(utils.EngineTestBase):
                     'task2.t RUNNING', 'task2.t SUCCESS(5)',
                     'fail.t RUNNING',
                     'fail.t FAILURE(Failure: RuntimeError: Woot!)',
-                    'fail.t REVERTING', 'fail.t REVERTED',
-                    'task2.t REVERTING', 'task2.t REVERTED',
-                    'task1.t REVERTING', 'task1.t REVERTED']
+                    'fail.t REVERTING', 'fail.t REVERTED(None)',
+                    'task2.t REVERTING', 'task2.t REVERTED(None)',
+                    'task1.t REVERTING', 'task1.t REVERTED(None)']
         self.assertEqual(expected, capturer.values)
 
 
@@ -529,18 +552,19 @@ class EngineLinearAndUnorderedExceptionsTest(utils.EngineTestBase):
             self.assertFailuresRegexp(RuntimeError, '^Woot', engine.run)
 
         # NOTE(imelnikov): we don't know if task 3 was run, but if it was,
-        # it should have been reverted in correct order.
+        # it should have been REVERTED(None) in correct order.
         possible_values_no_task3 = [
             'task1.t RUNNING', 'task2.t RUNNING',
             'fail.t FAILURE(Failure: RuntimeError: Woot!)',
-            'task2.t REVERTED', 'task1.t REVERTED'
+            'task2.t REVERTED(None)', 'task1.t REVERTED(None)'
         ]
         self.assertIsSuperAndSubsequence(capturer.values,
                                          possible_values_no_task3)
         if 'task3' in capturer.values:
             possible_values_task3 = [
                 'task1.t RUNNING', 'task2.t RUNNING', 'task3.t RUNNING',
-                'task3.t REVERTED', 'task2.t REVERTED', 'task1.t REVERTED'
+                'task3.t REVERTED(None)', 'task2.t REVERTED(None)',
+                'task1.t REVERTED(None)'
             ]
             self.assertIsSuperAndSubsequence(capturer.values,
                                              possible_values_task3)
@@ -561,12 +585,12 @@ class EngineLinearAndUnorderedExceptionsTest(utils.EngineTestBase):
             self.assertFailuresRegexp(RuntimeError, '^Gotcha', engine.run)
 
         # NOTE(imelnikov): we don't know if task 3 was run, but if it was,
-        # it should have been reverted in correct order.
+        # it should have been REVERTED(None) in correct order.
         possible_values = ['task1.t RUNNING', 'task1.t SUCCESS(5)',
                            'task2.t RUNNING', 'task2.t SUCCESS(5)',
                            'task3.t RUNNING', 'task3.t SUCCESS(5)',
                            'task3.t REVERTING',
-                           'task3.t REVERTED']
+                           'task3.t REVERTED(None)']
         self.assertIsSuperAndSubsequence(possible_values, capturer.values)
         possible_values_no_task3 = ['task1.t RUNNING', 'task2.t RUNNING']
         self.assertIsSuperAndSubsequence(capturer.values,
@@ -589,12 +613,12 @@ class EngineLinearAndUnorderedExceptionsTest(utils.EngineTestBase):
         # NOTE(imelnikov): if task1 was run, it should have been reverted.
         if 'task1' in capturer.values:
             task1_story = ['task1.t RUNNING', 'task1.t SUCCESS(5)',
-                           'task1.t REVERTED']
+                           'task1.t REVERTED(None)']
             self.assertIsSuperAndSubsequence(capturer.values, task1_story)
 
         # NOTE(imelnikov): task2 should have been run and reverted
         task2_story = ['task2.t RUNNING', 'task2.t SUCCESS(5)',
-                       'task2.t REVERTED']
+                       'task2.t REVERTED(None)']
         self.assertIsSuperAndSubsequence(capturer.values, task2_story)
 
     def test_revert_raises_for_linear_in_unordered(self):
@@ -608,7 +632,7 @@ class EngineLinearAndUnorderedExceptionsTest(utils.EngineTestBase):
         engine = self._make_engine(flow)
         with utils.CaptureListener(engine, capture_flow=False) as capturer:
             self.assertFailuresRegexp(RuntimeError, '^Gotcha', engine.run)
-        self.assertNotIn('task2.t REVERTED', capturer.values)
+        self.assertNotIn('task2.t REVERTED(None)', capturer.values)
 
 
 class EngineGraphFlowTest(utils.EngineTestBase):
@@ -697,11 +721,11 @@ class EngineGraphFlowTest(utils.EngineTestBase):
                     'task3.t RUNNING',
                     'task3.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task3.t REVERTING',
-                    'task3.t REVERTED',
+                    'task3.t REVERTED(None)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'task1.t REVERTING',
-                    'task1.t REVERTED']
+                    'task1.t REVERTED(None)']
         self.assertEqual(expected, capturer.values)
         self.assertEqual(engine.storage.get_flow_state(), states.REVERTED)
 
diff --git a/taskflow/tests/unit/test_retries.py b/taskflow/tests/unit/test_retries.py
index ddb256b..54f51bb 100644
--- a/taskflow/tests/unit/test_retries.py
+++ b/taskflow/tests/unit/test_retries.py
@@ -82,8 +82,8 @@ class RetryTest(utils.EngineTestBase):
                     'task1.t RUNNING', 'task1.t SUCCESS(5)',
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot!)',
-                    'task2.t REVERTING', 'task2.t REVERTED',
-                    'task1.t REVERTING', 'task1.t REVERTED',
+                    'task2.t REVERTING', 'task2.t REVERTED(None)',
+                    'task1.t REVERTING', 'task1.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task1.t PENDING',
                     'task2.t PENDING',
@@ -114,9 +114,9 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task1.t PENDING',
                     'task2.t PENDING',
@@ -127,11 +127,11 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -153,9 +153,9 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'task1.t REVERTING',
-                    'task1.t FAILURE',
+                    'task1.t REVERT_FAILURE(Failure: RuntimeError: Gotcha!)',
                     'flow-1.f FAILURE']
         self.assertEqual(expected, capturer.values)
 
@@ -185,9 +185,9 @@ class RetryTest(utils.EngineTestBase):
                     'task3.t RUNNING',
                     'task3.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task3.t REVERTING',
-                    'task3.t REVERTED',
+                    'task3.t REVERTED(None)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r2.r RETRYING',
                     'task2.t PENDING',
                     'task3.t PENDING',
@@ -231,15 +231,15 @@ class RetryTest(utils.EngineTestBase):
                     'task4.t RUNNING',
                     'task4.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task4.t REVERTING',
-                    'task4.t REVERTED',
+                    'task4.t REVERTED(None)',
                     'task3.t REVERTING',
-                    'task3.t REVERTED',
+                    'task3.t REVERTED(None)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r2.r REVERTING',
-                    'r2.r REVERTED',
+                    'r2.r REVERTED(None)',
                     'task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task1.t PENDING',
                     'r2.r PENDING',
@@ -280,8 +280,8 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task2.t REVERTING',
                     'task1.t REVERTING',
-                    'task2.t REVERTED',
-                    'task1.t REVERTED',
+                    'task2.t REVERTED(None)',
+                    'task1.t REVERTED(None)',
                     'r.r RETRYING',
                     'task1.t PENDING',
                     'task2.t PENDING',
@@ -316,11 +316,11 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r2.r REVERTING',
-                    'r2.r REVERTED',
+                    'r2.r REVERTED(None)',
                     'task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task1.t PENDING',
                     'r2.r PENDING',
@@ -359,9 +359,9 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -388,11 +388,11 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -417,13 +417,13 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r2.r REVERTING',
-                    'r2.r REVERTED',
+                    'r2.r REVERTED(None)',
                     'task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -515,7 +515,7 @@ class RetryTest(utils.EngineTestBase):
                     'c.t RUNNING',
                     'c.t FAILURE(Failure: RuntimeError: Woot!)',
                     'c.t REVERTING',
-                    'c.t REVERTED',
+                    'c.t REVERTED(None)',
                     'r1.r RETRYING',
                     'c.t PENDING',
                     'r1.r RUNNING',
@@ -542,9 +542,9 @@ class RetryTest(utils.EngineTestBase):
                     't2.t RUNNING',
                     't2.t FAILURE(Failure: RuntimeError: Woot!)',
                     't2.t REVERTING',
-                    't2.t REVERTED',
+                    't2.t REVERTED(None)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     't2.t PENDING',
@@ -555,9 +555,9 @@ class RetryTest(utils.EngineTestBase):
                     't2.t RUNNING',
                     't2.t FAILURE(Failure: RuntimeError: Woot!)',
                     't2.t REVERTING',
-                    't2.t REVERTED',
+                    't2.t REVERTED(None)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     't2.t PENDING',
@@ -568,11 +568,11 @@ class RetryTest(utils.EngineTestBase):
                     't2.t RUNNING',
                     't2.t FAILURE(Failure: RuntimeError: Woot!)',
                     't2.t REVERTING',
-                    't2.t REVERTED',
+                    't2.t REVERTED(None)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -589,7 +589,7 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     'r1.r RUNNING',
@@ -597,7 +597,7 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 2)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     'r1.r RUNNING',
@@ -605,7 +605,7 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     'r1.r RUNNING',
@@ -613,9 +613,9 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 5)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -632,7 +632,7 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 2)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     'r1.r RUNNING',
@@ -640,7 +640,7 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     'r1.r RUNNING',
@@ -648,9 +648,9 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 5)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertItemsEqual(capturer.values, expected)
 
@@ -674,7 +674,7 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task2.t PENDING',
                     'r1.r RUNNING',
@@ -682,7 +682,7 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot with 2)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task2.t PENDING',
                     'r1.r RUNNING',
@@ -690,7 +690,7 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task2.t PENDING',
                     'r1.r RUNNING',
@@ -698,9 +698,9 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot with 5)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -724,7 +724,7 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task2.t PENDING',
                     'r1.r RUNNING',
@@ -732,7 +732,7 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot with 2)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task2.t PENDING',
                     'r1.r RUNNING',
@@ -740,7 +740,7 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task2.t PENDING',
                     'r1.r RUNNING',
@@ -748,11 +748,11 @@ class RetryTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot with 5)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -778,7 +778,7 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     'r1.r RUNNING',
@@ -786,7 +786,7 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 2)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     'r1.r RUNNING',
@@ -794,9 +794,9 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 5)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -814,7 +814,7 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     'r1.r RUNNING',
@@ -822,7 +822,7 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 2)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r RETRYING',
                     't1.t PENDING',
                     'r1.r RUNNING',
@@ -830,9 +830,9 @@ class RetryTest(utils.EngineTestBase):
                     't1.t RUNNING',
                     't1.t FAILURE(Failure: RuntimeError: Woot with 5)',
                     't1.t REVERTING',
-                    't1.t REVERTED',
+                    't1.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertItemsEqual(capturer.values, expected)
 
@@ -857,7 +857,7 @@ class RetryTest(utils.EngineTestBase):
                     'task-2.t RUNNING',
                     'task-2.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     'task-2.t REVERTING',
-                    'task-2.t REVERTED',
+                    'task-2.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task-2.t PENDING',
                     'r1.r RUNNING',
@@ -865,7 +865,7 @@ class RetryTest(utils.EngineTestBase):
                     'task-2.t RUNNING',
                     'task-2.t FAILURE(Failure: RuntimeError: Woot with 2)',
                     'task-2.t REVERTING',
-                    'task-2.t REVERTED',
+                    'task-2.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task-2.t PENDING',
                     'r1.r RUNNING',
@@ -873,9 +873,9 @@ class RetryTest(utils.EngineTestBase):
                     'task-2.t RUNNING',
                     'task-2.t FAILURE(Failure: RuntimeError: Woot with 5)',
                     'task-2.t REVERTING',
-                    'task-2.t REVERTED',
+                    'task-2.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -901,7 +901,7 @@ class RetryTest(utils.EngineTestBase):
                     'task-2.t RUNNING',
                     'task-2.t FAILURE(Failure: RuntimeError: Woot with 3)',
                     'task-2.t REVERTING',
-                    'task-2.t REVERTED',
+                    'task-2.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task-2.t PENDING',
                     'r1.r RUNNING',
@@ -909,7 +909,7 @@ class RetryTest(utils.EngineTestBase):
                     'task-2.t RUNNING',
                     'task-2.t FAILURE(Failure: RuntimeError: Woot with 2)',
                     'task-2.t REVERTING',
-                    'task-2.t REVERTED',
+                    'task-2.t REVERTED(None)',
                     'r1.r RETRYING',
                     'task-2.t PENDING',
                     'r1.r RUNNING',
@@ -917,11 +917,11 @@ class RetryTest(utils.EngineTestBase):
                     'task-2.t RUNNING',
                     'task-2.t FAILURE(Failure: RuntimeError: Woot with 5)',
                     'task-2.t REVERTING',
-                    'task-2.t REVERTED',
+                    'task-2.t REVERTED(None)',
                     'r1.r REVERTING',
-                    'r1.r REVERTED',
+                    'r1.r REVERTED(None)',
                     'task-1.t REVERTING',
-                    'task-1.t REVERTED',
+                    'task-1.t REVERTED(None)',
                     'flow-1.f REVERTED']
         self.assertEqual(expected, capturer.values)
 
@@ -973,7 +973,7 @@ class RetryTest(utils.EngineTestBase):
         with utils.CaptureListener(engine) as capturer:
             engine.run()
         expected = ['task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'flow-1_retry.r RETRYING',
                     'task1.t PENDING',
                     'flow-1_retry.r RUNNING',
@@ -988,7 +988,7 @@ class RetryTest(utils.EngineTestBase):
         with utils.CaptureListener(engine) as capturer:
             engine.run()
         expected = ['task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'flow-1_retry.r RETRYING',
                     'task1.t PENDING',
                     'flow-1_retry.r RUNNING',
@@ -1003,7 +1003,7 @@ class RetryTest(utils.EngineTestBase):
         with utils.CaptureListener(engine) as capturer:
             engine.run()
         expected = ['task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'flow-1_retry.r RETRYING',
                     'task1.t PENDING',
                     'flow-1_retry.r RUNNING',
@@ -1018,7 +1018,7 @@ class RetryTest(utils.EngineTestBase):
         with utils.CaptureListener(engine) as capturer:
             engine.run()
         expected = ['task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'flow-1_retry.r RETRYING',
                     'task1.t PENDING',
                     'flow-1_retry.r RUNNING',
@@ -1032,7 +1032,7 @@ class RetryTest(utils.EngineTestBase):
         engine = self._pretend_to_run_a_flow_and_crash('revert scheduled')
         with utils.CaptureListener(engine) as capturer:
             engine.run()
-        expected = ['task1.t REVERTED',
+        expected = ['task1.t REVERTED(None)',
                     'flow-1_retry.r RETRYING',
                     'task1.t PENDING',
                     'flow-1_retry.r RUNNING',
@@ -1077,16 +1077,16 @@ class RetryTest(utils.EngineTestBase):
                     'c.t FAILURE(Failure: RuntimeError: Woot!)',
                     'a.t REVERTING',
                     'c.t REVERTING',
-                    'a.t REVERTED',
-                    'c.t REVERTED',
+                    'a.t REVERTED(None)',
+                    'c.t REVERTED(None)',
                     'b.t REVERTING',
-                    'b.t REVERTED']
+                    'b.t REVERTED(None)']
         self.assertItemsEqual(capturer.values[:8], expected)
         # Task 'a' was or was not executed again, both cases are ok.
         self.assertIsSuperAndSubsequence(capturer.values[8:], [
             'b.t RUNNING',
             'c.t FAILURE(Failure: RuntimeError: Woot!)',
-            'b.t REVERTED',
+            'b.t REVERTED(None)',
         ])
         self.assertEqual(engine.storage.get_flow_state(), st.REVERTED)
 
@@ -1107,9 +1107,9 @@ class RetryTest(utils.EngineTestBase):
         with utils.CaptureListener(engine, capture_flow=False) as capturer:
             engine.run()
         expected = ['c.t REVERTING',
-                    'c.t REVERTED',
+                    'c.t REVERTED(None)',
                     'b.t REVERTING',
-                    'b.t REVERTED']
+                    'b.t REVERTED(None)']
         self.assertItemsEqual(capturer.values[:4], expected)
         expected = ['test2_retry.r RETRYING',
                     'b.t PENDING',
@@ -1149,10 +1149,10 @@ class RetryParallelExecutionTest(utils.EngineTestBase):
                     'task2.t RUNNING',
                     'task2.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'task1.t SUCCESS(5)',
                     'task1.t REVERTING',
-                    'task1.t REVERTED',
+                    'task1.t REVERTED(None)',
                     'r.r RETRYING',
                     'task1.t PENDING',
                     'task2.t PENDING',
@@ -1189,10 +1189,10 @@ class RetryParallelExecutionTest(utils.EngineTestBase):
                     'task3.t FAILURE(Failure: RuntimeError: Woot!)',
                     'task3.t REVERTING',
                     'task1.t REVERTING',
-                    'task3.t REVERTED',
-                    'task1.t REVERTED',
+                    'task3.t REVERTED(None)',
+                    'task1.t REVERTED(None)',
                     'task2.t REVERTING',
-                    'task2.t REVERTED',
+                    'task2.t REVERTED(None)',
                     'r.r RETRYING',
                     'task1.t PENDING',
                     'task2.t PENDING',
diff --git a/taskflow/tests/unit/test_storage.py b/taskflow/tests/unit/test_storage.py
index 958d5a5..0e1c47f 100644
--- a/taskflow/tests/unit/test_storage.py
+++ b/taskflow/tests/unit/test_storage.py
@@ -118,13 +118,6 @@ class StorageTestMixin(object):
         self.assertEqual(s.fetch_all(), {})
         self.assertEqual(s.get_atom_state('my task'), states.SUCCESS)
 
-    def test_save_and_get_other_state(self):
-        s = self._get_storage()
-        s.ensure_atom(test_utils.NoopTask('my task'))
-        s.save('my task', 5, states.FAILURE)
-        self.assertEqual(s.get('my task'), 5)
-        self.assertEqual(s.get_atom_state('my task'), states.FAILURE)
-
     def test_save_and_get_cached_failure(self):
         a_failure = failure.Failure.from_exception(RuntimeError('Woot!'))
         s = self._get_storage()
@@ -141,7 +134,7 @@ class StorageTestMixin(object):
         s.ensure_atom(test_utils.NoopTask('my task'))
         s.save('my task', a_failure, states.FAILURE)
         self.assertEqual(s.get('my task'), a_failure)
-        s._failures['my task'] = None
+        s._failures['my task'] = {}
         self.assertTrue(a_failure.matches(s.get('my task')))
 
     def test_get_failure_from_reverted_task(self):
@@ -564,6 +557,33 @@ class StorageTestMixin(object):
         args = s.fetch_mapped_args(t.rebind, atom_name=t.name)
         self.assertEqual(3, args['x'])
 
+    def test_save_fetch(self):
+        t = test_utils.GiveBackRevert('my task')
+        s = self._get_storage()
+        s.ensure_atom(t)
+        s.save('my task', 2)
+        self.assertEqual(2, s.get('my task'))
+        self.assertRaises(exceptions.NotFound,
+                          s.get_revert_result, 'my task')
+
+    def test_save_fetch_revert(self):
+        t = test_utils.GiveBackRevert('my task')
+        s = self._get_storage()
+        s.ensure_atom(t)
+        s.set_atom_intention('my task', states.REVERT)
+        s.save('my task', 2, state=states.REVERTED)
+        self.assertRaises(exceptions.NotFound, s.get, 'my task')
+        self.assertEqual(2, s.get_revert_result('my task'))
+
+    def test_save_fail_fetch_revert(self):
+        t = test_utils.GiveBackRevert('my task')
+        s = self._get_storage()
+        s.ensure_atom(t)
+        s.set_atom_intention('my task', states.REVERT)
+        a_failure = failure.Failure.from_exception(RuntimeError('Woot!'))
+        s.save('my task', a_failure, state=states.REVERT_FAILURE)
+        self.assertEqual(a_failure, s.get_revert_result('my task'))
+
 
 class StorageMemoryTest(StorageTestMixin, test.TestCase):
     def setUp(self):
diff --git a/taskflow/tests/unit/test_suspend.py b/taskflow/tests/unit/test_suspend.py
index e5d0288..1b358ac 100644
--- a/taskflow/tests/unit/test_suspend.py
+++ b/taskflow/tests/unit/test_suspend.py
@@ -97,14 +97,14 @@ class SuspendTest(utils.EngineTestBase):
                     'c.t RUNNING',
                     'c.t FAILURE(Failure: RuntimeError: Woot!)',
                     'c.t REVERTING',
-                    'c.t REVERTED',
+                    'c.t REVERTED(None)',
                     'b.t REVERTING',
-                    'b.t REVERTED']
+                    'b.t REVERTED(None)']
         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)
-        expected = ['a.t REVERTING', 'a.t REVERTED']
+        expected = ['a.t REVERTING', 'a.t REVERTED(None)']
         self.assertEqual(expected, capturer.values)
 
     def test_suspend_and_resume_linear_flow_on_revert(self):
@@ -124,9 +124,9 @@ class SuspendTest(utils.EngineTestBase):
                     'c.t RUNNING',
                     'c.t FAILURE(Failure: RuntimeError: Woot!)',
                     'c.t REVERTING',
-                    'c.t REVERTED',
+                    'c.t REVERTED(None)',
                     'b.t REVERTING',
-                    'b.t REVERTED']
+                    'b.t REVERTED(None)']
         self.assertEqual(expected, capturer.values)
 
         # pretend we are resuming
@@ -135,7 +135,7 @@ class SuspendTest(utils.EngineTestBase):
             self.assertRaisesRegexp(RuntimeError, '^Woot', engine2.run)
         self.assertEqual(engine2.storage.get_flow_state(), states.REVERTED)
         expected = ['a.t REVERTING',
-                    'a.t REVERTED']
+                    'a.t REVERTED(None)']
         self.assertEqual(expected, capturer2.values)
 
     def test_suspend_and_revert_even_if_task_is_gone(self):
@@ -157,9 +157,9 @@ class SuspendTest(utils.EngineTestBase):
                     'c.t RUNNING',
                     'c.t FAILURE(Failure: RuntimeError: Woot!)',
                     'c.t REVERTING',
-                    'c.t REVERTED',
+                    'c.t REVERTED(None)',
                     'b.t REVERTING',
-                    'b.t REVERTED']
+                    'b.t REVERTED(None)']
         self.assertEqual(expected, capturer.values)
 
         # pretend we are resuming, but task 'c' gone when flow got updated
@@ -171,7 +171,7 @@ class SuspendTest(utils.EngineTestBase):
         with utils.CaptureListener(engine2, capture_flow=False) as capturer2:
             self.assertRaisesRegexp(RuntimeError, '^Woot', engine2.run)
         self.assertEqual(engine2.storage.get_flow_state(), states.REVERTED)
-        expected = ['a.t REVERTING', 'a.t REVERTED']
+        expected = ['a.t REVERTING', 'a.t REVERTED(None)']
         self.assertEqual(capturer2.values, expected)
 
     def test_storage_is_rechecked(self):
diff --git a/taskflow/tests/unit/worker_based/test_worker.py b/taskflow/tests/unit/worker_based/test_worker.py
index 3acf245..c598673 100644
--- a/taskflow/tests/unit/worker_based/test_worker.py
+++ b/taskflow/tests/unit/worker_based/test_worker.py
@@ -33,7 +33,7 @@ class TestWorker(test.MockTestCase):
         self.broker_url = 'test-url'
         self.exchange = 'test-exchange'
         self.topic = 'test-topic'
-        self.endpoint_count = 25
+        self.endpoint_count = 26
 
         # patch classes
         self.executor_mock, self.executor_inst_mock = self.patchClass(