def test_check_non_zero_exit_code(self):
EXECUTION_CHECKER.check__w_source_variants(
self,
pgm_args.interpret_py_source_line('exit(1)').as_str,
Arrangement.phase_agnostic(tcds=TcdsArrangement(), ),
MultiSourceExpectation.phase_agnostic(
main_result=result_assertions.equals(1, '')))
def test_check_non_zero_exit_code_with_output_to_stderr(self):
python_program = 'import sys; sys.stderr.write("on stderr"); exit(2)'
EXECUTION_CHECKER.check__w_source_variants(
self,
pgm_args.interpret_py_source_line(python_program).as_str,
Arrangement.phase_agnostic(tcds=TcdsArrangement(), ),
MultiSourceExpectation.phase_agnostic(
main_result=result_assertions.equals(2, 'on stderr')))
def runTest(self):
# ARRANGE #
test_setup = StdinCheckWithProgramWExitCode0ForSuccess()
# ACT & ASSERT #
EXECUTION_CHECKER.check__abs_stx(
self,
test_setup.program_that_checks_stdin__syntax(
'the contents of stdin'),
Arrangement.phase_agnostic(tcds=TcdsArrangement(
tcds_contents=test_setup.tcds_contents, ), ),
Expectation.phase_agnostic(main_result=result_assertions.equals(
test_setup.exit_code_of_successful_application, None)),
)
def test_check_non_zero_exit_code(self):
self._check_single_line_arguments_with_source_variants(
args.sequence([pgm_args.interpret_py_source_file('exit-with-value-on-command-line.py'),
2]).as_str,
tcds_test.Arrangement(
hds_contents_before=hds_case_dir_contents(DirContents([
File('exit-with-value-on-command-line.py',
py_pgm_that_exits_with_1st_value_on_command_line('on stderr'))]))),
tcds_test.Expectation(
expected_action_result=result_assertions.equals(2, 'on stderr'),
)
)
def test_symbol_references(self):
file_to_interpret = fs.File(
'python-logic_symbol_utils.py',
python_program_that_exits_with_code_given_as_first_cl_arg)
file_to_interpret_symbol = StringConstantSymbolContext(
'file_to_interpret_symbol', file_to_interpret.file_name)
python_interpreter_symbol = StringConstantSymbolContext(
'python_interpreter_symbol', sys.executable)
exit_code_symbol = StringIntConstantSymbolContext(
'exit_code_symbol', 72)
argument = ' {python_interpreter} {interpret_option} {file_to_interpret} "{exit_code}"'.format(
python_interpreter=python_interpreter_symbol.name__sym_ref_syntax,
interpret_option=args.option(
syntax_elements.EXISTING_FILE_OPTION_NAME).as_str,
file_to_interpret=file_to_interpret_symbol.name__sym_ref_syntax,
exit_code=exit_code_symbol.name__sym_ref_syntax,
)
following_line = 'following line'
source = remaining_source(argument, [following_line])
arrangement = Arrangement.phase_agnostic(
tcds=TcdsArrangement(tcds_contents=TcdsPopulatorForRelOptionType(
path_relativities.ALL_REL_OPTIONS_ARG_CONFIG.options.
default_option, fs.DirContents([file_to_interpret])), ),
symbols=SymbolContext.symbol_table_of_contexts([
python_interpreter_symbol,
file_to_interpret_symbol,
exit_code_symbol,
]),
)
expectation = Expectation.phase_agnostic(
source=assert_source(current_line_number=asrt.equals(2),
column_index=asrt.equals(0)),
symbol_usages=asrt.matches_sequence([
python_interpreter_symbol.usage_assertion__path_or_string(
syntax_elements.EXE_FILE_REL_OPTION_ARG_CONF.options.
accepted_relativity_variants),
file_to_interpret_symbol.usage_assertion__path_or_string(
path_relativities.ALL_REL_OPTIONS_ARG_CONFIG.options.
accepted_relativity_variants),
exit_code_symbol.usage_assertion__w_str_rendering,
]),
main_result=result_assertions.equals(exit_code_symbol.int_value,
''),
)
parser = sut.embryo_parser('instruction-name')
embryo_check.check(self, parser, source, arrangement, expectation)
def test_check_zero_exit_code__rel_tmp(self):
self._check_single_line_arguments_with_source_variants(
args.sequence([
pgm_args.interpret_py_source_file(
path_arguments.RelOptPathArgument('exit-with-value-on-command-line.py',
RelOptionType.REL_TMP)),
0,
]).as_str,
tcds_test.Arrangement(
sds_contents_before=contents_in(RelSdsOptionType.REL_TMP,
DirContents([
File('exit-with-value-on-command-line.py',
py_pgm_that_exits_with_1st_value_on_command_line(''))]))),
tcds_test.Expectation(
expected_action_result=result_assertions.equals(0, None)),
)
def test_check_zero_exit_code(self):
EXECUTION_CHECKER.check__w_source_variants(
self,
args.sequence([
pgm_args.symbol_ref_command_line(
self.program_that_executes_py_pgm_symbol.name), 0
]).as_str,
Arrangement.phase_agnostic(
tcds=TcdsArrangement(tcds_contents=self.py_file_rel_opt_conf.
populator_for_relativity_option_root(
DirContents([self.py_file])), ),
symbols=self.symbols),
MultiSourceExpectation.phase_agnostic(
main_result=result_assertions.equals(0, None),
symbol_usages=asrt.matches_sequence([
self.program_that_executes_py_pgm_symbol.
reference_assertion
])))
def test_stdin_is_concatenation_of_string_sources_WHEN_program_defines_multiple_stdin(
self):
# ARRANGE #
test_setup = MultipleStdinOfProgramTestSetup(self)
# ACT & ASSERT #
EXECUTION_CHECKER.check__abs_stx__std_layouts_and_source_variants(
self,
test_setup.program_w_stdin_syntax,
Arrangement.phase_agnostic(
os_services=test_setup.os_services_w_stdin_check,
symbols=test_setup.program_symbol.symbol_table,
tcds=TcdsArrangement(),
),
MultiSourceExpectation.phase_agnostic(
symbol_usages=test_setup.program_symbol.usages_assertion,
main_result=result_assertions.equals(test_setup.exit_code,
None)),
)
def test_symbol_references(self):
python_interpreter_symbol = StringConstantSymbolContext(
'python_interpreter_symbol', sys.executable)
execute_program_option_symbol = StringConstantSymbolContext(
'execute_program_option', '-c')
exit_code_symbol = StringIntConstantSymbolContext(
'exit_code_symbol', 87)
argument = ' {python_interpreter} {execute_program_option} {source_option} exit({exit_code}) '.format(
python_interpreter=python_interpreter_symbol.name__sym_ref_syntax,
execute_program_option=execute_program_option_symbol.
name__sym_ref_syntax,
source_option=syntax_elements.
REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER,
exit_code=exit_code_symbol.name__sym_ref_syntax,
)
arrangement = Arrangement.phase_agnostic(
symbols=SymbolContext.symbol_table_of_contexts([
python_interpreter_symbol,
execute_program_option_symbol,
exit_code_symbol,
]),
tcds=TcdsArrangement(),
)
source = remaining_source(argument, ['following line'])
expectation = Expectation.phase_agnostic(
source=assert_source(current_line_number=asrt.equals(2),
column_index=asrt.equals(0)),
symbol_usages=asrt.matches_sequence([
python_interpreter_symbol.usage_assertion__path_or_string(
syntax_elements.EXE_FILE_REL_OPTION_ARG_CONF.options.
accepted_relativity_variants),
execute_program_option_symbol.usage_assertion__w_str_rendering,
exit_code_symbol.usage_assertion__w_str_rendering,
]),
main_result=result_assertions.equals(exit_code_symbol.int_value,
''),
)
parser = sut.embryo_parser('instruction-name')
embryo_check.check(self, parser, source, arrangement, expectation)
def runTest(self):
executor = CommandExecutorThatJustReturnsConstant(
1,
string_to_write_to_stderr='output on stderr'
)
CHECKER.check__w_source_variants(
self,
command_line(
'program',
).as_str,
Arrangement.phase_agnostic(
os_services=os_services_access.new_for_cmd_exe(executor),
tcds=TcdsArrangement(),
),
MultiSourceExpectation.phase_agnostic(
main_result=result_assertions.equals(executor.constant_return_value,
executor.string_to_write_to_stderr),
),
)
def test_symbol_references(self):
expected_exit_status = 72
file_to_interpret = fs.File('python-logic_symbol_utils.py',
py_script_that_exists_with_status(expected_exit_status))
file_to_interpret_symbol = StringConstantSymbolContext('file_to_interpret_symbol',
file_to_interpret.file_name)
python_interpreter_symbol = StringConstantSymbolContext('python_interpreter_symbol', sys.executable)
argument = ' "{python_interpreter}" {file_to_interpret}'.format(
python_interpreter=python_interpreter_symbol.name__sym_ref_syntax,
file_to_interpret=file_to_interpret_symbol.name__sym_ref_syntax,
)
following_line = 'following line'
source = remaining_source(argument, [following_line])
arrangement = Arrangement.phase_agnostic(
tcds=TcdsArrangement(
tcds_contents=TcdsPopulatorForRelOptionType(
RelOptionType.REL_ACT,
fs.DirContents([file_to_interpret])),
),
symbols=SymbolContext.symbol_table_of_contexts([
python_interpreter_symbol,
file_to_interpret_symbol,
]),
)
expectation = Expectation.phase_agnostic(
source=assert_source(current_line_number=asrt.equals(2),
column_index=asrt.equals(0)),
symbol_usages=asrt.matches_sequence([
python_interpreter_symbol.usage_assertion__w_str_rendering,
file_to_interpret_symbol.usage_assertion__w_str_rendering,
]),
main_result=result_assertions.equals(expected_exit_status, ''),
)
parser = sut.embryo_parser('instruction-name')
embryo_check.check(self, parser, source, arrangement, expectation)
def runTest(self):
non_zero_exit_code = 1
exe_file = fs.python_executable_file(
'program-name',
py_programs.copy_stdin_to_stderr_and_exit_with(non_zero_exit_code)
)
with tmp_dir_in_path_with_files(fs.DirContents([exe_file])) as env:
# ACT & ASSERT #
CHECKER.check(
self,
command_line(
exe_file.name,
).as_remaining_source,
Arrangement.phase_agnostic(
process_execution_settings=proc_exe_env_for_test(environ=env),
tcds=TcdsArrangement(),
),
Expectation.phase_agnostic_2(
source=asrt_source.source_is_at_end,
main_result=result_assertions.equals(non_zero_exit_code, ''),
),
)
def test_stdin_is_devnull_WHEN_program_do_not_define_stdin(self):
# ARRANGE #
test_setup = NoStdinTestSetup(self, exit_code=0)
for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference(
):
with self.subTest(pgm_and_args_case.name):
# ACT & ASSERT #
EXECUTION_CHECKER.check__abs_stx__std_layouts_and_source_variants(
self,
pgm_and_args_case.pgm_and_args,
Arrangement.phase_agnostic(
os_services=test_setup.os_services_w_stdin_check,
symbols=pgm_and_args_case.symbol_table,
tcds=TcdsArrangement(
tcds_contents=pgm_and_args_case.tcds, ),
),
MultiSourceExpectation.phase_agnostic(
symbol_usages=pgm_and_args_case.usages_assertion,
main_result=result_assertions.equals(
test_setup.exit_code, None)),
)
def check_successful_execution(put: unittest.TestCase,
arguments: ArgumentElementsRenderer,
symbols: SymbolTable,
symbol_usages: Assertion[Sequence[SymbolUsage]],
expected_command: Assertion[Command],
):
executor_that_records_arguments = CommandExecutorThatRecordsArguments()
CHECKER.check__w_source_variants(
put,
arguments.as_str,
Arrangement.phase_agnostic(
os_services=os_services_access.new_for_cmd_exe(executor_that_records_arguments),
symbols=symbols,
tcds=TcdsArrangement(),
),
MultiSourceExpectation.phase_agnostic(
symbol_usages=symbol_usages,
side_effects_on_tcds=ExecutedCommandAssertion(
executor_that_records_arguments,
lambda tcds: expected_command,
),
main_result=result_assertions.equals(0, None),
),
)
def test_check_non_zero_exit_code(self):
self._check_single_line_arguments_with_source_variants(
pgm_args.interpret_py_source_line('exit(1)').as_str,
tcds_test.Arrangement(),
tcds_test.Expectation(expected_action_result=result_assertions.equals(1, '')))
def test_check_non_zero_exit_code_with_output_to_stderr(self):
python_program = 'import sys; sys.stderr.write("on stderr"); exit(2)'
self._check_single_line_arguments_with_source_variants(
self._python_interpreter_for_source_on_command_line(python_program),
tcds_test.Arrangement(),
tcds_test.Expectation(expected_action_result=result_assertions.equals(2, 'on stderr')))
def test_check_non_zero_exit_code(self):
self._check_single_line_arguments_with_source_variants(
self._python_interpreter_for_source_on_command_line('exit(1)'),
tcds_test.Arrangement(),
tcds_test.Expectation(expected_action_result=result_assertions.equals(1, '')))
