def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
for maybe_with_transformer_option in TRANSFORMER_OPTION_ALTERNATIVES:
with self.subTest(
maybe_with_transformer_option=maybe_with_transformer_option
):
self._check_with_source_variants(
test_configuration.arguments_for(
args(
'{maybe_with_transformer_option} {maybe_not} {empty}',
maybe_with_transformer_option=
maybe_with_transformer_option,
maybe_not=maybe_not.
nothing__if_positive__not_option__if_negative)),
model_constructor.of_str(
self, 'contents that makes the file non-empty'),
arrangement_w_tcds(
post_population_action=
MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY),
Expectation(execution=ExecutionExpectation(
main_result=maybe_not.
fail__if_positive__pass_if_negative), ),
)
def runTest(self):
# ARRANGE #
input_lines = [
'1st',
'2nd',
'3rd',
]
expected_line_matcher_models = line_matcher_models.models_for_lines__validated(input_lines)
string_transformer_model = model_constructor.of_lines_wo_nl(self, input_lines)
models_output = []
line_matcher = LineMatcherSymbolContext.of_primitive(
'MATCHER',
LineMatcherThatCollectsModels(models_output, True),
)
line_matcher_arg = lm_args.SymbolReference(line_matcher.name)
arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg))
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
source=remaining_source(arguments),
input_=string_transformer_model,
arrangement=arrangement_w_tcds(
symbols=line_matcher.symbol_table,
),
expectation=Expectation(
ParseExpectation(
symbol_references=line_matcher.references_assertion
),
ExecutionExpectation(
main_result=asrt.anything_goes(),
),
prim_asrt__any
),
)
self.assertEqual(expected_line_matcher_models,
models_output,
'models given to line matcher')
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
actual_contents = lines_content(['123'])
here_doc = here_document_as_elements(['1.3'])
for transformer_option_arguments in TRANSFORMER_OPTION_ALTERNATIVES_ELEMENTS:
with self.subTest(maybe_with_transformer_option=transformer_option_arguments):
argument_elements = ArgumentElements(transformer_option_arguments +
maybe_not.empty__if_positive__not_option__if_negative +
[matcher_options.MATCHES_ARGUMENT]
).followed_by(here_doc)
self._check(
argument_elements.as_remaining_source,
model_constructor.of_str(self, actual_contents),
arrangement_w_tcds(),
Expectation(
ParseExpectation(
source=asrt_source.is_at_end_of_line(1 + len(here_doc.following_lines)),
),
ExecutionExpectation(
main_result=maybe_not.pass__if_positive__fail__if_negative
),
),
)
def runTest(self):
self._check_with_source_variants(
test_configuration.arguments_for(
args('{maybe_not} {equals} {file_option} {relativity_option} expected.txt',
maybe_not=self.not_opt.nothing__if_positive__not_option__if_negative,
relativity_option=self.rel_opt.option_argument)),
model_constructor.of_str(self, 'expected'),
arrangement_w_tcds(
self.rel_opt.populator_for_relativity_option_root(
DirContents([File('expected.txt', 'expected')])),
post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY,
symbols=self.rel_opt.symbols.in_arrangement(),
),
Expectation(
ParseExpectation(
symbol_references=self.rel_opt.symbols.usages_expectation(),
),
ExecutionExpectation(
main_result=self.not_opt.pass__if_positive__fail__if_negative,
),
),
)
def runTest(self):
any_char_glob_pattern_string_symbol = StringSymbolContext.of_constant(
'glob_pattern_string_symbol', '*')
arguments = arg.Name(
arg.NameGlobPatternVariant(
'AB' +
any_char_glob_pattern_string_symbol.name__sym_ref_syntax))
integration_check.CHECKER__PARSE_FULL.check__w_source_variants(
self,
arguments=arguments.as_arguments,
input_=integration_check.constant_relative_file_name('ABC'),
arrangement=arrangement_w_tcds(
symbols=any_char_glob_pattern_string_symbol.symbol_table),
expectation=Expectation(
ParseExpectation(symbol_references=asrt.matches_sequence([
is_reference_to__regex_string_part(
any_char_glob_pattern_string_symbol.name),
]), ),
ExecutionExpectation(
main_result=asrt_matching_result.matches_value(True)),
))
def test_invalid_arguments_without_symbol_references(self):
test_cases = [
' {op} a'.format(op=comparators.EQ.name),
'{op} 1.5'.format(op=comparators.GT.name),
]
for condition_str in test_cases:
with self.subTest(msg=condition_str):
instr_arg = self._conf().arguments_constructor.apply(
condition_str)
for source in equivalent_source_variants__for_expression_parser(
self, Arguments(instr_arg)):
self._check(
source,
Arrangement(),
Expectation(
ParseExpectation(
symbol_references=asrt.is_empty_sequence, ),
ExecutionExpectation(
validation=asrt_validation.ValidationAssertions
.pre_sds_fails__w_any_msg(), ),
),
)
def runTest(self):
# ARRANGE #
def get_trace(data: T) -> tree.Node[T]:
return tree.Node.empty('name of string matcher', data)
for string_matcher_result in [False, True]:
string_matcher = StringMatcherSymbolContext.of_primitive(
'STRING_MATCHER',
ConstantMatcherWithCustomTrace(get_trace,
string_matcher_result),
)
expected_trace = tree.Node(
MATCHER_NAME,
string_matcher_result,
(),
[get_trace(string_matcher_result)],
)
# ACT & ASSERT #
with self.subTest(string_matcher_result=string_matcher_result):
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
arguments=lm_args.Contents(
sm_args2.SymbolReferenceWReferenceSyntax(
string_matcher.name), ).as_arguments,
input_=models.ARBITRARY_MODEL,
arrangement=arrangement_wo_tcds(
symbols=string_matcher.symbol_table, ),
expectation=Expectation(
ParseExpectation(symbol_references=string_matcher.
references_assertion),
ExecutionExpectation(
main_result=asrt_matching_result.matches(
asrt.equals(string_matcher_result),
trace=asrt_trace_rendering.
matches_node_renderer(
asrt_d_tree.equals_node(expected_trace)),
))),
)
def runTest(self):
# ARRANGE #
line_contents = 'the line contents'
def get_string_matcher_model_as_single_string(
model: StringSource) -> str:
return model.contents().as_str
matching_result = True
string_matcher = StringMatcherSymbolContext.of_primitive(
'STRING_MATCHER',
matcher_w_init_action.matcher_that_applies_assertion(
self,
assertion=asrt.equals(line_contents),
get_actual=get_string_matcher_model_as_single_string,
message_builder=asrt.MessageBuilder.new(
'string-matcher-model'),
result=matching_result,
),
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
arguments=lm_args.Contents(
sm_args2.SymbolReferenceWReferenceSyntax(
string_matcher.name), ).as_arguments,
input_=models.constant((1, line_contents)),
arrangement=arrangement_wo_tcds(
symbols=string_matcher.symbol_table, ),
expectation=Expectation(
ParseExpectation(
symbol_references=string_matcher.references_assertion),
ExecutionExpectation(
main_result=asrt_matching_result.matches_value__w_header(
asrt.equals(matching_result),
header=asrt.equals(MATCHER_NAME),
))),
)
def check_regex(put: unittest.TestCase,
conf: Configuration,
pattern: str,
ignore_case: bool,
model: ModelConstructor,
expected_result: bool,
):
pattern_string_symbol = StringSymbolContext.of_constant(
'PATTERN_SYMBOL',
pattern,
default_restrictions=is_reference_restrictions__regex()
)
arguments = conf.arguments(
NameRegexVariant.of(pattern_string_symbol.name__sym_ref_syntax,
ignore_case=ignore_case)
)
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
put,
arguments=arguments.as_arguments,
input_=model,
arrangement=arrangement_wo_tcds(
symbols=pattern_string_symbol.symbol_table
),
expectation=Expectation(
ParseExpectation(
symbol_references=asrt.matches_sequence([
pattern_string_symbol.reference_assertion,
]),
),
ExecutionExpectation(
main_result=asrt_matching_result.matches_value__w_header(
asrt.equals(expected_result),
asrt.equals(conf.node_name)
)
),
)
)
def test_dir(self):
file_name = 'destination'
file_name_syntax = StringLiteralAbsStx(file_name, QuoteType.HARD)
explicit_dir_contents = LiteralFilesSourceAbsStx(())
file_spec_syntax = dir_spec(
file_name_syntax,
DirContentsExplicitAbsStx(ModificationType.APPEND,
explicit_dir_contents),
)
for dir_contents_case in file_must_exist_as_dir(file_name):
with self.subTest(dir_contents=dir_contents_case.name):
integration_check.CHECKER.check__abs_stx(
self,
LiteralFilesSourceAbsStx([file_spec_syntax]),
dir_contents_case.value,
arrangement_w_tcds(),
Expectation(
parse=IS_AT_END_OF_1ST_LNE,
execution=ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text(),
)
),
)
def runTest(self):
# 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,
),
)
def test_recursive_model(self):
# ARRANGE #
file_in_sub_dir = File.empty('file-in-sub-dir')
dir_in_checked_dir = Dir(
'top-level-dir',
[file_in_sub_dir],
)
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'the-dir')
# ACT & ASSERT #
check_non_full_and_full(
self,
fc_args.FilesCondition([
fc_args.FileCondition(dir_in_checked_dir.name),
fc_args.FileCondition(file_in_sub_dir.name),
]),
model_constructor__recursive(checked_dir.path_sdv),
Arrangement(tcds=checked_dir.tcds_arrangement_dir_with_contents(
[dir_in_checked_dir])),
Expectation(
ParseExpectation(symbol_references=asrt.is_empty_sequence),
ExecutionExpectation(main_result=asrt.equals(False)),
),
)
def test_just_symbol_reference(self):
contents_symbol = StringConstantSymbolContext(
'contents_symbol_name',
'symbol value contents',
default_restrictions=asrt_rest.is__w_str_rendering(),
)
string_source_syntax = StringSourceOfStringAbsStx.of_plain(
str_abs_stx.StringSymbolAbsStx(contents_symbol.name))
CHECKER.check__abs_stx(
self, string_source_syntax, None,
arrangement_w_tcds(symbols=contents_symbol.symbol_table, ),
Expectation.of_prim__const(
primitive=asrt_string_source.
pre_post_freeze__matches_str__const(
contents_symbol.str_value,
may_depend_on_external_resources=False),
parse=ParseExpectation(
symbol_references=asrt.matches_singleton_sequence(
references.is_reference_to__string_source_or_string(
contents_symbol.name)), ),
))
def test_failure_to_execute_program(self):
# ARRANGE #
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(
self,
args.syntax_for_run(
program_args.system_program_argument_elements(
NON_EXISTING_SYSTEM_PROGRAM),
ignore_exit_code=with_ignored_exit_code,
).as_remaining_source,
model_constructor.arbitrary(self),
arrangement_w_tcds(),
Expectation(
ParseExpectation(
source=asrt_source.is_at_end_of_line(1), ),
ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text()),
),
)
def _check(self,
expected_contents: str,
actual_contents: str,
may_depend_on_external_resources: bool,
expected_result: bool,
):
string_symbol_with_expected = StringSymbolContext.of_constant(
'EXPECTED_CONTENTS_SYMBOL',
expected_contents,
)
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
args2.Equals.eq_string(
string_symbol_with_expected.name__sym_ref_syntax
).as_remaining_source,
model_constructor.of_str(
self,
actual_contents,
may_depend_on_external_resources=may_depend_on_external_resources,
),
arrangement_w_tcds(
symbols=string_symbol_with_expected.symbol_table
),
Expectation(
ParseExpectation(
symbol_references=
asrt.matches_singleton_sequence(
references.is_reference_to__string_source_or_string(string_symbol_with_expected.name)
)
),
execution=ExecutionExpectation(
main_result=asrt_matching_result.matches_value(
expected_result
)
),
),
)
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
# ARRANGE #
named_transformer = StringTransformerSymbolContext.of_primitive(
'the_transformer', every_line_empty())
checked_file = File('actual.txt', 'some\ntext')
symbols = named_transformer.symbol_table
expected_symbol_reference_to_transformer = is_reference_to_string_transformer(
named_transformer.name)
expected_symbol_usages = asrt.matches_sequence(
[expected_symbol_reference_to_transformer])
# ACT & ASSERT #
self._check_with_source_variants(
arguments=arguments_for(
sm_args.args(
'{transform_option} {the_transformer} {maybe_not} {empty}',
the_transformer=named_transformer.name,
maybe_not=maybe_not.
nothing__if_positive__not_option__if_negative)),
model_constructor=integration_check.constant_relative_file_name(
checked_file.name),
arrangement=arrangement_w_tcds(
non_hds_contents=single_file_in_current_dir(checked_file),
symbols=symbols,
),
expectation=Expectation(
ParseExpectation(symbol_references=expected_symbol_usages),
ExecutionExpectation(
main_result=maybe_not.pass__if_positive__fail__if_negative,
),
))
def test_populate_result_dir_with_act_result(self):
act_result = SubProcessResult(
exitcode=72,
stdout='the stdout',
stderr='the stderr',
)
result_dir_contains_files_corresponding_to_act_result = asrt_tcds_contents.dir_contains_exactly(
RelOptionType.REL_RESULT,
DirContents([
File(sds.RESULT_FILE__EXITCODE, str(act_result.exitcode)),
File(sds.RESULT_FILE__STDOUT, str(act_result.stdout)),
File(sds.RESULT_FILE__STDERR, str(act_result.stderr)),
])
)
all_tcds_dirs_but_result_dir_are_empty = asrt.and_([
dir_is_empty(tcds_dir)
for tcds_dir in RelOptionType if tcds_dir is not RelOptionType.REL_RESULT
])
self._check___single_and_multi(
utils.single_line_arguments(),
ARBITRARY_MODEL,
parser_of_matcher_that_is_an_assertion_on_tcds(
self,
asrt.and_([
result_dir_contains_files_corresponding_to_act_result,
all_tcds_dirs_but_result_dir_are_empty,
]
)
),
arrangement_w_tcds(
act_result=ActResultProducerFromActResult(act_result)
),
Expectation(),
)
def runTest(self):
model__original = 'the model text'
the_model_constructor = model_constructor.of_str(self, model__original)
string_transformer = StringTransformerSymbolContext.of_primitive(
'THE_STRING_TRANSFORMER', string_transformers.to_uppercase())
sm_equals = StringMatcherSymbolContext.of_primitive(
'STRING_MATCHER_1',
string_matchers.EqualsConstant(model__original.upper()))
symbol = [
string_transformer,
sm_equals,
]
after_bin_op = 'after bin op'
sm_conjunction = args2.conjunction([
args2.SymbolReference(sm_equals.name),
args2.Custom(after_bin_op),
])
arguments = args2.Transformed(string_transformer.name__sym_ref_syntax,
sm_conjunction)
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
source=arguments.as_remaining_source,
input_=the_model_constructor,
arrangement=arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(symbol), ),
expectation=Expectation(
ParseExpectation(source=asrt_source.is_at_line(
current_line_number=1,
remaining_part_of_current_line=' '.join(
[sm_conjunction.operator, after_bin_op])),
symbol_references=SymbolContext.
references_assertion_of_contexts(symbol)),
ExecutionExpectation(
main_result=asrt_matching_result.matches_value(True))),
)
def test_symbols_from_comparison_SHOULD_be_reported(self):
# ARRANGE #
checked_dir_contents = DirContents([File.empty('1'), File.empty('2')])
checked_path = rel_opts.conf_rel_sds(RelSdsOptionType.REL_ACT)
operand_sym_ref = StringIntConstantSymbolContext(
'operand_symbol_name',
len(checked_dir_contents.file_system_elements),
default_restrictions=symbol_reference.
is_reference_restrictions__integer_expression(),
)
matcher_arguments = im_args.comparison(comparators.EQ,
operand_sym_ref.argument)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
args.NumFiles(
matcher_arguments.as_str,
int_expr_on_new_line=True,
).as_remaining_source,
model.model_with_rel_root_as_source_path(checked_path),
arrangement_w_tcds(
symbols=operand_sym_ref.symbol_table,
tcds_contents=checked_path.
populator_for_relativity_option_root(checked_dir_contents),
),
Expectation(
ParseExpectation(
source=asrt_source.is_at_end_of_line(2),
symbol_references=operand_sym_ref.references_assertion,
),
ExecutionExpectation(
main_result=asrt_matching_result.matches_value(True)),
))
def test_matcher_symbol_should_be_reported(self):
# ARRANGE #
matcher_symbol = IntegerMatcherSymbolContextOfPrimitiveConstant(
'MATCHER_SYMBOL',
True,
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
args.NumFiles(
matcher_symbol.name__sym_ref_syntax,
int_expr_on_new_line=True,
).as_remaining_source, model.arbitrary_model(),
arrangement_w_tcds(symbols=matcher_symbol.symbol_table, ),
Expectation(
ParseExpectation(
source=asrt_source.is_at_end_of_line(2),
symbol_references=matcher_symbol.references_assertion,
),
ExecutionExpectation(
main_result=asrt_matching_result.matches_value(
matcher_symbol.result_value)),
))
def runTest(self):
# ARRANGE #
helper = IntegrationCheckHelper()
argument_cases = [
NIE(
'prune followed by selection',
input_value=fsm_args.Prune(
fm_args.SymbolReference(NAME_STARTS_WITH__P1.name),
fsm_args.Selection(
fm_args.SymbolReference(NAME_STARTS_WITH__S1.name),
helper.files_matcher_sym_ref_arg(),
),
),
expected_value=asrt.matches_sequence([
NAME_STARTS_WITH__P1.reference_assertion,
NAME_STARTS_WITH__S1.reference_assertion,
helper.symbol_reference_assertion,
]),
),
NIE(
'selection followed by prune',
input_value=fsm_args.Selection(
fm_args.SymbolReference(NAME_STARTS_WITH__S1.name),
fsm_args.Prune(
fm_args.SymbolReference(NAME_STARTS_WITH__P1.name),
helper.files_matcher_sym_ref_arg(),
),
),
expected_value=asrt.matches_sequence([
NAME_STARTS_WITH__S1.reference_assertion,
NAME_STARTS_WITH__P1.reference_assertion,
helper.symbol_reference_assertion,
]),
),
]
contents_case = COMBINATION_OF_PRUNE_AND_SELECTION
# ACT & ASSERT #
for argument_case in argument_cases:
with self.subTest(argument_case.name):
integration_check.CHECKER__PARSE_FULL.check__w_source_variants(
self,
arguments=argument_case.input_value.as_arguments,
input_=helper.model_constructor_for_checked_dir__recursive(
),
arrangement=helper.arrangement_for_contents_of_model(
checked_dir_contents=contents_case.actual,
files_matcher_symbol_value=model_checker.matcher(
self,
helper.dir_arg.path_sdv,
contents_case.expected,
),
additional_symbols=[
NAME_STARTS_WITH__P1,
NAME_STARTS_WITH__S1,
],
),
expectation=Expectation(
ParseExpectation(
symbol_references=argument_case.expected_value, )),
)
def test_string_transformer_should_be_parsed_as_simple_expression(self):
the_layout = LayoutSpec.of_default()
output_from_program = 'untransformed output from the program'
sym_ref_program_syntax = ProgramOfSymbolReferenceAbsStx(
'PROGRAM_THAT_EXECUTES_PY_FILE')
str_trans__unused = StringTransformerSymbolReferenceAbsStx(
'UNUSED_TRANSFORMER')
program_w_complex_str_trans_wo_parentheses = program_abs_stx.FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(sym_ref_program_syntax.symbol_name),
transformation=str_trans_abs_stx.
StringTransformerCompositionAbsStx(
[
TO_UPPER_TRANSFORMER_SYMBOL.abstract_syntax,
str_trans__unused,
],
within_parens=False,
allow_elements_on_separate_lines=False,
))
expected_remaining_tokens = TokenSequence.concat([
TokenSequence.singleton(
str_trans_abs_stx.names.SEQUENCE_OPERATOR_NAME),
str_trans__unused.tokenization(),
])
expected_remaining_source = expected_remaining_tokens.layout(
the_layout)
checker = integration_check.checker__w_arbitrary_file_relativities()
py_program_file = File(
'program.py',
py_programs.py_pgm_with_stdout_stderr_exit_code(
exit_code=0,
stdout_output=output_from_program,
stderr_output=output_from_program,
),
)
py_file_rel_conf = rel_opt.conf_rel_any(RelOptionType.REL_HDS_CASE)
py_file_conf = py_file_rel_conf.named_file_conf(py_program_file.name)
program_symbol__that_executes_py_file = ProgramSymbolContext.of_sdv(
sym_ref_program_syntax.symbol_name,
program_sdvs.interpret_py_source_file_that_must_exist(
py_file_conf.path_sdv))
symbols = [
program_symbol__that_executes_py_file,
TO_UPPER_TRANSFORMER_SYMBOL,
]
for output_file in ProcOutputFile:
for ignore_exit_code in [False, True]:
syntax = string_source_abs_stx.StringSourceOfProgramAbsStx(
output_file,
program_w_complex_str_trans_wo_parentheses,
ignore_exit_code=ignore_exit_code,
)
with self.subTest(output_file=output_file,
ignore_exit_code=ignore_exit_code):
checker.check__abs_stx__wo_input(
self,
syntax,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols),
tcds_contents=py_file_rel_conf.
populator_for_relativity_option_root(
DirContents([py_program_file]))),
Expectation(
ParseExpectation(
source=asrt_source.source_is_not_at_end(
remaining_source=asrt.equals(
expected_remaining_source)),
symbol_references=SymbolContext.
references_assertion_of_contexts(symbols),
)),
the_layout,
)
def check_cases__named(put: unittest.TestCase,
cases: Sequence[NameAndValue[Case]]):
for case in cases:
with put.subTest(case.name):
check(put, case.value)
def check(put: unittest.TestCase, case: Case):
integration_check.CHECKER__PARSE_SIMPLE__WO_IMPLICIT_MODEL_EVALUATION.check(
put, case.arguments.as_remaining_source,
_model_w_access_check(put, case.model, case.max_num_lines_from_iter),
arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(case.symbols)),
Expectation(
parse=ParseExpectation(source=asrt_source.is_at_end_of_line(1),
symbol_references=SymbolContext.
references_assertion_of_contexts(
case.symbols)),
execution=ExecutionExpectation(main_result=asrt_string_source.
matches__lines__check_just_as_lines(
case.expected_output_lines)),
))
class IntSymbol:
def __init__(self, name: str):
self.name = name
def value(self, value: int) -> StringConstantSymbolContext:
return StringIntConstantSymbolContext(
self.name,
def is_expectation_of_execution_result_of(
expected: bool) -> Expectation[MatcherWTrace[MODEL], MatchingResult]:
return Expectation(execution=ExecutionExpectation(
main_result=asrt_matching_result.matches_value(expected)))
def test_multiple_files(self):
# ARRANGE #
name_of_regular_file = 'a-regular-file'
name_of_dir = 'a-dir'
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP,
'dir-w-multiple-files')
arrangement = Arrangement(
IS_REGULAR_AND_IS_DIR_MATCHER_SYMBOLS,
checked_dir.tcds_arrangement_dir_with_contents([
File.empty(name_of_regular_file),
Dir.empty(name_of_dir),
]))
cases = [
Case(
'no file matchers',
fc_args.FilesCondition([
fc_args.FileCondition(name_of_regular_file),
fc_args.FileCondition(name_of_dir),
]),
arrangement,
Expectation(
ParseExpectation(symbol_references=asrt.is_empty_sequence),
MATCHING_EXECUTION_EXPECTATION,
),
),
Case(
'with matcher on regular file',
fc_args.FilesCondition([
fc_args.FileCondition(
name_of_regular_file,
fm_args.SymbolReferenceWReferenceSyntax(
IS_REGULAR_FILE_FILE_MATCHER.name)),
fc_args.FileCondition(name_of_dir),
]),
arrangement,
Expectation(
ParseExpectation(
symbol_references=asrt.matches_singleton_sequence(
IS_REGULAR_FILE_FILE_MATCHER.reference_assertion)),
MATCHING_EXECUTION_EXPECTATION,
),
),
Case(
'with matcher on dir',
fc_args.FilesCondition([
fc_args.FileCondition(name_of_regular_file),
fc_args.FileCondition(
name_of_dir,
fm_args.SymbolReferenceWReferenceSyntax(
IS_DIR_FILE_MATCHER.name)),
]),
arrangement,
Expectation(
ParseExpectation(
symbol_references=asrt.matches_singleton_sequence(
IS_DIR_FILE_MATCHER.reference_assertion)),
MATCHING_EXECUTION_EXPECTATION,
),
),
Case(
'with matcher on both files',
fc_args.FilesCondition([
fc_args.FileCondition(
name_of_regular_file,
fm_args.SymbolReferenceWReferenceSyntax(
IS_REGULAR_FILE_FILE_MATCHER.name)),
fc_args.FileCondition(
name_of_dir,
fm_args.SymbolReferenceWReferenceSyntax(
IS_DIR_FILE_MATCHER.name)),
]),
arrangement,
Expectation(
ParseExpectation(symbol_references=asrt.matches_sequence([
IS_REGULAR_FILE_FILE_MATCHER.reference_assertion,
IS_DIR_FILE_MATCHER.reference_assertion,
])),
MATCHING_EXECUTION_EXPECTATION,
),
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
check_non_full_and_full(
self,
case.files_condition,
model_constructor__non_recursive(checked_dir.path_sdv),
case.arrangement,
case.expectation,
)
def test_single_file(self):
# ARRANGE #
name_of_file_in_model = 'file-in-model'
name_of_file_not_in_model = 'file-not-in-model'
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP,
'dir-w-single-file')
cases = [
Case(
'no file matcher - different names',
fc_args.FilesCondition([
fc_args.FileCondition(name_of_file_not_in_model),
]),
Arrangement(
IS_REGULAR_AND_IS_DIR_MATCHER_SYMBOLS,
checked_dir.tcds_arrangement_dir_with_contents(
[File.empty(name_of_file_in_model)])),
Expectation(
ParseExpectation(symbol_references=asrt.is_empty_sequence),
NON_MATCHING_EXECUTION_EXPECTATION,
),
),
Case(
'same names - non-matching matcher/actual is dir',
fc_args.FilesCondition([
fc_args.FileCondition(
name_of_file_in_model,
fm_args.SymbolReferenceWReferenceSyntax(
IS_REGULAR_FILE_FILE_MATCHER.name)),
]),
Arrangement(
IS_REGULAR_AND_IS_DIR_MATCHER_SYMBOLS,
checked_dir.tcds_arrangement_dir_with_contents(
[Dir.empty(name_of_file_in_model)])),
Expectation(
ParseExpectation(
symbol_references=asrt.matches_singleton_sequence(
IS_REGULAR_FILE_FILE_MATCHER.reference_assertion)),
NON_MATCHING_EXECUTION_EXPECTATION,
),
),
Case(
'same names - non-matching matcher/actual is regular file',
fc_args.FilesCondition([
fc_args.FileCondition(
name_of_file_in_model,
fm_args.SymbolReferenceWReferenceSyntax(
IS_DIR_FILE_MATCHER.name)),
]),
Arrangement(
IS_REGULAR_AND_IS_DIR_MATCHER_SYMBOLS,
checked_dir.tcds_arrangement_dir_with_contents(
[File.empty(name_of_file_in_model)])),
Expectation(
ParseExpectation(
symbol_references=asrt.matches_singleton_sequence(
IS_DIR_FILE_MATCHER.reference_assertion)),
NON_MATCHING_EXECUTION_EXPECTATION,
),
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
check_non_full_and_full(
self,
case.files_condition,
model_constructor__non_recursive(checked_dir.path_sdv),
case.arrangement,
case.expectation,
)
def runTest(self):
# ARRANGE #
positive_expectation = expectation_type_config__non_is_success(
ExpectationType.POSITIVE)
rel_opt_conf = rel_opt_confs.conf_rel_sds(RelSdsOptionType.REL_TMP)
parser = sut.parsers().full
# dir contents
checked_dir = Dir('checked-dir', [
File.empty('a.x'),
File.empty('a.y'),
File.empty('b.x'),
File.empty('b.y'),
])
# arguments
file_matcher_arg__begins_with_a = fm_args.file_matcher_arguments(
name_pattern='a*')
file_matcher_arg__ends_with_x = fm_args.file_matcher_arguments(
name_pattern='*.x')
files_matcher_args__num_files_eq_1 = fsm_args.NumFilesAssertionVariant(
int_args.int_condition(comparators.EQ, 1))
files_matcher_args__num_files_ending_with_x_eq_1 = fsm_args.SelectionAndMatcherArgumentsConstructor(
file_matcher_arg__ends_with_x,
files_matcher_args__num_files_eq_1,
)
files_matcher_source__num_files_ending_with_x_eq_1 = files_matcher_args__num_files_ending_with_x_eq_1.apply(
positive_expectation)
symbol_name = 'FILES_MATCHER_SYMBOL'
files_matcher_args__begins_with_a__symbol = fsm_args.SelectionAndMatcherArgumentsConstructor(
file_matcher_arg__begins_with_a,
fsm_args.symbol_reference(symbol_name),
)
files_matcher_source__begins_with_a__symbol = files_matcher_args__begins_with_a__symbol.apply(
positive_expectation)
num_files_ending_with_x_eq_1_resolver = parser.parse(
remaining_source(
files_matcher_source__num_files_ending_with_x_eq_1))
symbols = FilesMatcherSymbolContext.of_sdv(
symbol_name,
num_files_ending_with_x_eq_1_resolver,
).symbol_table
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check(
self,
remaining_source(files_matcher_source__begins_with_a__symbol),
model.model_with_source_path_as_sub_dir_of_rel_root(
checked_dir.name)(rel_opt_conf),
arrangement_w_tcds(
non_hds_contents=rel_opt_conf.
populator_for_relativity_option_root__sds(
DirContents([checked_dir])),
symbols=symbols,
),
Expectation(
ParseExpectation(symbol_references=asrt.matches_sequence(
[is_reference_to_files_matcher(symbol_name)]), ),
ExecutionExpectation(
main_result=matcher_assertions.is_matching_success(), ),
))
def expectation(self) -> Expectation:
return Expectation(
ParseExpectation(symbol_references=asrt.matches_singleton_sequence(
is_reference_to_files_matcher(self.files_matcher_name)), ),
ExecutionExpectation(is_hard_error=asrt_matcher.is_hard_error(
asrt.equals(self.error_message))))
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
# ARRANGE #
string_to_prepend = '.'
initial_model_contents = '\n'
model_after_2_transformations = ''.join(
[string_to_prepend, string_to_prepend, initial_model_contents])
initial_model = model_constructor.of_str(self, initial_model_contents)
equals_expected_matcher = StringMatcherSymbolContext.of_primitive(
'EQUALS_EXPECTED',
EqualsMatcherTestImpl(model_after_2_transformations))
prepend_transformer_symbol = StringTransformerSymbolContext.of_primitive(
'PREPEND_TRANSFORMER',
string_transformers.of_line_transformer__w_preserved_line_ending(
'prepend to each line', lambda line:
(line + string_to_prepend)))
prepend_trans_arg = str_trans_syntax.syntax_for_transformer_option(
prepend_transformer_symbol.name)
trans_and_eq_expected_matcher_source = remaining_source(
'{prepend_trans_arg} {equals_expected_matcher}'.format(
prepend_trans_arg=prepend_trans_arg,
equals_expected_matcher=equals_expected_matcher.name,
))
# ACT & ASSERT #
parser = sut.parsers().full
prepend_and_equals_expected_matcher_sdv = parser.parse(
trans_and_eq_expected_matcher_source)
prepend_and_equals_expected_matcher = StringMatcherSymbolContext.of_sdv(
'PREPEND_AND_EQUALS_EXPECTED',
prepend_and_equals_expected_matcher_sdv)
symbols = SymbolContext.symbol_table_of_contexts([
equals_expected_matcher,
prepend_transformer_symbol,
prepend_and_equals_expected_matcher,
])
expected_symbol_references = asrt.matches_sequence([
is_reference_to_string_transformer(
prepend_transformer_symbol.name),
is_reference_to_string_matcher(
prepend_and_equals_expected_matcher.name),
])
self._check_with_source_variants(
test_configuration.arguments_for(
args(
'{prepend_trans_arg} {maybe_not} {prepend_and_equals_expected_matcher}',
prepend_trans_arg=prepend_trans_arg,
maybe_not=maybe_not.
nothing__if_positive__not_option__if_negative,
prepend_and_equals_expected_matcher=
prepend_and_equals_expected_matcher.name)), initial_model,
arrangement_w_tcds(symbols=symbols),
Expectation(
ParseExpectation(
symbol_references=expected_symbol_references, ),
ExecutionExpectation(
main_result=maybe_not.pass__if_positive__fail__if_negative,
),
))
def test__exists__SHOULD_consider_only_files_matched_by_the_file_matcher(self):
# ARRANGE #
name_of_checked_dir = 'name-of-checked-dir'
name_starts_with_selected = FileMatcherSymbolContext.of_primitive(
'a_file_matcher_symbol',
FileMatcherThatMatchesAnyFileWhosNameStartsWith('selected'))
files_in_checked_dir = Dir(name_of_checked_dir, [
File(
'selected-non-empty-file.txt', 'contents of non-emtpy file'),
File.empty('un-selected-empty-file.txt'),
Dir.empty('un-selected-dir'),
sym_link(
'un-selected-sym-link-to-dir', 'un-selected-dir'),
sym_link(
'un-selected-broken-sym-link', 'non-existing-file'),
])
symbol_table_with_file_matcher = name_starts_with_selected.symbol_table
relativity_root_conf = AN_ACCEPTED_SDS_REL_OPT_CONFIG
expected_symbol_references = asrt.matches_sequence([
is_reference_to_file_matcher(name_starts_with_selected.name)
])
# ACT & ASSERT #
for file_is_empty_assertion in self.file_content_assertion_variants_that_pass_iff_file_is_empty:
arguments_constructor = args.complete_arguments_constructor(
FileQuantificationAssertionVariant(
Quantifier.EXISTS,
file_contents_arg2(file_is_empty_assertion)),
file_matcher=name_starts_with_selected.name
)
for expectation_type in ExpectationType:
etc = expectation_type_config__non_is_success(expectation_type)
arguments = arguments_constructor.apply(etc)
with self.subTest(
expectation_type=expectation_type.name,
arguments=arguments):
integration_check.CHECKER__PARSE_FULL.check(
self,
remaining_source(arguments),
model.model_with_source_path_as_sub_dir_of_rel_root(name_of_checked_dir)(relativity_root_conf),
arrangement=
arrangement_w_tcds(
tcds_contents=relativity_root_conf.populator_for_relativity_option_root(
DirContents([
files_in_checked_dir,
])
),
symbols=symbol_table_with_file_matcher
),
expectation=
Expectation(
ParseExpectation(
symbol_references=expected_symbol_references
),
ExecutionExpectation(
main_result=etc.fail__if_positive__pass_if_negative,
),
)
)
