def test_call(self, popen, fcntl, select, logger):
popen_obj, exp_result = self.prepare_close(popen)
select.return_value = [popen_obj.stdout, popen_obj.stderr], [], []
runner = subprocess_runner.Subprocess()
# noinspection PyTypeChecker
result = runner.execute(command)
self.assertEqual(result, exp_result)
popen.assert_has_calls((mock.call(args=[command],
cwd=None,
env=None,
shell=True,
stderr=subprocess.PIPE,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
universal_newlines=False), ))
logger.assert_has_calls([
mock.call.debug("\nExecuting command: {!r}".format(
command.rstrip())),
] + [
mock.call.debug(str(x.rstrip().decode('utf-8')))
for x in stdout_list
] + [
mock.call.debug(str(x.rstrip().decode('utf-8')))
for x in stderr_list
] + [
mock.call.debug('\n{cmd!r} execution results: '
'Exit code: {code!s}'.format(
cmd=command, code=result.exit_code)),
])
self.assertIn(mock.call.poll(), popen_obj.mock_calls)
def test_check_call(self, execute, logger):
exit_code = 0
return_value = {
'stderr_str': '0\n1',
'stdout_str': '2\n3',
'stderr_brief': '0\n1',
'stdout_brief': '2\n3',
'exit_code': exit_code,
'stderr': [b' \n', b'0\n', b'1\n', b' \n'],
'stdout': [b' \n', b'2\n', b'3\n', b' \n']
}
execute.return_value = return_value
verbose = False
runner = subprocess_runner.Subprocess()
# noinspection PyTypeChecker
result = runner.check_call(command=command,
verbose=verbose,
timeout=None)
execute.assert_called_once_with(command, verbose, None)
self.assertEqual(result, return_value)
exit_code = 1
return_value['exit_code'] = exit_code
execute.reset_mock()
execute.return_value = return_value
with self.assertRaises(error.DevopsCalledProcessError):
# noinspection PyTypeChecker
runner.check_call(command=command, verbose=verbose, timeout=None)
execute.assert_called_once_with(command, verbose, None)
def test_call_verbose(self, popen, fcntl, select, logger):
popen_obj, _ = self.prepare_close(popen)
select.return_value = [popen_obj.stdout, popen_obj.stderr], [], []
runner = subprocess_runner.Subprocess()
# noinspection PyTypeChecker
result = runner.execute(command, verbose=True)
logger.assert_has_calls([
mock.call.info("\nExecuting command: {!r}".format(
command.rstrip())),
] + [
mock.call.info(str(x.rstrip().decode('utf-8')))
for x in stdout_list
] + [
mock.call.error(str(x.rstrip().decode('utf-8')))
for x in stderr_list
] + [
mock.call.info('\n{cmd!r} execution results: '
'Exit code: {code!s}'.format(
cmd=command,
code=result.exit_code,
)),
])
def test_call(self, popen, fcntl, select, logger):
popen_obj, exp_result = self.prepare_close(popen)
select.return_value = [popen_obj.stdout, popen_obj.stderr], [], []
runner = subprocess_runner.Subprocess()
# noinspection PyTypeChecker
result = runner.execute(command)
self.assertEqual(result, exp_result)
popen.assert_has_calls((mock.call(args=[command],
cwd=None,
env=None,
shell=True,
stderr=subprocess.PIPE,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
universal_newlines=False), ))
logger.assert_has_calls((
mock.call.debug("Executing command: {!r}".format(
command.rstrip())),
mock.call.debug('{cmd!r} execution results:\n'
'Exit code: {code!s}\n'
'BRIEF STDOUT:\n'
'{stdout}\n'
'BRIEF STDERR:\n'
'{stderr}'.format(cmd=command,
code=result.exit_code,
stdout=result.stdout_brief,
stderr=result.stderr_brief)),
))
self.assertIn(mock.call.poll(), popen_obj.mock_calls)
def test_call(self, popen, fcntl, select, logger):
popen_obj, exp_result = self.prepare_close(popen)
select.return_value = [popen_obj.stdout, popen_obj.stderr], [], []
runner = subprocess_runner.Subprocess()
# noinspection PyTypeChecker
result = runner.execute(command)
self.assertEqual(result, exp_result)
popen.assert_has_calls((mock.call(args=[command],
cwd=None,
env=None,
shell=True,
stderr=subprocess.PIPE,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
universal_newlines=False), ))
logger.assert_has_calls([
mock.call.debug(command_log),
] + [
mock.call.debug(str(x.rstrip().decode('utf-8')))
for x in stdout_list
] + [
mock.call.debug(str(x.rstrip().decode('utf-8')))
for x in stderr_list
] + [
mock.call.debug(self.gen_cmd_result_log_message(result)),
])
self.assertIn(mock.call.poll(), popen_obj.mock_calls)
def local(self):
"""Get Subprocess instance for local operations like:
underlay.local.execute(command, verbose=False, timeout=None)
underlay.local.check_call(
command, verbose=False, timeout=None,
error_info=None, expected=None, raise_on_err=True)
underlay.local.check_stderr(
command, verbose=False, timeout=None,
error_info=None, raise_on_err=True)
"""
return subprocess_runner.Subprocess()
def test_check_stderr(self, check_call, logger):
return_value = {
'stderr_str': '',
'stdout_str': '2\n3',
'stderr_brief': '',
'stdout_brief': '2\n3',
'exit_code': 0,
'stderr': [],
'stdout': [b' \n', b'2\n', b'3\n', b' \n']
}
check_call.return_value = return_value
verbose = False
raise_on_err = True
runner = subprocess_runner.Subprocess()
# noinspection PyTypeChecker
result = runner.check_stderr(command=command,
verbose=verbose,
timeout=None,
raise_on_err=raise_on_err)
check_call.assert_called_once_with(command,
verbose,
timeout=None,
error_info=None,
raise_on_err=raise_on_err)
self.assertEqual(result, return_value)
return_value['stderr_str'] = '0\n1'
return_value['stderr_brief'] = '0\n1'
return_value['stderr'] = [b' \n', b'0\n', b'1\n', b' \n']
check_call.reset_mock()
check_call.return_value = return_value
with self.assertRaises(error.DevopsCalledProcessError):
# noinspection PyTypeChecker
runner.check_stderr(command=command,
verbose=verbose,
timeout=None,
raise_on_err=raise_on_err)
check_call.assert_called_once_with(command,
verbose,
timeout=None,
error_info=None,
raise_on_err=raise_on_err)
def test_call_verbose(self, popen, fcntl, select, logger):
popen_obj, _ = self.prepare_close(popen)
select.return_value = [popen_obj.stdout, popen_obj.stderr], [], []
runner = subprocess_runner.Subprocess()
# noinspection PyTypeChecker
result = runner.execute(command, verbose=True)
logger.assert_has_calls([
mock.call.info(command_log),
] + [
mock.call.info(str(x.rstrip().decode('utf-8')))
for x in stdout_list
] + [
mock.call.error(str(x.rstrip().decode('utf-8')))
for x in stderr_list
] + [
mock.call.info(self.gen_cmd_result_log_message(result)),
])
def test_call_verbose(self, popen, fcntl, select, logger):
popen_obj, _ = self.prepare_close(popen)
select.return_value = [popen_obj.stdout, popen_obj.stderr], [], []
runner = subprocess_runner.Subprocess()
# noinspection PyTypeChecker
result = runner.execute(command, verbose=True)
logger.assert_has_calls((
mock.call.debug("Executing command: {!r}".format(
command.rstrip())),
mock.call.debug('{cmd!r} execution results:\n'
'Exit code: {code!s}\n'
'STDOUT:\n'
'{stdout}\n'
'STDERR:\n'
'{stderr}'.format(cmd=command,
code=result.exit_code,
stdout=result.stdout_str,
stderr=result.stderr_str)),
))
