Example #1
0
    def test_task_dependencies_with_post_definition_injections_custom_names(self):
        import pybuilder.reactor

        with patch("pybuilder.reactor.Task"):
            @task
            def task1():
                pass

            @task
            @depends(task1)
            def task2():
                pass

            @task("task_3")
            @depends(task1)
            @dependents(task2)
            def task3():
                pass

            module1 = ModuleType("mock_module_one")
            module1.task1 = task1
            module1.task2 = task2

            module2 = ModuleType("mock_module_two")
            module2.task3 = task3

            self.reactor.collect_tasks_and_actions_and_initializers(module1)
            pybuilder.reactor.Task.assert_has_calls([call("task1", task1, [], ''),
                                                     call("task2", task2, [TaskDependency(task1)], '')])

            self.reactor.collect_tasks_and_actions_and_initializers(module2)
            pybuilder.reactor.Task.assert_has_calls([call("task_3", task3, [TaskDependency(task1)], '')])
            self.execution_manager.register_late_task_dependencies.assert_has_calls(
                [call({}), call({"task2": [TaskDependency("task_3")]})])
    def test_running_plugin_cram_from_target(self,
                                             execute_mock,
                                             read_file_mock,
                                             os_mock,
                                             report_mock,
                                             find_files_mock,
                                             command_mock
                                             ):
        project = Project('.')
        project.set_property('cram_run_test_from_target', True)
        project.set_property('dir_dist', 'python')
        project.set_property('dir_dist_scripts', 'scripts')
        project.set_property('verbose', False)
        logger = Mock()

        command_mock.return_value = ['cram']
        find_files_mock.return_value = ['test1.cram', 'test2.cram']
        report_mock.return_value = 'report_file'
        os_mock.copy.return_value = {}
        read_file_mock.return_value = ['test failes for file', '# results']
        execute_mock.return_value = 0

        run_cram_tests(project, logger)
        execute_mock.assert_called_once_with(
            ['cram', 'test1.cram', 'test2.cram'], 'report_file',
            error_file_name='report_file',
            env={'PYTHONPATH': './python:', 'PATH': './python/scripts:'}
        )
        expected_info_calls = [call('Running Cram command line tests'),
                               call('Cram tests were fine'),
                               call('results'),
                               ]
        self.assertEquals(expected_info_calls, logger.info.call_args_list)
    def test_should_output_happypath_test_for_teamcity(self, output):
        with TeamCityTestProxy().and_test_name('important-test'):
            pass

        self.assertEqual(output.call_args_list,
                         [
                             call("##teamcity[testStarted name='important-test']"),
                             call("##teamcity[testFinished name='important-test']")
                         ])
Example #4
0
    def test_should_render_verbose_task_list_with_descriptions(self, print_text_line):
        self.task_1.description = ["any", "description", "for", "task", "1"]
        self.task_2.description = ["any", "description", "for", "task", "2"]

        print_list_of_tasks(self.mock_reactor, quiet=False)

        print_text_line.assert_has_calls([call('Tasks found for project "any-project-name":'),
                                          call('    task-1 - any description for task 1'),
                                          call('    task-2 - any description for task 2')])
    def test_should_set_default_properties(self, mock_execute_tests_matching):
        mock_project = Mock(Project)

        init_test_source_directory(mock_project)

        self.assertEqual(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)])
Example #6
0
    def test_should_raise_when_verifying_project_directory_and_build_descriptor_does_not_exist(
        self, os_path_abspath, os_path_exists, os_path_isdir, os_path_join
    ):
        self.assertRaises(PyBuilderException, self.reactor.verify_project_directory, "spam", "eggs")

        os_path_abspath.assert_called_with("spam")
        os_path_exists.assert_has_calls([call("spam"), call("spam/eggs")])
        os_path_isdir.assert_called_with("spam")
        os_path_join.assert_called_with("spam", "eggs")
Example #7
0
    def test_should_render_verbose_task_list_with_dependencies(self, print_text_line):
        self.task_1.dependencies = ["any-dependency", "any-other-dependency"]

        print_list_of_tasks(self.mock_reactor, quiet=False)

        print_text_line.assert_has_calls([call('Tasks found for project "any-project-name":'),
                                          call('    task-1 - <no description available>'),
                                          call('             depends on tasks: any-dependency any-other-dependency'),
                                          call('    task-2 - <no description available>')])
