def run_test(self):
def resolve_validator_that_fails_pre_sds(
symbols: SymbolTable) -> DdvValidator:
return ConstantDdvValidator.of_pre_sds(
asrt_text_doc.new_single_string_text_for_test('err msg'))
referenced_system_program_sdv_w_invalid_arguments = program_sdvs.system_program(
string_sdvs.str_constant('valid-system-program'),
ArgumentsSdv(list_sdvs.from_str_constant('the arg'),
[resolve_validator_that_fails_pre_sds]))
valid_program_symbol = ProgramSymbolContext.of_sdv(
'VALID_PROGRAM', referenced_system_program_sdv_w_invalid_arguments)
argument_syntax = ArgumentOfRichStringAbsStx.of_str('valid-arg')
reference_and_additional_invalid_argument = self.source_to_parse(
valid_program_symbol.name,
[argument_syntax],
)
# ACT & ASSERT #
self.integration_checker(
).check__abs_stx__layouts__source_variants__wo_input(
self.put,
equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc,
reference_and_additional_invalid_argument,
arrangement_w_tcds(symbols=valid_program_symbol.symbol_table, ),
MultiSourceExpectation.of_const(
symbol_references=valid_program_symbol.references_assertion,
primitive=asrt.anything_goes(),
execution=ExecutionExpectation(
validation=validation.ValidationAssertions.
pre_sds_fails__w_any_msg(), )),
)
def test_stdin_only_as_source_argument(self):
# ARRANGE #
for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference(
):
for validation_case in validation_cases.failing_validation_cases():
program_w_stdin = FullProgramAbsStx(
pgm_and_args_case.pgm_and_args,
stdin=validation_case.value.syntax,
)
symbols = list(pgm_and_args_case.symbols) + [
validation_case.value.symbol_context
]
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_expr_parse__s__nsc,
program_w_stdin,
pgm_and_args_case.mk_arrangement(
SymbolContext.symbol_table_of_contexts(symbols)),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(symbols),
execution=ExecutionExpectation(
validation=validation_case.value.assertion, ),
primitive=asrt.anything_goes(),
),
sub_test_identifiers={
'command': pgm_and_args_case.name,
'validation': validation_case.name
},
)
def run_test(self):
relativity_conf = relativity_options.conf_rel_any(
self._missing_file_relativity)
referenced_program_arguments = [
'valid arg 1 of referenced', 'valid arg 2 of referenced'
]
referenced_system_program_sdv = program_sdvs.system_program(
string_sdvs.str_constant('valid-system-program'),
ArgumentsSdv.new_without_validation(
list_sdvs.from_str_constants(referenced_program_arguments)))
valid_program_symbol = ProgramSymbolContext.of_sdv(
'VALID_PROGRAM', referenced_system_program_sdv)
invalid_argument_syntax = ArgumentOfExistingPathAbsStx(
relativity_conf.path_abs_stx_of_name('non-existing-file'))
reference_and_additional_invalid_argument = self.source_to_parse(
valid_program_symbol.name,
[invalid_argument_syntax],
)
# ACT & ASSERT #
self.integration_checker(
).check__abs_stx__layouts__source_variants__wo_input(
self.put,
equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc,
reference_and_additional_invalid_argument,
arrangement_w_tcds(symbols=valid_program_symbol.symbol_table, ),
MultiSourceExpectation.of_const(
symbol_references=valid_program_symbol.references_assertion,
primitive=asrt.anything_goes(),
execution=ExecutionExpectation(
validation=FAILING_VALIDATION_ASSERTION_FOR_PARTITION[
relativity_conf.directory_structure_partition], )),
)
def _check_failing_validation_of_referenced_program__for_relativity(self, missing_file_relativity: RelOptionType):
relativity_conf = relativity_options.conf_rel_any(missing_file_relativity)
program_symbol_with_ref_to_non_exiting_exe_file = ProgramSymbolContext.of_sdv(
'PGM_WITH_REF_TO_EXE_FILE',
program_sdvs.ref_to_exe_file(
constant(simple_of_rel_option(relativity_conf.relativity_option,
'non-existing-exe-file')))
)
program_symbol_with_ref_to_non_exiting_file_as_argument = ProgramSymbolContext.of_sdv(
'PGM_WITH_ARG_WITH_REF_TO_FILE',
program_sdvs.interpret_py_source_file_that_must_exist(
constant(simple_of_rel_option(relativity_conf.relativity_option,
'non-existing-python-file.py')))
)
expectation = MultiSourceExpectation.of_const(
symbol_references=asrt.anything_goes(),
primitive=asrt.anything_goes(),
execution=ExecutionExpectation(
validation=FAILING_VALIDATION_ASSERTION_FOR_PARTITION[relativity_conf.directory_structure_partition],
)
)
symbols = SymbolContext.symbol_table_of_contexts([
program_symbol_with_ref_to_non_exiting_exe_file,
program_symbol_with_ref_to_non_exiting_file_as_argument,
])
arrangement = arrangement_w_tcds(
symbols=symbols,
)
cases = [
NameAndValue(
'executable does not exist',
RawProgramOfSymbolReferenceAbsStx(program_symbol_with_ref_to_non_exiting_exe_file.name),
),
NameAndValue(
'file referenced from argument does not exist',
RawProgramOfSymbolReferenceAbsStx(program_symbol_with_ref_to_non_exiting_file_as_argument.name),
),
]
for case in cases:
with self.subTest(case=case.name):
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc,
case.value,
arrangement,
expectation,
)
def _check_failing_validation___for_relativity(
self, missing_file_relativity: RelOptionType):
relativity_conf = relativity_options.conf_rel_any(
missing_file_relativity)
invalid_argument_syntax = ArgumentOfExistingPathAbsStx(
relativity_conf.path_abs_stx_of_name('non-existing-file'))
arguments_cases = [
NameAndValue(
'1st argument fails validation',
[invalid_argument_syntax],
),
NameAndValue(
'2nd argument fails validation',
[
ArgumentOfRichStringAbsStx.of_str('valid1'),
invalid_argument_syntax,
ArgumentOfRichStringAbsStx.of_str('valid2')
],
),
]
for pgm_and_args_case in pgm_and_args_cases.cases__w_argument_list__excluding_program_reference(
):
for arguments_case in arguments_cases:
pgm_w_args = PgmAndArgsWArgumentsAbsStx(
pgm_and_args_case.pgm_and_args, arguments_case.value)
with self.subTest(pgm_and_args=pgm_and_args_case.name,
arguments=arguments_case.name):
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc,
pgm_w_args,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
pgm_and_args_case.symbols),
tcds_contents=pgm_and_args_case.tcds,
),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
pgm_and_args_case.symbols),
primitive=asrt.anything_goes(),
execution=ExecutionExpectation(
validation=
FAILING_VALIDATION_ASSERTION_FOR_PARTITION[
relativity_conf.
directory_structure_partition], )),
)
def test_WHEN_program_is_non_non_existing_system_command_THEN_result_SHOULD_be_hard_error(self):
failing_program_builder = program_abs_stx.TransformableProgramAbsStxBuilder(
program_abs_stx.ProgramOfSystemCommandLineAbsStx.of_str(NON_EXISTING_SYSTEM_PROGRAM)
)
transformer = TO_UPPER_TRANSFORMER_SYMBOL
symbols = transformer.symbol_table
cases = failing_program_builder.with_and_without_transformer_cases(transformer.abstract_syntax)
for ignore_exit_code in [False, True]:
for transformation_case in cases:
syntax = string_source_abs_stx.StringSourceOfProgramAbsStx(
ProcOutputFile.STDOUT,
transformation_case.value,
ignore_exit_code=ignore_exit_code,
)
checker = integration_check.checker__w_arbitrary_file_relativities()
with self.subTest(transformation=transformation_case.name,
ignore_exit_code=ignore_exit_code):
# ACT & ASSERT #
checker.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_full_line_expr_parse__s__nsc, OptionallyOnNewLine(syntax),
arrangement_w_tcds(
symbols=symbols,
),
MultiSourceExpectation.of_const(
symbol_references=asrt.anything_goes(),
primitive=asrt_string_source.pre_post_freeze(
asrt_str_src_contents.contents_raises_hard_error(
may_depend_on_external_resources=asrt.equals(True)
),
asrt_str_src_contents.contents_raises_hard_error__including_ext_deps(),
),
)
)
def test_stdin_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
str_src_contents__of_argument = 'the_str_src_contents__of_argument'
str_src_contents__of_referenced_pgm = 'the_str_src_contents__of_program'
stdin_argument_syntax = str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
str_src_contents__of_argument)
stdin_sdv__of_referenced = str_src_sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(str_src_contents__of_referenced_pgm))
referenced_program__system_program = 'the-system-program'
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(referenced_program__system_program),
stdin=[stdin_sdv__of_referenced],
)
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
symbols__symbol_table = [referenced_program]
symbols__expected_references = [referenced_program]
arguments_cases = [
NameAndValue(
'no arguments',
[],
),
NameAndValue(
'single argument',
['arg1'],
)
]
for arguments_case in arguments_cases:
with self.subTest(arguments=arguments_case.name):
program_w_stdin = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, [
ArgumentOfRichStringAbsStx.of_str(arg)
for arg in arguments_case.value
]),
stdin=stdin_argument_syntax,
)
expected_primitive = asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=asrt_command.
matches_system_program_command_driver(
asrt.equals(referenced_program__system_program)),
arguments=asrt.equals(arguments_case.value),
),
stdin=asrt.matches_sequence([
asrt_str_src.matches__str(
asrt.equals(str_src_contents__of_referenced_pgm)),
asrt_str_src.matches__str(
asrt.equals(str_src_contents__of_argument)),
]),
transformer=asrt_pgm_val.is_no_transformation(),
)
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self, equivalent_source_variants__for_expr_parse__s__nsc,
program_w_stdin,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols__symbol_table), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
primitive=expected_primitive,
))
def test_stdin_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
stdin_contents = 'str_src_contents'
valid_stdin_sdv = sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(stdin_contents))
valid_stdin_syntax = str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
stdin_contents)
referenced_program__system_program = 'the-system-program'
for validation_case in validation_cases.failing_validation_cases():
invalid_stdin_location_cases = [
ValidationCaseWAccumulation(
'in referenced symbol',
sdv_of_referenced_program=validation_case.value.
symbol_context.sdv,
syntax_accumulated=valid_stdin_syntax,
symbols=[],
),
ValidationCaseWAccumulation(
'as source argument',
sdv_of_referenced_program=valid_stdin_sdv,
syntax_accumulated=validation_case.value.syntax,
symbols=[validation_case.value.symbol_context],
),
]
for invalid_stdin_location_case in invalid_stdin_location_cases:
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(
referenced_program__system_program),
stdin=[
invalid_stdin_location_case.sdv_of_referenced_program
])
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
program_w_stdin = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, ),
stdin=invalid_stdin_location_case.syntax_of_accumulated,
)
symbols__all = [
validation_case.value.symbol_context, referenced_program
]
symbols__expected_references = [
referenced_program
] + invalid_stdin_location_case.symbols
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_expr_parse__s__nsc,
program_w_stdin,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols__all), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
execution=ExecutionExpectation(
validation=validation_case.value.assertion, ),
primitive=asrt.anything_goes(),
),
sub_test_identifiers={
'validation': validation_case.name,
'invalid_stdin_location':
invalid_stdin_location_case.name,
})
def test_transformation_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
transformer__in_referenced_program = StringTransformerPrimitiveSymbolContext(
'TRANSFORMER_IN_REFERENCED_PROGRAM',
string_transformers.delete_everything())
referenced_program__system_program = 'the-system-program'
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(referenced_program__system_program),
transformations=[transformer__in_referenced_program.reference_sdv])
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
transformer__in_source = StringTransformerPrimitiveSymbolContext(
'TRANSFORMER_IN_SOURCE', string_transformers.to_uppercase())
symbols__symbol_table = [
referenced_program, transformer__in_referenced_program,
transformer__in_source
]
symbols__expected_references = [
referenced_program, transformer__in_source
]
arguments_cases = [
NameAndValue(
'no arguments',
[],
),
NameAndValue(
'single argument',
['arg1'],
)
]
for arguments_case in arguments_cases:
with self.subTest(arguments=arguments_case.name):
program_w_transformer = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, [
ArgumentOfRichStringAbsStx.of_str(arg)
for arg in arguments_case.value
]),
transformation=transformer__in_source.abstract_syntax)
expected_primitive = asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=asrt_command.
matches_system_program_command_driver(
asrt.equals(referenced_program__system_program)),
arguments=asrt.equals(arguments_case.value),
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt.matches_sequence([
asrt.is_(transformer__in_referenced_program.primitive),
asrt.is_(transformer__in_source.primitive),
]),
)
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self, equivalent_source_variants__for_expr_parse__s__nsc,
program_w_transformer,
arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols__symbol_table), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
primitive=expected_primitive,
))
def test_transformation_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
valid_transformer = StringTransformerSymbolContext.of_arbitrary_value(
'VALID_TRANSFORMER', )
referenced_program__system_program = 'the-system-program'
for validation_case in validation_cases.failing_validation_cases(
'INVALID_TRANSFORMER'):
invalid_transformer_location_cases = [
ValidationCaseWAccumulation(
'in referenced program',
of_referenced_program=validation_case.value.symbol_context,
accumulated=valid_transformer,
),
ValidationCaseWAccumulation(
'in referenced program',
of_referenced_program=valid_transformer,
accumulated=validation_case.value.symbol_context,
),
]
for invalid_transformer_location_case in invalid_transformer_location_cases:
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(
referenced_program__system_program),
transformations=[
invalid_transformer_location_case.
of_referenced_program.reference_sdv
])
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
program_w_transformer = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, ),
transformation=invalid_transformer_location_case.
accumulated.abstract_syntax,
)
symbols__all = [
referenced_program,
valid_transformer,
validation_case.value.symbol_context,
]
symbols__expected_references = [
referenced_program,
invalid_transformer_location_case.accumulated
]
with self.subTest(validation=validation_case.name,
invalid_transformer_location=
invalid_transformer_location_case.name):
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_expr_parse__s__nsc,
program_w_transformer,
arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols__all), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
execution=ExecutionExpectation(
validation=validation_case.value.expectation,
),
primitive=asrt.anything_goes(),
))
def test_syntax_layout_variants(self):
# ARRANGE #
exit_code_from_program = 1
output_from_program = 'the output from the program'
transformer = TO_UPPER_TRANSFORMER_SYMBOL
sym_ref_program = ProgramOfSymbolReferenceAbsStx('PROGRAM_SYMBOL_NAME')
program_builder = program_abs_stx.TransformableProgramAbsStxBuilder(
ProgramOfSymbolReferenceAbsStx(sym_ref_program.symbol_name)
)
output_cases = [
OutputFileCase(
ProcOutputFile.STDOUT,
{
ProcOutputFile.STDOUT: output_from_program,
ProcOutputFile.STDERR: '',
}
),
OutputFileCase(
ProcOutputFile.STDERR,
{
ProcOutputFile.STDOUT: '',
ProcOutputFile.STDERR: output_from_program,
}
),
]
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
),
]
py_file_rel_conf = rel_opt.conf_rel_any(RelOptionType.REL_HDS_CASE)
for output_case in output_cases:
py_file = File('exit-with-hard-coded-exit-code.py',
py_programs.py_pgm_with_stdout_stderr_exit_code_2(
exit_code=exit_code_from_program,
output=output_case.program_output,
),
)
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 program_case in program_cases:
syntax = string_source_abs_stx.StringSourceOfProgramAbsStx(
output_case.output_file,
program_case.syntax,
ignore_exit_code=True,
)
expected_program_output = program_case.adapt_expected_program_output(output_from_program)
symbol_contexts = [program_symbol] + program_case.additional_symbols
# ACT && ASSERT #
checker = integration_check.checker__w_arbitrary_file_relativities()
with self.subTest(output_file=output_case.output_file,
program=program_case.name):
checker.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_full_line_expr_parse__s__nsc,
OptionallyOnNewLine(syntax),
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])
)
),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.references_assertion_of_contexts(symbol_contexts),
primitive=asrt_string_source.pre_post_freeze__matches_str__const_2(
expected_program_output,
may_depend_on_external_resources=True,
frozen_may_depend_on_external_resources=asrt.anything_goes(),
),
),
),
