def test_here_document(self): source = assignment_of_list_of_args(['<<MARKER'], ['single line', 'MARKER', 'following line']) sut.Parser().parse(ARBITRARY_FS_LOCATION_INFO, source) is_at_beginning_of_line(4).apply_with_message(self, source, 'source')
def _source_variant_test_cases__multi_line(num_source_lines: int ) -> List[Tuple[List[str], ValueAssertion[ParseSource]]]: return [ ([], every_line_is_consumed), (['following line'], is_at_beginning_of_line(num_source_lines + 1)), ([' '], is_at_beginning_of_line(num_source_lines + 1)), ]
def _source_variant_test_cases__multi_line( num_source_lines: int ) -> List[Tuple[List[str], Assertion[ParseSource]]]: return [ ([], asrt_source.source_is_at_end), (['following line'], asrt_source.is_at_beginning_of_line(num_source_lines + 1)), ([' '], asrt_source.is_at_beginning_of_line(num_source_lines + 1)), ]
def test_positive(self): cases = [ SourceCase('Dir on first line, DIR-CONTENTS-MATCHER on following line', source=remaining_source_lines([ DIR_TO_CHECK, EMPTINESS_CHECK_ARGUMENT, ]), source_assertion=asrt_source.source_is_at_end ), SourceCase('Dir on first line, DIR-CONTENTS-MATCHER on following line, followed by non-instr line', source=remaining_source_lines([ DIR_TO_CHECK, EMPTINESS_CHECK_ARGUMENT, 'following line', ]), source_assertion=asrt_source.is_at_beginning_of_line(3) ), SourceCase('Empty lines between arguments', source=remaining_source_lines([ DIR_TO_CHECK, '', EMPTINESS_CHECK_ARGUMENT, '', 'following line', ]), source_assertion=asrt_source.is_at_beginning_of_line(4) ), SourceCase('Followed by empty line ' '(a bit strange behaviour - should probably be at beginning of last line)', source=remaining_source_lines([ DIR_TO_CHECK, EMPTINESS_CHECK_ARGUMENT, '', ]), source_assertion=asrt_source.source_is_at_end ), SourceCase('With selection on separate line', source=remaining_source_lines([ DIR_TO_CHECK, selection_arguments(name_pattern='*'), EMPTINESS_CHECK_ARGUMENT, '', 'following line', ]), source_assertion=asrt_source.is_at_beginning_of_line(4) ), ] for case in cases: self._check_sub_test(case, PassOrFailOrHardErrorEnum.PASS)
def test_assignment_of_single_constant_line(self): value_str = 'value' symbol_name = 'name1' sb = SB.new_with(value_str=value_str, symbol_name=symbol_name) source = sb.lines( here_doc_lines(first_line_start='{string_type} {symbol_name} = ', marker='EOF', contents_lines=['{value_str}']) + ['following line'] ) # EXPECTATION # expected_container = string_constant_container(value_str + '\n') expected_definition = SymbolDefinition(symbol_name, expected_container) expectation = Expectation( symbol_usages=asrt.matches_sequence([ vs_asrt.equals_symbol(expected_definition, ignore_source_line=True) ]), symbols_after_main=assert_symbol_table_is_singleton( symbol_name, equals_container(expected_container), ), source=asrt_source.is_at_beginning_of_line(4) ) # ACT & ASSERT # self._check(source, ArrangementWithSds(), expectation)
def test_path_argument_SHOULD_use_posix_syntax(self): # ARRANGE # inclusion_directive_name = 'incl-directive' parser = sut.FileInclusionDirectiveParser(inclusion_directive_name) path_arg = pathlib.PurePosixPath('first') / 'second' inclusion_directive_line = inclusion_directive_name + ' ' + str( path_arg) source = source_of_lines([ inclusion_directive_line, 'second line', ]) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # expected_directive = is_file_inclusion_directive( matches_file_inclusion_directive( files_to_include=asrt.matches_sequence([ asrt.equals(pathlib.Path(path_arg)), ]), source=matches_line_sequence( first_line_number=asrt.equals(1), lines=asrt.matches_sequence( [asrt.equals(inclusion_directive_line)])))) expected_directive.apply_with_message(self, actual, 'parsed directive') expected_source = is_at_beginning_of_line(2) expected_source.apply_with_message(self, source, 'source')
def test_file__rel_home(self): accepted_relativity_options = [ rel_opt_conf.conf_rel_any(RelOptionType.REL_HOME_CASE), rel_opt_conf.default_conf_rel_any(RelOptionType.REL_HOME_CASE), rel_opt_conf.symbol_conf_rel_any( RelOptionType.REL_HOME_CASE, 'SYMBOL', sut.RELATIVITY_OPTIONS_CONFIGURATION.options.accepted_relativity_variants), ] for rel_opt in accepted_relativity_options: with self.subTest(option_string=rel_opt.option_argument): self._run(assignment_of('{file_option} {relativity_option} file.txt'.format( file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION), relativity_option=rel_opt.option_argument), ['following line']), Arrangement( hds_contents=case_home_dir_contents( DirContents([empty_file('file.txt')])), symbols=rel_opt.symbols.in_arrangement(), ), Expectation( settings_builder=AssertStdinFileIsSetToFile( file_refs.of_rel_option(RelOptionType.REL_HOME_CASE, file_refs.constant_path_part('file.txt'))), symbol_usages=rel_opt.symbols.usages_expectation(), source=is_at_beginning_of_line(2)), )
def test_with_symbol_references(self): symbol1 = NameAndValue('symbol_1_name', 'symbol 1 value') line_with_sym_ref_template = 'before symbol {symbol} after symbol' source = remaining_source_lines(['<<MARKER', line_with_sym_ref_template.format( symbol=symbol_reference_syntax_for_name(symbol1.name)), 'MARKER', 'Line 4', ] ) expectation = ExpectedHereDoc( resolved_here_doc_lines=[ line_with_sym_ref_template.format( symbol=symbol1.value) ], common=CommonExpectation( symbol_references=[ references.reference_to_any_data_type_value(symbol1.name), ], symbol_table=symbol_table_with_string_values_from_name_and_value([ symbol1, ]), source=asrt_source.is_at_beginning_of_line(4), ) ) _expect_here_doc(self, source, expectation)
def test_assignment_of_list_with_symbol_references(self): symbol_name = 'the_symbol_name' referred_symbol = SymbolWithReferenceSyntax('referred_symbol') source = remaining_source(src( '{list_type} {symbol_name} = {symbol_reference} ', symbol_name=symbol_name, symbol_reference=referred_symbol, ), ['following line'], ) expected_symbol_reference = references.reference_to_any_data_type_value(referred_symbol.name) expected_resolver = lrs.from_elements([lrs.symbol_element(expected_symbol_reference)]) expected_resolver_container = container(expected_resolver) expectation = Expectation( symbol_usages=asrt.matches_sequence([ vs_asrt.equals_symbol(SymbolDefinition(symbol_name, expected_resolver_container), ignore_source_line=True) ]), symbols_after_main=assert_symbol_table_is_singleton( symbol_name, equals_container(expected_resolver_container), ), source=asrt_source.is_at_beginning_of_line(2), ) self._check(source, ArrangementWithSds(), expectation)
def test_assignment_of_single_constant_line(self): value_str = 'value' symbol_name = 'name1' sb = SB.new_with(value_str=value_str, symbol_name=symbol_name) source = sb.lines( here_doc_lines(first_line_start='{string_type} {symbol_name} = ', marker='EOF', contents_lines=['{value_str}']) + ['following line'] ) # EXPECTATION # expected_symbol = StringConstantSymbolContext(symbol_name, value_str + '\n') expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ expected_symbol.assert_matches_definition_of_sdv ]), symbols_after_main=assert_symbol_table_is_singleton( symbol_name, expected_symbol.value.assert_matches_container_of_sdv, ), source=asrt_source.is_at_beginning_of_line(4) ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
def test_assignment_of_empty_list(self): symbol_name = 'the_symbol_name' sb = SB.new_with(symbol_name=symbol_name) cases = [ SourceCase('No following lines', source=sb.single_line('{list_type} {symbol_name} = '), source_assertion=asrt_source.source_is_at_end ), SourceCase('Following lines', source=sb.lines(['{list_type} {symbol_name} = ', 'following line'], ), source_assertion=asrt_source.is_at_beginning_of_line(2) ), ] expected_resolver = lrs.empty() expected_resolver_container = container(expected_resolver) for case in cases: with self.subTest(case.name): expectation = Expectation( symbol_usages=asrt.matches_sequence([ vs_asrt.equals_symbol(SymbolDefinition(symbol_name, expected_resolver_container), ignore_source_line=True) ]), symbols_after_main=assert_symbol_table_is_singleton( symbol_name, equals_container(expected_resolver_container), ), source=case.source_assertion ) self._check(case.source, ArrangementWithSds(), expectation)
def runTest(self): expected_content_line_template = 'expected content line, with {symbol} ref' def expected_content(symbol_content: str) -> str: return expected_content_line_template.format(symbol=symbol_content) symbol = NameAndValue('symbol_name', 'the symbol value') self._check( self.configuration.source_for( args('{maybe_not} {equals} <<EOF', maybe_not=self.maybe_not.nothing__if_positive__not_option__if_negative), [expected_content(symbol_reference_syntax_for_name(symbol.name)), 'EOF', 'following line']), self.configuration.arrangement_for_contents( lines_content([expected_content(symbol.value)]), post_sds_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=SymbolTable({ symbol.name: data_symbol_utils.string_constant_container(symbol.value), })), Expectation(main_result=self.maybe_not.pass__if_positive__fail__if_negative, symbol_usages=equals_symbol_references([ SymbolReference(symbol.name, is_any_data_type()) ]), source=is_at_beginning_of_line(4)), )
def test_path_argument_SHOULD_use_posix_syntax(self): # ARRANGE # inclusion_directive_name = 'incl-directive' parser = sut.FileInclusionDirectiveParser(inclusion_directive_name) path_arg = pathlib.PurePosixPath('first') / 'second' inclusion_directive_line = inclusion_directive_name + ' ' + str(path_arg) source = source_of_lines([ inclusion_directive_line, 'second line', ]) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # expected_directive = is_file_inclusion_directive( matches_file_inclusion_directive( files_to_include=asrt.matches_sequence([ asrt.equals(pathlib.Path(path_arg)), ]), source=matches_line_sequence( first_line_number=asrt.equals(1), lines=asrt.matches_sequence([ asrt.equals(inclusion_directive_line) ])) )) expected_directive.apply_with_message(self, actual, 'parsed directive') expected_source = is_at_beginning_of_line(2) expected_source.apply_with_message(self, source, 'source')
def test_doc_without_symbol_references(self): content_line_of_here_doc = 'content line of here doc' self._run(assignment_of(' <<MARKER ', [content_line_of_here_doc, 'MARKER', 'following line']), Arrangement(), Expectation( settings_builder=AssertStdinIsSetToContents( string_resolvers.str_constant(hd.contents_str_from_lines([content_line_of_here_doc])), ), source=is_at_beginning_of_line(4)), )
def runTest(self): self._check( self.configuration.source_for( args('{maybe_not} {equals} <<EOF', maybe_not=self.maybe_not.nothing__if_positive__not_option__if_negative), ['expected content line', 'EOF', 'the following line']), self.configuration.arrangement_for_contents( lines_content(['actual contents that is not equal to expected contents']), post_sds_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY), Expectation(main_result=self.maybe_not.fail__if_positive__pass_if_negative, source=is_at_beginning_of_line(4)), )
def test_not_last_line(self): expected_file = fs.empty_file('a-file-name.txt') self._check( remaining_source( '{file_name}'.format(file_name=expected_file.file_name), ['following line']), ArrangementWithSds( pre_contents_population_action=SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR, ), Expectation( main_result=IS_SUCCESS, source=is_at_beginning_of_line(2), ), )
def test_without_symbol_references(self): expected_contents_line = 'contents' source = remaining_source_lines(['<<MARKER', expected_contents_line, 'MARKER', 'Line 4', ]) expectation = ExpectedHereDoc( resolved_here_doc_lines=[expected_contents_line], common=CommonExpectation( symbol_references=[], source=asrt_source.is_at_beginning_of_line(4)) ) _expect_here_doc(self, source, expectation)
def runTest(self): expected_contents = 'expected contents' self._check( self.configuration.source_for( args('{maybe_not} {equals} {expected_contents} ', expected_contents=surrounded_by_hard_quotes_str(expected_contents), maybe_not=self.maybe_not.nothing__if_positive__not_option__if_negative), ['following line'] ), self.configuration.arrangement_for_contents( expected_contents, post_sds_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY), Expectation(main_result=self.maybe_not.pass__if_positive__fail__if_negative, source=asrt_source.is_at_beginning_of_line(2)), )
def test_WHEN_source_does_not_start_with_directive_name_THEN_return_value_SHOULD_be_none(self): # ARRANGE # inclusion_directive_name = 'the-directive' parser = sut.FileInclusionDirectiveParser(inclusion_directive_name) source = source_of_lines([ inclusion_directive_name + 'non-space arg', 'second line', ]) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # self.assertIsNone(actual, 'return value') expected_source = is_at_beginning_of_line(1) expected_source.apply_with_message(self, source, 'source')
def test_WHEN_source_does_not_start_with_directive_name_THEN_return_value_SHOULD_be_none( self): # ARRANGE # inclusion_directive_name = 'the-directive' parser = sut.FileInclusionDirectiveParser(inclusion_directive_name) source = source_of_lines([ inclusion_directive_name + 'non-space arg', 'second line', ]) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # self.assertIsNone(actual, 'return value') expected_source = is_at_beginning_of_line(1) expected_source.apply_with_message(self, source, 'source')
def test_with_symbol_references(self): symbol_1_name = 'symbol_1_name' symbol_2_name = 'symbol_2_name' test_cases = [ CaseWithSymbols( 'two argument form with a symbol that is a single integer', argument=' {op} {sym_ref}'.format(op=comparators.EQ.name, sym_ref=symbol_reference_syntax_for_name(symbol_1_name)), symbol_name_and_value_list=[NameAndValue(symbol_1_name, '72')], actual_value_for_pass=72, actual_value_for_fail=87, ), CaseWithSymbols( 'two argument form with two symbols that makes up the expected value when concatenated', argument=' {op} {sym_ref1}{sym_ref2}'.format( op=comparators.EQ.name, sym_ref1=symbol_reference_syntax_for_name(symbol_1_name), sym_ref2=symbol_reference_syntax_for_name(symbol_2_name)), symbol_name_and_value_list=[NameAndValue(symbol_1_name, '7'), NameAndValue(symbol_2_name, '2')], actual_value_for_pass=72, actual_value_for_fail=87, ), ] for case in test_cases: for sub_name, actual_value, result_expectation in [('pass', case.actual_value_for_pass, pfh_assertions.is_pass()), ('fail', case.actual_value_for_fail, pfh_assertions.is_fail())]: with self.subTest(name=case.name, sub_name=sub_name): self._run( remaining_source(case.argument, ['following line']), ArrangementPostAct( act_result_producer=act_result_of(actual_value), symbols=symbol_table_with_string_constant_symbols(case.symbol_name_and_value_list), ), Expectation( source=is_at_beginning_of_line(2), main_result=result_expectation, symbol_usages=equals_symbol_references( string_symbol_references_of(case.symbol_name_and_value_list)) ), )
def test_not_last_line__contents(self): hd_args = here_document_contents_arguments([]).as_arguments self._check( remaining_source( '{file_name} {hd_args}'.format( file_name='a-file-name.txt', hd_args=hd_args.first_line, ), hd_args.following_lines + ['following line']), ArrangementWithSds( pre_contents_population_action=SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR, ), Expectation( main_result=IS_SUCCESS, source=is_at_beginning_of_line(3), ), )
def test_assignment_of_program_without_arguments(self): python_source = 'exit(72)' resolver_of_referred_program = program_resolvers.for_py_source_on_command_line(python_source) name_of_defined_symbol = 'the_symbol' referred_symbol = NameAndValue( 'PRE_EXISTING_PROGRAM_SYMBOL', resolver_of_referred_program ) symbols = SymbolTable({ referred_symbol.name: symbol_utils.container(referred_symbol.value) }) program = pgm_args.symbol_ref_command_line(sym_ref_args.sym_ref_cmd_line( referred_symbol.name)) source = multi_line_source('{program_type} {defined_symbol} = {program}', ['following line'], defined_symbol=name_of_defined_symbol, program=program) expected_symbol_container = asrt_rs.matches_container( assertion_on_resolver=asrt_resolver.matches_resolver_of_program( references=asrt.matches_sequence([ is_program_reference_to(referred_symbol.name) ]), resolved_program_value=asrt_dir_dep_val.matches_multi_dir_dependent_value( DirDependencies.NONE, lambda tcds: matches_py_source_on_cmd_line_program(python_source)), symbols=symbols )) expectation = Expectation( source=asrt_source.is_at_beginning_of_line(2), symbol_usages=asrt.matches_sequence([ asrt_sym_usage.matches_definition( name=asrt.equals(name_of_defined_symbol), container=expected_symbol_container) ]), symbols_after_main=assert_symbol_table_is_singleton( expected_name=name_of_defined_symbol, value_assertion=expected_symbol_container, ) ) self._check(source, ArrangementWithSds(), expectation)
def test_element_from_first_parser_that_returns_an_element_SHOULD_be_returned(self): # ARRANGE # source_lines = ['first line', 'second line'] expected_returned_element = ParsedNonInstructionElement(single_line_sequence(1, 'expected'), ElementType.EMPTY) unexpected_returned_element = ParsedNonInstructionElement(single_line_sequence(1, 'unexpected'), ElementType.EMPTY) cases = [ NameAndValue('single successful parser', [ SectionElementParserThatReturnsConstantAndConsumesCurrentLine(expected_returned_element), ]) , NameAndValue('more than one successful parser', [ SectionElementParserThatReturnsConstantAndConsumesCurrentLine(expected_returned_element), SectionElementParserThatReturnsConstantAndConsumesCurrentLine(unexpected_returned_element), ] ), NameAndValue('first parser is unsuccessful - returns None', [ SectionElementParserThatReturnsNone(), SectionElementParserThatReturnsConstantAndConsumesCurrentLine(expected_returned_element), ] ), NameAndValue('first parser is unsuccessful - throws unrecognized element', [ SectionElementParserThatRaisesUnrecognizedSectionElementSourceError(), SectionElementParserThatReturnsConstantAndConsumesCurrentLine(expected_returned_element), ] ), ] for case in cases: with self.subTest(case.name): source = source_of_lines(source_lines) parser = sut.ParserFromSequenceOfParsers(case.value) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # self.assertIs(expected_returned_element, actual, 'return value from parser') expected_source = asrt_source.is_at_beginning_of_line(2) expected_source.apply_with_message(self, source, 'source')
def test_assignment_of_list_with_multiple_constant_elements(self): symbol_name = 'the_symbol_name' value_without_space = 'value_without_space' value_with_space = 'value with space' expected_resolver = lrs.from_str_constants([value_without_space, value_with_space]) expected_resolver_container = container(expected_resolver) sb = SB.new_with(symbol_name=symbol_name, value_without_space=value_without_space, value_with_space=value_with_space) cases = [ SourceCase('No following lines', source=sb.single_line( '{list_type} {symbol_name} = ' '{value_without_space} {soft_quote}{value_with_space}{soft_quote} '), source_assertion=asrt_source.source_is_at_end ), SourceCase('Following lines', source=sb.lines( [ '{list_type} {symbol_name} = ' '{value_without_space} {soft_quote}{value_with_space}{soft_quote}', 'following line', ]), source_assertion=asrt_source.is_at_beginning_of_line(2) ), ] for case in cases: with self.subTest(case.name): expectation = Expectation( symbol_usages=asrt.matches_sequence([ vs_asrt.equals_symbol(SymbolDefinition(symbol_name, expected_resolver_container), ignore_source_line=True) ]), symbols_after_main=assert_symbol_table_is_singleton( symbol_name, equals_container(expected_resolver_container), ), source=case.source_assertion, ) self._check(case.source, ArrangementWithSds(), expectation)
def test_element_from_first_parser_that_returns_an_element_SHOULD_be_returned( self): # ARRANGE # source_lines = ['first line', 'second line'] expected_returned_element = ParsedNonInstructionElement( single_line_sequence(1, 'expected'), ElementType.EMPTY) unexpected_returned_element = ParsedNonInstructionElement( single_line_sequence(1, 'unexpected'), ElementType.EMPTY) cases = [ NameAndValue('single successful parser', [ SectionElementParserThatReturnsConstantAndConsumesCurrentLine( expected_returned_element), ]), NameAndValue('more than one successful parser', [ SectionElementParserThatReturnsConstantAndConsumesCurrentLine( expected_returned_element), SectionElementParserThatReturnsConstantAndConsumesCurrentLine( unexpected_returned_element), ]), NameAndValue('first parser is unsuccessful - returns None', [ SectionElementParserThatReturnsNone(), SectionElementParserThatReturnsConstantAndConsumesCurrentLine( expected_returned_element), ]), NameAndValue( 'first parser is unsuccessful - throws unrecognized element', [ SectionElementParserThatRaisesUnrecognizedSectionElementSourceError( ), SectionElementParserThatReturnsConstantAndConsumesCurrentLine( expected_returned_element), ]), ] for case in cases: with self.subTest(case.name): source = source_of_lines(source_lines) parser = sut.ParserFromSequenceOfParsers(case.value) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # self.assertIs(expected_returned_element, actual, 'return value from parser') expected_source = asrt_source.is_at_beginning_of_line(2) expected_source.apply_with_message(self, source, 'source')
def test_valid_syntax_of_inclusion_directive(self): # ARRANGE # inclusion_directive_name = 'incl-directive' parser = sut.FileInclusionDirectiveParser(inclusion_directive_name) file_name = 'the-file-name' cases = [ NameAndValue('simple inclusion', inclusion_directive_name + ' ' + file_name, ), NameAndValue('some superfluous space around path argument', inclusion_directive_name + ' ' + file_name + ' ', ), ] for case in cases: with self.subTest(case.name): source = source_of_lines([ case.value, 'second line', ]) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # expected_directive = is_file_inclusion_directive( matches_file_inclusion_directive( files_to_include=asrt.matches_sequence([ asrt.equals(pathlib.Path(file_name)), ]), source=matches_line_sequence( first_line_number=asrt.equals(1), lines=asrt.matches_sequence([ asrt.equals(case.value) ])) )) expected_directive.apply_with_message(self, actual, 'parsed directive') expected_source = is_at_beginning_of_line(2) expected_source.apply_with_message(self, source, 'source')
def test_valid_syntax_of_inclusion_directive(self): # ARRANGE # inclusion_directive_name = 'incl-directive' parser = sut.FileInclusionDirectiveParser(inclusion_directive_name) file_name = 'the-file-name' cases = [ NameAndValue( 'simple inclusion', inclusion_directive_name + ' ' + file_name, ), NameAndValue( 'some superfluous space around path argument', inclusion_directive_name + ' ' + file_name + ' ', ), ] for case in cases: with self.subTest(case.name): source = source_of_lines([ case.value, 'second line', ]) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # expected_directive = is_file_inclusion_directive( matches_file_inclusion_directive( files_to_include=asrt.matches_sequence([ asrt.equals(pathlib.Path(file_name)), ]), source=matches_line_sequence( first_line_number=asrt.equals(1), lines=asrt.matches_sequence( [asrt.equals(case.value)])))) expected_directive.apply_with_message(self, actual, 'parsed directive') expected_source = is_at_beginning_of_line(2) expected_source.apply_with_message(self, source, 'source')
def test_negative(self): cases = [ SourceCase('Dir on 1st line, Negation and DIR-CONTENTS-MATCHER on 2nd line', source=remaining_source_lines([ DIR_TO_CHECK, instruction_arguments.NEGATION_ARGUMENT_STR + ' ' + EMPTINESS_CHECK_ARGUMENT, ]), source_assertion=asrt_source.source_is_at_end ), SourceCase('Dir on 1st line, Negation and DIR-CONTENTS-MATCHER on 2nd line, followed by non-instr lines', source=remaining_source_lines([ DIR_TO_CHECK, instruction_arguments.NEGATION_ARGUMENT_STR, EMPTINESS_CHECK_ARGUMENT, '', 'following line', ]), source_assertion=asrt_source.is_at_beginning_of_line(4) ), ] for case in cases: self._check_sub_test(case, PassOrFailOrHardErrorEnum.FAIL)
def test_doc_with_symbol_references(self): content_line_of_here_doc_template = 'content line of here doc with {symbol}' here_doc_contents_template = hd.contents_str_from_lines([content_line_of_here_doc_template]) symbol_name = 'symbol_name' symbol = NameAndValue('symbol_name', 'the symbol value') expected_symbol_references = [ SymbolReference(symbol.name, is_any_data_type()) ] cases = [ ('string value container', data_symbol_utils.string_constant_container('string symbol value')), ('file ref value container', data_symbol_utils.file_ref_constant_container( file_refs.rel_act(file_refs.constant_path_part('file-name.txt')))), ] for case in cases: with self.subTest(case[0]): self._run(assignment_of(' <<MARKER ', [content_line_of_here_doc_template.format( symbol=symbol_reference_syntax_for_name(symbol_name)), 'MARKER', 'following line']), Arrangement( symbols=SymbolTable({ symbol_name: case[1] }) ), Expectation( settings_builder=AssertStdinIsSetToContents( parse_string.string_resolver_from_string( here_doc_contents_template.format( symbol=symbol_reference_syntax_for_name(symbol_name)))), symbol_usages=equals_symbol_references(expected_symbol_references), source=is_at_beginning_of_line(4)), )
def test_successful_parse_of_sequence(self): # ARRANGE # regex_str = 'the_regex' replacement_str = 'the_replacement' symbol = NameAndValue('the_symbol_name', transformers.CustomStringTransformerTestImpl()) replace_transformer_syntax = argument_syntax.syntax_for_replace_transformer(regex_str, replacement_str) defined_name = 'defined_name' cases = [ SourceCase('Expression on single line', source= remaining_source( src('{lines_trans_type} {defined_name} = {transformer_argument}', defined_name=defined_name, transformer_argument=argument_syntax.syntax_for_sequence_of_transformers([ symbol.name, replace_transformer_syntax, ])), following_lines=['following line'], ), source_assertion=asrt_source.is_at_beginning_of_line(2) ), SourceCase('1st expr on first line followed by operator, 2nd expr on next line', source= remaining_source( src('{lines_trans_type} {defined_name} = {symbol_name} {sequence_operator}', defined_name=defined_name, symbol_name=symbol.name, sequence_operator=SEQUENCE_OPERATOR_NAME), following_lines=[replace_transformer_syntax], ), source_assertion=asrt_source.source_is_at_end ), SourceCase('1st expr on first line followed by operator, 2nd expr on next line, non-exr on 3rd line', source= remaining_source( src('{lines_trans_type} {defined_name} = {symbol_name} {sequence_operator}', defined_name=defined_name, symbol_name=symbol.name, sequence_operator=SEQUENCE_OPERATOR_NAME), following_lines=[replace_transformer_syntax, 'following line'], ), source_assertion=asrt_source.is_at_beginning_of_line(3) ), ] # EXPECTATION # the_sequence_transformer = SequenceStringTransformer([ symbol.value, transformers.replace_transformer(regex_str, replacement_str), ]) expected_container = matches_container( assertion_on_resolver= resolved_value_equals_string_transformer( the_sequence_transformer, references=asrt.matches_sequence([ is_reference_to_string_transformer(symbol.name), ]), symbols=SymbolTable({ symbol.name: container(StringTransformerConstant(symbol.value)), }), ) ) for source_case in cases: with self.subTest(source_case.name): expectation = Expectation( symbol_usages=asrt.matches_sequence([ asrt_sym_usage.matches_definition(asrt.equals(defined_name), expected_container) ]), symbols_after_main=assert_symbol_table_is_singleton( defined_name, expected_container, ), source=source_case.source_assertion ) # ACT & ASSERT # self._check(source_case.source, ArrangementWithSds(), expectation)
def test_fail_due_to_unexpected_source_after_parse(self): with self.assertRaises(utils.TestError): self._check( utils.ParserThatGives(_SUCCESSFUL_INSTRUCTION), utils.single_line_source(), sut.ArrangementPostAct(), Expectation(source=asrt_source.is_at_beginning_of_line(10), ))
def test_successful_parse_of_sequence(self): # ARRANGE # regex_str = 'the_regex' replacement_str = 'the_replacement' symbol = StringTransformerSymbolContext.of_primitive( 'the_symbol_name', string_transformers.must_not_be_used() ) replace_transformer_syntax = argument_syntax.syntax_for_replace_transformer(regex_str, replacement_str) defined_name = 'defined_name' cases = [ SourceCase('Expression on single line', source= remaining_source( src2(ValueType.STRING_TRANSFORMER, defined_name, argument_syntax.syntax_for_sequence_of_transformers([ symbol.name, replace_transformer_syntax, ])), following_lines=['following line'], ), source_assertion=asrt_source.is_at_beginning_of_line(2) ), SourceCase('Expression on following line', source= remaining_source( src2(ValueType.STRING_TRANSFORMER, defined_name, '{new_line} {transformer_argument}', transformer_argument=argument_syntax.syntax_for_sequence_of_transformers([ symbol.name, replace_transformer_syntax, ])), following_lines=['following line'], ), source_assertion=asrt_source.is_at_beginning_of_line(3) ), SourceCase('1st expr on first line followed by operator, 2nd expr on next line', source= remaining_source( src2(ValueType.STRING_TRANSFORMER, defined_name, '{the_symbol_name} {sequence_operator}', the_symbol_name=symbol.name, sequence_operator=SEQUENCE_OPERATOR_NAME), following_lines=[replace_transformer_syntax], ), source_assertion=asrt_source.source_is_at_end ), SourceCase('1st expr on first line followed by operator, 2nd expr on next line, non-exr on 3rd line', source= remaining_source( src2(ValueType.STRING_TRANSFORMER, defined_name, '{the_symbol_name} {sequence_operator}', the_symbol_name=symbol.name, sequence_operator=SEQUENCE_OPERATOR_NAME), following_lines=[replace_transformer_syntax, 'following line'], ), source_assertion=asrt_source.is_at_beginning_of_line(3) ), ] # EXPECTATION # expected_container = matches_container( asrt.equals(ValueType.STRING_TRANSFORMER), sdv=matches_sdv_of_string_transformer_constant( references=asrt.matches_sequence([ is_reference_to_string_transformer(symbol.name), ]), primitive_value=asrt_string_transformer.is_identity_transformer(False), symbols=symbol.symbol_table, ) ) for source_case in cases: with self.subTest(source_case.name): expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ asrt_sym_usage.matches_definition(asrt.equals(defined_name), expected_container) ]), symbols_after_main=assert_symbol_table_is_singleton( defined_name, expected_container, ), source=source_case.source_assertion ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source_case.source, Arrangement.phase_agnostic(), expectation)