示例#1
0
    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]))
示例#3
0
    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())
示例#7
0
    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")
示例#9
0
    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"]))
示例#10
0
    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"]))
示例#11
0
    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)
示例#12
0
    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"]))
示例#13
0
    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)
示例#14
0
    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"))
示例#15
0
    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"))
示例#16
0
    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"))
示例#17
0
    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"])
示例#18
0
    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)
示例#19
0
    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"])
示例#20
0
    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(), {})
示例#21
0
    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)
示例#22
0
    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(), {})
示例#23
0
    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"))
示例#24
0
    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"))
示例#25
0
    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())
示例#26
0
    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"])
示例#27
0
    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})
示例#28
0
    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"))
示例#29
0
    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)], '')
示例#30
0
    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")))
示例#31
0
    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]))
示例#32
0
    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]))
示例#33
0
 def setUp(self):
     self.execution_manager = ExecutionManager(mock(Logger))
示例#34
0
 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)
示例#35
0
 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)
示例#36
0
 def setUp(self):
     self.project = mock()
     self.loader = BuiltinPluginLoader(mock())
示例#37
0
 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")
示例#38
0
 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")
示例#39
0
 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")
示例#40
0
 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)
示例#41
0
 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)
示例#42
0
    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(), {})
示例#43
0
 def test_should_return_single_task_name(self):
     self.execution_manager.register_task(mock(name="spam"))
     self.assertEquals(["spam"], self.execution_manager.task_names)
示例#44
0
    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)
示例#45
0
 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")
示例#47
0
 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)
示例#48
0
 def setUp(self):
     self.project = mock()
     self.loader = ThirdPartyPluginLoader(mock())
示例#49
0
 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")