def test_matcher_SHOULD_be_parsed_as_full_expression(self):
matcher_helpers.check_matcher_should_be_parsed_as_full_expression(
self,
FileMatcherSymbolContext.of_arbitrary_value('symbol_1'),
FileMatcherSymbolContext.of_arbitrary_value('symbol_2'),
ValueType.FILE_MATCHER,
)
def runTest(self):
# ARRANGE #
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'a-dir')
unconditionally_hard_error_file_matcher = FileMatcherSymbolContext.of_primitive(
'unconditionally_hard_error_file_matcher',
matchers.MatcherThatReportsHardError())
file_in_model = 'a-file'
# ACT & ASSERT #
check_non_full_and_full(
self,
fc_args.FilesCondition([
fc_args.FileCondition(
file_in_model,
fm_args.SymbolReferenceWReferenceSyntax(
unconditionally_hard_error_file_matcher.name)),
]),
model_constructor__non_recursive(checked_dir.path_sdv),
Arrangement(
symbols=unconditionally_hard_error_file_matcher.symbol_table,
tcds=checked_dir.tcds_arrangement_dir_with_contents(
[File.empty(file_in_model)])),
Expectation(
ParseExpectation(
symbol_references=asrt.matches_singleton_sequence(
unconditionally_hard_error_file_matcher.
reference_assertion)),
ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text())),
)
def test_one_file_wo_matcher_and_one_w_matcher(self):
# ARRANGE #
file_name_w_matcher = 'file-name-with-matcher'
file_name_wo_matcher = 'file-name-without-matcher'
fm_symbol = 'file_matcher'
arguments = args.FilesCondition([
args.FileCondition(file_name_wo_matcher),
args.FileCondition(
file_name_w_matcher,
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol)),
])
# ACT & ASSERT #
CHECKER.check_multi__w_source_variants(
self, arguments.as_arguments,
asrt.matches_sequence([is_reference_to_file_matcher(fm_symbol)]),
None, [
NExArr(
'FileMatcher should give {}'.format(expected_result),
PrimAndExeExpectation.of_prim__const(
asrt_primitive.files_matches({
PurePosixPath(file_name_wo_matcher):
asrt.is_none,
PurePosixPath(file_name_w_matcher):
asrt_primitive.is_matcher_that_gives(
expected_result)
})),
arrangement_wo_tcds(
FileMatcherSymbolContext.of_primitive_constant(
fm_symbol, expected_result).symbol_table),
) for expected_result in [False, True]
])
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 __init__(
self,
symbol_name: str,
expectation: ValidationExpectationSvh,
actual: ValidationActual,
):
self._expectation = expectation
self._symbol_context = FileMatcherSymbolContext.of_sdv(
symbol_name, _successful_matcher_with_validation(actual))
def test_fails_if_applied(put: unittest.TestCase) -> FileMatcherSymbolContext:
return FileMatcherSymbolContext.of_sdv(
'test_fails_if_applied',
sdv_components.matcher_sdv_from_constant_primitive(
matcher_w_init_action.matcher_that_applies_assertion(
put,
asrt.fail('must not be applied'),
lambda x: x,
asrt.MessageBuilder.new_empty(),
True,
)))
def __init__(
self,
expectation: ValidationAssertions,
actual: ValidationActual,
symbol_name: str = 'file_matcher_symbol',
):
self._expectation = expectation
self._symbol_context = FileMatcherSymbolContext.of_sdv(
symbol_name,
_successful_matcher_with_validation(actual),
)
def test_single_file_name_with_matcher(self):
# ARRANGE #
file_name = 'file-name'
fm_symbol = 'file_matcher'
cases = [
NameAndValue(
'single name entry',
args.FilesCondition([
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol))
]),
),
NameAndValue(
'two entries with same file name, 1st without and 2nd with FileMatcher',
args.FilesCondition([
args.FileCondition(file_name),
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol)),
]),
),
NameAndValue(
'two entries with same file name, 1st with and 2nd without FileMatcher',
args.FilesCondition([
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol)),
args.FileCondition(file_name),
]),
),
]
# ACT & ASSERT #
for case in cases:
with self.subTest(case.name):
CHECKER.check_multi__w_source_variants(
self, case.value.as_arguments,
asrt.matches_sequence(
[is_reference_to_file_matcher(fm_symbol)]), None,
[
NExArr(
'FileMatcher should give {}'.format(
expected_result),
PrimAndExeExpectation.of_prim__const(
asrt_primitive.files_matches({
PurePosixPath(file_name):
asrt_primitive.is_matcher_that_gives(
expected_result)
})),
arrangement_wo_tcds(
FileMatcherSymbolContext.of_primitive_constant(
fm_symbol, expected_result).symbol_table),
) for expected_result in [False, True]
])
def result_is_single_file_name_w_lazy_conjunction_w_1st_is_applied_before_2nd(
file_name: str,
fm1: NameAndValue[bool],
fm2: NameAndValue[bool],
additional_symbols: Sequence[SymbolContext] = (),
additional_entries: Optional[Mapping[
PurePosixPath, Assertion[Optional[FileMatcher]]]] = None
) -> NExArr[PrimAndExeExpectation[FilesCondition, Optional[MatchingResult]],
Arrangement]:
expected_result_of_complex = fm1.value and fm2.value
sequence_builder = ApplicationSequenceFrom1Builder()
fst_matcher = sequence_builder.add_applied(fm1, 1)
snd_matcher__w_respect_to_laziness = (sequence_builder.add_applied(
fm2, 2) if fm1.value else sequence_builder.add_un_applied(fm2))
symbols = []
symbols += additional_symbols
symbols += [
FileMatcherSymbolContext.of_sdv(fm1.name, fst_matcher),
FileMatcherSymbolContext.of_sdv(fm2.name,
snd_matcher__w_respect_to_laziness),
]
entries = ({} if additional_entries is None else dict(additional_entries))
entries.update({
PurePosixPath(file_name):
asrt_primitive.is_matcher_that_gives(expected_result_of_complex)
})
return NExArr(
'combination of {} && {}'.format(fm1.value, fm2.value),
PrimAndExeExpectation.of_prim__const(
matches_w_application_order(
entries, sequence_builder.expected_application_sequence())),
arrangement_wo_tcds(SymbolContext.symbol_table_of_contexts(symbols)),
)
def _name_starts_with__and_hard_error_if_applied_to_non_directory(
name: str,
expected_name_prefix: str,
) -> FileMatcherSymbolContext:
return FileMatcherSymbolContext.of_sdv(
name,
combinator_sdvs.Conjunction(
[
sdv_components.matcher_sdv_from_constant_primitive(
file_matchers.BaseNameStartsWithMatcher(
expected_name_prefix)),
sdv_components.matcher_sdv_from_constant_primitive(
_HardErrorIfAppliedToNonDirectory()),
],
combinator_matchers.no_op_freezer,
))
def test_two_different_files_w_matcher(self):
# ARRANGE #
file_name__constant = 'file-name-with-constant-matcher'
file_name__w_variations = 'file-name-with-matcher-with-variations'
fm__constant = FileMatcherSymbolContextOfPrimitiveConstant(
'fm_constant', True)
fm__w_variations = 'fm_w_variations'
arguments = args.FilesCondition([
args.FileCondition(
file_name__constant,
fm_args.SymbolReferenceWReferenceSyntax(fm__constant.name)),
args.FileCondition(
file_name__w_variations,
fm_args.SymbolReferenceWReferenceSyntax(fm__w_variations)),
])
# ACT & ASSERT #
CHECKER.check_multi__w_source_variants(
self, arguments.as_arguments,
asrt.matches_sequence([
fm__constant.reference_assertion,
is_reference_to_file_matcher(fm__w_variations),
]), None, [
NExArr(
'FileMatcher with variations should give {}'.format(
expected_result_of_matcher_w_variations),
PrimAndExeExpectation.of_prim__const(
asrt_primitive.files_matches({
PurePosixPath(file_name__constant):
asrt_primitive.is_matcher_that_gives(
fm__constant.result_value),
PurePosixPath(file_name__w_variations):
asrt_primitive.is_matcher_that_gives(
expected_result_of_matcher_w_variations)
})),
arrangement_wo_tcds(
SymbolContext.symbol_table_of_contexts([
fm__constant,
FileMatcherSymbolContext.of_primitive_constant(
fm__w_variations,
expected_result_of_matcher_w_variations),
])),
) for expected_result_of_matcher_w_variations in [False, True]
])
def test_validation_error_SHOULD_be_reported_WHEN_file_name_is_invalid(
self):
# ARRANGE #
valid_fm = FileMatcherSymbolContext.of_primitive_constant(
'a_valid_file_matcher', True)
arguments = args.FilesCondition([
args.FileCondition(
'/an/absolute/file/name',
fm_args.SymbolReferenceWReferenceSyntax(valid_fm.name)),
])
# ACT & ASSERT #
CHECKER.check(
self, arguments.as_remaining_source, None,
arrangement_wo_tcds(valid_fm.symbol_table),
Expectation(
ParseExpectation(
symbol_references=asrt.matches_singleton_sequence(
valid_fm.reference_assertion)),
ExecutionExpectation(validation=ValidationAssertions.
pre_sds_fails__w_any_msg())))
def runTest(self):
# ARRANGE #
error_message = 'error message from file matcher'
file_matcher_that_raises_hard_error = FileMatcherSymbolContext.of_primitive(
'file_matcher_that_raises_hard_error',
matchers.MatcherThatReportsHardError(error_message)
)
path_relativity = conf_rel_sds(RelSdsOptionType.REL_ACT)
checked_file = File.empty('checked-file.txt')
argument = args.CompleteInstructionArg(
ExpectationType.POSITIVE,
path_relativity.path_argument_of_rel_name(checked_file.name),
fm_args.SymbolReference(file_matcher_that_raises_hard_error.name))
# ACT & ASSERT #
CHECKER.check(
self,
remaining_source(str(argument)),
ArrangementPostAct(
symbols=file_matcher_that_raises_hard_error.symbol_table,
sds_contents=path_relativity.populator_for_relativity_option_root__sds(
DirContents([checked_file])
)
),
instruction_check.expectation(
main_result=pfh_assertions.is_hard_error(
asrt_text_doc.rendered_text_matches(asrt_str.contains(error_message))
),
symbol_usages=asrt.matches_sequence([
file_matcher_that_raises_hard_error.reference_assertion
])
))
def runTest(self):
# ARRANGE #
checked_dir = DirArgumentHelper(RelOptionType.REL_ACT, 'a-dir')
fc_file_1 = 'file-1'
fc_file_2 = 'file-2'
file_name_not_in_fc = 'not-in-fc'
unconditionally_matching_file_matcher = FileMatcherSymbolContext.of_primitive_constant(
'unconditionally_matching_file_matcher', True)
unconditionally_matching_file_matcher_sym_ref_arg = fm_args.SymbolReferenceWReferenceSyntax(
unconditionally_matching_file_matcher.name)
unconditionally_matching_file_matcher_sym_ref_assertion = unconditionally_matching_file_matcher.reference_assertion
symbol_table_with_unconditionally_matching_file_matcher = unconditionally_matching_file_matcher.symbol_table
files_condition_w_2_files_cases = [
NIE(
'no file matcher',
asrt.is_empty_sequence,
fc_args.FilesCondition([
fc_args.FileCondition(fc_file_1),
fc_args.FileCondition(fc_file_2),
]),
),
NIE(
'file matcher on one file',
asrt.matches_sequence([
unconditionally_matching_file_matcher_sym_ref_assertion,
]),
fc_args.FilesCondition([
fc_args.FileCondition(
fc_file_1,
unconditionally_matching_file_matcher_sym_ref_arg),
fc_args.FileCondition(fc_file_2),
]),
),
NIE(
'file matcher on all files',
asrt.matches_sequence([
unconditionally_matching_file_matcher_sym_ref_assertion,
unconditionally_matching_file_matcher_sym_ref_assertion,
]),
fc_args.FilesCondition([
fc_args.FileCondition(
fc_file_1,
unconditionally_matching_file_matcher_sym_ref_arg),
fc_args.FileCondition(
fc_file_2,
unconditionally_matching_file_matcher_sym_ref_arg),
]),
),
]
expectation_of_matching_giving_false = PrimAndExeExpectation.of_exe(
main_result=asrt.equals(False))
model_contents_cases = [
NExArr(
'model is empty',
expectation_of_matching_giving_false,
Arrangement(
symbols=
symbol_table_with_unconditionally_matching_file_matcher,
tcds=checked_dir.tcds_arrangement_dir_with_contents([])),
),
NExArr(
'model contains single file with name in FILES-CONDITION',
expectation_of_matching_giving_false,
Arrangement(
symbols=
symbol_table_with_unconditionally_matching_file_matcher,
tcds=checked_dir.tcds_arrangement_dir_with_contents(
[File.empty(fc_file_1)])),
),
NExArr(
'model contains single file with name not in FILES-CONDITION',
expectation_of_matching_giving_false,
Arrangement(
symbols=
symbol_table_with_unconditionally_matching_file_matcher,
tcds=checked_dir.tcds_arrangement_dir_with_contents(
[File.empty(file_name_not_in_fc)])),
),
]
for files_condition_w_2_files_case in files_condition_w_2_files_cases:
with self.subTest(files_condition_w_2_files_case.name):
# ACT & ASSERT #
check_non_full_and_full__multi(
self,
files_condition_w_2_files_case.input_value,
symbol_references=files_condition_w_2_files_case.
expected_value,
model=model_constructor__non_recursive(
checked_dir.path_sdv),
execution=model_contents_cases,
)
def test_3_file_names__1_fn_2_times_w_matchers_that_should_be_combined(
self):
# ARRANGE #
fn_1_time_wo_fm = 'file-name--1-time--wo-matcher'
fn_1_time_w_fm = 'file-name-1-time--w-matcher'
fn_2_times_w_fm = 'file-name-2-times--w-matcher'
fn_1_time__fm = NavBuilder('fn_1_time__fm')
fn_2_times__fm_1 = NavBuilder('fn_2_times__fm_1')
fn_2_times__fm_2 = NavBuilder('fn_2_times__fm_2')
cases = [
NIE(
'files wo matcher combination : before',
[
is_reference_to_file_matcher(fn_1_time__fm.name),
is_reference_to_file_matcher(fn_2_times__fm_1.name),
is_reference_to_file_matcher(fn_2_times__fm_2.name),
],
args.FilesCondition([
args.FileCondition(fn_1_time_wo_fm),
args.FileCondition(
fn_1_time_w_fm,
fm_args.SymbolReferenceWReferenceSyntax(
fn_1_time__fm.name)),
args.FileCondition(
fn_2_times_w_fm,
fm_args.SymbolReferenceWReferenceSyntax(
fn_2_times__fm_1.name)),
args.FileCondition(
fn_2_times_w_fm,
fm_args.SymbolReferenceWReferenceSyntax(
fn_2_times__fm_2.name)),
]),
),
NIE(
'files wo matcher combination : between',
[
is_reference_to_file_matcher(fn_2_times__fm_1.name),
is_reference_to_file_matcher(fn_1_time__fm.name),
is_reference_to_file_matcher(fn_2_times__fm_2.name),
],
args.FilesCondition([
args.FileCondition(
fn_2_times_w_fm,
fm_args.SymbolReferenceWReferenceSyntax(
fn_2_times__fm_1.name)),
args.FileCondition(fn_1_time_wo_fm),
args.FileCondition(
fn_1_time_w_fm,
fm_args.SymbolReferenceWReferenceSyntax(
fn_1_time__fm.name)),
args.FileCondition(
fn_2_times_w_fm,
fm_args.SymbolReferenceWReferenceSyntax(
fn_2_times__fm_2.name)),
]),
),
NIE(
'files wo matcher combination : after',
[
is_reference_to_file_matcher(fn_2_times__fm_1.name),
is_reference_to_file_matcher(fn_2_times__fm_2.name),
is_reference_to_file_matcher(fn_1_time__fm.name),
],
args.FilesCondition([
args.FileCondition(
fn_2_times_w_fm,
fm_args.SymbolReferenceWReferenceSyntax(
fn_2_times__fm_1.name)),
args.FileCondition(
fn_2_times_w_fm,
fm_args.SymbolReferenceWReferenceSyntax(
fn_2_times__fm_2.name)),
args.FileCondition(fn_1_time_wo_fm),
args.FileCondition(
fn_1_time_w_fm,
fm_args.SymbolReferenceWReferenceSyntax(
fn_1_time__fm.name)),
]),
),
]
# ACT & ASSERT #
for case in cases:
with self.subTest(case.name):
CHECKER.check_multi(
self, case.input_value.as_arguments,
ParseExpectation(symbol_references=asrt.matches_sequence(
case.expected_value)), None,
[
result_is_single_file_name_w_lazy_conjunction_w_1st_is_applied_before_2nd(
fn_2_times_w_fm,
fn_2_times__fm_1.build(fm1),
fn_2_times__fm_2.build(fm2),
additional_symbols=[
FileMatcherSymbolContext.of_primitive_constant(
fn_1_time__fm.name, fm2)
],
additional_entries={
PurePosixPath(fn_1_time_wo_fm):
asrt.is_none,
PurePosixPath(fn_1_time_w_fm):
asrt_primitive.is_matcher_that_gives(fm2),
}) for (fm1, fm2) in [(False, False), (
False, True), (True, False), (True, True)]
])
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,
),
)
)
def mk_logic_type_context_of_sdv(
self, name: str,
sdv: MatcherSdv[FileMatcherModel]) -> FileMatcherSymbolContext:
return FileMatcherSymbolContext.of_sdv(name, sdv)
def is_regular_file_matcher(symbol_name: str) -> FileMatcherSymbolContext:
return FileMatcherSymbolContext.of_primitive(
symbol_name,
file_matchers.IsRegularFileMatcher()
)
text_doc_assertions.new_single_string_text_for_test(
'Test failure: File is not a directory'))
return matching_result.of(True)
NAME_STARTS_WITH__P1 = _name_starts_with__and_hard_error_if_applied_to_non_directory(
'name_starts_with_P1', 'P1')
NAME_STARTS_WITH__P2 = _name_starts_with__and_hard_error_if_applied_to_non_directory(
'name_starts_with_P2',
'P2',
)
NAME_STARTS_WITH__S1 = FileMatcherSymbolContext.of_sdv(
'name_starts_with_S1',
sdv_components.matcher_sdv_from_constant_primitive(
file_matchers.BaseNameStartsWithMatcher('S1')))
NO_ACTION_ON_FILES_THEMSELVES__CONTENTS = [
File.empty('P1-f'),
Dir.empty('P1-d'),
sym_link('P1-s', 'P1-f'),
sym_link('P1-sb', 'no-P2-existing'),
]
FILES_SHOULD_BE_INCLUDED_EVEN_IF_MATCH__DEPTH_0 = NEA.new_identical_expected_and_actual(
'files should be included even if match / depth 0',
NO_ACTION_ON_FILES_THEMSELVES__CONTENTS,
)
FILES_SHOULD_BE_INCLUDED_EVEN_IF_MATCH__DEPTH_1 = NEA.new_identical_expected_and_actual(
def is_dir_file_matcher(symbol_name: str) -> FileMatcherSymbolContext:
return FileMatcherSymbolContext.of_primitive(
symbol_name,
file_matchers.IsDirectoryMatcher()
)
def mk_logic_type_context_of_primitive(
self, name: str, primitive: MatcherWTrace[FileMatcherModel]
) -> FileMatcherSymbolContext:
return FileMatcherSymbolContext.of_primitive(name, primitive)
