def test_retry_tasks_that_has_not_been_reverted(self):
flow = lf.Flow('flow-1', retry.Times(3, 'r1', provides='x')).add(
utils.ConditionalTask('c'),
utils.ProgressingTask('t1')
)
engine = self._make_engine(flow)
engine.storage.inject({'y': 2})
with utils.CaptureListener(engine) as capturer:
engine.run()
expected = ['flow-1.f RUNNING',
'r1.r RUNNING',
'r1.r SUCCESS(1)',
'c.t RUNNING',
'c.t FAILURE(Failure: RuntimeError: Woot!)',
'c.t REVERTING',
'c.t REVERTED',
'r1.r RETRYING',
'c.t PENDING',
'r1.r RUNNING',
'r1.r SUCCESS(2)',
'c.t RUNNING',
'c.t SUCCESS(None)',
't1.t RUNNING',
't1.t SUCCESS(5)',
'flow-1.f SUCCESS']
self.assertEqual(capturer.values, expected)
def test_unordered_flow_task_fails_parallel_tasks_should_be_reverted(self):
flow = uf.Flow('flow-1', retry.Times(3, 'r', provides='x')).add(
utils.ProgressingTask("task1"),
utils.ConditionalTask("task2")
)
engine = self._make_engine(flow)
engine.storage.inject({'y': 2})
with utils.CaptureListener(engine) as capturer:
engine.run()
self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2})
expected = ['flow-1.f RUNNING',
'r.r RUNNING',
'r.r SUCCESS(1)',
'task1.t RUNNING',
'task2.t RUNNING',
'task1.t SUCCESS(5)',
'task2.t FAILURE(Failure: RuntimeError: Woot!)',
'task2.t REVERTING',
'task1.t REVERTING',
'task2.t REVERTED',
'task1.t REVERTED',
'r.r RETRYING',
'task1.t PENDING',
'task2.t PENDING',
'r.r RUNNING',
'r.r SUCCESS(2)',
'task1.t RUNNING',
'task2.t RUNNING',
'task1.t SUCCESS(5)',
'task2.t SUCCESS(None)',
'flow-1.f SUCCESS']
self.assertItemsEqual(capturer.values, expected)
def test_revert_all_retry(self):
flow = lf.Flow('flow-1', retry.Times(3, 'r1', provides='x')).add(
utils.ProgressingTask("task1"),
lf.Flow('flow-2', retry.AlwaysRevertAll('r2')).add(
utils.ConditionalTask("task2"))
)
engine = self._make_engine(flow)
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})
expected = ['flow-1.f RUNNING',
'r1.r RUNNING',
'r1.r SUCCESS(1)',
'task1.t RUNNING',
'task1.t SUCCESS(5)',
'r2.r RUNNING',
'r2.r SUCCESS(None)',
'task2.t RUNNING',
'task2.t FAILURE(Failure: RuntimeError: Woot!)',
'task2.t REVERTING',
'task2.t REVERTED',
'r2.r REVERTING',
'r2.r REVERTED',
'task1.t REVERTING',
'task1.t REVERTED',
'r1.r REVERTING',
'r1.r REVERTED',
'flow-1.f REVERTED']
self.assertEqual(expected, capturer.values)
def test_nested_flow_reverts_parent_retries(self):
retry1 = retry.Times(3, 'r1', provides='x')
retry2 = retry.Times(0, 'r2', provides='x2')
flow = lf.Flow('flow-1', retry1).add(
utils.SaveOrderTask("task1"),
lf.Flow('flow-2', retry2).add(utils.ConditionalTask("task2")))
engine = self._make_engine(flow)
engine.storage.inject({'y': 2})
utils.register_notifiers(engine, self.values)
engine.run()
self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2, 'x2': 1})
expected = [
'flow RUNNING', 'r1 RUNNING', 'r1 SUCCESS', 'task1 RUNNING',
'task1', 'task1 SUCCESS', 'r2 RUNNING', 'r2 SUCCESS',
'task2 RUNNING', 'task2', 'task2 FAILURE', 'task2 REVERTING',
u'task2 reverted(Failure: RuntimeError: Woot!)', 'task2 REVERTED',
'r2 REVERTING', 'r2 REVERTED', 'task1 REVERTING',
'task1 reverted(5)', 'task1 REVERTED', 'r1 RETRYING',
'task1 PENDING', 'r2 PENDING', 'task2 PENDING', 'r1 RUNNING',
'r1 SUCCESS', 'task1 RUNNING', 'task1', 'task1 SUCCESS',
'r2 RUNNING', 'r2 SUCCESS', 'task2 RUNNING', 'task2',
'task2 SUCCESS', 'flow SUCCESS'
]
self.assertEqual(self.values, expected)
def test_states_retry_failure_parent_flow_fails(self):
flow = lf.Flow('flow-1', retry.Times(3, 'r1', provides='x1')).add(
utils.TaskNoRequiresNoReturns("task1"),
lf.Flow('flow-2', retry.Times(3, 'r2', provides='x2')).add(
utils.TaskNoRequiresNoReturns("task2"),
utils.TaskNoRequiresNoReturns("task3")),
utils.ConditionalTask("task4", rebind={'x': 'x1'}))
engine = self._make_engine(flow)
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
})
expected = [
'flow-1.f RUNNING', 'r1.r RUNNING', 'r1.r SUCCESS(1)',
'task1.t RUNNING', 'task1.t SUCCESS(None)', 'r2.r RUNNING',
'r2.r SUCCESS(1)', 'task2.t RUNNING', 'task2.t SUCCESS(None)',
'task3.t RUNNING', 'task3.t SUCCESS(None)', 'task4.t RUNNING',
'task4.t FAILURE(Failure: RuntimeError: Woot!)',
'task4.t REVERTING', 'task4.t REVERTED', 'task3.t REVERTING',
'task3.t REVERTED', 'task2.t REVERTING', 'task2.t REVERTED',
'r2.r REVERTING', 'r2.r REVERTED', 'task1.t REVERTING',
'task1.t REVERTED', 'r1.r RETRYING', 'task1.t PENDING',
'r2.r PENDING', 'task2.t PENDING', 'task3.t PENDING',
'task4.t PENDING', 'r1.r RUNNING', 'r1.r SUCCESS(2)',
'task1.t RUNNING', 'task1.t SUCCESS(None)', 'r2.r RUNNING',
'r2.r SUCCESS(1)', 'task2.t RUNNING', 'task2.t SUCCESS(None)',
'task3.t RUNNING', 'task3.t SUCCESS(None)', 'task4.t RUNNING',
'task4.t SUCCESS(None)', 'flow-1.f SUCCESS'
]
self.assertEqual(expected, capturer.values)
def test_states_retry_success_linear_flow(self):
flow = lf.Flow('flow-1', retry.Times(4, 'r1', provides='x')).add(
utils.ProgressingTask("task1"),
utils.ConditionalTask("task2")
)
engine = self._make_engine(flow)
engine.storage.inject({'y': 2})
with utils.CaptureListener(engine) as capturer:
engine.run()
self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2})
expected = ['flow-1.f RUNNING',
'r1.r RUNNING', 'r1.r SUCCESS(1)',
'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',
'r1.r RETRYING',
'task1.t PENDING',
'task2.t PENDING',
'r1.r RUNNING',
'r1.r SUCCESS(2)',
'task1.t RUNNING',
'task1.t SUCCESS(5)',
'task2.t RUNNING',
'task2.t SUCCESS(None)',
'flow-1.f SUCCESS']
self.assertEqual(expected, capturer.values)
def test_states_retry_failure_parent_flow_fails(self):
flow = lf.Flow('flow-1', retry.Times(3, 'r1', provides='x1')).add(
utils.TaskNoRequiresNoReturns("task1"),
lf.Flow('flow-2', retry.Times(3, 'r2', provides='x2')).add(
utils.TaskNoRequiresNoReturns("task2"),
utils.TaskNoRequiresNoReturns("task3")),
utils.ConditionalTask("task4", rebind={'x': 'x1'}))
engine = self._make_engine(flow)
utils.register_notifiers(engine, self.values)
engine.storage.inject({'y': 2})
engine.run()
self.assertEqual(engine.storage.fetch_all(), {
'y': 2,
'x1': 2,
'x2': 1
})
expected = [
'flow RUNNING', 'r1 RUNNING', 'r1 SUCCESS', 'task1 RUNNING',
'task1 SUCCESS', 'r2 RUNNING', 'r2 SUCCESS', 'task2 RUNNING',
'task2 SUCCESS', 'task3 RUNNING', 'task3 SUCCESS', 'task4 RUNNING',
'task4', 'task4 FAILURE', 'task4 REVERTING',
u'task4 reverted(Failure: RuntimeError: Woot!)', 'task4 REVERTED',
'task3 REVERTING', 'task3 REVERTED', 'task2 REVERTING',
'task2 REVERTED', 'r2 REVERTING', 'r2 REVERTED', 'task1 REVERTING',
'task1 REVERTED', 'r1 RETRYING', 'task1 PENDING', 'r2 PENDING',
'task2 PENDING', 'task3 PENDING', 'task4 PENDING', 'r1 RUNNING',
'r1 SUCCESS', 'task1 RUNNING', 'task1 SUCCESS', 'r2 RUNNING',
'r2 SUCCESS', 'task2 RUNNING', 'task2 SUCCESS', 'task3 RUNNING',
'task3 SUCCESS', 'task4 RUNNING', 'task4', 'task4 SUCCESS',
'flow SUCCESS'
]
self.assertEqual(self.values, expected)
def test_nested_flow_reverts_parent_retries(self):
retry1 = retry.Times(3, 'r1', provides='x')
retry2 = retry.Times(0, 'r2', provides='x2')
flow = lf.Flow('flow-1', retry1).add(
utils.ProgressingTask("task1"),
lf.Flow('flow-2', retry2).add(utils.ConditionalTask("task2")))
engine = self._make_engine(flow)
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})
expected = [
'flow-1.f RUNNING', 'r1.r RUNNING', 'r1.r SUCCESS(1)',
'task1.t RUNNING', 'task1.t SUCCESS(5)', 'r2.r RUNNING',
'r2.r SUCCESS(1)', 'task2.t RUNNING',
'task2.t FAILURE(Failure: RuntimeError: Woot!)',
'task2.t REVERTING', 'task2.t REVERTED', 'r2.r REVERTING',
'r2.r REVERTED', 'task1.t REVERTING', 'task1.t REVERTED',
'r1.r RETRYING', 'task1.t PENDING', 'r2.r PENDING',
'task2.t PENDING', 'r1.r RUNNING', 'r1.r SUCCESS(2)',
'task1.t RUNNING', 'task1.t SUCCESS(5)', 'r2.r RUNNING',
'r2.r SUCCESS(1)', 'task2.t RUNNING', 'task2.t SUCCESS(None)',
'flow-1.f SUCCESS'
]
self.assertEqual(expected, capturer.values)
def test_parameterized_for_each_empty_collection(self):
values = []
retry1 = retry.ParameterizedForEach('r1', provides='x')
flow = lf.Flow('flow-1', retry1).add(utils.ConditionalTask('t1'))
engine = self._make_engine(flow)
engine.storage.inject({'values': values, 'y': 1})
self.assertRaisesRegexp(exc.NotFound, '^No elements left', engine.run)
def test_when_subflow_fails_revert_running_tasks(self):
waiting_task = utils.WaitForOneFromTask('task1', 'task2',
[st.SUCCESS, st.FAILURE])
flow = uf.Flow('flow-1', retry.Times(3, 'r', provides='x')).add(
waiting_task,
utils.ConditionalTask('task2')
)
engine = self._make_engine(flow)
engine.task_notifier.register('*', waiting_task.callback)
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})
expected = ['r.r RUNNING',
'r.r SUCCESS(1)',
'task1.t RUNNING',
'task2.t RUNNING',
'task2.t FAILURE(Failure: RuntimeError: Woot!)',
'task2.t REVERTING',
'task2.t REVERTED',
'task1.t SUCCESS(5)',
'task1.t REVERTING',
'task1.t REVERTED',
'r.r RETRYING',
'task1.t PENDING',
'task2.t PENDING',
'r.r RUNNING',
'r.r SUCCESS(2)',
'task1.t RUNNING',
'task2.t RUNNING',
'task2.t SUCCESS(None)',
'task1.t SUCCESS(5)']
self.assertItemsEqual(capturer.values, expected)
def test_retry_tasks_that_has_not_been_reverted(self):
flow = lf.Flow('flow-1', retry.Times(3, 'r1', provides='x')).add(
utils.ConditionalTask('c'), utils.SaveOrderTask('t1'))
engine = self._make_engine(flow)
engine.storage.inject({'y': 2})
engine.run()
expected = [
'c', u'c reverted(Failure: RuntimeError: Woot!)', 'c', 't1'
]
self.assertEqual(self.values, expected)
def test_unordered_flow_task_fails_parallel_tasks_should_be_reverted(self):
flow = uf.Flow('flow-1', retry.Times(3, 'r', provides='x')).add(
utils.SaveOrderTask("task1"), utils.ConditionalTask("task2"))
engine = self._make_engine(flow)
engine.storage.inject({'y': 2})
engine.run()
self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2})
expected = [
'task2', 'task1', u'task2 reverted(Failure: RuntimeError: Woot!)',
'task1 reverted(5)', 'task2', 'task1'
]
self.assertItemsEqual(self.values, expected)
def test_when_subflow_fails_revert_running_tasks(self):
waiting_task = utils.WaitForOneFromTask('task1', 'task2',
[st.SUCCESS, st.FAILURE])
flow = uf.Flow('flow-1', retry.Times(3, 'r', provides='x')).add(
waiting_task, utils.ConditionalTask('task2'))
engine = self._make_engine(flow)
engine.task_notifier.register('*', waiting_task.callback)
engine.storage.inject({'y': 2})
engine.run()
self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2})
expected = [
'task2', 'task1', u'task2 reverted(Failure: RuntimeError: Woot!)',
'task1 reverted(5)', 'task2', 'task1'
]
self.assertItemsEqual(self.values, expected)
def test_states_retry_failure_linear_flow(self):
flow = lf.Flow('flow-1', retry.Times(2, 'r1', provides='x')).add(
utils.NastyTask("task1"), utils.ConditionalTask("task2"))
engine = self._make_engine(flow)
utils.register_notifiers(engine, self.values)
engine.storage.inject({'y': 4})
self.assertRaisesRegexp(RuntimeError, '^Gotcha', engine.run)
self.assertEqual(engine.storage.fetch_all(), {'y': 4, 'x': 1})
expected = [
'flow RUNNING', 'r1 RUNNING', 'r1 SUCCESS', 'task1 RUNNING',
'task1 SUCCESS', 'task2 RUNNING', 'task2', 'task2 FAILURE',
'task2 REVERTING', u'task2 reverted(Failure: RuntimeError: Woot!)',
'task2 REVERTED', 'task1 REVERTING', 'task1 FAILURE',
'flow FAILURE'
]
self.assertEqual(self.values, expected)
def test_states_retry_failure_linear_flow(self):
flow = lf.Flow('flow-1', retry.Times(2, 'r1', provides='x')).add(
utils.NastyTask("task1"), utils.ConditionalTask("task2"))
engine = self._make_engine(flow)
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})
expected = [
'flow-1.f RUNNING', 'r1.r RUNNING', 'r1.r SUCCESS(1)',
'task1.t RUNNING', 'task1.t SUCCESS(None)', 'task2.t RUNNING',
'task2.t FAILURE(Failure: RuntimeError: Woot!)',
'task2.t REVERTING', 'task2.t REVERTED', 'task1.t REVERTING',
'task1.t FAILURE', 'flow-1.f FAILURE'
]
self.assertEqual(expected, capturer.values)
def test_states_retry_success_linear_flow(self):
flow = lf.Flow('flow-1', retry.Times(4, 'r1', provides='x')).add(
utils.SaveOrderTask("task1"), utils.ConditionalTask("task2"))
engine = self._make_engine(flow)
utils.register_notifiers(engine, self.values)
engine.storage.inject({'y': 2})
engine.run()
self.assertEqual(engine.storage.fetch_all(), {'y': 2, 'x': 2})
expected = [
'flow RUNNING', 'r1 RUNNING', 'r1 SUCCESS', 'task1 RUNNING',
'task1', 'task1 SUCCESS', 'task2 RUNNING', 'task2',
'task2 FAILURE', 'task2 REVERTING',
u'task2 reverted(Failure: RuntimeError: Woot!)', 'task2 REVERTED',
'task1 REVERTING', 'task1 reverted(5)', 'task1 REVERTED',
'r1 RETRYING', 'task1 PENDING', 'task2 PENDING', 'r1 RUNNING',
'r1 SUCCESS', 'task1 RUNNING', 'task1', 'task1 SUCCESS',
'task2 RUNNING', 'task2', 'task2 SUCCESS', 'flow SUCCESS'
]
self.assertEqual(self.values, expected)
def test_revert_all_retry(self):
flow = lf.Flow('flow-1', retry.Times(3, 'r1', provides='x')).add(
utils.SaveOrderTask("task1"),
lf.Flow('flow-2', retry.AlwaysRevertAll('r2')).add(
utils.ConditionalTask("task2")))
engine = self._make_engine(flow)
engine.storage.inject({'y': 2})
utils.register_notifiers(engine, self.values)
self.assertRaisesRegexp(RuntimeError, '^Woot', engine.run)
self.assertEqual(engine.storage.fetch_all(), {'y': 2})
expected = [
'flow RUNNING', 'r1 RUNNING', 'r1 SUCCESS', 'task1 RUNNING',
'task1', 'task1 SUCCESS', 'r2 RUNNING', 'r2 SUCCESS',
'task2 RUNNING', 'task2', 'task2 FAILURE', 'task2 REVERTING',
u'task2 reverted(Failure: RuntimeError: Woot!)', 'task2 REVERTED',
'r2 REVERTING', 'r2 REVERTED', 'task1 REVERTING',
'task1 reverted(5)', 'task1 REVERTED', 'r1 REVERTING',
'r1 REVERTED', 'flow REVERTED'
]
self.assertEqual(self.values, expected)