Example #8
0
    def test_should_return_directory_and_full_path_of_descriptor_when_verifying_project_directory(
        self, os_path_abspath, os_path_exists, os_path_isdir, os_path_join, os_path_isfile
    ):
        self.assertEquals(("/spam", "/spam/eggs"), self.reactor.verify_project_directory("spam", "eggs"))

        os_path_abspath.assert_called_with("spam")
        os_path_exists.assert_has_calls([call("/spam"), call("/spam/eggs")])
        os_path_isdir.assert_called_with("/spam")
        os_path_join.assert_called_with("/spam", "eggs")
        os_path_isfile.assert_called_with("/spam/eggs")
    def test_should_output_failed_test_for_teamcity(self, output):
        with TeamCityTestProxy().and_test_name('important-test') as test:
            test.fails('booom')

        self.assertEqual(output.call_args_list,
                         [
                             call("##teamcity[testStarted name='important-test']"),
                             call("##teamcity[testFailed name='important-test' message='See details' details='booom']"),
                             call("##teamcity[testFinished name='important-test']")
                         ])
Example #10
0
    def test_should_check_that_sphinx_can_be_executed(self, mock_assert_can_execute):
        mock_logger = Mock(Logger)

        assert_sphinx_is_available(mock_logger)

        mock_assert_can_execute.assert_has_calls(
            [
                call(['sphinx-build', '--version'], 'sphinx', 'plugin python.sphinx'),
                call(['sphinx-apidoc', '--version'], 'sphinx', 'plugin python.sphinx')
            ]
        )
    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')])
Example #12
0
    def test_should_set_up_project_when_directories_missing(self, mock_os):
        scaffolding = PythonProjectScaffolding('some-project')
        mock_os.path.exists.return_value = False

        scaffolding.set_up_project()

        self.assertEqual(mock_os.makedirs.call_args_list,
                         [
                             call('src/main/python'),
                             call('src/unittest/python'),
                             call('docs'),
                             call('src/main/scripts')
                         ])
