453 lines
16 KiB
Python
453 lines
16 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright 2015 Hewlett-Packard Development Company, L.P.
|
|
# Copyright (C) 2013 Yahoo! Inc. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from taskflow import task
|
|
from taskflow import test
|
|
from taskflow.test import mock
|
|
from taskflow.types import notifier
|
|
|
|
|
|
class MyTask(task.Task):
|
|
def execute(self, context, spam, eggs):
|
|
pass
|
|
|
|
|
|
class KwargsTask(task.Task):
|
|
def execute(self, spam, **kwargs):
|
|
pass
|
|
|
|
|
|
class DefaultArgTask(task.Task):
|
|
def execute(self, spam, eggs=()):
|
|
pass
|
|
|
|
|
|
class DefaultProvidesTask(task.Task):
|
|
default_provides = 'def'
|
|
|
|
def execute(self):
|
|
return None
|
|
|
|
|
|
class ProgressTask(task.Task):
|
|
def execute(self, values, **kwargs):
|
|
for value in values:
|
|
self.update_progress(value)
|
|
|
|
|
|
class SeparateRevertTask(task.Task):
|
|
def execute(self, execute_arg):
|
|
pass
|
|
|
|
def revert(self, revert_arg, result, flow_failures):
|
|
pass
|
|
|
|
|
|
class SeparateRevertOptionalTask(task.Task):
|
|
def execute(self, execute_arg=None):
|
|
pass
|
|
|
|
def revert(self, result, flow_failures, revert_arg=None):
|
|
pass
|
|
|
|
|
|
class RevertKwargsTask(task.Task):
|
|
def execute(self, execute_arg1, execute_arg2):
|
|
pass
|
|
|
|
def revert(self, execute_arg1, *args, **kwargs):
|
|
pass
|
|
|
|
|
|
class TaskTest(test.TestCase):
|
|
|
|
def test_passed_name(self):
|
|
my_task = MyTask(name='my name')
|
|
self.assertEqual('my name', my_task.name)
|
|
|
|
def test_generated_name(self):
|
|
my_task = MyTask()
|
|
self.assertEqual('%s.%s' % (__name__, 'MyTask'),
|
|
my_task.name)
|
|
|
|
def test_task_str(self):
|
|
my_task = MyTask(name='my')
|
|
self.assertEqual('my==1.0', str(my_task))
|
|
|
|
def test_task_repr(self):
|
|
my_task = MyTask(name='my')
|
|
self.assertEqual('<%s.MyTask my==1.0>' % __name__, repr(my_task))
|
|
|
|
def test_no_provides(self):
|
|
my_task = MyTask()
|
|
self.assertEqual({}, my_task.save_as)
|
|
|
|
def test_provides(self):
|
|
my_task = MyTask(provides='food')
|
|
self.assertEqual({'food': None}, my_task.save_as)
|
|
|
|
def test_multi_provides(self):
|
|
my_task = MyTask(provides=('food', 'water'))
|
|
self.assertEqual({'food': 0, 'water': 1}, my_task.save_as)
|
|
|
|
def test_unpack(self):
|
|
my_task = MyTask(provides=('food',))
|
|
self.assertEqual({'food': 0}, my_task.save_as)
|
|
|
|
def test_bad_provides(self):
|
|
self.assertRaisesRegex(TypeError, '^Atom provides',
|
|
MyTask, provides=object())
|
|
|
|
def test_requires_by_default(self):
|
|
my_task = MyTask()
|
|
expected = {
|
|
'spam': 'spam',
|
|
'eggs': 'eggs',
|
|
'context': 'context'
|
|
}
|
|
self.assertEqual(expected,
|
|
my_task.rebind)
|
|
self.assertEqual(set(['spam', 'eggs', 'context']),
|
|
my_task.requires)
|
|
|
|
def test_requires_amended(self):
|
|
my_task = MyTask(requires=('spam', 'eggs'))
|
|
expected = {
|
|
'spam': 'spam',
|
|
'eggs': 'eggs',
|
|
'context': 'context'
|
|
}
|
|
self.assertEqual(expected, my_task.rebind)
|
|
|
|
def test_requires_explicit(self):
|
|
my_task = MyTask(auto_extract=False,
|
|
requires=('spam', 'eggs', 'context'))
|
|
expected = {
|
|
'spam': 'spam',
|
|
'eggs': 'eggs',
|
|
'context': 'context'
|
|
}
|
|
self.assertEqual(expected, my_task.rebind)
|
|
|
|
def test_requires_explicit_not_enough(self):
|
|
self.assertRaisesRegex(ValueError, '^Missing arguments',
|
|
MyTask,
|
|
auto_extract=False, requires=('spam', 'eggs'))
|
|
|
|
def test_requires_ignores_optional(self):
|
|
my_task = DefaultArgTask()
|
|
self.assertEqual(set(['spam']), my_task.requires)
|
|
self.assertEqual(set(['eggs']), my_task.optional)
|
|
|
|
def test_requires_allows_optional(self):
|
|
my_task = DefaultArgTask(requires=('spam', 'eggs'))
|
|
self.assertEqual(set(['spam', 'eggs']), my_task.requires)
|
|
self.assertEqual(set(), my_task.optional)
|
|
|
|
def test_rebind_includes_optional(self):
|
|
my_task = DefaultArgTask()
|
|
expected = {
|
|
'spam': 'spam',
|
|
'eggs': 'eggs',
|
|
}
|
|
self.assertEqual(expected, my_task.rebind)
|
|
|
|
def test_rebind_all_args(self):
|
|
my_task = MyTask(rebind={'spam': 'a', 'eggs': 'b', 'context': 'c'})
|
|
expected = {
|
|
'spam': 'a',
|
|
'eggs': 'b',
|
|
'context': 'c'
|
|
}
|
|
self.assertEqual(expected, my_task.rebind)
|
|
self.assertEqual(set(['a', 'b', 'c']),
|
|
my_task.requires)
|
|
|
|
def test_rebind_partial(self):
|
|
my_task = MyTask(rebind={'spam': 'a', 'eggs': 'b'})
|
|
expected = {
|
|
'spam': 'a',
|
|
'eggs': 'b',
|
|
'context': 'context'
|
|
}
|
|
self.assertEqual(expected, my_task.rebind)
|
|
self.assertEqual(set(['a', 'b', 'context']),
|
|
my_task.requires)
|
|
|
|
def test_rebind_unknown(self):
|
|
self.assertRaisesRegex(ValueError, '^Extra arguments',
|
|
MyTask, rebind={'foo': 'bar'})
|
|
|
|
def test_rebind_unknown_kwargs(self):
|
|
my_task = KwargsTask(rebind={'foo': 'bar'})
|
|
expected = {
|
|
'foo': 'bar',
|
|
'spam': 'spam'
|
|
}
|
|
self.assertEqual(expected, my_task.rebind)
|
|
|
|
def test_rebind_list_all(self):
|
|
my_task = MyTask(rebind=('a', 'b', 'c'))
|
|
expected = {
|
|
'context': 'a',
|
|
'spam': 'b',
|
|
'eggs': 'c'
|
|
}
|
|
self.assertEqual(expected, my_task.rebind)
|
|
self.assertEqual(set(['a', 'b', 'c']),
|
|
my_task.requires)
|
|
|
|
def test_rebind_list_partial(self):
|
|
my_task = MyTask(rebind=('a', 'b'))
|
|
expected = {
|
|
'context': 'a',
|
|
'spam': 'b',
|
|
'eggs': 'eggs'
|
|
}
|
|
self.assertEqual(expected, my_task.rebind)
|
|
self.assertEqual(set(['a', 'b', 'eggs']),
|
|
my_task.requires)
|
|
|
|
def test_rebind_list_more(self):
|
|
self.assertRaisesRegex(ValueError, '^Extra arguments',
|
|
MyTask, rebind=('a', 'b', 'c', 'd'))
|
|
|
|
def test_rebind_list_more_kwargs(self):
|
|
my_task = KwargsTask(rebind=('a', 'b', 'c'))
|
|
expected = {
|
|
'spam': 'a',
|
|
'b': 'b',
|
|
'c': 'c'
|
|
}
|
|
self.assertEqual(expected, my_task.rebind)
|
|
self.assertEqual(set(['a', 'b', 'c']),
|
|
my_task.requires)
|
|
|
|
def test_rebind_list_bad_value(self):
|
|
self.assertRaisesRegex(TypeError, '^Invalid rebind value',
|
|
MyTask, rebind=object())
|
|
|
|
def test_default_provides(self):
|
|
my_task = DefaultProvidesTask()
|
|
self.assertEqual(set(['def']), my_task.provides)
|
|
self.assertEqual({'def': None}, my_task.save_as)
|
|
|
|
def test_default_provides_can_be_overridden(self):
|
|
my_task = DefaultProvidesTask(provides=('spam', 'eggs'))
|
|
self.assertEqual(set(['spam', 'eggs']), my_task.provides)
|
|
self.assertEqual({'spam': 0, 'eggs': 1}, my_task.save_as)
|
|
|
|
def test_update_progress_within_bounds(self):
|
|
values = [0.0, 0.5, 1.0]
|
|
result = []
|
|
|
|
def progress_callback(event_type, details):
|
|
result.append(details.pop('progress'))
|
|
|
|
a_task = ProgressTask()
|
|
a_task.notifier.register(task.EVENT_UPDATE_PROGRESS, progress_callback)
|
|
a_task.execute(values)
|
|
self.assertEqual(values, result)
|
|
|
|
@mock.patch.object(task.LOG, 'warning')
|
|
def test_update_progress_lower_bound(self, mocked_warning):
|
|
result = []
|
|
|
|
def progress_callback(event_type, details):
|
|
result.append(details.pop('progress'))
|
|
|
|
a_task = ProgressTask()
|
|
a_task.notifier.register(task.EVENT_UPDATE_PROGRESS, progress_callback)
|
|
a_task.execute([-1.0, -0.5, 0.0])
|
|
self.assertEqual([0.0, 0.0, 0.0], result)
|
|
self.assertEqual(2, mocked_warning.call_count)
|
|
|
|
@mock.patch.object(task.LOG, 'warning')
|
|
def test_update_progress_upper_bound(self, mocked_warning):
|
|
result = []
|
|
|
|
def progress_callback(event_type, details):
|
|
result.append(details.pop('progress'))
|
|
|
|
a_task = ProgressTask()
|
|
a_task.notifier.register(task.EVENT_UPDATE_PROGRESS, progress_callback)
|
|
a_task.execute([1.0, 1.5, 2.0])
|
|
self.assertEqual([1.0, 1.0, 1.0], result)
|
|
self.assertEqual(2, mocked_warning.call_count)
|
|
|
|
@mock.patch.object(notifier.LOG, 'warning')
|
|
def test_update_progress_handler_failure(self, mocked_warning):
|
|
|
|
def progress_callback(*args, **kwargs):
|
|
raise Exception('Woot!')
|
|
|
|
a_task = ProgressTask()
|
|
a_task.notifier.register(task.EVENT_UPDATE_PROGRESS, progress_callback)
|
|
a_task.execute([0.5])
|
|
self.assertEqual(1, mocked_warning.call_count)
|
|
|
|
def test_register_handler_is_none(self):
|
|
a_task = MyTask()
|
|
self.assertRaises(ValueError, a_task.notifier.register,
|
|
task.EVENT_UPDATE_PROGRESS, None)
|
|
self.assertEqual(0, len(a_task.notifier))
|
|
|
|
def test_deregister_any_handler(self):
|
|
a_task = MyTask()
|
|
self.assertEqual(0, len(a_task.notifier))
|
|
a_task.notifier.register(task.EVENT_UPDATE_PROGRESS,
|
|
lambda event_type, details: None)
|
|
self.assertEqual(1, len(a_task.notifier))
|
|
a_task.notifier.deregister_event(task.EVENT_UPDATE_PROGRESS)
|
|
self.assertEqual(0, len(a_task.notifier))
|
|
|
|
def test_deregister_any_handler_empty_listeners(self):
|
|
a_task = MyTask()
|
|
self.assertEqual(0, len(a_task.notifier))
|
|
self.assertFalse(a_task.notifier.deregister_event(
|
|
task.EVENT_UPDATE_PROGRESS))
|
|
self.assertEqual(0, len(a_task.notifier))
|
|
|
|
def test_deregister_non_existent_listener(self):
|
|
handler1 = lambda event_type, details: None
|
|
handler2 = lambda event_type, details: None
|
|
a_task = MyTask()
|
|
a_task.notifier.register(task.EVENT_UPDATE_PROGRESS, handler1)
|
|
self.assertEqual(1, len(list(a_task.notifier.listeners_iter())))
|
|
a_task.notifier.deregister(task.EVENT_UPDATE_PROGRESS, handler2)
|
|
self.assertEqual(1, len(list(a_task.notifier.listeners_iter())))
|
|
a_task.notifier.deregister(task.EVENT_UPDATE_PROGRESS, handler1)
|
|
self.assertEqual(0, len(list(a_task.notifier.listeners_iter())))
|
|
|
|
def test_bind_not_callable(self):
|
|
a_task = MyTask()
|
|
self.assertRaises(ValueError, a_task.notifier.register,
|
|
task.EVENT_UPDATE_PROGRESS, 2)
|
|
|
|
def test_copy_no_listeners(self):
|
|
handler1 = lambda event_type, details: None
|
|
a_task = MyTask()
|
|
a_task.notifier.register(task.EVENT_UPDATE_PROGRESS, handler1)
|
|
b_task = a_task.copy(retain_listeners=False)
|
|
self.assertEqual(1, len(a_task.notifier))
|
|
self.assertEqual(0, len(b_task.notifier))
|
|
|
|
def test_copy_listeners(self):
|
|
handler1 = lambda event_type, details: None
|
|
handler2 = lambda event_type, details: None
|
|
a_task = MyTask()
|
|
a_task.notifier.register(task.EVENT_UPDATE_PROGRESS, handler1)
|
|
b_task = a_task.copy()
|
|
self.assertEqual(1, len(b_task.notifier))
|
|
self.assertTrue(a_task.notifier.deregister_event(
|
|
task.EVENT_UPDATE_PROGRESS))
|
|
self.assertEqual(0, len(a_task.notifier))
|
|
self.assertEqual(1, len(b_task.notifier))
|
|
b_task.notifier.register(task.EVENT_UPDATE_PROGRESS, handler2)
|
|
listeners = dict(list(b_task.notifier.listeners_iter()))
|
|
self.assertEqual(2, len(listeners[task.EVENT_UPDATE_PROGRESS]))
|
|
self.assertEqual(0, len(a_task.notifier))
|
|
|
|
def test_separate_revert_args(self):
|
|
my_task = SeparateRevertTask(rebind=('a',), revert_rebind=('b',))
|
|
self.assertEqual({'execute_arg': 'a'}, my_task.rebind)
|
|
self.assertEqual({'revert_arg': 'b'}, my_task.revert_rebind)
|
|
self.assertEqual(set(['a', 'b']),
|
|
my_task.requires)
|
|
|
|
my_task = SeparateRevertTask(requires='execute_arg',
|
|
revert_requires='revert_arg')
|
|
|
|
self.assertEqual({'execute_arg': 'execute_arg'}, my_task.rebind)
|
|
self.assertEqual({'revert_arg': 'revert_arg'}, my_task.revert_rebind)
|
|
self.assertEqual(set(['execute_arg', 'revert_arg']),
|
|
my_task.requires)
|
|
|
|
def test_separate_revert_optional_args(self):
|
|
my_task = SeparateRevertOptionalTask()
|
|
self.assertEqual(set(['execute_arg']), my_task.optional)
|
|
self.assertEqual(set(['revert_arg']), my_task.revert_optional)
|
|
|
|
def test_revert_kwargs(self):
|
|
my_task = RevertKwargsTask()
|
|
expected_rebind = {'execute_arg1': 'execute_arg1',
|
|
'execute_arg2': 'execute_arg2'}
|
|
self.assertEqual(expected_rebind, my_task.rebind)
|
|
expected_rebind = {'execute_arg1': 'execute_arg1'}
|
|
self.assertEqual(expected_rebind, my_task.revert_rebind)
|
|
self.assertEqual(set(['execute_arg1', 'execute_arg2']),
|
|
my_task.requires)
|
|
|
|
|
|
class FunctorTaskTest(test.TestCase):
|
|
|
|
def test_creation_with_version(self):
|
|
version = (2, 0)
|
|
f_task = task.FunctorTask(lambda: None, version=version)
|
|
self.assertEqual(version, f_task.version)
|
|
|
|
def test_execute_not_callable(self):
|
|
self.assertRaises(ValueError, task.FunctorTask, 2)
|
|
|
|
def test_revert_not_callable(self):
|
|
self.assertRaises(ValueError, task.FunctorTask, lambda: None,
|
|
revert=2)
|
|
|
|
|
|
class ReduceFunctorTaskTest(test.TestCase):
|
|
|
|
def test_invalid_functor(self):
|
|
# Functor not callable
|
|
self.assertRaises(ValueError, task.ReduceFunctorTask, 2, requires=5)
|
|
|
|
# Functor takes no arguments
|
|
self.assertRaises(ValueError, task.ReduceFunctorTask, lambda: None,
|
|
requires=5)
|
|
|
|
# Functor takes too few arguments
|
|
self.assertRaises(ValueError, task.ReduceFunctorTask, lambda x: None,
|
|
requires=5)
|
|
|
|
def test_functor_invalid_requires(self):
|
|
# Invalid type, requires is not iterable
|
|
self.assertRaises(TypeError, task.ReduceFunctorTask,
|
|
lambda x, y: None, requires=1)
|
|
|
|
# Too few elements in requires
|
|
self.assertRaises(ValueError, task.ReduceFunctorTask,
|
|
lambda x, y: None, requires=[1])
|
|
|
|
|
|
class MapFunctorTaskTest(test.TestCase):
|
|
|
|
def test_invalid_functor(self):
|
|
# Functor not callable
|
|
self.assertRaises(ValueError, task.MapFunctorTask, 2, requires=5)
|
|
|
|
# Functor takes no arguments
|
|
self.assertRaises(ValueError, task.MapFunctorTask, lambda: None,
|
|
requires=5)
|
|
|
|
# Functor takes too many arguments
|
|
self.assertRaises(ValueError, task.MapFunctorTask, lambda x, y: None,
|
|
requires=5)
|
|
|
|
def test_functor_invalid_requires(self):
|
|
# Invalid type, requires is not iterable
|
|
self.assertRaises(TypeError, task.MapFunctorTask, lambda x: None,
|
|
requires=1)
|