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_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_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_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_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 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_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_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_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_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_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_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_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_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_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_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_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_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"])