Example #13
0
    def test_ensure_action_registered_for_two_tasks_is_executed_two_times(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=False)
        self.execution_manager.register_action(action)

        self.execution_manager.resolve_dependencies()

        self.execution_manager.execute_execution_plan([spam, eggs])

        action.execute.assert_has_calls([call(ANY), call(ANY)])
    def test_should_discover_source_dirs_when_script_sources_are_included(self, _):
        project = Mock()

        project.get_property.side_effect = lambda _property: (
            _property if _property != 'dir_source_integrationtest_python' else None)

        files = discover_affected_dirs(False, True, project)

        self.assertEqual(project.get_property.call_args_list,
                         [call('dir_source_main_python'),
                          call('dir_source_main_scripts'),
                          call('dir_source_main_scripts')])
        self.assertEqual(files,
                         ['dir_source_main_python', 'dir_source_main_scripts'])
    def test_sphinx_generate(self,
                             execute_command,
                             mkdir,
                             exists,
                             rmtree,
                             open
                             ):
        execute_command.return_value = 0
        exists.return_value = True

        sphinx_mock = Mock()
        sys.modules["sphinx"] = sphinx_mock

        try:
            sphinx_mock.version_info = (1, 5, 3, 4, 5)

            self.project.set_property("sphinx_source_dir", "sphinx_source_dir")
            self.project.set_property("sphinx_config_path", "sphinx_config_path")
            self.project.set_property("sphinx_output_dir", "sphinx_output_dir")
            self.project.set_property("dir_target", "dir_target")
            self.project.set_property("dir_source_main_python", "dir_source")
            self.project.set_property("sphinx_project_name", "project_name")
            self.project.set_property("sphinx_project_conf", {"a": 1, "b": "foo"})
            self.project.set_property("sphinx_run_apidoc", True)
            self.project.set_property("sphinx_doc_builder", ['JSONx', 'pdf'])

            sphinx_generate(self.project, Mock())
        finally:
            del sys.modules["sphinx"]

        exists.assert_called_with(nc("basedir/dir_target/sphinx_pyb/apidoc"))
        rmtree.assert_called_with(nc("basedir/dir_target/sphinx_pyb/apidoc"))
        mkdir.assert_called_with(nc("basedir/dir_target/sphinx_pyb/apidoc"))
        print(open().__enter__().write.call_args_list)
        open().__enter__().write.assert_has_calls([call("a = 1\n"), call("b = 'foo'\n"), call(
            "\nimport sys\nsys.path.insert(0, %r)\n" % nc("basedir/dir_source"))], any_order=True)
        execute_command.assert_has_calls([
            call([sys.executable, '-m', 'sphinx.apidoc', '-H', 'project_name', '-o',
                  nc('basedir/dir_target/sphinx_pyb/apidoc'), nc('basedir/dir_source')]
                 if sys.version_info[:2] < (3, 3) else
                 [sys.executable, '-m', 'sphinx.apidoc', '-H', 'project_name', '--implicit-namespaces', '-o',
                 nc('basedir/dir_target/sphinx_pyb/apidoc'), nc('basedir/dir_source')],
                 nc('basedir/dir_target/reports/sphinx-apidoc'), shell=False),
            call([sys.executable, '-m', 'sphinx', '-b', 'JSONx', nc('basedir/sphinx_config_path'),
                 nc('basedir/sphinx_output_dir/JSONx')],
                 nc('basedir/dir_target/reports/sphinx_JSONx'), shell=False),
            call([sys.executable, '-m', 'sphinx', '-b', 'pdf', nc('basedir/sphinx_config_path'),
                 nc('basedir/sphinx_output_dir/pdf')],
                 nc('basedir/dir_target/reports/sphinx_pdf'), shell=False)])
    def test_should_write_pydev_files(self, os, mock_open):
        project = Project('basedir', name='pybuilder')
        project.set_property('dir_source_main_python', 'src/main/python')
        init_pydev_plugin(project)
        mock_open.return_value = MagicMock(spec=TYPE_FILE)
        os.path.join.side_effect = lambda first, second: first + '/' + second

        pydev_generate(project, Mock())

        self.assertEqual(mock_open.call_args_list,
                         [call('basedir/.project', 'w'), call('basedir/.pydevproject', 'w')])
        metadata_file = mock_open.return_value.__enter__.return_value

        self.assertEqual(metadata_file.write.call_args_list,
                         [call("""<?xml version="1.0" encoding="UTF-8"?>

<!-- This file has been generated by the PyBuilder Pydev Plugin -->

<projectDescription>
    <name>pybuilder</name>
    <comment></comment>
    <projects>
    </projects>
    <buildSpec>
        <buildCommand>
            <name>org.python.pydev.PyDevBuilder</name>
            <arguments>
            </arguments>
        </buildCommand>
    </buildSpec>
    <natures>
        <nature>org.python.pydev.pythonNature</nature>
    </natures>
</projectDescription>
"""),
                          call("""<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?eclipse-pydev version="1.0"?>

<!-- This file has been generated by the PyBuilder Pydev Plugin -->

<pydev_project>
    <pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
    <pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
    <pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
\t\t<path>/pybuilder/src/main/python</path>

    </pydev_pathproperty>
</pydev_project>
""")])
Example #17
0
    def test_running_plugin_fails(
        self,
        read_file_mock,
        report_mock,
        find_files_mock,
        command_mock,
        tail_mock,
    ):
        project = Project('.')
        project.set_property('verbose', False)
        project.set_property('dir_source_main_python', 'python')
        project.set_property('dir_source_main_scripts', 'scripts')

        logger = Mock()
        reactor = Mock()
        reactor.python_env_registry = {}
        reactor.python_env_registry["pybuilder"] = pyb_env = Mock()
        reactor.pybuilder_venv = pyb_env
        pyb_env.environ = {}
        pyb_env.executable = ["a/b"]
        execute_mock = pyb_env.execute_command = Mock()

        command_mock.return_value = ['cram']
        find_files_mock.return_value = ['test1.cram', 'test2.cram']
        report_mock.return_value = 'report_file'
        read_file_mock.return_value = ['test failes for file', '# results']
        execute_mock.return_value = 1
        tail_mock.return_value = "tail data"

        self.assertRaises(BuildFailedException, run_cram_tests, project,
                          logger, reactor)
        execute_mock.assert_called_once_with(
            ['a/b', 'cram', 'test1.cram', 'test2.cram'],
            'report_file',
            error_file_name='report_file',
            env={
                'PYTHONPATH': np(jp(project.basedir, 'python')) + pathsep,
                'PATH': np(jp(project.basedir, 'scripts')) + pathsep
            })
        expected_info_calls = [
            call('Running Cram command line tests'),
        ]
        expected_error_calls = [
            call(
                'Cram tests failed! See report_file for full details:\ntail data'
            ),
        ]
        self.assertEqual(expected_info_calls, logger.info.call_args_list)
        self.assertEqual(expected_error_calls, logger.error.call_args_list)
    def test_should_discover_source_dirs_when_test_sources_are_included_no_integrationtests(self, _):
        project = Mock()

        project.get_property.side_effect = lambda \
            _property: _property if _property != 'dir_source_integrationtest_python' else None

        files = discover_affected_dirs(True, False, project)

        self.assertEqual(project.get_property.call_args_list,
                         [call('dir_source_main_python'),
                          call('dir_source_unittest_python'),
                          call('dir_source_unittest_python'),
                          call('dir_source_integrationtest_python')])
        self.assertEquals(files,
                          ['dir_source_main_python', 'dir_source_unittest_python'])
