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 runTest(self):
# ARRANGE #
arguments = names.IDENTITY_TRANSFORMER_NAME
model_content_lines = ['the model contents line 1']
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__w_source_variants(
self,
Arguments(arguments),
model_constructor.of_lines(self, model_content_lines),
arrangement_w_tcds(),
Expectation(
ParseExpectation(
symbol_references=asrt.is_empty_sequence,
),
ExecutionExpectation(
main_result=asrt_string_source.pre_post_freeze__matches_lines__identical(
asrt.equals(model_content_lines),
may_depend_on_external_resources=asrt.equals(False),
)
),
prim_asrt__constant(is_identity_transformer(True)),
adv=freeze_check.first_invoked_method_of_source_model__is_freeze,
)
)
def runTest(self):
# ARRANGE #
for arguments in self.argument_cases():
for may_depend_on_external_resources in [False, True]:
with self.subTest(may_depend_on_external_resources=may_depend_on_external_resources,
arguments=repr(arguments)):
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
remaining_source(arguments),
self.model(may_depend_on_external_resources),
arrangement_w_tcds(),
Expectation(
ParseExpectation(
symbol_references=asrt.is_empty_sequence
),
ExecutionExpectation(
main_result=asrt_string_source.pre_post_freeze__matches_lines__any_frozen_ext_deps(
self.expected_output_lines_for_model(),
may_depend_on_external_resources=asrt.equals(may_depend_on_external_resources),
),
),
prim_asrt__constant(
asrt_string_transformer.is_identity_transformer(
self.is_identity_transformer()
)
)
),
)
def expectation_of_successful_execution(output_lines: List[str],
may_depend_on_external_resources: bool,
frozen_may_depend_on_external_resources: Assertion[bool],
symbol_references: Assertion[Sequence[SymbolReference]],
is_identity_transformer: bool = False,
source: Assertion[ParseSource] = asrt.anything_goes(),
adv: Callable[
[AssertionResolvingEnvironment],
Assertion[ApplicationEnvironmentDependentValue[StringTransformer]]
] = adv_asrt__any,
) -> StExpectation:
return Expectation(
ParseExpectation(
source=source,
symbol_references=symbol_references
),
ExecutionExpectation(
main_result=asrt_string_source.pre_post_freeze__matches_lines(
asrt.equals(output_lines),
may_depend_on_external_resources=asrt.equals(may_depend_on_external_resources),
frozen_may_depend_on_external_resources=frozen_may_depend_on_external_resources,
),
),
prim_asrt__constant(
asrt_string_transformer.is_identity_transformer(is_identity_transformer)
),
adv,
)
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 runTest(self):
# ARRANGE #
program_symbol = ProgramSymbolContext.of_arbitrary_value(
'PROGRAM_SYMBOL')
executor_that_do_not_run_any_program = CommandExecutorThatJustReturnsConstant(
0)
for may_depend_on_external_resources in [False, True]:
for with_ignored_exit_code in [False, True]:
with self.subTest(
with_ignored_exit_code=with_ignored_exit_code,
may_depend_on_external_resources=
may_depend_on_external_resources):
# ACT && ASSERT #
pass
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
args.syntax_for_run(
program_args.symbol_ref_command_elements(
program_symbol.name),
ignore_exit_code=with_ignored_exit_code,
).as_remaining_source,
model_constructor.empty(self,
may_depend_on_external_resources=
may_depend_on_external_resources),
arrangement_w_tcds(
symbols=program_symbol.symbol_table,
process_execution=ProcessExecutionArrangement(
os_services=os_services_access.new_for_cmd_exe(
executor_that_do_not_run_any_program)),
),
Expectation(
ParseExpectation(symbol_references=program_symbol.
references_assertion, ),
ExecutionExpectation(
main_result=asrt_string_source.
pre_post_freeze__matches_lines(
asrt.anything_goes(),
may_depend_on_external_resources=asrt.equals(
True),
frozen_may_depend_on_external_resources=asrt.
anything_goes(),
)),
prim_asrt__constant(
asrt_string_transformer.is_identity_transformer(
False)),
),
)
def expectation_of_successful_execution__check_only_as_lines(
output_lines: List[str],
symbol_references: Assertion[Sequence[SymbolReference]],
source: Assertion[ParseSource] = asrt.anything_goes(),
) -> StExpectation:
return Expectation(
ParseExpectation(
source=source,
symbol_references=symbol_references
),
ExecutionExpectation(
main_result=asrt_string_source.matches__lines__check_just_as_lines(output_lines),
),
prim_asrt__constant(
asrt_string_transformer.is_identity_transformer(False)
)
)
def runTest(self):
successful_transformer = StringTransformerSymbolContext.of_identity(
'successful_transformer')
for case in validation_cases.failing_validation_cases(
'failing_transformer'):
failing_symbol_context = case.value.symbol_context
symbols = SymbolContext.symbol_table_of_contexts([
failing_symbol_context,
successful_transformer,
])
order_cases = [
NameAndValue(
'1st transformer fails',
[failing_symbol_context.name, successful_transformer.name
]),
NameAndValue(
'2nd transformer fails',
[successful_transformer.name, failing_symbol_context.name
]),
]
for order_case in order_cases:
arguments = st_args.syntax_for_sequence_of_transformers(
order_case.value)
expected_symbol_references = asrt.matches_sequence([
is_reference_to_string_transformer(symbol_name)
for symbol_name in order_case.value
])
with self.subTest(validation_case=case.name,
order_case=order_case.name):
integration_check.CHECKER__PARSE_FULL.check__w_source_variants(
self, Arguments(arguments),
model_constructor.of_lines(self, []),
arrangement_w_tcds(symbols=symbols),
Expectation(
ParseExpectation(
symbol_references=expected_symbol_references),
ExecutionExpectation(
validation=case.value.expectation, ),
prim_asrt__constant(
is_identity_transformer(False)),
))
def arguments_case(
command_line_arguments: List[str],
) -> NExArr[PrimAndExeExpectation[StringTransformer, StringSource],
Arrangement]:
arg_list_symbol = ListSymbolContext.of_constants(
command_line_arg_list_symbol_name, command_line_arguments)
symbols = [
program_symbol,
arg_list_symbol,
]
expected_lines_on_stdout = asrt.matches_sequence(
[asrt.equals(arg + '\n') for arg in command_line_arguments])
return NExArr(
'Arguments: ' + repr(command_line_arguments),
PrimAndExeExpectation(
ExecutionExpectation(
main_result=asrt_string_source.
pre_post_freeze__matches_lines(
expected_lines_on_stdout,
may_depend_on_external_resources=asrt.equals(True),
frozen_may_depend_on_external_resources=asrt.
anything_goes(),
)),
prim_asrt__constant(
asrt_string_transformer.is_identity_transformer(
False)),
),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(symbols),
tcds_contents=py_file_rel_opt_conf.
populator_for_relativity_option_root(DirContents([py_file
])),
),
)
# ARRANGE #
model_contents = 'the contents of the model'
test_setup = StdinCheckViaCopyToOutputFileTestSetup(
ProcOutputFile.STDOUT)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__abs_stx(
self,
RunProgramAbsStx(test_setup.program_that_copies_stdin_syntax(), ),
model_constructor.of_str(self, model_contents),
arrangement_w_tcds(symbols=SymbolContext.symbol_table_of_contexts(
test_setup.symbols), ),
Expectation(
parse=ParseExpectation(
symbol_references=SymbolContext.
references_assertion_of_contexts(test_setup.symbols)),
execution=ExecutionExpectation(
main_result=asrt_string_source.pre_post_freeze__identical(
asrt_contents.matches__str(asrt.equals(
model_contents)))),
primitive=PRIMITIVE_IS_NOT_IDENTITY_TRANSFORMATION,
),
)
EXECUTION_OUTPUT_IS_EMPTY = ExecutionExpectation(
main_result=asrt_string_source.pre_post_freeze__identical(
asrt_contents.matches__str(asrt.equals(''))))
PRIMITIVE_IS_NOT_IDENTITY_TRANSFORMATION = prim_asrt__constant(
asrt_string_transformer.is_identity_transformer(False))
def test_successful_parse_of_sequence(self):
# ARRANGE #
regex_str = 'the_regex'
replacement_str = 'the_replacement'
symbol = StringTransformerSymbolContext.of_primitive(
'the_symbol_name',
string_transformers.must_not_be_used()
)
replace_transformer_syntax = argument_syntax.syntax_for_replace_transformer(regex_str,
replacement_str)
defined_name = 'defined_name'
cases = [
SourceCase('Expression on single line',
source=
remaining_source(
src2(ValueType.STRING_TRANSFORMER,
defined_name,
argument_syntax.syntax_for_sequence_of_transformers([
symbol.name,
replace_transformer_syntax,
])),
following_lines=['following line'],
),
source_assertion=asrt_source.is_at_beginning_of_line(2)
),
SourceCase('Expression on following line',
source=
remaining_source(
src2(ValueType.STRING_TRANSFORMER, defined_name, '{new_line} {transformer_argument}',
transformer_argument=argument_syntax.syntax_for_sequence_of_transformers([
symbol.name,
replace_transformer_syntax,
])),
following_lines=['following line'],
),
source_assertion=asrt_source.is_at_beginning_of_line(3)
),
SourceCase('1st expr on first line followed by operator, 2nd expr on next line',
source=
remaining_source(
src2(ValueType.STRING_TRANSFORMER, defined_name, '{the_symbol_name} {sequence_operator}',
the_symbol_name=symbol.name,
sequence_operator=SEQUENCE_OPERATOR_NAME),
following_lines=[replace_transformer_syntax],
),
source_assertion=asrt_source.source_is_at_end
),
SourceCase('1st expr on first line followed by operator, 2nd expr on next line, non-exr on 3rd line',
source=
remaining_source(
src2(ValueType.STRING_TRANSFORMER, defined_name, '{the_symbol_name} {sequence_operator}',
the_symbol_name=symbol.name,
sequence_operator=SEQUENCE_OPERATOR_NAME),
following_lines=[replace_transformer_syntax,
'following line'],
),
source_assertion=asrt_source.is_at_beginning_of_line(3)
),
]
# EXPECTATION #
expected_container = matches_container(
asrt.equals(ValueType.STRING_TRANSFORMER),
sdv=matches_sdv_of_string_transformer_constant(
references=asrt.matches_sequence([
is_reference_to_string_transformer(symbol.name),
]),
primitive_value=asrt_string_transformer.is_identity_transformer(False),
symbols=symbol.symbol_table,
)
)
for source_case in cases:
with self.subTest(source_case.name):
expectation = Expectation.phase_agnostic(
symbol_usages=asrt.matches_sequence([
asrt_sym_usage.matches_definition(asrt.equals(defined_name),
expected_container)
]),
symbols_after_main=assert_symbol_table_is_singleton(
defined_name,
expected_container,
),
source=source_case.source_assertion
)
# ACT & ASSERT #
INSTRUCTION_CHECKER.check(self, source_case.source, Arrangement.phase_agnostic(), expectation)
