Пример #1
0
    def test_communicate_error(self, mock_popen):
        expected_error = "expected error"
        command = ["a_command"]
        command_str = "a_command"
        mock_process = mock.MagicMock(spec_set=["communicate", "returncode"])
        exception = OSError()
        exception.strerror = expected_error
        mock_process.communicate.side_effect = exception
        mock_popen.return_value = mock_process

        runner = lib.CommandRunner(self.mock_logger, self.mock_reporter)
        assert_raise_library_error(
            lambda: runner.run(command),
            (severity.ERROR, report_codes.RUN_EXTERNAL_PROCESS_ERROR, {
                "command": command_str,
                "reason": expected_error,
            }))

        mock_process.communicate.assert_called_once_with(None)
        self.assert_popen_called_with(mock_popen, command, {
            "env": {},
            "stdin": DEVNULL,
        })
        logger_calls = [
            mock.call("Running: {0}\nEnvironment:".format(command_str)),
        ]
        self.assertEqual(self.mock_logger.debug.call_count, len(logger_calls))
        self.mock_logger.debug.assert_has_calls(logger_calls)
        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [(severity.DEBUG, report_codes.RUN_EXTERNAL_PROCESS_STARTED, {
                "command": command_str,
                "stdin": None,
                "environment": dict(),
            })])
Пример #2
0
    def test_basic(self, mock_popen):
        expected_stdout = "expected stdout"
        expected_stderr = "expected stderr"
        expected_retval = 123
        command = ["a_command"]
        command_str = "a_command"
        mock_process = mock.MagicMock(spec_set=["communicate", "returncode"])
        mock_process.communicate.return_value = (expected_stdout,
                                                 expected_stderr)
        mock_process.returncode = expected_retval
        mock_popen.return_value = mock_process

        runner = lib.CommandRunner(self.mock_logger, self.mock_reporter)
        real_stdout, real_stderr, real_retval = runner.run(command)

        self.assertEqual(real_stdout, expected_stdout)
        self.assertEqual(real_stderr, expected_stderr)
        self.assertEqual(real_retval, expected_retval)
        mock_process.communicate.assert_called_once_with(None)
        self.assert_popen_called_with(mock_popen, command, {
            "env": {},
            "stdin": DEVNULL,
        })
        logger_calls = [
            mock.call("Running: {0}\nEnvironment:".format(command_str)),
            mock.call(
                outdent("""\
                    Finished running: {0}
                    Return value: {1}
                    --Debug Stdout Start--
                    {2}
                    --Debug Stdout End--
                    --Debug Stderr Start--
                    {3}
                    --Debug Stderr End--""").format(
                    command_str,
                    expected_retval,
                    expected_stdout,
                    expected_stderr,
                ))
        ]
        self.assertEqual(self.mock_logger.debug.call_count, len(logger_calls))
        self.mock_logger.debug.assert_has_calls(logger_calls)
        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [(severity.DEBUG, report_codes.RUN_EXTERNAL_PROCESS_STARTED, {
                "command": command_str,
                "stdin": None,
                "environment": dict(),
            }),
             (severity.DEBUG, report_codes.RUN_EXTERNAL_PROCESS_FINISHED, {
                 "command": command_str,
                 "return_value": expected_retval,
                 "stdout": expected_stdout,
                 "stderr": expected_stderr,
             })])
Пример #3
0
    def test_env(self, mock_popen):
        expected_stdout = "expected output"
        expected_stderr = "expected stderr"
        expected_retval = 123
        command = ["a_command"]
        command_str = "a_command"
        mock_process = mock.MagicMock(spec_set=["communicate", "returncode"])
        mock_process.communicate.return_value = (
            expected_stdout,
            expected_stderr,
        )
        mock_process.returncode = expected_retval
        mock_popen.return_value = mock_process

        global_env = {"a": "a", "b": "b"}
        runner = lib.CommandRunner(self.mock_logger, self.mock_reporter,
                                   global_env.copy())
        # {C} is for check that no python template conflict appear
        real_stdout, real_stderr, real_retval = runner.run(command,
                                                           env_extend={
                                                               "b": "B",
                                                               "c": "{C}"
                                                           })
        # check that env_exted did not affect initial env of runner
        # pylint: disable=protected-access
        self.assertEqual(runner._env_vars, global_env)

        self.assertEqual(real_stdout, expected_stdout)
        self.assertEqual(real_stderr, expected_stderr)
        self.assertEqual(real_retval, expected_retval)
        mock_process.communicate.assert_called_once_with(None)
        self.assert_popen_called_with(
            mock_popen,
            command,
            {
                "env": {
                    "a": "a",
                    "b": "B",
                    "c": "{C}"
                },
                "stdin": DEVNULL,
            },
        )
        logger_calls = [
            mock.call(
                outdent("""\
                    Running: {0}
                    Environment:
                      a=a
                      b=B
                      c={1}""").format(command_str, "{C}")),
            mock.call(
                outdent("""\
                    Finished running: {0}
                    Return value: {1}
                    --Debug Stdout Start--
                    {2}
                    --Debug Stdout End--
                    --Debug Stderr Start--
                    {3}
                    --Debug Stderr End--""").format(
                    command_str,
                    expected_retval,
                    expected_stdout,
                    expected_stderr,
                )),
        ]
        self.assertEqual(self.mock_logger.debug.call_count, len(logger_calls))
        self.mock_logger.debug.assert_has_calls(logger_calls)
        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [
                (
                    severity.DEBUG,
                    report_codes.RUN_EXTERNAL_PROCESS_STARTED,
                    {
                        "command": command_str,
                        "stdin": None,
                        "environment": {
                            "a": "a",
                            "b": "B",
                            "c": "{C}"
                        },
                    },
                ),
                (
                    severity.DEBUG,
                    report_codes.RUN_EXTERNAL_PROCESS_FINISHED,
                    {
                        "command": command_str,
                        "return_value": expected_retval,
                        "stdout": expected_stdout,
                        "stderr": expected_stderr,
                    },
                ),
            ],
        )