Example #19
0
    def test_running_plugin_failure_no_tests(self,
                                             execute_mock,
                                             read_file_mock,
                                             os_mock,
                                             report_mock,
                                             find_files_mock,
                                             command_mock
                                             ):
        project = Project('.')
        project.set_property('verbose', True)
        project.set_property('dir_source_main_python', 'python')
        project.set_property('dir_source_main_scripts', 'scripts')
        project.set_property("cram_fail_if_no_tests", True)
        logger = Mock()

        command_mock.return_value = ['cram']
        find_files_mock.return_value = []
        report_mock.return_value = 'report_file'
        os_mock.copy.return_value = {}
        read_file_mock.return_value = ['test failes for file', '# results']
        execute_mock.return_value = 1

        self.assertRaises(
            BuildFailedException, run_cram_tests, project, logger)

        execute_mock.assert_not_called()
        expected_info_calls = [call('Running Cram command line tests'),
                               ]
        self.assertEquals(expected_info_calls, logger.info.call_args_list)
Example #20
0
    def test_running_plugin_failure_no_tests(self, read_file_mock, report_mock,
                                             find_files_mock, command_mock):
        project = Project('.')
        project.set_property('verbose', True)
        project.set_property('dir_source_main_python', 'python')
        project.set_property('dir_source_main_scripts', 'scripts')
        project.set_property("cram_fail_if_no_tests", True)
        project._plugin_env = {}
        logger = Mock()
        reactor = Mock()
        reactor.python_env_registry = {}
        reactor.python_env_registry["pybuilder"] = pyb_env = Mock()
        pyb_env.environ = {}
        execute_mock = pyb_env.execute_command = Mock()

        command_mock.return_value = ['cram']
        find_files_mock.return_value = []
        report_mock.return_value = 'report_file'
        read_file_mock.return_value = ['test failes for file', '# results']
        execute_mock.return_value = 1

        self.assertRaises(BuildFailedException, run_cram_tests, project,
                          logger, reactor)

        execute_mock.assert_not_called()
        expected_info_calls = [
            call('Running Cram command line tests'),
        ]
        self.assertEqual(expected_info_calls, logger.info.call_args_list)
    def test_should_discover_source_files_when_test_sources_are_included_and_only_integrationtests(self,
                                                                                                   discover_python_files):
        project = Mock()

        def get_property(property):
            if property == 'dir_source_unittest_python':
                return None
            return property

        project.get_property.side_effect = get_property

        discover_affected_files(True, False, project)

        self.assertEqual(discover_python_files.call_args_list,
                         [call('dir_source_main_python'),
                          call('dir_source_integrationtest_python')])
    def test_should_execute_external_command_and_return_execution_result(self, execution, read):
        execution.return_value = 0, '/tmp/reports/command-name'
        read.side_effect = lambda argument: {
            '/tmp/reports/command-name': ['Running...', 'OK all done!'],
            '/tmp/reports/command-name.err': ['Oh no! I am not python8 compatible!', 'I will explode now.']
        }[argument]
        logger = Mock()

        result = self.command.run_on_production_source_files(logger)

        self.assertEqual(result.exit_code, 0)
        self.assertEqual(result.report_file, '/tmp/reports/command-name')
        self.assertEqual(read.call_args_list[0], call('/tmp/reports/command-name'))
        self.assertEqual(result.report_lines, ['Running...', 'OK all done!'])
        self.assertEqual(result.error_report_file, '/tmp/reports/command-name.err')
        self.assertEqual(read.call_args_list[1], call('/tmp/reports/command-name.err'))
        self.assertEqual(result.error_report_lines, ['Oh no! I am not python8 compatible!', 'I will explode now.'])
