def test_assignment_of_symbols_and_constant_text_within_soft_quotes(self): # ARRANGE # referred_symbol1 = SymbolWithReferenceSyntax('referred_symbol_1') referred_symbol2 = SymbolWithReferenceSyntax('referred_symbol_2') assigned_symbol = StringSymbolContext.of_sdv( 'defined_symbol', string_sdv_from_fragments([ symbol(referred_symbol1.name), constant(' between '), symbol(referred_symbol2.name), ])) source = single_line_source('{string_type} {name} = {soft_quote}{sym_ref1} between {sym_ref2}{soft_quote}', soft_quote=SOFT_QUOTE_CHAR, name=assigned_symbol.name, sym_ref1=referred_symbol1, sym_ref2=referred_symbol2) expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ assigned_symbol.assert_matches_definition_of_sdv, ]), symbols_after_main=assert_symbol_table_is_singleton( assigned_symbol.name, assigned_symbol.value.assert_matches_container_of_sdv, ) ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
def test_invalid_arguments_with_symbol_references(self): symbol_name = SymbolWithReferenceSyntax('symbol_name') operand_arg_with_symbol_ref_list = [ ' {op} {sym}'.format(op=comparators.EQ.name, sym=symbol_name), ] invalid_symbol_values = [ 'not_a_number', '1.5', '72 87', ] for invalid_symbol_value in invalid_symbol_values: symbol = StringConstantSymbolContext(symbol_name.name, invalid_symbol_value) for operand_arg_with_symbol_ref in operand_arg_with_symbol_ref_list: arguments = self._conf().arguments_constructor.apply( operand_arg_with_symbol_ref) with self.subTest(argument=arguments, invalid_symbol_value=invalid_symbol_value): for source in equivalent_source_variants__for_expression_parser( self, Arguments(arguments)): self._check( source, Arrangement(symbols=symbol.symbol_table), Expectation( ParseExpectation( symbol_references=asrt.matches_sequence([ symbol. reference_assertion__string__w_all_indirect_refs_are_strings ]), ), ExecutionExpectation( validation=asrt_validation. ValidationAssertions. pre_sds_fails__w_any_msg(), ), ), )
def test_assignment_of_single_symbol_reference(self): # ARRANGE # referred_symbol = SymbolWithReferenceSyntax('referred_symbol') expected_sdv = string_sdv_from_fragments([symbol(referred_symbol.name), constant('\n')]) assigned_symbol = StringSymbolContext.of_sdv( 'defined_symbol', expected_sdv, ) sb = SB.new_with(referred_symbol=referred_symbol, name_of_defined_symbol=assigned_symbol.name) source = sb.lines( here_doc_lines(first_line_start='{string_type} {name_of_defined_symbol} = ', marker='EOF', contents_lines=[str(referred_symbol)]) ) # EXPECTATION # expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ assigned_symbol.assert_matches_definition_of_sdv, ]), symbols_after_main=assert_symbol_table_is_singleton( assigned_symbol.name, assigned_symbol.value.assert_matches_container_of_sdv, ) ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
def test_invalid_arguments_with_symbol_references(self): symbol_name = SymbolWithReferenceSyntax('symbol_name') operand_arg_with_symbol_ref_list = [ ' {op} {sym}'.format(op=comparators.EQ.name, sym=symbol_name), ] invalid_symbol_values = [ 'not_a_number', '1.5', '72 87', ] for invalid_symbol_value in invalid_symbol_values: symbol = StringConstantSymbolContext(symbol_name.name, invalid_symbol_value) for operand_arg_with_symbol_ref in operand_arg_with_symbol_ref_list: arguments = self._conf().arguments_constructor.apply( operand_arg_with_symbol_ref) with self.subTest(argument=arguments, invalid_symbol_value=invalid_symbol_value): for source in equivalent_source_variants__with_source_check__consume_last_line( self, arguments): self._check( source, ArrangementPostAct(symbols=symbol.symbol_table), Expectation( validation_pre_sds=svh_asrt. is_validation_error(), symbol_usages=asrt.matches_sequence([ symbol. reference_assertion__string__w_all_indirect_refs_are_strings ]), ), )
def successful_parse_of_single_symbol() -> List[TC]: symbol_ref = SymbolWithReferenceSyntax('validSymbol_name_1') single_symbol = [symbol(symbol_ref.name)] return [ TC( _src('{symbol_reference}', symbol_reference=symbol_ref), Expectation( fragments=single_symbol, token_stream=assert_token_stream(is_null=asrt.is_true), )), TC( _src('{symbol_reference} rest', symbol_reference=symbol_ref), Expectation( fragments=single_symbol, token_stream=assert_token_stream( head_token=assert_token_string_is('rest')), )), TC( _src('{soft_quote}{symbol_reference}{soft_quote} rest', soft_quote=SOFT_QUOTE_CHAR, symbol_reference=symbol_ref), Expectation( fragments=single_symbol, token_stream=assert_token_stream( head_token=assert_token_string_is('rest')), )), ]
def test_invalid_arguments_with_symbol_references(self): symbol_name = SymbolWithReferenceSyntax('symbol_name') operand_arg_with_symbol_ref_list = [ IntegerMatcherComparisonAbsStx.of_cmp_op( comparators.EQ, StringSymbolAbsStx(symbol_name.name), ), ] invalid_symbol_values = [ 'not_a_number', '1.5', '72 87', ] for invalid_symbol_value in invalid_symbol_values: symbol = StringConstantSymbolContext(symbol_name.name, invalid_symbol_value) for operand_arg_with_symbol_ref in operand_arg_with_symbol_ref_list: full_syntax = self._conf().arguments_constructor.apply( operand_arg_with_symbol_ref) with self.subTest(argument=full_syntax.as_str__default(), invalid_symbol_value=invalid_symbol_value): self._check( full_syntax, ArrangementPostAct2(symbols=symbol.symbol_table), MultiSourceExpectation( symbol_usages=asrt.matches_sequence([ symbol. reference_assertion__string__w_all_indirect_refs_are_strings ]), execution=ExecutionExpectation( validation_pre_sds=svh_asrt. is_validation_error(), ), ), )
def test_successful_parse(self): # ARRANGE # symbol_ref = SymbolWithReferenceSyntax('validSymbol_name_1') single_symbol = [symbol(symbol_ref.name)] parse_source = ParseSource( _src('{soft_quote}{symbol_reference}{soft_quote} rest', soft_quote=SOFT_QUOTE_CHAR, symbol_reference=symbol_ref)) # ACT # actual = sut.parse_string_sdv_from_parse_source(parse_source) # ASSERT # assertion_on_result = assert_equals_string_sdv(single_symbol) assertion_on_result.apply_with_message(self, actual, 'result') assertion_on_parse_source = assert_source( remaining_part_of_current_line=asrt.equals('rest')) assertion_on_parse_source.apply_with_message(self, parse_source, 'parse_source')
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_assignment_of_single_symbol_reference(self): # ARRANGE # referred_symbol = SymbolWithReferenceSyntax('referred_symbol') assigned_symbol = StringSymbolContext.of_sdv('defined_symbol', string_sdv_from_fragments([symbol(referred_symbol.name)])) source = single_line_source('{string_type} {name} = {symbol_reference}', name=assigned_symbol.name, symbol_reference=referred_symbol) expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ assigned_symbol.assert_matches_definition_of_sdv, ]), symbols_after_main=assert_symbol_table_is_singleton( assigned_symbol.name, assigned_symbol.value.assert_matches_container_of_sdv, ) ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
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(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 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, )