def test_references(self): reference_1 = TypeWithStrRenderingSymbolReference('symbol_1_name', is_any_type_w_str_rendering()) reference_2 = TypeWithStrRenderingSymbolReference('symbol_2_name', OrReferenceRestrictions([])) cases = [ ( 'no elements', sut.ListSdv([]), asrt.is_empty_sequence, ), ( 'single string constant element', sut.ListSdv([list_sdvs.str_element('string value')]), asrt.is_empty_sequence, ), ( 'multiple elements with multiple references', sut.ListSdv([ list_sdvs.symbol_element(reference_1.reference), list_sdvs.str_element('constant value'), list_sdvs.symbol_element(reference_2.reference), ]), asrt.matches_sequence([ reference_1.reference_assertion, reference_2.reference_assertion, ]), ), ] for test_name, list_sdv, expected_references_assertion in cases: with self.subTest(test_name=test_name): actual = list_sdv.references expected_references_assertion.apply_without_message(self, actual)
def test_references(self): string_constant_1 = 'string constant 1' reference_1 = TypeWithStrRenderingSymbolReference( 'symbol_1_name', is_any_type_w_str_rendering()) reference_2 = TypeWithStrRenderingSymbolReference( 'symbol_2_name', OrReferenceRestrictions([])) cases = [ ( 'no fragments', sut.StringSdv(()), asrt.is_empty_sequence, ), ( 'single string constant fragment', sut.StringSdv((impl.ConstantStringFragmentSdv(' value'), )), asrt.is_empty_sequence, ), ( 'multiple fragments of different types', sut.StringSdv(( impl.SymbolStringFragmentSdv(reference_1.reference), impl.ConstantStringFragmentSdv(string_constant_1), impl.SymbolStringFragmentSdv(reference_2.reference), )), asrt.matches_sequence([ reference_1.reference_assertion, reference_2.reference_assertion, ]), ), ] for test_name, string_sdv, expected_references_assertion in cases: with self.subTest(test_name=test_name): actual = string_sdv.references expected_references_assertion.apply_without_message( self, actual)
def test_symbol_usages_of_object_returned_by_parser_SHOULD_be_reported( self): # ARRANGE # symbol_reference = NameAndValue( 'symbol_name', reference_restrictions.is_any_type_w_str_rendering()) expected_symbol_references = [ SymbolReference(symbol_reference.name, symbol_reference.value) ] actor = sut.ActorFromParts( ParserWithConstantResult( SymbolUserWithConstantSymbolReferences( expected_symbol_references)), sut.UnconditionallySuccessfulValidatorConstructor(), _ExecutorConstructorForConstant( UnconditionallySuccessfulExecutor()), ) # ACT & ASSERT # check_execution( self, actor, [], arrangement_w_tcds(), Expectation(symbol_usages=asrt.matches_sequence([ asrt_sym_ref.matches_reference_2( symbol_reference.name, data_restrictions_assertions.equals__w_str_rendering( symbol_reference.value)) ])))
def string_sdv_from_fragments(fragments: Sequence[symbol_syntax.Fragment], reference_restrictions: Optional[ReferenceRestrictions] = None, ) -> StringSdv: if reference_restrictions is None: reference_restrictions = _reference_restrictions.is_any_type_w_str_rendering() return StringSdv(tuple([fragment_sdv_from_fragment(f, reference_restrictions) for f in fragments]))
def string_sdv_of_single_symbol_reference( symbol_name: str, restrictions: ReferenceRestrictions = reference_restrictions.is_any_type_w_str_rendering(), ) -> StringSdv: symbol_reference = SymbolReference(symbol_name, restrictions) fragments = [ string_sdvs.symbol_fragment(symbol_reference) ] return StringSdv(tuple(fragments))
def test_should_have_exactly_one_references(self): # ARRANGE # symbol_reference = TypeWithStrRenderingSymbolReference( 'the_symbol_name', is_any_type_w_str_rendering()) fragment = impl.SymbolStringFragmentSdv(symbol_reference.reference) # ACT # actual = list(fragment.references) # ASSERT # assertion = asrt.matches_singleton_sequence( symbol_reference.reference_assertion) assertion.apply_without_message(self, actual)
def test_file_path(self): relativity_test_cases = [ (RelOptionType.REL_HDS_CASE, True), (RelOptionType.REL_ACT, False), ] path_suffix_str = 'path-suffix-file.txt' path_suffix_test_cases = [ (path_part_sdvs.from_constant_str(path_suffix_str), ()), (path_part_sdvs.from_string( string_sdv_of_single_symbol_reference( 'path_suffix_symbol', reference_restrictions.is_any_type_w_str_rendering())), (StringConstantSymbolContext('path_suffix_symbol', path_suffix_str).entry, )), ] for rel_option, exists_pre_sds in relativity_test_cases: # ARRANGE # path_component_from_referenced_path = 'path-component-from-referenced-file-ref' referenced_sym = ConstantSuffixPathDdvSymbolContext( 'path_symbol', rel_option, path_component_from_referenced_path) for path_suffix, symbol_table_entries in path_suffix_test_cases: fr_sdv_to_check = sut.PathSdvRelSymbol( path_suffix, _symbol_reference_of_path_with_accepted( referenced_sym.name, rel_option)) symbol_table = referenced_sym.symbol_table symbol_table.add_all(symbol_table_entries) tcds = fake_tcds() expected_root_path = _root_path_of_option(rel_option, tcds) expected_path = expected_root_path / path_component_from_referenced_path / path_suffix_str expected_path_str = str(expected_path) environment = PathResolvingEnvironmentPreOrPostSds( tcds, symbol_table) with self.subTest(msg=str(rel_option)): # ACT # path_to_check = fr_sdv_to_check.resolve( environment.symbols) if exists_pre_sds: tested_path_msg = 'value_pre_sds' actual_path = path_to_check.value_pre_sds( environment.hds) else: tested_path_msg = 'value_post_sds' actual_path = path_to_check.value_post_sds( environment.sds) actual_path_pre_or_post_sds = path_to_check.value_of_any_dependency( environment.tcds) # ASSERT # self.assertEqual(expected_path_str, str(actual_path), tested_path_msg) self.assertEqual(expected_path_str, str(actual_path_pre_or_post_sds), 'value_of_any_dependency')
def test_that_fails_due_to_missing_symbol_reference(self): with self.assertRaises(utils.TestError): symbol_usages_of_instruction = [] self._check( utils.ParserThatGives( cleanup_phase_instruction_that(symbol_usages=do_return( symbol_usages_of_instruction))), utils.single_line_source(), sut.Arrangement(), sut.Expectation(symbol_usages=asrt.matches_singleton_sequence( matches_data_type_symbol_reference( 'symbol_name', reference_restrictions.is_any_type_w_str_rendering())) ), )
def test_that_fails_due_to_missing_symbol_reference(self): symbol_usages_of_instruction = [] self._check_source_and_exe_variants__failing_assertions( ParserThatGives( instruction_embryo_that__phase_agnostic( symbol_usages=do_return(symbol_usages_of_instruction))), Arrangement.phase_agnostic(), Expectation.phase_agnostic( symbol_usages=asrt.matches_singleton_sequence( matches_data_type_symbol_reference( 'symbol_name', reference_restrictions.is_any_type_w_str_rendering() ) )), )
def test_exists_pre_sds(self): # ARRANGE # relativity_test_cases = [ ( RelOptionType.REL_HDS_CASE, True, ), ( RelOptionType.REL_TMP, False, ), ] path_suffix_test_cases = [ (path_part_sdvs.from_constant_str('file.txt'), []), ( path_part_sdvs.from_string( string_sdv_of_single_symbol_reference( 'path_suffix_symbol_name', reference_restrictions.is_any_type_w_str_rendering()), ), [ StringConstantSymbolContext('path_suffix_symbol_name', 'path-suffix').entry ], ), ] for rel_option_type_of_referenced_symbol, expected_exists_pre_sds in relativity_test_cases: referenced_path = ConstantSuffixPathDdvSymbolContext( 'SYMBOL_NAME', rel_option_type_of_referenced_symbol, 'referenced-file-name') for path_suffix, sym_tbl_entries in path_suffix_test_cases: symbol_table = referenced_path.symbol_table symbol_table.add_all(sym_tbl_entries) with self.subTest( msg='rel_option_type={} ,path_suffix_type={}'.format( rel_option_type_of_referenced_symbol, path_suffix)): path_sdv_to_check = sut.PathSdvRelSymbol( path_suffix, _symbol_reference_of_path_with_accepted( referenced_path.name, rel_option_type_of_referenced_symbol)) # ACT # actual = path_sdv_to_check.resolve( symbol_table).exists_pre_sds() # ASSERT # self.assertEqual(expected_exists_pre_sds, actual, 'existence pre SDS')
def is_reference_restrictions__glob_pattern_string( ) -> Assertion[ReferenceRestrictions]: return asrt_data_rest.equals__w_str_rendering( reference_restrictions.is_any_type_w_str_rendering())
def _symbol_reference(symbol_name: str) -> SymbolReference: return SymbolReference( symbol_name, reference_restrictions.is_any_type_w_str_rendering(), )
from exactly_lib.definitions.entity import syntax_elements from exactly_lib.impls.types.string_ import parse_string from exactly_lib.section_document.element_parsers.token_stream_parser import TokenParser, from_parse_source, \ ParserFromTokens from exactly_lib.section_document.parse_source import ParseSource from exactly_lib.symbol.sdv_structure import SymbolReference, SymbolName from exactly_lib.type_val_deps.sym_ref.w_str_rend_restrictions import reference_restrictions from exactly_lib.type_val_deps.types.list_ import list_sdvs as lrs from exactly_lib.type_val_deps.types.list_.list_sdv import ListSdv from exactly_lib.type_val_deps.types.string_.string_sdv import StringSdv from exactly_lib.util import either from . import generic_parser _STRING_ELEMENT_PARSE_CONFIGURATION = parse_string.Configuration( syntax_elements.STRING_SYNTAX_ELEMENT.singular_name, reference_restrictions.is_any_type_w_str_rendering(), ) def parse_list(source: ParseSource) -> ListSdv: with from_parse_source(source) as token_parser: return parse_list_from_token_parser(token_parser) def parse_list_from_token_parser(token_parser: TokenParser) -> ListSdv: return lrs.from_elements(_consume_elements_from_token_parser(token_parser)) def _consume_elements_from_token_parser(token_parser: TokenParser) -> List[lrs.ElementSdv]: return _ELEMENT_SEQUENCE_PARSER.parse(token_parser)
def is__w_str_rendering() -> Assertion[ReferenceRestrictions]: return equals__w_str_rendering( reference_restrictions.is_any_type_w_str_rendering())
def reference__w_str_rendering(self) -> SymbolReference: return SymbolReference( self.name, reference_restrictions.is_any_type_w_str_rendering())