def test_ensure_project_name_is_set_from_attribute_when_instantiating_project(self): module = ModuleType("mock_module") module.name = "mock_module" self.reactor.project = Mock() self.reactor.project_module = module self.reactor.apply_project_attributes() self.assertEqual("mock_module", self.reactor.project.name)
def test_should_run_pylint_with_default_options(self, execute_tool): project = Project(".") init_pylint(project) execute_pylint(project, Mock(Logger)) execute_tool.assert_called_with(project, "pylint", ["pylint"] + DEFAULT_PYLINT_OPTIONS, True)
def test_ensure_task_is_executed_when_calling_execute_task(self): task = Mock(name="spam", dependencies=[]) self.execution_manager.register_task(task) self.execution_manager.resolve_dependencies() self.execution_manager.execute_task(task, a=1) task.execute.assert_called_with(ANY, {"a": 1})
def testForkParamPassing(self): def test_func(foo, bar): return "%s%s" % (foo, bar) val = fork_process(Mock(), target=test_func, kwargs={ "foo": "foo", "bar": 10 }) self.assertEqual(len(val), 2) self.assertEqual(val[0], 0) self.assertEqual(val[1], "foo10") val = fork_process(Mock(), target=test_func, args=("foo", 20)) self.assertEqual(len(val), 2) self.assertEqual(val[0], 0) self.assertEqual(val[1], "foo20")
def test_should_install_plugin(self, execute, tempfile, read_file): read_file.return_value = ["no problems", "so far"] execute.return_value = 0 tempfile.NamedTemporaryFile().__enter__( ).name.__eq__.return_value = True _install_external_plugin(Mock(), "pypi:some-plugin", None, Mock(), None) execute.assert_called_with(PIP_EXEC_STANZA + [ 'install', '--index-url', ANY, '--extra-index-url', ANY, '--trusted-host', ANY, 'some-plugin' ], shell=False, outfile_name=ANY, error_file_name=ANY, cwd=".", env=ANY)
def testForkNoException(self): def test_func(): return "success" val = fork_process(Mock(), target=test_func) self.assertEqual(len(val), 2) self.assertEqual(val[0], 0) self.assertEqual(val[1], "success")
def test_should_raise_exception_when_circular_reference_is_detected_on_single_task( self): one = Mock(name="one", dependencies=[TaskDependency("one")]) self.execution_manager.register_task(one) self.execution_manager.resolve_dependencies() self.assertRaises(CircularTaskDependencyException, self.execution_manager.build_execution_plan, ["one"])
def test_should_return_execution_plan_with_single_task_when_single_task_is_to_be_executed( self): one = Mock(name="one", dependencies=[]) self.execution_manager.register_task(one) self.execution_manager.resolve_dependencies() self.assertEqual([one], self.execution_manager.build_execution_plan(["one"]))
def test_should_discover_source_files_when_test_sources_not_included( self, discover_python_files): project = Mock() project.get_property.return_value = 'source_directory' discover_python_files.return_value = ['foo.py', 'bar.py'] files = discover_affected_files(False, False, project) discover_python_files.assert_called_with('source_directory') self.assertEqual(files, ['foo.py', 'bar.py'])
def test_should_execute_callable_without_arguments(self): def callable(): callable.called = True callable.called = False Task("callable", callable).execute(Mock(), {}) self.assertTrue(callable.called)
def test_build_coverage_report_two_module(self, coverage, render_report): execution_name = "mock coverage" execution_prefix = "mock_coverage" project = Mock() modules = [ Mock(__name__='module_a', __file__='module_a.py'), Mock(__name__='module_b', __file__='module_b.py') ] project.get_property.side_effect = [70, 70, 70, False, False, False] module_a_coverage = Mock() module_a_coverage.statements = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] module_a_coverage.excluded = [] module_a_coverage.missing = [1, 2, 3, 4, 5] n = module_a_coverage.numbers n.n_statements = 10 n.n_excluded = 0 n.n_missing = 5 n.n_branches = 8 n.n_partial_branches = 5 n.n_missing_branches = 5 module_b_coverage = Mock() module_b_coverage.statements = [1, 2, 3, 4, 5] module_b_coverage.excluded = [] module_b_coverage.missing = [1, 2] n = module_b_coverage.numbers n.n_statements = 4 n.n_excluded = 0 n.n_missing = 2 n.n_branches = 8 n.n_partial_branches = 3 n.n_missing_branches = 3 coverage._analyze.side_effect = [module_a_coverage, module_b_coverage] self.assertTrue( _build_coverage_report(project, MagicMock(Logger), execution_name, execution_prefix, coverage, modules) is None ) report = render_report.call_args[0][0] self.assertEqual(report['overall_coverage'], 50) self.assertEqual(report['overall_branch_coverage'], 50) self.assertEqual(report['overall_branch_partial_coverage'], 50)
def test_should_check_that_sphinx_can_be_executed(self, mock_assert_can_execute): mock_logger = Mock(Logger) assert_sphinx_is_available(mock_logger) expected_command_line = ['sphinx-build', '--version'] mock_assert_can_execute.assert_called_with(expected_command_line, 'sphinx', 'plugin python.sphinx')
def test_should_run_pylint_with_custom_options(self, execute_tool): project = Project(".") init_pylint(project) project.set_property("pylint_options", ["--test", "-f", "--x=y"]) execute_pylint(project, Mock(Logger)) execute_tool.assert_called_with(project, "pylint", ["pylint", "--test", "-f", "--x=y"], True)
def test_should_check_that_gzip_is_executable(self, mock_assert_can_execute): mock_logger = Mock(Logger) assert_gzip_is_executable(mock_logger) mock_assert_can_execute.assert_called_with( caller="plugin ronn_manpage_plugin", command_and_arguments=["gzip", "--version"], prerequisite="gzip")
def test_should_set_default_properties(self, mock_execute_tests_matching): mock_project = Mock(Project) init_test_source_directory(mock_project) self.assertEquals(mock_project.set_property_if_unset.call_args_list, [call('dir_source_unittest_python', 'src/unittest/python'), call('pyfix_unittest_module_glob', '*_pyfix_tests'), call('pyfix_unittest_file_suffix', None)])
def test_should_execute_tool_on_source_files(self, affected, execute, read, log): project = Mock() project.expand_path.return_value = '/path/to/report' affected.return_value = ['file1', 'file2'] execute_tool_on_source_files(project, 'name', 'foo --bar') execute.assert_called_with(['foo --bar', 'file1', 'file2'], '/path/to/report')
def test_build_coverage_report_two_module(self, coverage, render_report): execution_name = "mock" execution_description = "mock coverage" config_prefix = "mock_coverage" project = Mock() source_path = "" module_names = ["module_a", "module_b"] module_files = ["module_a.py", "module_b.py"] project.get_property.side_effect = [70, 70, 70, False, False, False] module_a_coverage = Mock() module_a_coverage.statements = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] module_a_coverage.excluded = [] module_a_coverage.missing = [1, 2, 3, 4, 5] n = module_a_coverage.numbers n.n_statements = 10 n.n_excluded = 0 n.n_missing = 5 n.n_branches = 8 n.n_partial_branches = 5 n.n_missing_branches = 5 module_b_coverage = Mock() module_b_coverage.statements = [1, 2, 3, 4, 5] module_b_coverage.excluded = [] module_b_coverage.missing = [1, 2] n = module_b_coverage.numbers n.n_statements = 4 n.n_excluded = 0 n.n_missing = 2 n.n_branches = 8 n.n_partial_branches = 3 n.n_missing_branches = 3 coverage._analyze.side_effect = [module_a_coverage, module_b_coverage] self.assertTrue(_build_coverage_report(project, MagicMock(Logger), execution_description, execution_name, config_prefix, coverage, source_path, module_names, module_files) is None) report = render_report.call_args[0][0] self.assertEqual(report["overall_coverage"], 50) self.assertEqual(report["overall_branch_coverage"], 50) self.assertEqual(report["overall_branch_partial_coverage"], 50)
def test_execute_command(self, popen, _): popen.return_value = Mock() popen.return_value.wait.return_value = 0 self.assertEquals(execute_command(["test", "commands"]), 0) self.assertEquals( execute_command(["test", "commands"], outfile_name="test.out"), 0) self.assertEquals( execute_command(["test", "commands"], outfile_name="test.out", error_file_name="test.out.err"), 0)
def test_verify_late_dependency(self): one = Mock(name="one", dependencies=[]) two = Mock(name="two", dependencies=[TaskDependency("one")]) three = Mock(name="three", dependencies=[TaskDependency("one")]) self.execution_manager.register_task(one, two) self.execution_manager.register_task(three) self.execution_manager.register_late_task_dependencies( {"two": [TaskDependency("three")]}) self.execution_manager.resolve_dependencies() self.assertEqual([], self.execution_manager._task_dependencies.get("one")) self.assertEqual( [TaskDependency(one), TaskDependency(three)], self.execution_manager._task_dependencies.get("two")) self.assertEqual( [TaskDependency(one)], self.execution_manager._task_dependencies.get("three"))
def test_shortest_execution_plan_always_executes_target(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.assertEqual( [three], self.execution_manager.build_shortest_execution_plan("three")) self.execution_manager._tasks_executed.append(three) self.assertEqual( [three], self.execution_manager.build_shortest_execution_plan("three"))
def test_should_check_that_ronn_is_executable(self, mock_assert_can_execute): mock_logger = Mock(Logger) assert_ronn_is_executable(mock_logger) mock_assert_can_execute.assert_called_with( caller='plugin ronn_manpage_plugin', command_and_arguments=['ronn', '--version'], prerequisite='ronn')
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.assertEqual([], self.execution_manager._task_dependencies.get("one")) self.assertEqual([TaskDependency(one)], self.execution_manager._task_dependencies.get("two")) self.assertEqual( [TaskDependency(one), TaskDependency(two)], self.execution_manager._task_dependencies.get("three"))
def test_should_load_tests_from_discovered_modules( self, mock_discover_modules_matching, mock_unittest, runner): mock_modules = Mock() mock_discover_modules_matching.return_value = mock_modules execute_tests_matching(runner, self.mock_logger, '/path/to/test/sources', '*_tests.py') mock_unittest.defaultTestLoader.loadTestsFromNames.assert_called_with( mock_modules)
def test_should_return_actual_test_results(self, mock_discover_modules, mock_unittest, runner): mock_tests = Mock() mock_unittest.defaultTestLoader.loadTestsFromNames.return_value = mock_tests runner.return_value.run.return_value = self.mock_result actual, _ = execute_tests(runner, self.mock_logger, '/path/to/test/sources', '_tests.py') self.assertEqual(self.mock_result, actual)
def test_should_run_discovered_and_loaded_tests(self, mock_discover_modules, mock_unittest, runner): mock_tests = Mock() mock_unittest.defaultTestLoader.loadTestsFromNames.return_value = mock_tests execute_tests(runner, self.mock_logger, '/path/to/test/sources', '_tests.py') runner.return_value.run.assert_called_with(mock_tests)
def test_should_discover_source_files_when_scripts_are_included( self, discover_files_matching, _): project = Mock() project.get_property.return_value = True project.get_property.side_effect = lambda _property: _property discover_affected_files(False, True, project) discover_files_matching.assert_called_with('dir_source_main_scripts', '*')
def test_should_execute_callable_with_single_arguments(self): def callable(spam): callable.called = True callable.spam = spam callable.called = False Task("callable", callable).execute(Mock(), {"spam": "spam"}) self.assertTrue(callable.called) self.assertEqual("spam", callable.spam)
def setUp(self): self.logger = Mock(Logger) self.dependencies_to_install_with_pip = [ Dependency('test'), Dependency('pip') ] self.dependencies_to_install_without_pip = [ Dependency('test'), Dependency('test2') ] from pybuilder import pip_common, pip_utils self.pip_common_object = pip_common.Version("1.2.3") self.pip_utils_method = pip_utils.pip_install
def test_should_check_that_pylint_can_be_executed(self, mock_assert_can_execute): mock_logger = Mock(Logger) check_pep8_available(mock_logger) expected_command_line = ('pep8', ) mock_assert_can_execute.assert_called_with(expected_command_line, 'pep8', 'plugin python.pep8')
def test_should_discover_source_files_when_test_sources_are_included(self, discover_python_files): project = Mock() project.get_property.side_effect = lambda _property: _property discover_affected_files(True, False, project) self.assertEqual(discover_python_files.call_args_list, [call('dir_source_main_python'), call('dir_source_unittest_python'), call('dir_source_integrationtest_python')])