Example #23
0
    def test_should_prompt_user_with_defaults(self, prompt, os):
        os.path.basename.return_value = 'project'
        collect_project_information()

        self.assertEqual(prompt.call_args_list,
                         [
                             call('Project name', 'project'),
                             call('Source directory', 'src/main/python'),
                             call('Docs directory', 'docs'),
                             call('Unittest directory', 'src/unittest/python'),
                             call('Scripts directory', 'src/main/scripts'),
                             call('Use plugin python.flake8 (Y/n)?', 'y'),
                             call('Use plugin python.coverage (Y/n)?', 'y'),
                             call('Use plugin python.distutils (Y/n)?', 'y')
                         ])
Example #24
0
    def test_running_plugin_fails_with_verbose(self,
                                               execute_mock,
                                               read_file_mock,
                                               os_mock,
                                               report_mock,
                                               find_files_mock,
                                               command_mock
                                               ):
        project = Project('.')
        project.set_property('verbose', True)
        project.set_property('dir_source_main_python', 'python')
        project.set_property('dir_source_main_scripts', 'scripts')
        logger = Mock()

        command_mock.return_value = ['cram']
        find_files_mock.return_value = ['test1.cram', 'test2.cram']
        report_mock.return_value = 'report_file'
        os_mock.copy.return_value = {}
        read_file_mock.return_value = ['test failes for file', '# results']
        execute_mock.return_value = 1

        self.assertRaises(
            BuildFailedException, run_cram_tests, project, logger)
        execute_mock.assert_called_once_with(
            ['cram', 'test1.cram', 'test2.cram'], 'report_file',
            error_file_name='report_file',
            env={'PYTHONPATH': './python:', 'PATH': './scripts:'}
        )
        expected_info_calls = [call('Running Cram command line tests'),
                               ]
        expected_error_calls = [call('Cram tests failed!'),
                                call('test failes for file'),
                                call('# results'),
                                call("See: 'report_file' for details"),
                                ]
        self.assertEquals(expected_info_calls, logger.info.call_args_list)
        self.assertEquals(expected_error_calls, logger.error.call_args_list)
Example #25
0
    def test_shortest_execution_plan_executed(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.execute_execution_plan(self.execution_manager.build_execution_plan("two"))
        one.execute.assert_has_calls([call(ANY, {})])
        two.execute.assert_has_calls([call(ANY, {})])
        three.execute.assert_not_called()

        self.execution_manager.execute_execution_plan(self.execution_manager.build_shortest_execution_plan("three"))
        one.execute.assert_has_calls([call(ANY, {})])
        two.execute.assert_has_calls([call(ANY, {})])
        three.execute.assert_has_calls([call(ANY, {})])

        self.execution_manager.execute_execution_plan(self.execution_manager.build_shortest_execution_plan("three"))
        one.execute.assert_has_calls([call(ANY, {})])
        two.execute.assert_has_calls([call(ANY, {})])
        three.execute.assert_has_calls([call(ANY, {}), call(ANY, {})])
Example #26
0
    def test_task_dependencies(self):
        import pybuilder.reactor

        with patch("pybuilder.reactor.Task"):
            @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 = ModuleType("mock_module")
            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)

            pybuilder.reactor.Task.assert_has_calls([call("task1", task1, [], ''),
                                                     call("task2", task2, [TaskDependency(task1)], ''),
                                                     call("task3", task3, [TaskDependency(task5, True)], ''),
                                                     call("task4", task4, [TaskDependency(task3, True)], ''),
                                                     call("task5", task5, [], ''),
                                                     call("task6", task6,
                                                          [TaskDependency(task1), TaskDependency(task2, True),
                                                           TaskDependency(task4), TaskDependency(task5)], '')])
    def test_should_warn_when_report_lines_present(self):
        logger = Mock()
        log_report(logger, 'name', ['line1 ', 'line 2 '])

        self.assertEqual(logger.warn.call_args_list,
                         [call('name: line1'), call('name: line 2')])
Example #28
0
    def test_should_render_verbose_task_list_without_descriptions_and_dependencies(self, print_text_line):
        print_list_of_tasks(self.mock_reactor, quiet=False)

        print_text_line.assert_has_calls([call('Tasks found for project "any-project-name":'),
                                          call('    task-1 - <no description available>'),
                                          call('    task-2 - <no description available>')])