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')])
