def test_should_collect_all_tasks_when_several_tasks_given(self):
one = mock(name="one", dependencies=[], optional_dependencies=[])
two = mock(name="two", dependencies=["three"])
three = mock(name="three", dependencies=[], optional_dependencies=[])
self.execution_manager.register_task(one, two, three)
self.assertEqual(self.execution_manager.collect_all_transitive_tasks(["one", "two"]), set([one, two, three]))
def test_should_collect_all_tasks_when_there_is_a_simple_dependency(self):
one = mock(name="one", dependencies=[TaskDependency("two")])
two = mock(name="two", dependencies=[])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies()
self.assertEqual(self.execution_manager.collect_all_transitive_tasks(["one"]), set([one, two]))
def test_ensure_project_attributes_are_set_when_instantiating_project(self):
module = mock(
version="version",
default_task="default_task",
summary="summary",
home_page="home_page",
description="description",
authors="authors",
license="license",
url="url",
)
self.reactor.project = mock()
self.reactor.project_module = module
self.reactor.apply_project_attributes()
self.assertEquals("version", self.reactor.project.version)
self.assertEquals("default_task", self.reactor.project.default_task)
self.assertEquals("summary", self.reactor.project.summary)
self.assertEquals("home_page", self.reactor.project.home_page)
self.assertEquals("description", self.reactor.project.description)
self.assertEquals("authors", self.reactor.project.authors)
self.assertEquals("license", self.reactor.project.license)
self.assertEquals("url", self.reactor.project.url)
def setUp(self):
self.project = mock()
self.fist_delegatee = mock()
self.second_delegatee = mock()
self.loader = DispatchingPluginLoader(
mock, self.fist_delegatee, self.second_delegatee)
def test_ensure_after_action_teardown_suppression_works_when_action_fails(self):
task = mock(name="task", dependencies=[])
action_regular = mock(name="action_regular", execute_before=[], execute_after=["task"], teardown=False)
when(action_regular).execute({}).thenRaise(ValueError("simulated action error"))
action_teardown = mock(name="action_teardown", execute_before=[], execute_after=["task"], teardown=True)
action_after_teardown = mock(name="action_after_teardown", execute_before=[], execute_after=["task"],
teardown=False)
self.execution_manager.register_action(action_regular)
self.execution_manager.register_action(action_teardown)
self.execution_manager.register_action(action_after_teardown)
self.execution_manager.register_task(task)
self.execution_manager.resolve_dependencies()
try:
self.execution_manager.execute_task(task)
self.assertTrue(False, "should not have reached here")
except Exception as e:
self.assertEquals(type(e), ValueError)
self.assertEquals(str(e), "simulated action error")
verify(task).execute(any(), {})
verify(action_regular).execute({})
verify(action_teardown).execute({})
verify(action_after_teardown, times(0)).execute({})
def test_ensure_after_action_teardown_is_executed_and_suppresses(self):
task = mock(name="task", dependencies=[])
when(task).execute(any(), {}).thenRaise(ValueError("simulated task error"))
action_teardown1 = mock(name="action_teardown1", execute_before=[], execute_after=["task"], teardown=True,
source="task")
when(action_teardown1).execute({}).thenRaise(ValueError("simulated action error teardown1"))
action_teardown2 = mock(name="action_teardown2", execute_before=[], execute_after=["task"], teardown=True,
source="task")
self.execution_manager.register_action(action_teardown1)
self.execution_manager.register_action(action_teardown2)
self.execution_manager.register_task(task)
self.execution_manager.resolve_dependencies()
try:
self.execution_manager.execute_task(task)
self.assertTrue(False, "should not have reached here")
except Exception as e:
self.assertEquals(type(e), ValueError)
self.assertEquals(str(e), "simulated task error")
verify(task).execute(any(), {})
verify(action_teardown1).execute({})
verify(action_teardown2).execute({})
verify(self.execution_manager.logger).error(
"Executing action '%s' from '%s' resulted in an error that was suppressed:\n%s", "action_teardown1",
"task", any())
def test_should_only_collect_required_tasks(self):
one = mock(name="one", dependencies=["three"])
two = mock(name="two", dependencies=[])
three = mock(name="three", dependencies=[])
self.execution_manager.register_task(one, two, three)
self.assertEqual(self.execution_manager.collect_all_transitive_tasks(["one"]), set([one, three]))
def test_ensure_that_required_tasks_are_not_optionally_excluded(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[TaskDependency("one")])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies(exclude_optional_tasks=["one"])
self.assertRaises(RequiredTaskExclusionException, self.execution_manager.build_execution_plan, "two")
def test_ensure_that_tasks_are_not_executed_multiple_times_when_being_dependencies(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=["one"])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies()
self.assertEqual([one, two], self.execution_manager.build_execution_plan(["one", "two"]))
def test_ensure_that_dependencies_are_executed_before_root_task(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=["one"])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies()
self.assertEqual([one, two], self.execution_manager.build_execution_plan(["two"]))
def test_ensure_project_name_is_set_from_attribute_when_instantiating_project(self):
module = mock(name="name")
self.reactor.project = mock()
self.reactor.project_module = module
self.reactor.apply_project_attributes()
self.assertEquals("name", self.reactor.project.name)
def test_should_return_execution_plan_with_two_tasks_when_two_tasks_are_to_be_executed(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies()
self.assertEqual([one, two], self.execution_manager.build_execution_plan(["one", "two"]))
def test_ensure_task_is_replaced_when_registering_two_tasks_with_same_name(self):
original = mock(name="spam")
replacement = mock(name="spam")
self.execution_manager.register_task(original)
self.execution_manager.register_task(replacement)
verify(original).extend(replacement)
def test_ensure_that_dependencies_are_resolved_when_simple_dependency_is_found(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[TaskDependency("one")])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies()
self.assertEquals([], self.execution_manager._task_dependencies.get("one"))
self.assertEquals([TaskDependency(one)], self.execution_manager._task_dependencies.get("two"))
def test_override_optional_dependency_with_required(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[TaskDependency("one", True), TaskDependency("one")])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies()
self.assertEquals([], self.execution_manager._task_dependencies.get("one"))
self.assertEquals([TaskDependency(one)], self.execution_manager._task_dependencies.get("two"))
def test_ignore_second_required_dependency(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[TaskDependency("one"), TaskDependency("one")])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies()
self.assertEquals([], self.execution_manager._task_dependencies.get("one"))
self.assertEquals([TaskDependency(one)], self.execution_manager._task_dependencies.get("two"))
def test_should_raise_exception_when_circular_reference_is_detected_on_two_tasks(self):
one = mock(name="one", dependencies=[TaskDependency("two")])
two = mock(name="two", dependencies=[TaskDependency("one")])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies()
self.assertRaises(CircularTaskDependencyException,
self.execution_manager.build_execution_plan, ["one"])
def test_ensure_that_required_tasks_are_force_excluded(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[TaskDependency("one")])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies(exclude_tasks=["one"])
execution_plan = self.execution_manager.build_execution_plan("two")
self.assertEquals([two], execution_plan)
def test_should_raise_exception_when_circular_reference_is_detected_on_indirect_required_tasks(self):
one = mock(name="one", dependencies=["two"], optional_dependencies=[])
two = mock(name="two", dependencies=["three"], optional_dependencies=[])
three = mock(name="three", dependencies=["two"], optional_dependencies=[])
self.execution_manager.register_task(one, two, three)
self.execution_manager.resolve_dependencies()
self.assertRaises(CircularTaskDependencyException,
self.execution_manager.build_execution_plan, ["one"])
def test_ensure_tasks_are_executed(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies()
self.execution_manager.execute_execution_plan([one, two])
verify(one).execute(any(), {})
verify(two).execute(any(), {})
def test_ensure_that_optional_branch_is_excluded(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[TaskDependency("one")])
three = mock(name="three", dependencies=[TaskDependency("two", True)])
self.execution_manager.register_task(one, two, three)
self.execution_manager.resolve_dependencies(exclude_optional_tasks=["two"])
execution_plan = self.execution_manager.build_execution_plan("three")
self.assertEquals([three], execution_plan)
def test_ensure_after_action_is_executed_when_task_is_executed(self):
task = mock(name="task", dependencies=[])
action = mock(name="action", execute_before=[], execute_after=["task"])
self.execution_manager.register_action(action)
self.execution_manager.register_task(task)
self.execution_manager.resolve_dependencies()
self.execution_manager.execute_task(task)
verify(action).execute({})
verify(task).execute(any(), {})
def test_ensure_that_dependencies_are_resolved_when_task_depends_on_multiple_tasks(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[TaskDependency("one")])
three = mock(name="three", dependencies=[TaskDependency("one"), TaskDependency("two")])
self.execution_manager.register_task(one, two, three)
self.execution_manager.resolve_dependencies()
self.assertEquals([], self.execution_manager._task_dependencies.get("one"))
self.assertEquals([TaskDependency(one)], self.execution_manager._task_dependencies.get("two"))
self.assertEquals(
[TaskDependency(one), TaskDependency(two)], self.execution_manager._task_dependencies.get("three"))
def test_ensure_that_required_tasks_are_force_excluded(self):
one = mock(name="one", dependencies=[], optional_dependencies=[])
two = mock(name="two", dependencies=["one"], optional_dependencies=[])
self.execution_manager.register_task(one, two)
self.execution_manager.resolve_dependencies(exclude_tasks=["one"])
self.assertEquals(
[], self.execution_manager._task_dependencies.get("one"))
self.assertEquals(
[], self.execution_manager._task_dependencies.get("two"))
def test_ensure_action_registered_for_two_tasks_is_executed_only_once_if_single_attribute_is_present(self):
spam = mock(name="spam", dependencies=[])
eggs = mock(name="eggs", dependencies=[])
self.execution_manager.register_task(spam, eggs)
action = mock(name="action", execute_before=[], execute_after=["spam", "eggs"], only_once=True)
self.execution_manager.register_action(action)
self.execution_manager.resolve_dependencies()
self.execution_manager.execute_execution_plan([spam, eggs])
verify(action, times(1)).execute(any())
def test_shortest_execution_plan_checks_circularity(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[TaskDependency("one")])
three = mock(name="three", dependencies=[TaskDependency("two")])
self.execution_manager.register_task(one, two, three)
self.execution_manager.resolve_dependencies()
self.execution_manager._tasks_executed.append(one)
self.execution_manager._current_task = two
self.assertRaises(CircularTaskDependencyException, self.execution_manager.build_shortest_execution_plan,
["three"])
def test_ensure_that_registered_initializers_are_executed_when_calling_execute_initializers(self):
initializer_1 = mock()
when(initializer_1).is_applicable(any()).thenReturn(True)
self.execution_manager.register_initializer(initializer_1)
initializer_2 = mock()
when(initializer_2).is_applicable(any()).thenReturn(True)
self.execution_manager.register_initializer(initializer_2)
self.execution_manager.execute_initializers(a=1)
verify(initializer_1).execute({"a": 1})
verify(initializer_2).execute({"a": 1})
def test_is_task_in_current_execution_plan(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[TaskDependency("one")])
three = mock(name="three", dependencies=[TaskDependency("one"), TaskDependency("two")])
self.execution_manager.register_task(one, two, three)
self.execution_manager.resolve_dependencies(exclude_all_optional=True)
self.execution_manager._current_execution_plan = self.execution_manager.build_execution_plan("three")
self.assertTrue(self.execution_manager.is_task_in_current_execution_plan("three"))
self.assertTrue(self.execution_manager.is_task_in_current_execution_plan("two"))
self.assertTrue(self.execution_manager.is_task_in_current_execution_plan("one"))
self.assertFalse(self.execution_manager.is_task_in_current_execution_plan("four"))
def test_task_dependencies(self):
import pybuilder.reactor
when(pybuilder.reactor).Task().thenReturn(mock())
@task
def task1():
pass
@task
@depends(task1)
def task2():
pass
@task
def task3():
pass
@task
@depends(optional(task3))
@dependents("task6")
def task4():
pass
@task
@dependents("task6", optional(task3))
def task5():
pass
@task
@depends(task1, optional(task2))
def task6():
pass
module = mock()
module.task1 = task1
module.task2 = task2
module.task3 = task3
module.task4 = task4
module.task5 = task5
module.task6 = task6
self.reactor.collect_tasks_and_actions_and_initializers(module)
inorder.verify(pybuilder.reactor).Task("task1", task1, [], '')
inorder.verify(pybuilder.reactor).Task("task2", task2, [TaskDependency(task1)], '')
inorder.verify(pybuilder.reactor).Task("task3", task3, [TaskDependency(task5, True)], '')
inorder.verify(pybuilder.reactor).Task("task4", task4, [TaskDependency(task3, True)], '')
inorder.verify(pybuilder.reactor).Task("task5", task5, [], '')
inorder.verify(pybuilder.reactor).Task("task6", task6, [TaskDependency(task1), TaskDependency(task2, True),
TaskDependency(task4), TaskDependency(task5)], '')
def test_shortest_execution_plan_reruns_on_demand(self):
one = mock(name="one", dependencies=[])
two = mock(name="two", dependencies=[TaskDependency("one")])
three = mock(name="three", dependencies=[TaskDependency("two")])
self.execution_manager.register_task(one, two, three)
self.execution_manager.resolve_dependencies()
self.execution_manager._tasks_executed.append(one)
self.execution_manager._tasks_executed.append(two)
self.assertEquals([two, three], self.execution_manager.build_shortest_execution_plan(("two", "three")))
self.assertEquals([two, three], self.execution_manager.build_shortest_execution_plan(("three", "two")))
self.assertEquals([one, two, three], self.execution_manager.build_shortest_execution_plan(("three", "one")))
def test_should_collect_all_tasks_when_there_are_no_dependencies(self):
one = mock(name="one", dependencies=[])
self.execution_manager.register_task(one)
self.assertEqual(self.execution_manager.collect_all_transitive_tasks(["one"]), set([one]))
def test_should_collect_all_tasks_when_there_is_a_simple_dependency(self):
one = mock(name="one", dependencies=["two"])
two = mock(name="two", dependencies=[])
self.execution_manager.register_task(one, two)
self.assertEqual(self.execution_manager.collect_all_transitive_tasks(["one"]), set([one, two]))
def setUp(self):
self.execution_manager = ExecutionManager(mock(Logger))
def setUp(self):
self.plugin_loader_mock = mock(PluginLoader)
self.logger = mock()
self.execution_manager = mock(ExecutionManager)
self.reactor = Reactor(
self.logger, self.execution_manager, self.plugin_loader_mock)
def test_ensure_action_is_registered(self):
action = mock(name="action")
self.execution_manager.register_action(action)
self.assertEquals({"action": action}, self.execution_manager._actions)
def setUp(self):
self.project = mock()
self.loader = BuiltinPluginLoader(mock())
def test_version_exact_match(self):
plugin_module = mock()
pluginloader.PYB_VERSION = Version("1.2.3")
plugin_module.pyb_version = "===1.2.3"
_check_plugin_version(plugin_module, "test plugin")
def test_version_compatible_match(self):
plugin_module = mock()
pluginloader.PYB_VERSION = Version("1.2.3")
plugin_module.pyb_version = "~=1.2"
_check_plugin_version(plugin_module, "test plugin")
def test_version_multiple_specifier_match(self):
plugin_module = mock()
pluginloader.PYB_VERSION = Version("1.2.3")
plugin_module.pyb_version = ">=1.2.0,<=1.2.4"
_check_plugin_version(plugin_module, "test plugin")
def test_ensure_that_initializer_is_added_when_calling_register_initializer(
self):
initializer = mock()
self.execution_manager.register_initializer(initializer)
self.assertEquals([initializer], self.execution_manager.initializers)
def test_should_return_all_task_names(self):
self.execution_manager.register_task(mock(name="spam"),
mock(name="eggs"))
self.assertEquals(["eggs", "spam"], self.execution_manager.task_names)
def test_should_raise_exception_when_callable_argument_cannot_be_satisfied(self):
def callable(spam):
pass
executable = Task("callable", callable)
self.assertRaises(ValueError, executable.execute, mock(), {})
def test_should_return_single_task_name(self):
self.execution_manager.register_task(mock(name="spam"))
self.assertEquals(["spam"], self.execution_manager.task_names)
def test_should_raise_exception_when_project_is_not_valid(self):
self.reactor.project = mock(properties={})
when(self.reactor.project).validate().thenReturn(["spam"])
self.assertRaises(ProjectValidationFailedException, self.reactor.build)
def test_should_raise_exception_when_calling_execute_task_before_resolve_dependencies(
self):
self.assertRaises(DependenciesNotResolvedException,
self.execution_manager.execute_task, mock())
def test_should_return_project_property_when_property_is_defined(self):
project_mock = mock(Project, name="my name")
self.assertEquals("my name", ProjectDictWrapper(project_mock)["name"])
verify(project_mock, never).get_property("name", "name")
def test_ensure_task_is_added_when_calling_register_task(self):
task = mock()
self.execution_manager.register_task(task)
self.assertEquals([task], self.execution_manager.tasks)
def setUp(self):
self.project = mock()
self.loader = ThirdPartyPluginLoader(mock())
def test_version_no_match(self):
plugin_module = mock()
pluginloader.PYB_VERSION = Version("1.2.3")
plugin_module.pyb_version = ">=1.2.5"
self.assertRaises(IncompatiblePluginException, _check_plugin_version,
plugin_module, "test plugin")
