def runTest(self):
# ARRANGE #
stdin_from_act_exe_input = 'the stdin from the Act Execution Input (via [setup])'
stdin_defined_by_the_program = 'the stdin defined by the program'
test_setup = StdinCheckViaCopyToOutputFileTestSetup(
ProcOutputFile.STDOUT,
stdin_defined_for_program=[
ss_sdvs.const_str(stdin_defined_by_the_program)
])
full_stdin = stdin_defined_by_the_program + stdin_from_act_exe_input
# ACT & ASSERT #
CHECKER.check__abs_stx(
self,
test_setup.program_that_copies_stdin_syntax(),
Arrangement(
symbols=SymbolContext.symbol_table_of_contexts(
test_setup.symbols),
atc_exe_input=AtcExeInputArr(
stdin_contents=stdin_from_act_exe_input, ),
tcds=TcdsArrangementPreAct(),
),
Expectation(
symbol_usages=SymbolContext.usages_assertion_of_contexts(
test_setup.symbols),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=asrt_proc_result.
matches_proc_result(exit_code=asrt.equals(0),
stdout=asrt.equals(full_stdin))),
),
)
def runTest(self):
# ARRANGE #
string_72_plus = StringSymbolContext.of_constant(
'SYMBOL_72_PLUS',
'72+',
default_restrictions=asrt_data_rest.
is__string__w_all_indirect_refs_are_strings(),
)
string_5 = StringSymbolContext.of_constant(
'SYMBOL_5',
'5',
default_restrictions=asrt_data_rest.
is__string__w_all_indirect_refs_are_strings(),
)
expected = 72 + 5
all_symbols = [string_72_plus, string_5]
value_syntax = StringConcatAbsStx([
string_72_plus.abstract_syntax,
string_5.abstract_syntax,
])
# ACT & ASSERT #
self.conf.instruction_checker.check_parsing__abs_stx__const(
self, self.conf.parser(),
InstructionArgumentsAbsStx.of_int(value_syntax),
self.conf.arrangement(
symbols=SymbolContext.symbol_table_of_contexts(all_symbols), ),
self.conf.expect_success(
symbol_usages=SymbolContext.usages_assertion_of_contexts(
all_symbols),
instruction_settings=asrt_is.matches(
timeout=asrt.equals(expected))))
def _check(put: unittest.TestCase,
integer_matcher: IntegerMatcherAbsStx,
integer_matcher_symbols: List[SymbolContext]):
# ARRANGE #
program_symbol = ProgramSymbolContext.of_arbitrary_value('PROGRAM_SYMBOL')
all_symbols = [program_symbol] + integer_matcher_symbols
command_execution_counter = recording.Counter(initial_value=0)
# ACT & ASSERT #
CHECKER.check__abs_stx(
put,
InstructionArguments(
program_symbol.abstract_syntax,
integer_matcher,
),
ArrangementPostAct2(
symbols=SymbolContext.symbol_table_of_contexts(all_symbols),
process_execution=ProcessExecutionArrangement(
os_services=os_services_w_cmd_exe_counting__w_wrapped(
command_execution_counter,
CommandExecutorThatJustReturnsConstant(1)
),
)
),
Expectation2(
ParseExpectation(
symbol_usages=SymbolContext.usages_assertion_of_contexts(all_symbols)
)
),
)
put.assertEqual(1,
command_execution_counter.value,
'number of times the program has been executed')
def runTest(self):
# ARRANGE #
checked_dir = Dir.empty('the-checked-dir')
fsm_1 = FilesMatcherSymbolContextOfPrimitiveConstant('fsm_1', True)
fsm_2 = FilesMatcherSymbolContextOfPrimitiveConstant('fsm_2', False)
symbols = [fsm_1, fsm_2]
rel_conf = rel_opt_conf.conf_rel_any(RelOptionType.REL_ACT)
arguments = args.recursive(
rel_conf.path_argument_of_rel_name(checked_dir.name),
fsm_args.disjunction([fsm_1.argument, fsm_2.argument]),
)
is_pass = fsm_1.result_value or fsm_2.result_value
# ACT # & ASSERT #
INSTRUCTION_CHECKER.check_2(
self, arguments.as_remaining_source,
ArrangementPostAct2(
symbols=SymbolContext.symbol_table_of_contexts(symbols),
tcds=TcdsArrangementPostAct(
tcds_contents=rel_conf.
populator_for_relativity_option_root(
DirContents([checked_dir])))),
Expectation2(
ParseExpectation(
source=asrt_source.source_is_at_end,
symbol_usages=SymbolContext.usages_assertion_of_contexts(
symbols),
),
ExecutionExpectation(
main_result=asrt_pfh.is_non_hard_error(is_pass), ),
))
def runTest(self):
# ARRANGE #
sm_1 = StringMatcherSymbolContextOfPrimitiveConstant('sm_1', True)
sm_2 = StringMatcherSymbolContextOfPrimitiveConstant('sm_2', False)
symbols = [sm_1, sm_2]
matcher_syntax = StringMatcherInfixOpAbsStx.disjunction([
sm_1.abstract_syntax,
sm_2.abstract_syntax,
])
is_pass = sm_1.result_value or sm_2.result_value
# ACT & ASSERT #
self.configuration.checker.check__abs_stx__source_variants(
self, self.configuration.syntax_for_matcher(matcher_syntax),
self.configuration.arrangement_for_contents(
actual_contents='',
symbols=SymbolContext.symbol_table_of_contexts(symbols),
post_sds_population_action=
MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY,
).as_arrangement_2(),
MultiSourceExpectation(
symbol_usages=SymbolContext.usages_assertion_of_contexts(
symbols),
execution=ExecutionExpectation(
main_result=asrt_pfh.is_non_hard_error(is_pass), ),
))
def runTest(self):
string_72_plus = StringSymbolContext.of_constant(
'SYMBOL_72_PLUS',
'72+',
default_restrictions=asrt_data_rest.
is__string__w_all_indirect_refs_are_strings(),
)
string_5 = StringSymbolContext.of_constant(
'SYMBOL_5',
'5',
default_restrictions=asrt_data_rest.
is__string__w_all_indirect_refs_are_strings(),
)
expected = 72 + 5
all_symbols = [string_72_plus, string_5]
value_syntax = StringConcatAbsStx([
string_72_plus.abstract_syntax,
string_5.abstract_syntax,
])
CHECKER.check__abs_stx__layout_and_source_variants(
self,
InstructionArgumentsAbsStx.of_int(value_syntax),
Arrangement.phase_agnostic(
symbols=SymbolContext.symbol_table_of_contexts(all_symbols), ),
MultiSourceExpectation.phase_agnostic(
symbol_usages=SymbolContext.usages_assertion_of_contexts(
all_symbols),
instruction_settings=asrt_instr_settings.matches(
timeout=asrt.equals(expected))),
)
def test_stdin_is_concatenation_of_string_sources_WHEN_program_defines_multiple_stdin(
self):
# ARRANGE #
test_setup = MultipleStdinOfProgramTestSetup(self, exit_code=0)
all_symbols = [
test_setup.program_symbol, CONST_TRUE_INT_MATCHER_SYMBOL
]
# ACT & ASSERT #
CHECKER.check__abs_stx__source_variants(
self,
InstructionArguments(
test_setup.program_w_stdin_syntax,
CONST_TRUE_INT_MATCHER_SYMBOL.abstract_syntax,
),
ArrangementPostAct2(
symbols=SymbolContext.symbol_table_of_contexts(all_symbols),
process_execution=test_setup.proc_exe_env__w_stdin_check,
),
MultiSourceExpectation(
symbol_usages=SymbolContext.usages_assertion_of_contexts(
all_symbols),
execution=ExecutionExpectation(main_result=asrt_pfh.is_pass()),
),
)
def runTest(self):
vars_before = [
ValueWSymRefsAndVarRefs.REFERENCED_VAR_1,
ValueWSymRefsAndVarRefs.REFERENCED_VAR_2
]
setup_before = EnvironsSetup(vars_before, vars_before)
var_to_set__resolved = NameAndValue(
NameWSymRefs.RESOLVED_STR,
ValueWSymRefsAndVarRefs.VALUE_WO_VAR_REFS)
all_symbols = NameWSymRefs.SYMBOL_CONTEXTS + ValueWSymRefsAndVarRefs.SYMBOL_CONTEXTS
execution_cases = _exe_cases_of_modification(
before_modification=setup_before,
after_modification=setup_before.new_with_added(
var_to_set__resolved, var_to_set__resolved),
symbols=SymbolContext.symbol_table_of_contexts(all_symbols),
)
# ACT & ASSERT #
CHECKER.check__abs_stx__multi__std_layouts_and_source_variants(
self,
SetVariableArgumentsAbsStx(
NameWSymRefs.STRING_ABS_STX,
StringSourceOfStringAbsStx(
ValueWSymRefsAndVarRefs.STRING_ABS_STX),
phase_spec=None,
),
symbol_usages=SymbolContext.usages_assertion_of_contexts(
all_symbols),
execution_cases=execution_cases,
)
def runTest(self):
# ARRANGE #
program_symbol = StringConstantSymbolContext(
'program_name_symbol',
'the-program',
default_restrictions=asrt_rest.is__string__w_all_indirect_refs_are_strings(),
)
argument_list_symbol = ListConstantSymbolContext(
'arguments_symbol',
['1st', '2nd'],
)
symbols = [program_symbol, argument_list_symbol]
expected_command = asrt_command.matches_command(
driver=asrt_command.matches_system_program_command_driver(
asrt.equals(program_symbol.str_value)
),
arguments=asrt.equals(argument_list_symbol.constant),
)
# ACT & ASSERT #
check_successful_execution(
self,
arguments=command_line(
program_symbol.name__sym_ref_syntax,
program_arguments.simple(argument_list_symbol.name__sym_ref_syntax),
),
expected_command=expected_command,
symbols=SymbolContext.symbol_table_of_contexts(symbols),
symbol_usages=SymbolContext.usages_assertion_of_contexts(symbols)
)
def _test_symbol_reference_in_contents(
self, symbol_ref_syntax_2_contents_arguments: Callable[
[str], StringSourceAbsStx],
symbol_value_2_expected_contents: Callable[[str], str]):
contents_symbol = StringConstantSymbolContext(
'contents_symbol_name',
'contents symbol value',
default_restrictions=asrt_rest.is__w_str_rendering(),
)
expected_contents = symbol_value_2_expected_contents(
contents_symbol.str_value)
symbols = [contents_symbol]
expected_symbol_references = SymbolContext.references_assertion_of_contexts(
symbols)
symbol_table = SymbolContext.symbol_table_of_contexts(symbols)
string_source_syntax = symbol_ref_syntax_2_contents_arguments(
symbol_reference_syntax_for_name(contents_symbol.name))
CHECKER.check__abs_stx(
self, string_source_syntax, None,
arrangement_w_tcds(symbols=symbol_table, ),
Expectation.of_prim__const(
primitive=asrt_string_source.
pre_post_freeze__matches_str__const(
expected_contents, may_depend_on_external_resources=False),
parse=ParseExpectation(
symbol_references=expected_symbol_references, ),
))
def runTest(self):
vars_before = [
ValueWSymRefsAndVarRefs.REFERENCED_VAR_1,
ValueWSymRefsAndVarRefs.REFERENCED_VAR_2
]
var_to_set__resolved = NameAndValue(
NameWSymRefs.RESOLVED_STR,
ValueWSymRefsAndVarRefs.VALUE_WO_VAR_REFS)
all_symbols = NameWSymRefs.SYMBOL_CONTEXTS + ValueWSymRefsAndVarRefs.SYMBOL_CONTEXTS
execution_cases = _exe_cases_of_modification(
before_modification=vars_before,
after_modification=vars_before + [var_to_set__resolved],
symbols=SymbolContext.symbol_table_of_contexts(all_symbols),
)
# ACT & ASSERT #
for phase_spec__source in [None, Phase.NON_ACT]:
CHECKER.check__abs_stx__multi__std_layouts_and_source_variants(
self,
SetVariableArgumentsAbsStx(
NameWSymRefs.STRING_ABS_STX,
StringSourceOfStringAbsStx(
ValueWSymRefsAndVarRefs.STRING_ABS_STX),
phase_spec=phase_spec__source,
),
symbol_usages=SymbolContext.usages_assertion_of_contexts(
all_symbols),
execution_cases=execution_cases,
sub_test_identifiers={
'phase_spec__source': phase_spec__source,
},
)
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 runTest(self):
file_in_root = File.empty('file-in-root.txt')
files_in_root_dir = [file_in_root]
file_matcher_symbol = FileMatcherSymbolContext.of_primitive_constant(
'FILE_MATCHER_SYMBOL',
True,
)
file_matcher_cases = [
NInpArr(
'wo file matcher',
None,
(),
),
NInpArr(
'w file matcher',
file_matcher_symbol.abstract_syntax,
[file_matcher_symbol],
),
]
relativity_cases = [
rel_opt_conf.conf_rel_any(RelOptionType.REL_TMP),
rel_opt_conf.conf_rel_any(RelOptionType.REL_HDS_CASE),
]
for expectation_type in ExpectationType:
for file_matcher_case in file_matcher_cases:
for rel_conf in relativity_cases:
with self.subTest(relativity=rel_conf.relativity,
file_matcher=file_matcher_case.name,
expectation_type=expectation_type):
CHECKER.check__abs_stx__source_variants(
self,
InstructionArguments(
rel_conf.path_abs_stx_of_name__c([
file_in_root.name,
'path-to-check'
]),
expectation_type=expectation_type,
file_matcher=file_matcher_case.input,
),
ArrangementPostAct2(
symbols=SymbolContext.symbol_table_of_contexts(file_matcher_case.arrangement),
tcds=TcdsArrangementPostAct(
tcds_contents=rel_conf.populator_for_relativity_option_root(
DirContents(files_in_root_dir)
)
)
),
MultiSourceExpectation(
symbol_usages=SymbolContext.usages_assertion_of_contexts(file_matcher_case.arrangement),
execution=ExecutionExpectation(
main_result=pfh_assertions.is_pass_of_fail(
expectation_type is ExpectationType.NEGATIVE
)
)
)
)
def _check_with_exit_code(self, exit_code: int):
# ARRANGE #
result = SubProcessResult(
exitcode=exit_code,
stdout='output on stdout',
stderr='output on stderr',
)
command_py_program = py_program.program_that_prints_and_exits_with_exit_code(result)
py_file = fs.File(
'the-program.py',
command_py_program,
)
program_wo_transformation = ProgramSymbolContext.of_sdv(
'PROGRAM_SYMBOL',
program_sdvs.interpret_py_source_file_that_must_exist(
path_sdvs.of_rel_option_with_const_file_name(
RelOptionType.REL_HDS_CASE,
py_file.name,
)
)
)
source = args.program(
args.symbol_ref_command_line(program_wo_transformation.name),
transformation=TO_UPPER_CASE_TRANSFORMER.name__sym_ref_syntax)
symbols = [
program_wo_transformation,
TO_UPPER_CASE_TRANSFORMER,
]
# ACT & ASSERT #
integration_check.check_execution(
self,
sut.actor(),
[instr(source.as_arguments.lines)],
arrangement_w_tcds(
symbol_table=SymbolContext.symbol_table_of_contexts(symbols),
hds_contents=hds_populators.contents_in(
RelHdsOptionType.REL_HDS_CASE,
DirContents([py_file]),
)
),
Expectation(
symbol_usages=SymbolContext.references_assertion_of_contexts(symbols),
execute=asrt_eh.is_exit_code(result.exitcode),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=asrt_proc_result.matches_proc_result(
exit_code=asrt.equals(result.exitcode),
stdout=asrt.equals(result.stdout.upper()),
stderr=asrt.equals(result.stderr),
)
)
),
)
def runTest(self):
# ARRANGE #
command_py_program = py_program.exit_with_code(0)
py_file = fs.File(
'the-program.py',
lines_content(command_py_program),
)
program_wo_transformation = ProgramSymbolContext.of_sdv(
'PROGRAM_SYMBOL',
program_sdvs.interpret_py_source_file_that_must_exist(
path_sdvs.of_rel_option_with_const_file_name(
RelOptionType.REL_HDS_CASE,
py_file.name,
)
)
)
error_message = 'error message from transformer'
transformer = StringTransformerPrimitiveSymbolContext(
'HARD_ERROR_TRANSFORMER',
string_transformers.model_access_raises_hard_error(error_message),
)
source = args.program(
args.symbol_ref_command_line(program_wo_transformation.name),
transformation=transformer.name__sym_ref_syntax)
symbols = [
program_wo_transformation,
transformer,
]
# ACT & ASSERT #
integration_check.check_execution(
self,
sut.actor(),
[instr(source.as_arguments.lines)],
arrangement_w_tcds(
symbol_table=SymbolContext.symbol_table_of_contexts(symbols),
hds_contents=hds_populators.contents_in(
RelHdsOptionType.REL_HDS_CASE,
DirContents([py_file]),
)
),
Expectation(
symbol_usages=SymbolContext.references_assertion_of_contexts(symbols),
execute=asrt_eh.matches_hard_error(
asrt_failure_details.is_failure_message_matching__td(
asrt_text_doc.is_string_for_test_that_equals(error_message)
)
),
),
)
def _test_symbol_reference_in_dst_file_and_contents(
self, symbol_ref_syntax_2_contents_arguments: Callable[
[str], StringSourceAbsStx],
symbol_value_2_expected_contents: Callable[[str], str]):
sub_dir_symbol = ConstantSuffixPathDdvSymbolContext(
'sub_dir_symbol',
RelOptionType.REL_ACT,
'sub-dir',
ACCEPTED_DST_RELATIVITY_VARIANTS,
)
contents_symbol = StringConstantSymbolContext(
'contents_symbol_name',
'contents symbol value',
default_restrictions=asrt_rest.is__w_str_rendering(),
)
expected_file_contents = symbol_value_2_expected_contents(
contents_symbol.str_value)
expected_file = fs.File('a-file-name.txt', expected_file_contents)
symbols = [sub_dir_symbol, contents_symbol]
expected_symbol_references = SymbolContext.references_assertion_of_contexts(
symbols)
symbol_table = SymbolContext.symbol_table_of_contexts(symbols)
contents_arguments = symbol_ref_syntax_2_contents_arguments(
symbol_reference_syntax_for_name(contents_symbol.name))
instruction_syntax = instr_abs_stx.create_w_explicit_contents(
path_abs_stx.PathStringAbsStx.of_plain_components(
[sub_dir_symbol.name__sym_ref_syntax, expected_file.name]),
contents_arguments,
)
integration_check.CHECKER__AFTER_ACT.check__abs_stx(
self, instruction_syntax,
Arrangement.phase_agnostic(
tcds=TcdsArrangement(
pre_population_action=
SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR__PLAIN, ),
symbols=symbol_table,
),
Expectation.phase_agnostic(
main_result=IS_SUCCESS,
symbol_usages=expected_symbol_references,
main_side_effects_on_sds=dir_contains_exactly(
sub_dir_symbol.rel_option_type,
fs.DirContents(
[fs.Dir(sub_dir_symbol.path_suffix,
[expected_file])])),
))
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_file_matcher_SHOULD_be_parsed_as_full_expression(self):
# ARRANGE #
file_name = 'file-name'
fm_1 = FileMatcherSymbolContextOfPrimitiveConstant(
'file_matcher_1', False)
fm_2 = FileMatcherSymbolContextOfPrimitiveConstant(
'file_matcher_2', True)
symbols = [fm_1, fm_2]
arguments = args.FilesCondition([
args.FileCondition(
file_name, fm_args.disjunction([fm_1.argument, fm_2.argument]))
])
expected_result = fm_1.result_value or fm_2.result_value
# ACT & ASSERT #
CHECKER.check__w_source_variants(
self,
arguments=arguments.as_arguments,
input_=None,
arrangement=arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(symbols)),
expectation=Expectation(
ParseExpectation(symbol_references=SymbolContext.
references_assertion_of_contexts(symbols)),
primitive=prim_asrt__constant(
asrt_primitive.files_matches({
PurePosixPath(file_name):
asrt_primitive.is_matcher_that_gives(expected_result)
}))))
def _check(
self,
arguments: ArgumentElements,
expected_result: bool,
all_symbols: Sequence[NameAndValue[MatcherWTrace[MODEL]]],
expected_trace: tree.Node[bool],
):
conf = self.configuration
helper = self._asrt_helper
conf.checker_for_parser_of_full_expr().check__w_source_variants(
self,
arguments.as_arguments,
conf.arbitrary_model,
Arrangement(symbols=SymbolContext.symbol_table_of_contexts([
conf.mk_logic_type_context_of_primitive(sym.name, sym.value)
for sym in all_symbols
]), ),
Expectation(
ParseExpectation(symbol_references=helper.is_sym_refs_to(
[sym.name for sym in all_symbols]), ),
ExecutionExpectation(main_result=asrt_matching_result.matches(
value=asrt.equals(expected_result),
trace=trace_equals(expected_trace)))),
)
def runTest(self):
# ARRANGE #
valid_program_symbol = ProgramSymbolContext.of_arbitrary_value(
'VALID_PROGRAM')
for invalid_matcher_case in im_validation_case.failing_validation_cases(
):
invalid_matcher_symbol = invalid_matcher_case.value.symbol_context
all_symbols = [valid_program_symbol, invalid_matcher_symbol]
with self.subTest(invalid_matcher_case.name):
# ACT & ASSERT #
invalid_matcher_symbol = invalid_matcher_case.value.symbol_context
CHECKER.check__abs_stx(
self,
InstructionArguments(
valid_program_symbol.abstract_syntax,
invalid_matcher_symbol.abstract_syntax,
),
ArrangementPostAct2(
symbols=SymbolContext.symbol_table_of_contexts(
all_symbols), ),
Expectation2(
ParseExpectation(
symbol_usages=SymbolContext.
usages_assertion_of_contexts(all_symbols)),
ExecutionExpectation.
validation_corresponding_to__post_sds_as_hard_error(
invalid_matcher_case.value.actual, ),
))
def runTest(self):
# ARRANGE #
valid_int_matcher_symbol = IntegerMatcherSymbolContext.of_arbitrary_value(
'VALID_INT_MATCHER')
for invalid_program_case in pgm_validation_cases.failing_validation_cases(
):
all_symbols = list(invalid_program_case.value.symbol_contexts) + [
valid_int_matcher_symbol
]
directly_referenced_symbols = [
invalid_program_case.value.program_symbol_context,
valid_int_matcher_symbol
]
with self.subTest(invalid_program_case.name):
# ACT & ASSERT #
CHECKER.check__abs_stx(
self,
InstructionArguments(
invalid_program_case.value.abstract_syntax,
valid_int_matcher_symbol.abstract_syntax,
),
ArrangementPostAct2(
symbols=SymbolContext.symbol_table_of_contexts(
all_symbols), ),
Expectation2(
ParseExpectation(symbol_usages=SymbolContext.
usages_assertion_of_contexts(
directly_referenced_symbols), ),
ExecutionExpectation.
validation_corresponding_to__post_sds_as_hard_error(
invalid_program_case.value.actual, ),
))
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):
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_relativity(
self,
rel_opt_conf: RelativityOptionConfigurationForRelNonHds,
):
# ARRANGE #
dst_path = rel_opt_conf.path_abs_stx_of_name('non-existing-file')
for modification in fs_abs_stx.ModificationType:
for validation_case in validation_cases.failing_validation_cases():
instruction_syntax = NewDirArguments(
dst_path,
fs_abs_stx.DirContentsExplicitAbsStx(
modification, validation_case.value.syntax),
)
all_symbols = rel_opt_conf.symbols.contexts_for_arrangement(
) + [validation_case.value.symbol_context]
# ACT & ASSERT
self.conf.instruction_checker.check_parsing__abs_stx__const(
self, self.conf.parser(), instruction_syntax,
self.conf.arrangement(
symbols=SymbolContext.symbol_table_of_contexts(
all_symbols), ),
self.conf.expect_failing_validation(
validation_case.value.actual,
symbol_usages=SymbolContext.
usages_assertion_of_contexts(all_symbols),
))
def _do_check(
self,
program: ProgramAbsStx,
process_execution_w_stdin_check: ProcessExecutionArrangement,
program_symbols: Sequence[SymbolContext],
tcds_contents: tcds_populators.TcdsPopulator = tcds_populators.empty(),
):
# ARRANGE #
string_matcher_const_true = StringMatcherSymbolContext.of_primitive(
'CONSTANT_TRUE',
ConstantMatcherWithCustomName('const true', True),
)
symbols = list(program_symbols) + [string_matcher_const_true]
copy_stdin_and_check_via_matcher = StdoutErrFromProgramAbsStx(
program,
string_matcher_const_true.abstract_syntax,
)
checker = instruction_check.Checker(self.configuration.parser())
# ACT & ASSERT #
checker.check__abs_stx__source_variants(
self,
copy_stdin_and_check_via_matcher,
ArrangementPostAct2(
symbols=SymbolContext.symbol_table_of_contexts(symbols),
tcds=TcdsArrangementPostAct(tcds_contents=tcds_contents),
process_execution=process_execution_w_stdin_check,
),
MultiSourceExpectation(symbol_usages=SymbolContext.
usages_assertion_of_contexts(symbols)),
)
def test_validation_should_fail_pre_sds_when_regex_is_invalid(self):
for regex_case in failing_regex_validation_cases():
arguments = self.conf.arguments(NameRegexVariant.of(regex_case.regex_string))
for expectation_type in ExpectationType:
with self.subTest(expectation_type=expectation_type,
validation_case=regex_case.case_name):
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
arguments=
arguments.as_arguments,
input_=
ARBITRARY_MODEL,
arrangement=
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(regex_case.symbols)
),
expectation=
Expectation(
ParseExpectation(
symbol_references=asrt.matches_sequence(regex_case.reference_assertions),
),
ExecutionExpectation(
validation=regex_case.expectation
),
)
)
def runTest(self):
# ARRANGE #
model_contents = 'the contents of stdin of program'
stdin_string_source_syntax = string_source_abs_stx.StringSourceOfStringAbsStx.of_str_hard(
model_contents, )
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):
test_setup = StdinCheckViaCopyToOutputFileTestSetup(
output_file)
# ACT & ASSERT #
CHECKER.check__abs_stx__wo_input(
self,
StringSourceOfProgramAbsStx(
output_file,
FullProgramAbsStx(
test_setup.program_that_copies_stdin_syntax(),
stdin=stdin_string_source_syntax),
ignore_exit_code,
),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
test_setup.symbols), ),
Expectation.of_prim__const(
parse=ParseExpectation(
symbol_references=SymbolContext.
references_assertion_of_contexts(
test_setup.symbols)),
primitive=asrt_string_source.
pre_post_freeze__identical(
asrt_contents.matches__str(
asrt.equals(model_contents))),
),
)
def test_here_document_with_symbol_references(self):
symbol1 = StringConstantSymbolContext('symbol_1_name',
'symbol 1 value')
symbol2 = StringConstantSymbolContext('symbol_2_name',
'symbol 2 value')
symbol3 = StringConstantSymbolContext('symbol_3_name',
'symbol 3 value')
line_with_sym_ref_template = 'before symbol {symbol} after symbol'
line_with_two_sym_refs_template = '{first_symbol} between symbols {second_symbol}'
cases = [
SuccessfulCase(
source_lines=[
'<<eof',
line_with_sym_ref_template.format(
symbol=symbol1.name__sym_ref_syntax),
'eof',
'following line',
],
expected_document_contents=hd.matches_resolved_value(
[
line_with_sym_ref_template.format(
symbol=symbol1.str_value),
],
symbol_references=[
symbol1.reference__w_str_rendering,
],
symbols=symbol1.symbol_table),
source_after_parse=asrt_source.is_at_end_of_line(3),
),
SuccessfulCase(
source_lines=[
'<<eof',
line_with_sym_ref_template.format(
symbol=symbol1.name__sym_ref_syntax),
line_with_two_sym_refs_template.format(
first_symbol=symbol2.name__sym_ref_syntax,
second_symbol=symbol3.name__sym_ref_syntax),
'eof',
'following line',
],
expected_document_contents=hd.matches_resolved_value(
[
line_with_sym_ref_template.format(
symbol=symbol1.str_value),
line_with_two_sym_refs_template.format(
first_symbol=symbol2.str_value,
second_symbol=symbol3.str_value),
],
symbol_references=[
symbol1.reference__w_str_rendering,
symbol2.reference__w_str_rendering,
symbol3.reference__w_str_rendering,
],
symbols=SymbolContext.symbol_table_of_contexts(
[symbol1, symbol2, symbol3], )),
source_after_parse=asrt_source.is_at_end_of_line(4),
),
]
for case in cases:
self._check_case(case)
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(
):
all_symbols = list(
pgm_and_args_case.symbols) + [CONST_TRUE_INT_MATCHER_SYMBOL]
with self.subTest(pgm_and_args_case.name):
# ACT & ASSERT #
CHECKER.check__abs_stx__source_variants(
self,
InstructionArguments(
test_setup.program_w_stdin_syntax(
pgm_and_args_case.pgm_and_args),
CONST_TRUE_INT_MATCHER_SYMBOL.abstract_syntax,
),
ArrangementPostAct2(
symbols=SymbolContext.symbol_table_of_contexts(
all_symbols),
process_execution=test_setup.
proc_exe_env__w_stdin_check,
tcds=TcdsArrangementPostAct(
tcds_contents=pgm_and_args_case.tcds, ),
),
MultiSourceExpectation(
symbol_usages=SymbolContext.
usages_assertion_of_contexts(all_symbols),
execution=ExecutionExpectation(
main_result=asrt_pfh.is_pass()),
),
)
class TestErrorMessage(unittest.TestCase):
string_sym_def_1 = StringConstantSymbolContext('symbol1')
string_sym_def_2 = StringConstantSymbolContext('symbol2')
symbol_table = SymbolContext.symbol_table_of_contexts(
[string_sym_def_1, string_sym_def_2])
def test_invalid_type(self):
# ACT #
actual = sut.ErrorMessage(self.string_sym_def_1.name,
self.symbol_table,
InvalidValueTypeFailure([ValueType.PATH]))
# ASSERT #
asrt_text_doc.assert_is_valid_text_renderer(self, actual)
def test_direct_reference(self):
# ACT #
actual = sut.ErrorMessage(
self.string_sym_def_1.name, self.symbol_table,
FailureOfDirectReference(_new_em('the message', 'the how to fix')))
# ASSERT #
asrt_text_doc.assert_is_valid_text_renderer(self, actual)
def test_indirect_reference(self):
# ACT #
actual = sut.ErrorMessage(
self.string_sym_def_1.name, self.symbol_table,
FailureOfIndirectReference(
self.string_sym_def_1.name, [self.string_sym_def_2.name],
_new_em('the message', 'the how to fix')))
# ASSERT #
asrt_text_doc.assert_is_valid_text_renderer(self, actual)
