def _check(
self,
output: StdOutputFilesContents,
exit_code_cases: List[int],
ignore_exit_code: bool,
execution_expectation: ExecutionExpectation,
):
# ARRANGE #
py_file_rel_opt_conf = rel_opt.conf_rel_any(RelOptionType.REL_TMP)
for exit_code in exit_code_cases:
with self.subTest(non_zero_exit_code=exit_code):
py_file = File(
'exit-with-hard-coded-exit-code.py',
py_programs.py_pgm_with_stdout_stderr_exit_code(
stdout_output=output.out,
stderr_output=output.err,
exit_code=exit_code,
),
)
py_file_conf = py_file_rel_opt_conf.named_file_conf(
py_file.name)
program_symbol = ProgramSymbolContext.of_sdv(
'PROGRAM_SYMBOL_NAME',
program_sdvs.interpret_py_source_file_that_must_exist(
py_file_conf.path_sdv))
# ACT && ASSERT #
integration_check.CHECKER__PARSE_FULL.check(
self,
args.syntax_for_run(
program_args.symbol_ref_command_elements(
program_symbol.name),
ignore_exit_code=ignore_exit_code,
).as_remaining_source,
model_constructor.arbitrary(self),
arrangement_w_tcds(
symbols=program_symbol.symbol_table,
tcds_contents=py_file_rel_opt_conf.
populator_for_relativity_option_root(
DirContents([py_file])),
),
Expectation(
ParseExpectation(
source=asrt_source.is_at_end_of_line(1),
symbol_references=program_symbol.
references_assertion),
execution_expectation,
),
)
def test_exit_code(self):
# ARRANGE #
exit_code = 3
program_file = File(
'program.py',
py_programs.py_pgm_with_stdout_stderr_exit_code(exit_code=exit_code),
)
with tmp_dir.tmp_dir(DirContents([program_file])) as tmp_dir_path:
executor = sut.ProcessorThatStoresResultInFilesInDir(COMMAND_EXECUTOR,
tmp_dir_path,
file_ctx_managers.dev_null(),
)
# ACT #
result = executor.process(ProcessExecutionSettings.null(),
py_exe.command_for_interpreting(tmp_dir_path / program_file.name))
# ASSERT #
self.assertEqual(exit_code,
result.exit_code,
'Exit code')
def _check_exit_codes(
self,
exit_code_cases: List[int],
ignore_exit_code: bool,
expected_primitive: Callable[
[str], multi_obj_assertions.ExpectationOnUnFrozenAndFrozen],
):
# ARRANGE #
program_output = {
ProcOutputFile.STDOUT: 'output on stdout',
ProcOutputFile.STDERR: 'output on stderr',
}
for exit_code in exit_code_cases:
py_program = py_programs.py_pgm_with_stdout_stderr_exit_code(
exit_code=exit_code,
stdout_output=program_output[ProcOutputFile.STDOUT],
stderr_output=program_output[ProcOutputFile.STDERR],
)
for output_file in ProcOutputFile:
expected_program_output = program_output[output_file]
with self.subTest(exit_code=exit_code,
output_file=output_file):
source_constructors = SourceConstructorForPySourceProgramViaCmdLine(
py_program,
ModelMaker(
ignore_exit_code=ignore_exit_code,
output_channel_to_capture=output_file,
mem_buff_size=1,
))
assertion = multi_obj_assertions.assertion_of_2_seq_w_file_first_and_last(
expected_primitive(expected_program_output), )
# ACT & ASSERT #
assertion.apply_without_message(
self,
source_constructors.build(),
)
def test_fail_WHEN_storage_dir_is_an_existing_regular_file(self):
# ARRANGE #
successful_py_program = File(
'successful.py',
py_programs.py_pgm_with_stdout_stderr_exit_code(exit_code=0),
)
existing_file = File.empty('a-file')
dir_contents = DirContents([successful_py_program, existing_file])
with tmp_dir.tmp_dir(dir_contents) as tmp_dir_path:
path_of_existing_regular_file = tmp_dir_path / existing_file.name
executor = sut.ProcessorThatStoresResultInFilesInDir(
COMMAND_EXECUTOR,
path_of_existing_regular_file,
file_ctx_managers.dev_null(),
)
with self.assertRaises(exception.ImplementationError) as ctx:
# ACT & ASSERT #
executor.process(
ProcessExecutionSettings.null(),
command_for_exe_file(tmp_dir_path / successful_py_program.name),
)
assert isinstance(ctx.exception, exception.ImplementationError)
self.assertIsInstance(ctx.exception.message, str, 'exception info')
def runTest(self):
non_zero_exit_code = 1
text_printed_by_program = 'the output from the program'
py_file = File(
'exit-with-hard-coded-exit-code.py',
py_programs.py_pgm_with_stdout_stderr_exit_code(
stdout_output=text_printed_by_program,
stderr_output='',
exit_code=non_zero_exit_code,
),
)
expected_file = fs.File(
'dst-file.txt',
text_printed_by_program.upper(),
)
to_upper_transformer = StringTransformerSymbolContext.of_primitive(
'TO_UPPER_CASE',
to_uppercase(),
)
symbols = to_upper_transformer.symbol_table
py_src_file_rel_opt_conf = rel_opt.conf_rel_any(
RelOptionType.REL_HDS_CASE)
dst_file_rel_opt_conf = conf_rel_non_hds(RelNonHdsOptionType.REL_TMP)
program_string_source_syntax = string_source_abs_stx.StringSourceOfProgramAbsStx(
ProcOutputFile.STDOUT,
program_abs_stx.FullProgramAbsStx(
program_abs_stx.ProgramOfPythonInterpreterAbsStx.
of_execute_python_src_file(
py_src_file_rel_opt_conf.path_abs_stx_of_name(
py_file.name)),
transformation=to_upper_transformer.abstract_syntax,
),
ignore_exit_code=True,
)
instruction_syntax = instr_abs_stx.create_w_explicit_contents(
dst_file_rel_opt_conf.path_abs_stx_of_name(expected_file.name),
program_string_source_syntax,
)
instruction_checker = self.conf.instruction_checker
parser = self.conf.parser()
for source_case in equivalent_source_variants__with_source_check__consume_last_line__abs_stx(
instruction_syntax):
with self.subTest(source_case.name):
source = source_case.value.source
# ACT #
instruction = parser.parse(ARBITRARY_FS_LOCATION_INFO, source)
# ASSERT #
source_case.value.expectation.apply_with_message(
self, source, 'source-after-parse')
# ACT & ASSERT #
instruction_checker.check(
self, instruction,
self.conf.arrangement(
pre_contents_population_action=
SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR,
symbols=symbols,
tcds_contents=py_src_file_rel_opt_conf.
populator_for_relativity_option_root(
DirContents([py_file]))),
self.conf.expect_success(
symbol_usages=asrt.matches_sequence([
to_upper_transformer.reference_assertion,
]),
main_side_effects_on_sds=non_hds_dir_contains_exactly(
dst_file_rel_opt_conf.root_dir__non_hds,
fs.DirContents([expected_file])),
))
def py_source(self) -> str:
return py_programs.py_pgm_with_stdout_stderr_exit_code(self.stdout_output,
self.stderr_output,
self.exit_code)
def test_string_transformer_should_be_parsed_as_simple_expression(self):
the_layout = LayoutSpec.of_default()
output_from_program = 'untransformed output from the program'
sym_ref_program_syntax = ProgramOfSymbolReferenceAbsStx(
'PROGRAM_THAT_EXECUTES_PY_FILE')
str_trans__unused = StringTransformerSymbolReferenceAbsStx(
'UNUSED_TRANSFORMER')
program_w_complex_str_trans_wo_parentheses = program_abs_stx.FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(sym_ref_program_syntax.symbol_name),
transformation=str_trans_abs_stx.
StringTransformerCompositionAbsStx(
[
TO_UPPER_TRANSFORMER_SYMBOL.abstract_syntax,
str_trans__unused,
],
within_parens=False,
allow_elements_on_separate_lines=False,
))
expected_remaining_tokens = TokenSequence.concat([
TokenSequence.singleton(
str_trans_abs_stx.names.SEQUENCE_OPERATOR_NAME),
str_trans__unused.tokenization(),
])
expected_remaining_source = expected_remaining_tokens.layout(
the_layout)
checker = integration_check.checker__w_arbitrary_file_relativities()
py_program_file = File(
'program.py',
py_programs.py_pgm_with_stdout_stderr_exit_code(
exit_code=0,
stdout_output=output_from_program,
stderr_output=output_from_program,
),
)
py_file_rel_conf = rel_opt.conf_rel_any(RelOptionType.REL_HDS_CASE)
py_file_conf = py_file_rel_conf.named_file_conf(py_program_file.name)
program_symbol__that_executes_py_file = ProgramSymbolContext.of_sdv(
sym_ref_program_syntax.symbol_name,
program_sdvs.interpret_py_source_file_that_must_exist(
py_file_conf.path_sdv))
symbols = [
program_symbol__that_executes_py_file,
TO_UPPER_TRANSFORMER_SYMBOL,
]
for output_file in ProcOutputFile:
for ignore_exit_code in [False, True]:
syntax = string_source_abs_stx.StringSourceOfProgramAbsStx(
output_file,
program_w_complex_str_trans_wo_parentheses,
ignore_exit_code=ignore_exit_code,
)
with self.subTest(output_file=output_file,
ignore_exit_code=ignore_exit_code):
checker.check__abs_stx__wo_input(
self,
syntax,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols),
tcds_contents=py_file_rel_conf.
populator_for_relativity_option_root(
DirContents([py_program_file]))),
Expectation(
ParseExpectation(
source=asrt_source.source_is_not_at_end(
remaining_source=asrt.equals(
expected_remaining_source)),
symbol_references=SymbolContext.
references_assertion_of_contexts(symbols),
)),
the_layout,
)
def test_without_transformation(self):
# ARRANGE #
stdout_contents = 'output on stdout'
stderr_contents = 'output on stderr'
exit_code_cases = [0, 72]
transformation_cases = [
NIE(
'stdout',
stdout_contents,
ProcOutputFile.STDOUT,
),
NIE(
'stderr',
stderr_contents,
ProcOutputFile.STDERR,
),
]
for exit_code_case in exit_code_cases:
for transformation_case in transformation_cases:
with self.subTest(exit_code=exit_code_case,
transformation=transformation_case.name):
python_source = py_pgm_with_stdout_stderr_exit_code(
stdout_contents, stderr_contents, exit_code_case)
sdv_of_referred_program = program_sdvs.for_py_source_on_command_line(
python_source)
program_that_executes_py_source = ProgramSymbolContext.of_sdv(
'PROGRAM_THAT_EXECUTES_PY_SOURCE',
sdv_of_referred_program)
source = parse_source_of__abs_stx(
ProgramOfSymbolReferenceAbsStx(
program_that_executes_py_source.name))
symbols = program_that_executes_py_source.symbol_table
# ACT & ASSERT #
CHECKER_W_TRANSFORMATION.check(
self, source, transformation_case.input_value,
arrangement_w_tcds(symbols=symbols, ),
Expectation(
ParseExpectation(
symbol_references=asrt.matches_sequence([
program_that_executes_py_source.
reference_assertion,
]), ),
ExecutionExpectation(
main_result=assert_process_result_data(
exitcode=asrt.equals(exit_code_case),
stdout_contents=asrt.equals(
stdout_contents),
stderr_contents=asrt.equals(
stderr_contents),
contents_after_transformation=asrt.equals(
transformation_case.expected_value),
))))
def test_with_transformation(self):
# ARRANGE #
stdout_contents = 'output on stdout'
stderr_contents = 'output on stderr'
exit_code_cases = [0, 72]
to_upper_transformer = test_transformers_setup.TO_UPPER_CASE_TRANSFORMER
transformation_cases = [
NIE(
'stdout',
stdout_contents.upper(),
ProcOutputFile.STDOUT,
),
NIE(
'stderr',
stderr_contents.upper(),
ProcOutputFile.STDERR,
),
]
for exit_code_case in exit_code_cases:
for transformation_case in transformation_cases:
with self.subTest(exit_code=exit_code_case,
transformation=transformation_case.name):
python_source = py_pgm_with_stdout_stderr_exit_code(
stdout_contents, stderr_contents, exit_code_case)
program_that_executes_py_source = ProgramSymbolContext.of_sdv(
'PROGRAM_THAT_EXECUTES_PY_SOURCE',
program_sdvs.for_py_source_on_command_line(
python_source))
source = pgm_args.symbol_ref_command_elements(
program_that_executes_py_source.name,
transformation=to_upper_transformer.name
).as_remaining_source
symbols = SymbolContext.symbol_table_of_contexts([
program_that_executes_py_source, to_upper_transformer
])
# ACT & ASSERT #
CHECKER_W_TRANSFORMATION.check(
self, source, transformation_case.input_value,
arrangement_w_tcds(symbols=symbols, ),
Expectation(
ParseExpectation(
symbol_references=asrt.matches_sequence([
program_that_executes_py_source.
reference_assertion,
is_reference_to_string_transformer(
to_upper_transformer.name),
]), ),
ExecutionExpectation(
main_result=assert_process_result_data(
exitcode=asrt.equals(exit_code_case),
stdout_contents=asrt.equals(
stdout_contents),
stderr_contents=asrt.equals(
stderr_contents),
contents_after_transformation=asrt.equals(
transformation_case.expected_value),
))))
def py_source(self) -> str:
return py_programs.py_pgm_with_stdout_stderr_exit_code(
self.stdout_output, self.stderr_output, self.exit_code)
def _check_exit_codes(self,
exit_code_cases: List[int],
ignore_exit_code: bool,
main_result: Assertion[Optional[TextRenderer]],
expected_output_dir_contents: Optional[Callable[[str, str], DirContents]],
):
# ARRANGE #
destination_file_name = 'dst-file.txt'
program_output = {
ProcOutputFile.STDOUT: 'output on stdout',
ProcOutputFile.STDERR: 'output on stderr',
}
transformer = TO_UPPER_TRANSFORMER_SYMBOL
sym_ref_program = ProgramOfSymbolReferenceAbsStx('PROGRAM_SYMBOL_NAME')
program_builder = program_abs_stx.TransformableProgramAbsStxBuilder(
ProgramOfSymbolReferenceAbsStx(sym_ref_program.symbol_name)
)
program_cases = [
ProgramAndSymbolsCase(
'without transformation',
program_builder.without_transformation(),
[],
adapt_expected_program_output=lambda s: s
),
ProgramAndSymbolsCase(
'with transformation',
program_builder.with_transformation(transformer.abstract_syntax),
[transformer],
adapt_expected_program_output=str.upper
),
]
program_builder.with_and_without_transformer_cases(transformer.abstract_syntax)
py_file_rel_conf = rel_opt.conf_rel_any(RelOptionType.REL_HDS_CASE)
dst_file_rel_conf = ARBITRARY_ALLOWED_DST_FILE_RELATIVITY
for output_file in ProcOutputFile:
for exit_code in exit_code_cases:
py_file = File('exit-with-hard-coded-exit-code.py',
py_programs.py_pgm_with_stdout_stderr_exit_code(
exit_code=exit_code,
stdout_output=program_output[ProcOutputFile.STDOUT],
stderr_output=program_output[ProcOutputFile.STDERR],
),
)
py_file_conf = py_file_rel_conf.named_file_conf(py_file.name)
dst_file_conf = dst_file_rel_conf.named_file_conf(destination_file_name)
program_symbol = ProgramSymbolContext.of_sdv(
sym_ref_program.symbol_name,
program_sdvs.interpret_py_source_file_that_must_exist(py_file_conf.path_sdv)
)
for program_case in program_cases:
instruction_syntax = instr_abs_stx.create_w_explicit_contents(
dst_file_conf.abstract_syntax,
string_source_abs_stx.StringSourceOfProgramAbsStx(
output_file,
program_case.syntax,
ignore_exit_code=ignore_exit_code)
)
expected_program_output = program_case.adapt_expected_program_output(program_output[output_file])
main_side_effects_on_sds = (
dst_file_rel_conf.assert_root_dir_contains_exactly(
expected_output_dir_contents(dst_file_conf.name, expected_program_output)
)
if expected_output_dir_contents is not None
else
asrt.anything_goes()
)
symbol_contexts = [program_symbol] + program_case.additional_symbols
# ACT && ASSERT #
for phase_is_after_act in [False, True]:
checker = integration_check.checker(phase_is_after_act)
checker.check__abs_stx__std_layouts_and_source_variants(
self,
instruction_syntax,
Arrangement.phase_agnostic(
symbols=SymbolContext.symbol_table_of_contexts(symbol_contexts),
tcds=TcdsArrangement(
tcds_contents=py_file_rel_conf.populator_for_relativity_option_root(
DirContents([py_file])
)
),
),
MultiSourceExpectation.phase_agnostic(
symbol_usages=SymbolContext.usages_assertion_of_contexts(symbol_contexts),
main_result=main_result,
main_side_effects_on_sds=main_side_effects_on_sds,
),
sub_test_identifiers={
'exit_code': exit_code,
'output_file': output_file,
'program': program_case.name,
'phase_is_after_act': phase_is_after_act,
},
)
def _check_exit_codes(self,
exit_code_cases: List[int],
ignore_exit_code: bool,
expected_primitive: Callable[[str], Assertion[StringSource]],
):
# ARRANGE #
program_output = {
ProcOutputFile.STDOUT: 'output on stdout',
ProcOutputFile.STDERR: 'output on stderr',
}
transformer = TO_UPPER_TRANSFORMER_SYMBOL
sym_ref_program = ProgramOfSymbolReferenceAbsStx('PROGRAM_SYMBOL_NAME')
program_builder = program_abs_stx.TransformableProgramAbsStxBuilder(
ProgramOfSymbolReferenceAbsStx(sym_ref_program.symbol_name)
)
program_cases = [
ProgramAndSymbolsCase(
'without transformation',
program_builder.without_transformation(),
[],
adapt_expected_program_output=lambda s: s
),
ProgramAndSymbolsCase(
'with transformation',
program_builder.with_transformation(transformer.abstract_syntax),
[transformer],
adapt_expected_program_output=str.upper
),
]
program_builder.with_and_without_transformer_cases(transformer.abstract_syntax)
py_file_rel_conf = rel_opt.conf_rel_any(RelOptionType.REL_HDS_CASE)
for exit_code in exit_code_cases:
py_file = File('exit-with-hard-coded-exit-code.py',
py_programs.py_pgm_with_stdout_stderr_exit_code(
exit_code=exit_code,
stdout_output=program_output[ProcOutputFile.STDOUT],
stderr_output=program_output[ProcOutputFile.STDERR],
),
)
py_file_conf = py_file_rel_conf.named_file_conf(py_file.name)
program_symbol = ProgramSymbolContext.of_sdv(
sym_ref_program.symbol_name,
program_sdvs.interpret_py_source_file_that_must_exist(py_file_conf.path_sdv)
)
for output_file in ProcOutputFile:
for program_case in program_cases:
syntax = string_source_abs_stx.StringSourceOfProgramAbsStx(
output_file,
program_case.syntax,
ignore_exit_code=ignore_exit_code,
)
expected_program_output = program_case.adapt_expected_program_output(program_output[output_file])
symbol_contexts = [program_symbol] + program_case.additional_symbols
# ACT && ASSERT #
checker = integration_check.checker__w_arbitrary_file_relativities()
with self.subTest(exit_code=exit_code,
output_file=output_file,
program=program_case.name):
checker.check__abs_stx(
self,
syntax,
None,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(symbol_contexts),
tcds_contents=py_file_rel_conf.populator_for_relativity_option_root(
DirContents([py_file])
)
),
Expectation(
ParseExpectation(
symbol_references=SymbolContext.references_assertion_of_contexts(symbol_contexts),
),
primitive=prim_asrt__constant(
expected_primitive(expected_program_output)
),
),
),