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 )