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 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 runTest(self):
for line_filter_case in LINE_FILTER_CASES:
for preserve_new_lines in [False, True]:
for regex_case in failing_regex_validation_cases():
all_symbols = line_filter_case.value.symbols + regex_case.symbols
source = ReplaceRegexAbsStx.of_str(
regex_case.regex_string,
'arbitrary_replacement',
preserve_new_lines=preserve_new_lines,
lines_filter=line_filter_case.value.syntax,
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants(
self,
source,
model_constructor.arbitrary(self),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
all_symbols)),
MultiSourceExpectation(
symbol_references=line_filter_case.value.
references_assertion__followed_by(
regex_case.reference_assertions),
execution=ExecutionExpectation(
validation=regex_case.expectation),
primitive=prim_asrt__constant(
is_identity_transformer(False)),
),
sub_test_identifiers={
'regex_case': regex_case.case_name,
'preserve_new_lines': preserve_new_lines,
'lines_filtering': line_filter_case.name,
})
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 test_stdin_is_contents_of_string_source_WHEN_program_defines_single_stdin(
self):
# ARRANGE #
test_setup = SingleStdinOfProgramTestSetup(self, exit_code=0)
for output_file in ProcOutputFile:
for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference(
):
for ignore_exit_code in [False, True]:
with self.subTest(output_file=output_file,
program=pgm_and_args_case.name,
ignore_exit_code=ignore_exit_code):
# ACT & ASSERT #
CHECKER.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_expr_parse__s__nsc,
StringSourceOfProgramAbsStx(
output_file,
test_setup.program_w_stdin_syntax(
pgm_and_args_case.pgm_and_args),
ignore_exit_code,
),
arrangement_w_tcds(
symbols=pgm_and_args_case.symbol_table,
process_execution=test_setup.
proc_exe_env__w_stdin_check,
tcds_contents=pgm_and_args_case.tcds,
),
MultiSourceExpectation.of_prim__const(
symbol_references=pgm_and_args_case.
references_assertion,
primitive=IS_EMPTY_STRING_SOURCE,
),
)
def test_transformer_component(self):
checker = integration_check.checker__w_arbitrary_file_relativities()
for validation_case in failing_validation_cases():
transformer_symbol = validation_case.value.symbol_context
program_syntax = program_abs_stx.FullProgramAbsStx(
program_abs_stx.ProgramOfSystemCommandLineAbsStx.of_str(
'a-system-command'),
transformation=transformer_symbol.abstract_syntax,
)
string_source_syntax = string_source_abs_stx.StringSourceOfProgramAbsStx(
ProcOutputFile.STDOUT,
program_syntax,
ignore_exit_code=False,
)
with self.subTest(validation_case.name):
checker.check__abs_stx__layouts__source_variants__wo_input(
self, equivalent_source_variants__for_expr_parse__s__nsc,
OptionallyOnNewLine(string_source_syntax),
arrangement_wo_tcds(
symbols=transformer_symbol.symbol_table),
MultiSourceExpectation(
symbol_references=transformer_symbol.
references_assertion,
execution=ExecutionExpectation(
validation=validation_case.value.expectation)))
def test_stdin_is_concatenation_of_string_sources_WHEN_program_defines_multiple_stdin(
self):
# ARRANGE #
test_setup = MultipleStdinOfProgramTestSetup(self, exit_code=0)
# ACT & ASSERT #
for output_file in ProcOutputFile:
for ignore_exit_code in [False, True]:
with self.subTest(output_file=output_file,
ignore_exit_code=ignore_exit_code):
CHECKER.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_expr_parse__s__nsc,
StringSourceOfProgramAbsStx(
output_file,
test_setup.program_w_stdin_syntax,
ignore_exit_code,
),
arrangement_w_tcds(
symbols=test_setup.program_symbol.symbol_table,
process_execution=test_setup.
proc_exe_env__w_stdin_check,
),
MultiSourceExpectation.of_prim__const(
symbol_references=test_setup.program_symbol.
references_assertion,
primitive=IS_EMPTY_STRING_SOURCE,
),
)
def test_with_reference_to_existing_file(self):
referenced_file = 'referenced-file.txt'
relativity_cases = [
relativity_options.conf_rel_hds(RelHdsOptionType.REL_HDS_CASE),
relativity_options.conf_rel_non_hds(RelNonHdsOptionType.REL_ACT),
]
for file_existence_case in FILE_EXISTENCE_CASES:
for relativity_conf in relativity_cases:
source_syntax = RawSystemCommandLineAbsStx.of_str(
'program_name', [
ArgumentOfExistingPathAbsStx(
relativity_conf.path_abs_stx_of_name(
referenced_file))
])
with self.subTest(
relativity=relativity_conf.option_string,
file_do_existence_case=file_existence_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,
source_syntax,
arrangement_w_tcds(
tcds_contents=relativity_conf.
populator_for_relativity_option_root(
DirContents(
file_existence_case.files_for_name(
referenced_file)))),
MultiSourceExpectation(execution=ExecutionExpectation(
validation=file_existence_case.expectation_for(
relativity_conf.directory_structure_partition))
),
)
def test_stdin_is_contents_of_string_source_WHEN_program_defines_single_stdin(self):
# ARRANGE #
test_setup = SingleStdinOfProgramTestSetup(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 #
integration_check.CHECKER__PARSE_FULL.check__abs_stx__layouts__source_variants(
self,
equivalent_source_variants__for_expr_parse__s__nsc,
abstract_syntaxes.RunProgramAbsStx(
test_setup.program_w_stdin_syntax(pgm_and_args_case.pgm_and_args),
abstract_syntaxes.PathArgumentPositionLast()
),
integration_check.ARBITRARY_MODEL,
arrangement_w_tcds(
symbols=pgm_and_args_case.symbol_table,
process_execution=test_setup.proc_exe_env__w_stdin_check,
tcds_contents=pgm_and_args_case.tcds,
),
MultiSourceExpectation(
symbol_references=pgm_and_args_case.references_assertion,
execution=ExecutionExpectation(
main_result=asrt_matching_result.matches_value(True)
),
),
)
def runTest(self):
# ARRANGE #
leaf_file_name = 'created-leaf'
for create_path_case in create_path_cases(leaf_file_name):
for rel_file_name_case in rel_file_name_cases__create(
leaf_file_name, create_path_case.expected_created_file):
syntax = LiteralFilesSourceAbsStx([
abs_stx.FileSpecAbsStx.of_file_type(
create_path_case.file_type,
file_name_arg(
str(rel_file_name_case.file_spec_file_name)),
create_path_case.contents__syntax,
)
])
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
syntax,
rel_file_name_case.arrangement,
arrangement_w_tcds(),
MultiSourceExpectation(execution=ExecutionExpectation(
main_result=asrt_fs.dir_contains_exactly_2(
rel_file_name_case.expected_root_dir_contents))),
sub_test_identifiers={
'create_case': create_path_case.name,
'rel_file_name_case': rel_file_name_case.name,
})
def test_string_symbol_reference(self):
for other_valid_file_spec_case in OTHER_VALID_FILE_SPECS:
for file_name_case in INVALID_FILE_NAMES:
file_name_symbol = StringSymbolContext.of_constant(
'FILE_NAME_SYMBOL',
file_name_case.value,
default_restrictions=asrt_rest.is__string__w_all_indirect_refs_are_strings(),
)
file_name_abs_stx = file_name_symbol.abstract_syntax
for file_spec_case in file_type_and_contents_variants(file_name_abs_stx):
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
LiteralFilesSourceAbsStx(other_valid_file_spec_case.value + [file_spec_case.value]),
models.empty(),
arrangement_wo_tcds(
symbols=file_name_symbol.symbol_table
),
MultiSourceExpectation(
symbol_references=file_name_symbol.references_assertion,
execution=ExecutionExpectation(
validation=ValidationAssertions.pre_sds_fails__w_any_msg()
)
),
sub_test_identifiers={
'file-name': file_name_case.name,
'type-and-contents': file_spec_case.name,
'other-valid-file-spec': other_valid_file_spec_case.name,
}
)
def test_stdin_is_concatenation_of_model_and_program_stdin_WHEN_program_defines_single_stdin(
self):
# ARRANGE #
model_contents = '\n'.join(('the', 'contents', 'of', 'the', 'model'))
test_setup = SingleStdinOfProgramTestSetup(
self, exit_code=0, additional_stdin=model_contents)
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 #
integration_check.CHECKER__PARSE_FULL.check__abs_stx__layouts__source_variants(
self,
equivalent_source_variants__for_expr_parse__s__nsc,
RunProgramAbsStx(
test_setup.program_w_stdin_syntax(
pgm_and_args_case.pgm_and_args), ),
model_constructor.of_str(self, model_contents),
arrangement_w_tcds(
symbols=pgm_and_args_case.symbol_table,
process_execution=test_setup.
proc_exe_env__w_stdin_check,
tcds_contents=pgm_and_args_case.tcds,
),
MultiSourceExpectation(
symbol_references=pgm_and_args_case.
references_assertion,
execution=EXECUTION_OUTPUT_IS_EMPTY,
primitive=PRIMITIVE_IS_NOT_IDENTITY_TRANSFORMATION,
),
)
def runTest(self):
# ARRANGE #
contents_cases: Sequence[NameAndValue[fs.FileSystemElements]] = [
NameAndValue(
'empty',
(),
),
NameAndValue(
'non-empty',
[fs.File.empty('empty-file.txt')],
),
]
for contents_case in contents_cases:
symbol = FilesSourceSymbolContext.of_primitive(
'SYMBOL_NAME',
FilesSourceThatWritesFileSystemElements(contents_case.value),
)
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
symbol.abstract_syntax,
models.empty(),
arrangement_w_tcds(
symbols=symbol.symbol_table,
),
MultiSourceExpectation(
symbol_references=symbol.references_assertion,
execution=ExecutionExpectation(
main_result=asrt_fs.dir_contains_exactly_2(contents_case.value)
)
),
sub_test_identifiers={
'contents': contents_case.name,
}
)
def test_without_transformer(self):
# ARRANGE #
src_file = fs.File('source-file.txt', 'contents of source file')
src_rel_opt_conf = conf_rel_any(RelOptionType.REL_TMP)
checker = integration_check.checker(parse_check.rel_opts_conf_of_single(src_rel_opt_conf.relativity))
file_contents_abs_stx = string_source_abs_stx.StringSourceOfFileAbsStx(
src_rel_opt_conf.path_abs_stx_of_name(src_file.name)
)
# ACT & ASSERT #
checker.check__abs_stx__layouts__std_source_variants__wo_input(
self,
OptionallyOnNewLine(file_contents_abs_stx),
arrangement_w_tcds(
tcds_contents=src_rel_opt_conf.populator_for_relativity_option_root(
DirContents([src_file]))
),
MultiSourceExpectation.of_prim__const(
asrt_string_source.pre_post_freeze__matches_str__const(
src_file.contents,
may_depend_on_external_resources=True,
),
symbol_references=asrt.is_empty_sequence,
)
)
def runTest(self):
# ARRANGE #
program_ref_case = pgm_and_args_cases.program_reference__w_argument_list()
def expected_program(env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=program_ref_case.expected_command_driver(env),
arguments=asrt.is_empty_sequence,
),
stdin=asrt_pgm_val.is_no_stdin(),
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,
OptionallyOnNewLine(WithinParensAbsStx(program_ref_case.pgm_and_args,
end_paren_on_separate_line=False)),
arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(program_ref_case.symbols),
),
MultiSourceExpectation(
symbol_references=SymbolContext.references_assertion_of_contexts(program_ref_case.symbols),
primitive=expected_program,
)
)
def test_transformation_only_as_source_argument(self):
# ARRANGE #
transformer = StringTransformerPrimitiveSymbolContext(
'STRING_TRANSFORMER', string_transformers.to_uppercase())
for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference(
):
program_w_transformer = FullProgramAbsStx(
pgm_and_args_case.pgm_and_args,
transformation=transformer.abstract_syntax)
symbols = list(pgm_and_args_case.symbols) + [transformer]
with self.subTest(command=pgm_and_args_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,
pgm_and_args_case.mk_arrangement(
SymbolContext.symbol_table_of_contexts(symbols)),
MultiSourceExpectation(
symbol_references=SymbolContext.
references_assertion_of_contexts(symbols),
primitive=lambda env: (asrt_pgm_val.matches_program(
asrt_command.
matches_command(driver=pgm_and_args_case.
expected_command_driver(env),
arguments=asrt.is_empty_sequence),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt.matches_singleton_sequence(
asrt.is_(transformer.primitive)),
))))
def runTest(self):
# ARRANGE #
for validation_case in validation_cases.failing_validation_cases():
for preserve_new_lines in [False, True]:
syntax = ReplaceRegexAbsStx.of_str(
'valid_regex',
'valid_replacement',
preserve_new_lines=preserve_new_lines,
lines_filter=validation_case.value.matcher_abs_stx,
)
line_matcher_symbol_context = validation_case.value.symbol_context
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants(
self,
syntax,
model_constructor.arbitrary(self),
arrangement_wo_tcds(
symbols=line_matcher_symbol_context.symbol_table),
MultiSourceExpectation(
symbol_references=line_matcher_symbol_context.
references_assertion,
execution=ExecutionExpectation(
validation=validation_case.value.expectation, )),
sub_test_identifiers={
'preserve_new_lines': preserve_new_lines,
'validation': validation_case.name,
})
def _check_case(self,
invalid_file_spec: FileSpecAbsStx,
contents_case: ContentsCase,
validation_case: NameAndValue[ValidationCaseWSymbolContextAndAssertion],
):
symbol_context = validation_case.value.symbol_context
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
LiteralFilesSourceAbsStx(contents_case.other_valid_file_spec.value + [invalid_file_spec]),
models.empty(),
arrangement_wo_tcds(
symbols=symbol_context.symbol_table
),
MultiSourceExpectation(
symbol_references=symbol_context.references_assertion,
execution=ExecutionExpectation(
validation=validation_case.value.assertion
)
),
sub_test_identifiers={
'validation': validation_case.name,
'other-valid-file-spec': contents_case.other_valid_file_spec.name,
'modification-type': contents_case.modification_type,
}
)
def test_dir(self):
# ARRANGE #
to_append_file = fs.File('file-to-append',
'contents of file to append')
pre_existing_file = fs.File('pre-existing',
'contents of pre existing file')
append_single_file__contents_syntax = abs_stx.DirContentsExplicitAbsStx(
ModificationType.APPEND,
abs_stx.LiteralFilesSourceAbsStx([
abs_stx.regular_file_spec(
file_name_arg(to_append_file.name),
abs_stx.FileContentsExplicitAbsStx(
ModificationType.CREATE,
str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
to_append_file.contents, QuoteType.HARD)))
]))
target_dir_name = 'destination-dir'
contents_cases: Sequence[AppendDirContentsCase] = [
AppendDirContentsCase(
'empty',
[],
[to_append_file],
),
AppendDirContentsCase(
'non-empty',
[pre_existing_file],
[pre_existing_file, to_append_file],
),
]
for target_location_case in target_locations():
syntax = abs_stx.LiteralFilesSourceAbsStx([
abs_stx.dir_spec(
file_name_arg(
target_location_case.target_rel_path(target_dir_name)),
append_single_file__contents_syntax,
)
])
for contents_case in contents_cases:
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
syntax, [
target_location_case.file_for_leaf(
contents_case.original(target_dir_name))
],
arrangement_w_tcds(),
MultiSourceExpectation(execution=ExecutionExpectation(
main_result=asrt_fs.dir_contains_exactly_2([
target_location_case.file_for_leaf(
fs.Dir(
target_dir_name, contents_case.
expected_contents_after_modification))
]))),
sub_test_identifiers={
'contents': contents_case.name,
'target_location': target_location_case.name
})
def runTest(self):
# ARRANGE #
arguments = ['arg']
str_src_contents = 'the_str_src_contents'
stdin_syntax = str_src_abs_stx.StringSourceWithinParensAbsStx(
str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
str_src_contents))
transformer_symbol = StringTransformerPrimitiveSymbolContext(
'TRANSFORMER', string_transformers.to_uppercase())
for pgm_and_args_case in pgm_and_args_cases.cases__w_argument_list__including_program_reference(
):
program_w_stdin = FullProgramAbsStx(
PgmAndArgsWArgumentsAbsStx(
pgm_and_args_case.pgm_and_args,
[
ArgumentOfRichStringAbsStx.of_str(arg)
for arg in arguments
],
),
stdin=stdin_syntax,
transformation=transformer_symbol.abstract_syntax,
)
symbols = list(pgm_and_args_case.symbols) + [transformer_symbol]
def expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=pgm_and_args_case.expected_command_driver(env),
arguments=asrt.equals(arguments),
),
stdin=asrt.matches_singleton_sequence(
asrt_str_src.matches__str(
asrt.equals(str_src_contents), )),
transformer=asrt.matches_singleton_sequence(
asrt.is_(transformer_symbol.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_stdin,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(symbols),
tcds_contents=pgm_and_args_case.tcds,
),
MultiSourceExpectation(
symbol_references=SymbolContext.
references_assertion_of_contexts(symbols),
primitive=expected_program,
),
sub_test_identifiers={'command': pgm_and_args_case.name})
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 runTest(self):
# ARRANGE #
py_file = File('stdin-to-upper.py',
_PGM_THAT_OUTPUTS_STDIN_IN_UPPER_CASE)
py_file_rel_opt_conf = rel_opt.conf_rel_any(RelOptionType.REL_TMP)
py_file_conf = py_file_rel_opt_conf.named_file_conf(py_file.name)
program_symbol = ProgramSymbolContext.of_sdv(
'PROGRAM_THAT_EXECUTES_PY_FILE',
program_sdvs.interpret_py_source_file_that_must_exist(py_file_conf.path_sdv)
)
input_model_lines = [
'the\n',
'input\n',
'model',
]
expected_output_model_lines = list(map(str.upper, input_model_lines))
for with_ignored_exit_code in [False, True]:
with self.subTest(with_ignored_exit_code=with_ignored_exit_code):
# ACT && ASSERT #
integration_check.CHECKER__PARSE_FULL.check__w_source_variants_for_full_line_parser(
self,
args.syntax_for_run(
program_args.symbol_ref_command_elements(program_symbol.name),
ignore_exit_code=with_ignored_exit_code,
),
model_constructor.of_lines(self, input_model_lines),
arrangement_w_tcds(
tcds_contents=py_file_rel_opt_conf.populator_for_relativity_option_root(
DirContents([py_file])
),
symbols=program_symbol.symbol_table,
),
MultiSourceExpectation(
symbol_references=program_symbol.references_assertion,
execution=ExecutionExpectation(
main_result=asrt_string_source.pre_post_freeze__matches_lines(
asrt.equals(expected_output_model_lines),
may_depend_on_external_resources=asrt.equals(True),
frozen_may_depend_on_external_resources=asrt.anything_goes(),
)
),
primitive=prim_asrt__constant(
asrt_string_transformer.is_identity_transformer(False)
),
),
)
def test_regular(self):
# ARRANGE #
to_append__text = '<appended text>'
non_empty_original__text = '<original text>'
append_contents_syntax = abs_stx.FileContentsExplicitAbsStx(
ModificationType.APPEND,
str_src_abs_stx.StringSourceOfStringAbsStx.of_str_hard(
to_append__text))
name_of_modified_file = 'destination.txt'
contents_cases: Sequence[AppendRegularContentsCase] = [
AppendRegularContentsCase(
'empty',
'',
to_append__text,
),
AppendRegularContentsCase(
'non-empty',
non_empty_original__text,
non_empty_original__text + to_append__text,
),
]
for target_location_case in target_locations():
syntax = abs_stx.LiteralFilesSourceAbsStx([
abs_stx.regular_file_spec(
file_name_arg(
target_location_case.target_rel_path(
name_of_modified_file)),
append_contents_syntax,
)
])
for contents_case in contents_cases:
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
syntax, [
target_location_case.file_for_leaf(
contents_case.original(name_of_modified_file))
],
arrangement_w_tcds(),
MultiSourceExpectation(execution=ExecutionExpectation(
main_result=asrt_fs.dir_contains_exactly_2([
target_location_case.file_for_leaf(
fs.File(
name_of_modified_file, contents_case.
expected_contents_after_modification))
]))),
sub_test_identifiers={
'contents': contents_case.name,
'target_location': target_location_case.name
})
def runTest(self):
# ARRANGE #
to_upper_transformer = StringTransformerSymbolContext.of_primitive(
'TRANSFORMER_SYMBOL',
string_transformers.to_uppercase(),
)
src_file = fs.File('src-file.txt', 'contents of source file')
src_file_rel_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE)
expected_contents = src_file.contents.upper()
path_relativity_variants = PathRelativityVariants({src_file_rel_conf.relativity}, True)
checker = integration_check.checker(RelOptionsConfiguration(path_relativity_variants,
src_file_rel_conf.relativity))
src_file_symbol = ConstantSuffixPathDdvSymbolContext(
'SRC_FILE_SYMBOL',
src_file_rel_conf.relativity,
src_file.name,
path_relativity_variants,
)
string_source_syntax = string_source_abs_stx.TransformedStringSourceAbsStx(
string_source_abs_stx.StringSourceOfFileAbsStx(src_file_symbol.abstract_syntax),
to_upper_transformer.abstract_syntax,
)
symbol_table = SymbolContext.symbol_table_of_contexts([
src_file_symbol,
to_upper_transformer,
])
# ACT & ASSERT #
checker.check__abs_stx__layouts__std_source_variants__wo_input(
self,
OptionallyOnNewLine(string_source_syntax),
arrangement_w_tcds(
symbols=symbol_table,
hds_contents=src_file_rel_conf.populator_for_relativity_option_root__hds(
DirContents([src_file]))
),
MultiSourceExpectation.of_prim__const(
asrt_string_source.pre_post_freeze__matches_str__const(
expected_contents,
may_depend_on_external_resources=True,
),
symbol_references=asrt.matches_sequence([
src_file_symbol.reference_assertion__path_or_string,
to_upper_transformer.reference_assertion,
]),
),
)
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_shell_program(self):
argument_string_template = 'first {string_symbol} between {list_symbol} after'
string_argument_symbol = StringConstantSymbolContext(
'STRING_ARGUMENT_SYMBOL',
'string argument',
)
list_argument_symbol = ListConstantSymbolContext(
'LIST_ARGUMENT_SYMBOL', ['list_arg_value_1', 'list arg value 2'])
symbols = [string_argument_symbol, list_argument_symbol]
command_line_syntax_str = argument_string_template.format(
string_symbol=string_argument_symbol.name__sym_ref_syntax,
list_symbol=list_argument_symbol.name__sym_ref_syntax,
)
command_line_str = argument_string_template.format(
string_symbol=string_argument_symbol.str_value,
list_symbol=' '.join(list_argument_symbol.constant_list),
)
syntax = ProgramOfShellCommandLineAbsStx(
StringLiteralAbsStx(command_line_syntax_str))
def expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
command=asrt_command.equals_shell_command(
command_line=command_line_str,
arguments=[],
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)
expectation = MultiSourceExpectation(
symbol_references=asrt.matches_sequence([
string_argument_symbol.reference_assertion__w_str_rendering,
list_argument_symbol.reference_assertion__w_str_rendering,
]),
primitive=expected_program,
)
# 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,
syntax,
arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(symbols), ),
expectation,
)
def test_without_reference_to_existing_file(self):
# ARRANGE #
abstract_syntax = RawSystemCommandLineAbsStx.of_str(
'program_name',
[ArgumentOfRichStringAbsStx.of_str('argument-that-is-not-a-file')])
# 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,
abstract_syntax,
arrangement_wo_tcds(),
MultiSourceExpectation(execution=ExecutionExpectation(
validation=validation.ValidationAssertions.all_passes())),
)
def test_wo_transformation(self):
# ARRANGE #
cases: List[NameAndValue[Case]] = [
NameAndValue('string', _string_case(_no_transformation)),
NameAndValue('string-source',
_string_source_case(_no_transformation)),
]
for case in cases:
# ACT & ASSERT #
CHECKER.check__abs_stx__layouts__std_source_variants__wo_input(
self,
case.value.syntax,
arrangement_w_tcds(symbols=case.value.symbol.symbol_table, ),
MultiSourceExpectation.of_prim(
symbol_references=asrt.matches_singleton_sequence(
references.is_reference_to__string_source_or_string(
case.value.symbol.name)),
primitive=case.value.expectation_of_primitive,
),
sub_test_identifiers={
'case': case.name,
})
def check__w_source_variants_for_full_line_parser_2(
self,
put: unittest.TestCase,
arguments: Arguments,
input_: INPUT,
arrangement: Arrangement,
expectation: Expectation[PRIMITIVE, OUTPUT],
):
self.check__w_source_variants_for_full_line_parser(
put, arguments, input_, arrangement,
MultiSourceExpectation(
expectation.parse.symbol_references,
expectation.execution,
expectation.primitive,
))
def test_here_doc(self):
# ARRANGE #
string_value = rich_str_abs_stx.HereDocAbsStx(
'single line in here doc\n')
string_source_syntax = string_source_abs_stx.StringSourceOfStringAbsStx(
string_value)
CHECKER.check__abs_stx__layouts__source_variants__wo_input(
self, equivalent_source_variants__for_full_line_expr_parse__s__nsc,
OptionallyOnNewLine(
WithinParensAbsStx(string_source_syntax,
end_paren_on_separate_line=True)),
arrangement_w_tcds(),
MultiSourceExpectation.of_prim__const(
asrt_string_source.pre_post_freeze__matches_str__const(
string_value.value,
may_depend_on_external_resources=False,
)))
