def test_not_equals(self): location1 = SourceLocation(self.line_sequence_1, self.path_a) location2 = SourceLocation(self.line_sequence_2, self.path_b) cases = [ NEA( 'without inclusion chain/different location', expected=source_location_path_without_inclusions(location1), actual=source_location_path_without_inclusions(location2), ), NEA( 'with inclusion chain/different location', expected=SourceLocationPath(location1, [location1]), actual=SourceLocationPath(location2, [location1]), ), NEA( 'different inclusion chain / different size', expected=SourceLocationPath(location1, [location1]), actual=SourceLocationPath(location1, []), ), NEA( 'different inclusion chain / different contents', expected=SourceLocationPath(location1, [location1]), actual=SourceLocationPath(location1, [location2]), ), ] for nea in cases: with self.subTest(nea.name): assertion = sut.equals_source_location_path(nea.expected) # ACT & ASSERT # assert_that_assertion_fails(assertion, nea.actual)
class ReferencedInclusionDirectiveFileInIncludedFileDoesNotExist( check_exception.Setup): file_1_invalid_inclusion_line = ' '.join( [INCLUDING_DIRECTIVE_INFO.singular_name, 'does-not-exist.txt']) file_1 = File('1.xly', lines_content([file_1_invalid_inclusion_line])) root_suite_inclusion_line = ' '.join( [INCLUDING_DIRECTIVE_INFO.singular_name, file_1.name]) inclusion_line_in_file_1 = single_line_sequence( 1, file_1_invalid_inclusion_line) root_suite_file = File( '0.suite', lines_content([ phase_names.CLEANUP.syntax, root_suite_inclusion_line, ])) inclusion_line_in_root_file = single_line_sequence( 2, root_suite_inclusion_line) expected_source_location_path = SourceLocationPath( SourceLocation( inclusion_line_in_file_1, file_1.name_as_path, ), [ SourceLocation( inclusion_line_in_root_file, root_suite_file.name_as_path, ) ]) def root_suite_based_at(self, root_path: pathlib.Path) -> pathlib.Path: return self.root_suite_file.name_as_path def file_structure_to_read(self) -> DirContents: return DirContents([self.root_suite_file, self.file_1]) def check_exception(self, root_path: pathlib.Path, actual: Exception, put: unittest.TestCase): put.assertIsInstance(actual, SuiteParseError) expectation = matches_suite_parse_error( suite_file=asrt.equals(self.root_suite_based_at(root_path)), maybe_section_name=asrt.equals(phase_names.CLEANUP.plain), source=equals_line_sequence(self.inclusion_line_in_file_1), source_location=equals_source_location_path( self.expected_source_location_path), document_parser_exception=asrt.is_instance( sec_doc_exceptions.FileAccessError), ) expectation.apply(put, actual)
def test_element_parser_SHOULD_be_able_to_report_syntax_error_by_returning_None(self): # ARRANGE # section_name = 'section-name' unknown_section_name = 'unknown-section-name' parser = new_parser_for( SectionsConfiguration([SectionConfiguration(section_name, SectionElementParserThatReturnsNone())], default_section_name=section_name)) unrecognized_line = 'unrecognized' cases = [ NEA('unrecognized source inside declared section', actual=[section_header(section_name), unrecognized_line, 'following line'], expected=matches_file_source_error( maybe_section_name=asrt.equals(section_name), location_path=[ SourceLocation(single_line_sequence(2, unrecognized_line), EXPECTED_SOURCE_FILE_PATH) ]) ), NEA('unrecognized source in default section', actual=[unrecognized_line, 'following line'], expected=matches_file_source_error( maybe_section_name=asrt.equals(section_name), location_path=[ SourceLocation(single_line_sequence(1, unrecognized_line), EXPECTED_SOURCE_FILE_PATH) ]) ), NEA('unrecognized section name', actual=[section_header(unknown_section_name), 'following line'], expected=matches_file_source_error( maybe_section_name=asrt.is_none, location_path=[ SourceLocation(single_line_sequence(1, section_header(unknown_section_name)), EXPECTED_SOURCE_FILE_PATH) ]) ), ] for nea in cases: with self.subTest(nea.name): with self.assertRaises(FileSourceError) as cm: # ACT & ASSERT # self._parse_lines(parser, nea.actual) nea.expected.apply_without_message(self, cm.exception)
def test_not_matches(self): # ARRANGE # expected_line_num = 2 expected_line_text = 'line text' expected_section_name = 'section name' expected_file_path = pathlib.Path('a path') expected_file_inclusion_chain = [ SourceLocation(single_line_sequence(2, 'inclusion line'), pathlib.Path('inclusion file path')) ] expected_abs_path_of_dir_containing_file = pathlib.Path( pathlib.Path.cwd().root) assertion = sut.equals_instruction_without_description( expected_line_num, expected_line_text, expected_section_name, expected_file_path, expected_file_inclusion_chain) cases = [ NameAndValue( 'unexpected line num', new_instruction(expected_line_num + 1, expected_line_text, expected_section_name, expected_file_path, expected_file_inclusion_chain)), NameAndValue( 'unexpected line text', new_instruction(expected_line_num, expected_line_text + ' unexpected', expected_section_name, expected_file_path, expected_file_inclusion_chain)), NameAndValue( 'unexpected section name', new_instruction(expected_line_num, expected_line_text, expected_section_name + ' unexpected', expected_file_path, expected_file_inclusion_chain)), NameAndValue( 'unexpected file path', new_instruction(expected_line_num, expected_line_text, expected_section_name, expected_file_path / 'unexpected', expected_file_inclusion_chain)), NameAndValue( 'unexpected abs path of dir containing file', new_instruction(expected_line_num, expected_line_text, expected_section_name, expected_file_path / 'unexpected', expected_file_inclusion_chain)), NameAndValue( 'unexpected file inclusion chain', new_instruction(expected_line_num, expected_line_text, expected_section_name, expected_file_path, [])), NameAndValue('unexpected element type - empty', new_empty(expected_line_num, expected_line_text)), NameAndValue('unexpected element type - comment', new_comment(expected_line_num, expected_line_text)), ] for nav in cases: with self.subTest(nav.name): # ACT & ASSERT # assert_that_assertion_fails(assertion, nav.value)
def test_assignment_of_single_constant_word(self): # ARRANGE # source = single_line_source('{string_type} name1 = v1') source_string = source.source_string parser = sut.EmbryoParser() the_file_path_rel_referrer = pathlib.Path('the-path-rel-referrer') the_file_location_info = FileLocationInfo( pathlib.Path.cwd(), the_file_path_rel_referrer, [ SourceLocation(LineSequence(10, ('line-in-inclusion-chain',)), pathlib.Path('the-path-rel-referrer-of-first-file')) ]) fs_location_info = FileSystemLocationInfo(the_file_location_info) # ACT # instruction = parser.parse(fs_location_info, source) # ASSERT # expected_source_location_path = SourceLocationPath( SourceLocation(single_line_sequence(1, source_string), the_file_path_rel_referrer), the_file_location_info.file_inclusion_chain, ) assertion = matches_source_location_info( abs_path_of_dir_containing_first_file_path=asrt.equals( the_file_location_info.abs_path_of_dir_containing_first_file_path), source_location_path=equals_source_location_path(expected_source_location_path) ) # ASSERT SANITY # assert 1 == len(instruction.symbol_usages), 'A single symbol should have been defined' symbol_definition = instruction.symbol_usages[0] assert isinstance(symbol_definition, SymbolDefinition) assertion.apply_without_message(self, symbol_definition.symbol_container.source_location)
def test_not_equals(self): cases = [ NEA( 'different path', SourceLocation(self.line_sequence_1, self.path_a), SourceLocation(self.line_sequence_1, self.path_b), ), NEA( 'different line sequence', SourceLocation(self.line_sequence_1, self.path_a), SourceLocation(self.line_sequence_2, self.path_a), ), ] for nea in cases: with self.subTest(nea.name): assertion = sut.equals_source_location(nea.expected) # ACT & ASSERT # assert_that_assertion_fails(assertion, nea.actual)
def test_equals(self): location1 = SourceLocation(self.line_sequence_1, self.path_a) location2 = SourceLocation(self.line_sequence_2, self.path_b) cases = [ NEA( 'without file inclusion chain', expected=source_location_path_without_inclusions(location1), actual=source_location_path_without_inclusions(location1), ), NEA( 'with file inclusion chain', expected=SourceLocationPath(location2, [location1]), actual=SourceLocationPath(location2, [location1]), ), ] for nea in cases: with self.subTest(nea.name): assertion = sut.equals_source_location_path(nea.expected) # ACT & ASSERT # assertion.apply_without_message(self, nea.actual)
def test_single_file_inclusion_chain_argument(self): # ARRANGE # file_inclusion_chain = [ SourceLocation(single_line_sequence(2, 'inclusion line'), pathlib.Path('inclusion file path')) ] self._test_all_element_types( sut.SectionContentElementBuilder( FileLocationInfo(pathlib.Path.cwd(), file_inclusion_chain=file_inclusion_chain)), assertion_on_file_path=asrt.is_none, assertion_on_file_inclusion_chain=equals_file_inclusion_chain( file_inclusion_chain))
def test_matches(self): # ARRANGE # expected_line_num = 1 expected_line_text = 'line text' expected_section_name = 'section name' expected_file_path = pathlib.Path('a path') expected_file_inclusion_chain = [ SourceLocation(single_line_sequence(2, 'inclusion line'), pathlib.Path('inclusion file path')) ] assertion = sut.equals_instruction_without_description( expected_line_num, expected_line_text, expected_section_name, expected_file_path, expected_file_inclusion_chain) actual = new_instruction(expected_line_num, expected_line_text, expected_section_name, expected_file_path, expected_file_inclusion_chain) # ACT & ASSERT # assertion.apply_without_message(self, actual)
def check_exception(self, root_path: pathlib.Path, actual: Exception, put: unittest.TestCase): put.assertIsInstance(actual, SuiteParseError) expected_source = single_line_sequence(1, '[invalid-section]') expectation = matches_suite_parse_error( suite_file=asrt.equals(self.root_suite_based_at(root_path)), maybe_section_name=asrt.is_none, source=equals_line_sequence(expected_source), source_location=equals_source_location_path( SourceLocationPath( SourceLocation( expected_source, Path('main.suite'), ), [])), document_parser_exception=asrt.is_instance( sec_doc_exceptions.FileSourceError), ) expectation.apply(put, actual)
def check_exception(self, root_path: pathlib.Path, actual: Exception, put: unittest.TestCase): put.assertIsInstance(actual, SuiteParseError) expected_source = single_line_sequence(2, self.file_inclusion_line) expectation = matches_suite_parse_error( suite_file=asrt.equals(self.root_suite_based_at(root_path)), maybe_section_name=asrt.equals(phase_names.SETUP.plain), source=equals_line_sequence(expected_source), source_location=equals_source_location_path( SourceLocationPath( SourceLocation( expected_source, self.root_suite_file, ), [])), document_parser_exception=asrt.is_instance( sec_doc_exceptions.FileAccessError), ) expectation.apply(put, actual)
def test_with_source(self): # ARRANGE # section_name = 'section-name' line_sequence_a = LineSequence(2, ['source a 1', 'source a 2']) file_path_a = pathlib.Path('file-a.src') minor_blocks_expectation = asrt.matches_sequence([ _matches_plain_minor_block_w_single_plain_line( section_line(section_name)), _matches_plain_minor_block_w_single_plain_line( file_and_line_num_line(file_path_a, line_sequence_a)), matches_source_code_minor_block(line_sequence_a.lines), ]) input_value = SourceLocationPath(location=SourceLocation( line_sequence_a, file_path_a), file_inclusion_chain=[]) with self.subTest(blocks_rendering='minor blocks'): # ACT # actual_renderer = source_location.location_minor_blocks_renderer( input_value, section_name, None) actual = actual_renderer.render_sequence() # ASSERT # minor_blocks_expectation.apply_without_message(self, actual) with self.subTest(blocks_rendering='major blocks'): expected_major_blocks = asrt.matches_sequence([ asrt_struct.matches_major_block__w_plain_properties( minor_blocks=minor_blocks_expectation) ]) # ACT # actual_renderer = source_location.location_blocks_renderer( input_value, section_name, None) actual = actual_renderer.render_sequence() # ASSERT # expected_major_blocks.apply_without_message(self, actual)
def test_with_file_inclusion_chain(self): # ARRANGE # final_loc_ls = single_line_sequence(0, 'line sequence 0') final_loc_dir = Path('final-loc-dir') final_loc_base_name = Path('final-loc-base-name') final_location = SourceLocation(final_loc_ls, final_loc_dir / final_loc_base_name) ls1 = single_line_sequence(1, 'line sequence 1') ls2 = single_line_sequence(2, 'line sequence 2') referrer_location_sub_dir = Path('referrer-location-sub-dir') link_sub_dir = Path('link-sub-dir') link_sub_dir2 = Path('link-sub-dir-2') base_name = Path('base-name') base_name2 = Path('base-name-2') cases = [ NIE('single link. referrer location is HERE, file_path_rel_referrer/inclusion=None', expected_value=[ ( [sut.line_number(ls1.first_line_number)] + expected_source_line_lines(ls1.lines) + expected_path_lines( final_loc_dir / final_loc_base_name, final_loc_ls.first_line_number) ), expected_source_line_lines(final_loc_ls.lines) ], input_value=SourceLocationPathInput( referrer_location=Path('.'), source_location_path=SourceLocationPath( final_location, [ SourceLocation( source=ls1, file_path_rel_referrer=None ) ]) ), ), NIE('multiple links. referrer location is sub-dir, file_path_rel_referrer in sub dir', expected_value=[ (expected_path_lines( referrer_location_sub_dir / link_sub_dir / base_name, ls1.first_line_number) + expected_source_line_lines(ls1.lines) + expected_path_lines( referrer_location_sub_dir / link_sub_dir / link_sub_dir2 / base_name2, ls2.first_line_number) + expected_source_line_lines(ls2.lines) + expected_path_lines( referrer_location_sub_dir / link_sub_dir / link_sub_dir2 / final_loc_dir / final_loc_base_name, final_loc_ls.first_line_number) ), expected_source_line_lines(final_loc_ls.lines) ], input_value=SourceLocationPathInput( referrer_location=referrer_location_sub_dir, source_location_path=SourceLocationPath( final_location, [ SourceLocation( source=ls1, file_path_rel_referrer=link_sub_dir / base_name, ), SourceLocation( source=ls2, file_path_rel_referrer=link_sub_dir2 / base_name2, ), ]) ), ), ] formatter = sut.default_formatter() for case in cases: with self.subTest(case.name): # ACT # blocks = formatter.source_location_path(case.input_value.referrer_location, case.input_value.source_location_path) # ASSERT # self.assertEqual(case.expected_value, blocks)
def _check_failing_line( self, configuration: sut.Configuration, phases: Sequence[Phase], invalid_line_cases: Sequence[NameAndValue[SourceAndStatus]]): proc_cases = [ NameAndValue( 'not allowed to pollute current process', sut.new_processor_that_should_not_pollute_current_process( configuration)), NameAndValue( 'allowed to pollute current process', sut.new_processor_that_is_allowed_to_pollute_current_process( configuration)), ] for phase in phases: for invalid_line_case in invalid_line_cases: source_and_status = invalid_line_case.value assert isinstance(source_and_status, SourceAndStatus) # Type info for IDE file_with_error = fs.file_with_lines('file-with-error.src', [ source_and_status.failing_source_line, ]) erroneous_line = single_line_sequence( 1, source_and_status.failing_source_line) test_case_file = fs.file_with_lines('test.case', [ section_header(phase.section_name), directive_for_inclusion_of_file(file_with_error.name), ]) line_that_includes_erroneous_file = single_line_sequence( 2, directive_for_inclusion_of_file(file_with_error.name)) cwd_contents = fs.DirContents( [test_case_file, file_with_error]) expected_source_location_path = SourceLocationPath( location=SourceLocation(erroneous_line, pathlib.Path( file_with_error.name)), file_inclusion_chain=[ SourceLocation(line_that_includes_erroneous_file, pathlib.Path(test_case_file.name)) ]) for proc_case in proc_cases: with self.subTest(phase=phase.section_name, proc=proc_case.name, line=erroneous_line.first_line): processor = proc_case.value assert isinstance(processor, Processor) with tmp_dir_as_cwd(cwd_contents): test_case_reference = test_case_reference_of_source_file( pathlib.Path(test_case_file.name)) # ACT # result = processor.apply(test_case_reference) # ASSERT # assert isinstance(result, Result) # Type info for IDE source_and_status.expected_result_statuses.apply_with_message( self, result, 'result statuses') source_location_path_expectation = equals_source_location_path( expected_source_location_path) source_location_path_expectation.apply_with_message( self, result.source_location_path, 'source location path')
def test_equals(self): assertion = sut.equals_source_location( SourceLocation(self.line_sequence_1, self.path_a)) # ACT & ASSERT # assertion.apply_without_message( self, SourceLocation(self.line_sequence_1, self.path_a))
from pathlib import Path from exactly_lib.section_document.source_location import SourceLocationPath, SourceLocation from exactly_lib.util.line_source import single_line_sequence SOURCE_LOCATION_PATH_WITH_INCLUSIONS_AND_FILE_NAMES = SourceLocationPath( SourceLocation(single_line_sequence(1, 'the line'), Path('src-file')), [ SourceLocation(single_line_sequence(2, 'the other line'), Path('other src-file')), ]) ARBITRARY_SOURCE_LOCATION_PATH = SourceLocationPath( SourceLocation(single_line_sequence(1, 'the line'), Path('src-file')), [])
from exactly_lib_test.section_document.test_resources import source_location_assertions as sut from exactly_lib_test.test_resources.test_of_test_resources_util import assert_that_assertion_fails from exactly_lib_test.test_resources.test_utils import NEA from exactly_lib_test.util.test_resources.line_source_assertions import ARBITRARY_LINE_SEQUENCE def suite() -> unittest.TestSuite: return unittest.TestSuite([ unittest.makeSuite(TestEqualsSourceLocation), unittest.makeSuite(TestEqualsSourceLocationPath), ]) ARBITRARY_SOURCE_LOCATION_INFO = sut.SourceLocationInfo( pathlib.Path('abs_path_of_dir_containing_first_file_path'), SourceLocationPath(SourceLocation(ARBITRARY_LINE_SEQUENCE, None), [])) class TestEqualsSourceLocation(unittest.TestCase): path_a = pathlib.Path('a') path_b = pathlib.Path('b') line_sequence_1 = LineSequence(1, ['line']) line_sequence_2 = LineSequence(2, ['line']) def test_not_equals(self): cases = [ NEA( 'different path', SourceLocation(self.line_sequence_1, self.path_a), SourceLocation(self.line_sequence_1, self.path_b),
def test_non_empty_chain(self): # ARRANGE # ls1 = single_line_sequence(1, 'line sequence 1') ls2 = single_line_sequence(2, 'line sequence 2') referrer_location_sub_dir = Path('referrer-location-sub-dir') link_sub_dir = Path('link-sub-dir') link_sub_dir2 = Path('link-sub-dir-2') base_name = Path('base-name') base_name2 = Path('base-name-2') cases = [ NIE('single link. referrer location is HERE, file_path_rel_referrer=None', expected_value=FileInclusionChainOutput( block=[sut.line_number(ls1.first_line_number)] + expected_source_line_lines(ls1.lines), next_referrer_location=Path('.'), ), input_value=FileInclusionChainInput( referrer_location=Path('.'), chain=[ SourceLocation( source=ls1, file_path_rel_referrer=None ) ] ), ), NIE('single link. referrer location is HERE, file_path_rel_referrer just base name', expected_value=FileInclusionChainOutput( block=expected_path_lines(base_name, ls1.first_line_number) + expected_source_line_lines(ls1.lines), next_referrer_location=Path('.'), ), input_value=FileInclusionChainInput( referrer_location=Path('.'), chain=[ SourceLocation( source=ls1, file_path_rel_referrer=base_name ) ] ), ), NIE('single link. referrer location is HERE, file_path_rel_referrer in sub dir', expected_value=FileInclusionChainOutput( block=expected_path_lines(link_sub_dir / base_name, ls1.first_line_number) + expected_source_line_lines(ls1.lines), next_referrer_location=link_sub_dir, ), input_value=FileInclusionChainInput( referrer_location=Path('.'), chain=[ SourceLocation( source=ls1, file_path_rel_referrer=link_sub_dir / base_name ) ] ), ), NIE('single link. referrer location is sub-dir, file_path_rel_referrer in sub dir', expected_value=FileInclusionChainOutput( block=expected_path_lines( referrer_location_sub_dir / link_sub_dir / base_name, ls1.first_line_number) + expected_source_line_lines(ls1.lines), next_referrer_location=referrer_location_sub_dir / link_sub_dir, ), input_value=FileInclusionChainInput( referrer_location=referrer_location_sub_dir, chain=[ SourceLocation( source=ls1, file_path_rel_referrer=link_sub_dir / base_name ) ] ), ), NIE('multiple links. referrer location is sub-dir, file_path_rel_referrer in sub dir', expected_value=FileInclusionChainOutput( block= (expected_path_lines( referrer_location_sub_dir / link_sub_dir / base_name, ls1.first_line_number) + expected_source_line_lines(ls1.lines) + expected_path_lines( referrer_location_sub_dir / link_sub_dir / link_sub_dir2 / base_name2, ls2.first_line_number) + expected_source_line_lines(ls2.lines) ), next_referrer_location=referrer_location_sub_dir / link_sub_dir / link_sub_dir2, ), input_value=FileInclusionChainInput( referrer_location=referrer_location_sub_dir, chain=[ SourceLocation( source=ls1, file_path_rel_referrer=link_sub_dir / base_name, ), SourceLocation( source=ls2, file_path_rel_referrer=link_sub_dir2 / base_name2, ), ] ), ), ] formatter = sut.default_formatter() for case in cases: with self.subTest(case.name): # ACT # block, referrer_location = formatter.file_inclusion_chain(case.input_value.referrer_location, case.input_value.chain) # ASSERT # self.assertEqual(case.expected_value.block, block, 'block') self.assertEqual(case.expected_value.next_referrer_location, referrer_location, 'referrer location')
def source_location(self) -> SourceLocationPath: return SourceLocationPath(SourceLocation(self.source, self.suite_file), [])