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 test_successful_parse_of_arbitrary_matcher(self):
defined_name = 'defined_name'
file_name = 'the-file-name'
# ARRANGE #
argument_cases = [
NameAndValue('value on same line',
'{files_condition}'
),
NameAndValue('value on following line',
'{new_line} {files_condition}'
),
]
for case in argument_cases:
with self.subTest(case.name):
source = remaining_source(
src2(ValueType.FILES_CONDITION, defined_name, case.value,
files_condition=arg_syntax.FilesCondition([arg_syntax.FileCondition(file_name)])),
)
# EXPECTATION #
expected_container = matches_container(
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 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):
# 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_access_of_sub_dir_for_failure_message_rendering(self):
# ARRANGE #
root_1__file = File.empty('f-1')
root_2__dir = Dir('d-2', [])
arguments = args.matches_full(
fc_args.FilesCondition([fc_args.FileCondition(root_1__file.name)])
)
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'checked-dir')
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__w_source_variants(
self,
arguments.as_arguments,
input_=model_constructor__recursive(checked_dir.path_sdv),
arrangement=Arrangement(
tcds=checked_dir.tcds_arrangement_dir_with_contents([
root_1__file,
root_2__dir,
])
),
expectation=Expectation(
parse=ParseExpectation(
symbol_references=asrt.is_empty_sequence,
),
execution=PRIM_AND_EXE_EXPECTATION__NON_MATCH.execution,
primitive=PRIM_AND_EXE_EXPECTATION__NON_MATCH.primitive,
),
)
def test_files_names_must_be_relative(self):
# ARRANGE #
cases = [
Case(
'absolute posix file name (constant)',
args.FilesCondition([
args.FileCondition(ABS_POSIX_PATH),
]),
SymbolsArrEx.empty(),
),
Case(
'valid file name and absolute posix file name (constant)',
args.FilesCondition([
args.FileCondition('valid-file-name'),
args.FileCondition(ABS_POSIX_PATH),
]),
SymbolsArrEx.empty(),
),
Case(
'absolute posix file name (symbol ref)',
args.FilesCondition([
args.FileCondition(
SymbolWithReferenceSyntax(ABS_POSIX_PATH_SYMBOL_NAME)),
]),
SymbolsArrEx([
StringConstantSymbolContext(ABS_POSIX_PATH_SYMBOL_NAME,
ABS_POSIX_PATH)
], [
is_sym_ref_to_string__w_all_indirect_refs_are_strings(
ABS_POSIX_PATH_SYMBOL_NAME)
]),
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
CHECKER.check__w_source_variants(
self, case.source.as_arguments, None,
arrangement_wo_tcds(case.symbols.symbol_table),
Expectation(
ParseExpectation(symbol_references=case.symbols.
expected_references_assertion),
ExecutionExpectation(validation=ValidationAssertions.
pre_sds_fails__w_any_msg())))
def test_forward_slash_should_separate_parts(self):
# ARRANGE #
multi_part_file_name = '/'.join(FILE_NAME_PARTS)
expected_file_names = {PurePosixPath(*FILE_NAME_PARTS): asrt.is_none}
multi_part_file_name_symbol = StringConstantSymbolContext(
'multi_part_file_name_symbol', multi_part_file_name)
cases = [
Case(
'multi part posix file name (constant)',
args.FilesCondition([
args.FileCondition(multi_part_file_name),
]),
SymbolsArrEx.empty(),
),
Case(
'multi part posix file name (symbol reference)',
args.FilesCondition([
args.FileCondition(
SymbolWithReferenceSyntax(
multi_part_file_name_symbol.name)),
]),
SymbolsArrEx([multi_part_file_name_symbol], [
is_sym_ref_to_string__w_all_indirect_refs_are_strings(
multi_part_file_name_symbol.name)
]),
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
CHECKER.check__w_source_variants(
self, case.source.as_arguments, None,
arrangement_wo_tcds(case.symbols.symbol_table),
Expectation(
ParseExpectation(symbol_references=case.symbols.
expected_references_assertion),
ExecutionExpectation(main_result=asrt.is_none, ),
primitive=prim_asrt__constant(
asrt_primitive.files_matches(
expected_file_names))))
def test_1_file_in_fc_wo_matcher(self):
# ARRANGE #
name_of_file_in_fc = 'file-in-files-condition'
name_of_file_not_in_fc_1 = 'file-not-in-files-condition-1'
name_of_file_not_in_fc_2 = 'file-not-in-files-condition-2'
arguments = args.matches_full(
fc_args.FilesCondition([fc_args.FileCondition(name_of_file_in_fc)])
)
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'dir-w-more-than-one-file')
execution_cases = [
NExArr(
'2 files: one file name matches',
PRIM_AND_EXE_EXPECTATION__NON_MATCH,
Arrangement(
tcds=checked_dir.tcds_arrangement_dir_with_contents([
File.empty(name_of_file_in_fc),
File.empty(name_of_file_not_in_fc_1),
])
)
),
NExArr(
'2 files: no file name matches',
PRIM_AND_EXE_EXPECTATION__NON_MATCH,
Arrangement(
tcds=checked_dir.tcds_arrangement_dir_with_contents([
File.empty(name_of_file_not_in_fc_1),
File.empty(name_of_file_not_in_fc_2),
])
)
),
NExArr(
'3 files: one file name matches',
PRIM_AND_EXE_EXPECTATION__NON_MATCH,
Arrangement(
tcds=checked_dir.tcds_arrangement_dir_with_contents([
File.empty(name_of_file_in_fc),
File.empty(name_of_file_not_in_fc_1),
File.empty(name_of_file_not_in_fc_2),
])
)
)
]
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check_multi__w_source_variants(
self,
arguments.as_arguments,
symbol_references=asrt.is_empty_sequence,
input_=model_constructor__non_recursive(checked_dir.path_sdv),
execution=execution_cases
)
def test_empty(self):
# ARRANGE #
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'empty-dir')
# ACT & ASSERT #
check_non_full_and_full(
self,
fc_args.FilesCondition([]),
model_constructor__non_recursive(checked_dir.path_sdv),
Arrangement(
tcds=checked_dir.tcds_arrangement_dir_with_contents([])),
Expectation(
ParseExpectation(symbol_references=asrt.is_empty_sequence),
ExecutionExpectation(main_result=asrt.equals(True)),
),
)
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_matcher_reports_validation_error(
self):
# ARRANGE #
fm_symbol_name = 'the_file_matcher'
arguments = args.FilesCondition([
args.FileCondition(
'file-name',
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol_name))
])
# ACT & ASSERT #
CHECKER.check_multi__w_source_variants(
self,
arguments.as_arguments,
symbol_references=asrt.matches_singleton_sequence(
is_reference_to_file_matcher(fm_symbol_name)),
input_=None,
execution=validation_cases.failing_validation_cases__multi_exe(
fm_symbol_name))
def test_back_slash_should_not_separate_parts(self):
# ARRANGE #
file_name_with_back_slash = '\\'.join(FILE_NAME_PARTS)
expected_file_names = {
PurePosixPath(file_name_with_back_slash): asrt.is_none
}
source = args.FilesCondition([
args.FileCondition(
surrounded_by_hard_quotes(file_name_with_back_slash)),
])
# ACT & ASSERT #
CHECKER.check__w_source_variants(
self, source.as_arguments, None, arrangement_wo_tcds(),
Expectation(
ParseExpectation(),
ExecutionExpectation(),
primitive=prim_asrt__constant(
asrt_primitive.files_matches(expected_file_names))))
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 test_validation_SHOULD_fail_WHEN_validation_of_files_condition_fails(
self):
# ARRANGE #
fm_symbol_name = 'the_file_matcher'
fc_argument = fc_args.FilesCondition([
fc_args.FileCondition(
'file-name',
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol_name))
])
for case in FULL_AND_NON_FULL_CASES:
fsm = case.arguments_for_fc(fc_argument)
with self.subTest(case.name):
# ACT & ASSERT #
CHECKER__PARSE_FULL.check_multi__w_source_variants(
self,
fsm.as_arguments,
symbol_references=asrt.matches_singleton_sequence(
is_reference_to_file_matcher(fm_symbol_name)),
input_=None,
execution=validation_cases.
failing_validation_cases__multi_exe(fm_symbol_name))
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 runTest(self):
# ARRANGE #
fm_symbol_name = 'file_matcher_symbol'
fc_argument = fc_args.FilesCondition([
fc_args.FileCondition('file-name',
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol_name))
])
symbol_references_expectation = asrt.matches_singleton_sequence(
is_reference_to_file_matcher(fm_symbol_name),
)
parser = sut.parsers().full
for case in FULL_AND_NON_FULL_CASES:
fsm = case.arguments_for_fc(fc_argument)
with self.subTest(case.name):
# ACT #
sdv = parser.parse(fsm.as_remaining_source)
# ASSERT #
symbol_references_expectation.apply_without_message(
self,
sdv.references,
)
def runTest(self):
# ARRANGE #
cases = [
NIE(
'file name reference',
[
is_sym_ref_to_string__w_all_indirect_refs_are_strings(
STRING_SYMBOL_NAME)
],
args.FilesCondition([
args.FileCondition(
SymbolWithReferenceSyntax(STRING_SYMBOL_NAME)),
]),
),
NIE(
'file name reference (embedded)',
[
is_sym_ref_to_string__w_all_indirect_refs_are_strings(
STRING_SYMBOL_NAME)
],
args.FilesCondition([
args.FileCondition(
'file-name-prefix-' +
str(SymbolWithReferenceSyntax(STRING_SYMBOL_NAME)) +
'-suffix'),
]),
),
NIE(
'file matcher reference',
[is_reference_to_file_matcher(FILE_MATCHER_SYMBOL_NAME)],
args.FilesCondition([
args.FileCondition(
'constant-file-name',
fm_args.SymbolReferenceWReferenceSyntax(
FILE_MATCHER_SYMBOL_NAME)),
]),
),
NIE(
'file name and file matcher reference',
[
is_sym_ref_to_string__w_all_indirect_refs_are_strings(
STRING_SYMBOL_NAME),
is_reference_to_file_matcher(FILE_MATCHER_SYMBOL_NAME),
],
args.FilesCondition([
args.FileCondition(
SymbolWithReferenceSyntax(STRING_SYMBOL_NAME),
fm_args.SymbolReferenceWReferenceSyntax(
FILE_MATCHER_SYMBOL_NAME)),
]),
),
NIE(
'multiple file name and file matcher reference',
[
is_sym_ref_to_string__w_all_indirect_refs_are_strings(
STRING_SYMBOL_NAME),
is_reference_to_file_matcher(FILE_MATCHER_SYMBOL_NAME),
is_sym_ref_to_string__w_all_indirect_refs_are_strings(
STRING_SYMBOL_NAME_2),
is_reference_to_file_matcher(FILE_MATCHER_SYMBOL_NAME_2),
],
args.FilesCondition([
args.FileCondition(
SymbolWithReferenceSyntax(STRING_SYMBOL_NAME),
fm_args.SymbolReferenceWReferenceSyntax(
FILE_MATCHER_SYMBOL_NAME),
),
args.FileCondition(
SymbolWithReferenceSyntax(STRING_SYMBOL_NAME_2),
fm_args.SymbolReferenceWReferenceSyntax(
FILE_MATCHER_SYMBOL_NAME_2),
),
]),
),
]
for must_be_on_current_line in [False, True]:
for case in cases:
with self.subTest(
case=case.name,
must_be_on_current_line=must_be_on_current_line):
# ACT #
actual = sut.parsers(must_be_on_current_line).full.parse(
case.input_value.as_remaining_source)
# ASSERT #
expectation = asrt.matches_sequence(case.expected_value)
expectation.apply_without_message(
self,
actual.references,
)
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 test(self):
# ARRANGE #
cases = [
CaseWithFiles(
'single file name',
args.FilesCondition([
args.FileCondition('file-name'),
]), SymbolsArrEx.empty(),
{PurePosixPath('file-name'): asrt.is_none}),
CaseWithFiles(
'two file names',
args.FilesCondition([
args.FileCondition('fn1'),
args.FileCondition('fn2'),
]), SymbolsArrEx.empty(), {
PurePosixPath('fn1'): asrt.is_none,
PurePosixPath('fn2'): asrt.is_none,
}),
CaseWithFiles(
'two files with the same names',
args.FilesCondition([
args.FileCondition('fn'),
args.FileCondition('fn'),
]), SymbolsArrEx.empty(), {
PurePosixPath('fn'): asrt.is_none,
}),
CaseWithFiles(
'some unique files, some repeated',
args.FilesCondition([
args.FileCondition('fn1'),
args.FileCondition('fn2'),
args.FileCondition('fn1'),
]), SymbolsArrEx.empty(), {
PurePosixPath('fn1'): asrt.is_none,
PurePosixPath('fn2'): asrt.is_none,
}),
CaseWithFiles(
'different symbols with identical value',
args.FilesCondition([
args.FileCondition(SymbolWithReferenceSyntax('sym_ref1')),
args.FileCondition(SymbolWithReferenceSyntax('sym_ref2')),
]),
SymbolsArrEx([
StringConstantSymbolContext('sym_ref1', 'fn'),
StringConstantSymbolContext('sym_ref2', 'fn'),
], [
is_sym_ref_to_string__w_all_indirect_refs_are_strings(
'sym_ref1'),
is_sym_ref_to_string__w_all_indirect_refs_are_strings(
'sym_ref2'),
]), {
PurePosixPath('fn'): asrt.is_none,
}),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
CHECKER.check__w_source_variants(
self, case.source.as_arguments, None,
arrangement_wo_tcds(case.symbols.symbol_table),
Expectation(
ParseExpectation(symbol_references=case.symbols.
expected_references_assertion),
ExecutionExpectation(),
prim_asrt__constant(
asrt_primitive.files_matches(case.expected))))
def test_single_repeated_file_name__2_w_fm_1_wo_fm(self):
# ARRANGE #
file_name = 'file-name'
fm1_symbol = NavBuilder('fm1')
fm2_symbol = NavBuilder('fm2')
cases = [
NameAndValue(
'two entries',
args.FilesCondition([
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(
fm1_symbol.name)),
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(
fm2_symbol.name)),
]),
),
NameAndValue(
'one empty entry above',
args.FilesCondition([
args.FileCondition(file_name),
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(
fm1_symbol.name)),
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(
fm2_symbol.name)),
]),
),
NameAndValue(
'one empty entry between',
args.FilesCondition([
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(
fm1_symbol.name)),
args.FileCondition(file_name),
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(
fm2_symbol.name)),
]),
),
NameAndValue(
'one empty entry below',
args.FilesCondition([
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(
fm1_symbol.name)),
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(
fm2_symbol.name)),
args.FileCondition(file_name),
]),
),
]
# ACT & ASSERT #
for case in cases:
with self.subTest(case.name):
CHECKER.check_multi(
self, case.value.as_arguments,
ParseExpectation(symbol_references=asrt.matches_sequence([
is_reference_to_file_matcher(fm1_symbol.name),
is_reference_to_file_matcher(fm2_symbol.name),
])), None, [
result_is_single_file_name_w_lazy_conjunction_w_1st_is_applied_before_2nd(
file_name,
fm1_symbol.build(fm1),
fm2_symbol.build(fm2),
) for (fm1, fm2) in [(False, False), (
False, True), (True, False), (True, True)]
])
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_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_2_files_in_fc(self):
# ARRANGE #
name_of_file_in_fc__1 = 'file-in-files-condition-1'
name_of_file_in_fc__2 = 'file-in-files-condition-2'
name_of_file_not_in_fc__1 = 'file-not-in-files-condition-1'
name_of_file_not_in_fc__2 = 'file-not-in-files-condition-2'
file_matcher_name = 'the_file_matcher'
arguments = args.matches_full(
fc_args.FilesCondition([
fc_args.FileCondition(name_of_file_in_fc__1,
fm_args.SymbolReferenceWReferenceSyntax(file_matcher_name)),
fc_args.FileCondition(name_of_file_in_fc__2),
])
)
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'dir-w-more-than-two-files')
execution_cases = [
NExArr(
'3 files: one file name matches, and matcher matches',
PRIM_AND_EXE_EXPECTATION__NON_MATCH,
Arrangement(
symbols=is_regular_file_matcher(file_matcher_name).symbol_table,
tcds=checked_dir.tcds_arrangement_dir_with_contents([
File.empty(name_of_file_in_fc__1),
File.empty(name_of_file_not_in_fc__1),
File.empty(name_of_file_not_in_fc__2),
])
)
),
NExArr(
'3 files: both file names matches, and matcher matches',
PRIM_AND_EXE_EXPECTATION__NON_MATCH,
Arrangement(
symbols=is_regular_file_matcher(file_matcher_name).symbol_table,
tcds=checked_dir.tcds_arrangement_dir_with_contents([
File.empty(name_of_file_in_fc__1),
File.empty(name_of_file_in_fc__2),
File.empty(name_of_file_not_in_fc__1),
])
)
),
NExArr(
'3 files: both file name matches, but matcher does not match',
PRIM_AND_EXE_EXPECTATION__NON_MATCH,
Arrangement(
symbols=is_dir_file_matcher(file_matcher_name).symbol_table,
tcds=checked_dir.tcds_arrangement_dir_with_contents([
File.empty(name_of_file_in_fc__1),
File.empty(name_of_file_in_fc__2),
File.empty(name_of_file_not_in_fc__1),
])
)
),
NExArr(
'4 files: both file name matches, and matcher matches',
PRIM_AND_EXE_EXPECTATION__NON_MATCH,
Arrangement(
symbols=is_regular_file_matcher(file_matcher_name).symbol_table,
tcds=checked_dir.tcds_arrangement_dir_with_contents([
File.empty(name_of_file_in_fc__1),
File.empty(name_of_file_in_fc__2),
File.empty(name_of_file_not_in_fc__1),
File.empty(name_of_file_not_in_fc__2),
])
)
),
]
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check_multi__w_source_variants(
self,
arguments.as_arguments,
symbol_references=asrt.matches_sequence([
is_reference_to_file_matcher(file_matcher_name),
]),
input_=model_constructor__non_recursive(checked_dir.path_sdv),
execution=execution_cases
)
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_1_file_in_fc_w_matcher(self):
# ARRANGE #
name_of_file_in_fc = 'file-in-files-condition'
name_of_file_not_in_fc_1 = 'file-not-in-files-condition-1'
name_of_file_not_in_fc_2 = 'file-not-in-files-condition-2'
arguments = args.matches_non_full(
fc_args.FilesCondition([
fc_args.FileCondition(name_of_file_in_fc,
fm_args.SymbolReferenceWReferenceSyntax(IS_REGULAR_FILE_FILE_MATCHER.name)),
])
)
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'dir-w-more-than-one-file')
execution_cases = [
NExArr(
'2 files: one file name matches, and matcher matches',
PRIM_AND_EXE_EXPECTATION__MATCH,
Arrangement(
symbols=IS_REGULAR_FILE_FILE_MATCHER.symbol_table,
tcds=checked_dir.tcds_arrangement_dir_with_contents([
File.empty(name_of_file_in_fc),
File.empty(name_of_file_not_in_fc_1),
])
)
),
NExArr(
'2 files: one file name matches, but matcher does not match',
PRIM_AND_EXE_EXPECTATION__NON_MATCH,
Arrangement(
symbols=is_dir_file_matcher(IS_REGULAR_FILE_FILE_MATCHER.name).symbol_table,
tcds=checked_dir.tcds_arrangement_dir_with_contents([
File.empty(name_of_file_in_fc),
File.empty(name_of_file_not_in_fc_1),
])
)
),
NExArr(
'3 files: one file name matches, and matcher matches',
PRIM_AND_EXE_EXPECTATION__MATCH,
Arrangement(
symbols=is_dir_file_matcher(IS_REGULAR_FILE_FILE_MATCHER.name).symbol_table,
tcds=checked_dir.tcds_arrangement_dir_with_contents([
Dir.empty(name_of_file_in_fc),
File.empty(name_of_file_not_in_fc_1),
File.empty(name_of_file_not_in_fc_2),
])
)
)
]
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check_multi__w_source_variants(
self,
arguments.as_arguments,
symbol_references=asrt.matches_sequence([
IS_REGULAR_FILE_FILE_MATCHER.reference_assertion,
]),
input_=model_constructor__non_recursive(checked_dir.path_sdv),
execution=execution_cases
)
