openstack
/
taskflow
Code Issues Proposed changes

Fix order of assertEqual for unit.test_* 

First parameter should be the expected value.

Change-Id: I2941296e38c3245da298cc64aeb5636fbc4b2eb6
Partial-Bug: #1357117
This commit is contained in:
lin-hua-cheng 2015-10-17 18:29:39 -07:00
parent dd22aff707
commit 9a7ed89133
13 changed files with 271 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
taskflow/tests/test_examples.py
View File

@ -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():

42
taskflow/tests/unit/test_arguments_passing.py
View File

@ -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):

16
taskflow/tests/unit/test_engine_helpers.py
View File

@ -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'))

56
taskflow/tests/unit/test_engines.py
View File

@ -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(),

48
taskflow/tests/unit/test_failure.py
View File

@ -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'嗨'

134
taskflow/tests/unit/test_flow_dependencies.py
View File

@ -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)

6
taskflow/tests/unit/test_functor_task.py
View File

@ -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

6
taskflow/tests/unit/test_progress.py
View File

@ -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 = []

45
taskflow/tests/unit/test_retries.py
View File

@ -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',

138
taskflow/tests/unit/test_storage.py
View File

@ -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'])

20
taskflow/tests/unit/test_suspend.py
View File

@ -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)

14
taskflow/tests/unit/test_utils.py
View File

@ -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)

14
taskflow/tests/unit/test_utils_binary.py
View File

@ -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,