def runTest(self): to_upper_transformer = NameAndValue( 'TRANSFORMER_SYMBOL', StringTransformerSdvConstantTestImpl(to_uppercase())) src_file = fs.File('src-file.txt', 'contents of source file') src_file_symbol = NameAndValue('SRC_FILE_SYMBOL', src_file.name) expected_dst_file = fs.File('dst-file-name.txt', src_file.contents.upper()) dst_file_symbol = NameAndValue('DST_FILE_SYMBOL', expected_dst_file.name) transformed_file_syntax = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfFileAbsStx( PathSymbolReferenceAbsStx(src_file_symbol.name)), str_trans_abs_stx.StringTransformerSymbolReferenceAbsStx( to_upper_transformer.name)) instruction_syntax = instr_abs_stx.create_w_explicit_contents( PathSymbolReferenceAbsStx(dst_file_symbol.name), transformed_file_syntax, ) # ACT # for layout_case in tokens_layout.STANDARD_LAYOUT_SPECS: with self.subTest(layout_case.name): instruction = self.conf.parse_checker.parse__abs_stx( self, instruction_syntax, layout_case.value) assert isinstance( instruction, TestCaseInstructionWithSymbols) # Sanity check # ASSERT # expected_symbol_usages = [ asrt_sym_ref.matches_reference_2( dst_file_symbol.name, asrt_w_str_rend_rest.equals__w_str_rendering( path_or_string_reference_restrictions( new_file.REL_OPT_ARG_CONF.options. accepted_relativity_variants))), asrt_sym_ref.matches_reference_2( src_file_symbol.name, asrt_w_str_rend_rest.equals__w_str_rendering( path_or_string_reference_restrictions( src_rel_opt_arg_conf_for_phase( self.conf.phase_is_after_act()).options. accepted_relativity_variants))), is_reference_to_string_transformer__usage( to_upper_transformer.name), ] expected_symbol_references = asrt.matches_sequence( expected_symbol_usages) expected_symbol_references.apply_without_message( self, instruction.symbol_usages())
def expected_symbols(self) -> Sequence[Assertion[SymbolReference]]: return [ asrt_sym_ref.matches_reference_2( self.min_depth.name, asrt_data_rest.equals__w_str_rendering( reference_restrictions. is_string__all_indirect_refs_are_strings())), asrt_sym_ref.matches_reference_2( self.max_depth.name, asrt_data_rest.equals__w_str_rendering( reference_restrictions. is_string__all_indirect_refs_are_strings())), self._helper.files_matcher_sym_assertion(), ]
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 is_reference_to__path_or_string(symbol_name: str, accepted_relativities: PathRelativityVariants, ) -> Assertion[SymbolReference]: return asrt_sym_ref.matches_reference_2( symbol_name, asrt_data_ref_restriction.equals__w_str_rendering( path_or_string_reference_restrictions(accepted_relativities)) )
def equals_data_type_symbol_reference(expected: SymbolReference) -> Assertion[SymbolReference]: restrictions = expected.restrictions if not isinstance(restrictions, WithStrRenderingTypeRestrictions): raise ValueError('Restrictions must be {}. Found {}'.format( WithStrRenderingTypeRestrictions, restrictions, )) return asrt_sym_ref.matches_reference_2(expected.name, asrt_w_str_rend_rest.equals__w_str_rendering(restrictions))
def equals_list_sdv_element(expected: list_sdv.ElementSdv, symbols: SymbolTable = None) -> Assertion[list_sdv.ElementSdv]: if symbols is None: symbols = symbol_table_with_values_matching_references(list(expected.references)) expected_resolved_value_list = expected.resolve(symbols) assertion_on_resolved_value = asrt.matches_sequence( [equals_string_ddv(sv) for sv in expected_resolved_value_list]) component_assertions = [ asrt.sub_component('references', lambda x: list(x.references), equals_symbol_references__w_str_rendering(list(expected.references))), asrt.sub_component('resolved value', lambda x: x.resolve(symbols), assertion_on_resolved_value), ] symbol_reference_assertion = asrt.is_none reference = expected.symbol_reference_if_is_symbol_reference if reference is not None: reference_restrictions = reference.restrictions if not isinstance(reference_restrictions, WithStrRenderingTypeRestrictions): raise ValueError('A list element must reference a data type value') assert isinstance(reference_restrictions, WithStrRenderingTypeRestrictions) # Type info for IDE symbol_reference_assertion = equals_data_type_symbol_reference(reference) asrt_sym_ref.matches_reference_2( reference.name, data_restrictions_assertions.equals__w_str_rendering( reference_restrictions) ) symbol_reference_component_assertion = asrt.sub_component('symbol_reference_if_is_symbol_reference', lambda x: x.symbol_reference_if_is_symbol_reference, symbol_reference_assertion) component_assertions.append(symbol_reference_component_assertion) return asrt.is_instance_with( list_sdv.ElementSdv, asrt.and_(component_assertions))
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())
from exactly_lib.symbol.sdv_structure import SymbolUsage, SymbolReference from exactly_lib.type_val_deps.sym_ref.w_str_rend_restrictions.reference_restrictions import \ is_string__all_indirect_refs_are_strings from exactly_lib_test.symbol.test_resources import symbol_usage_assertions as asrt_sym_usage from exactly_lib_test.test_resources.value_assertions import value_assertion as asrt from exactly_lib_test.test_resources.value_assertions.value_assertion import Assertion from exactly_lib_test.type_val_deps.test_resources.w_str_rend import data_restrictions_assertions as asrt_rest IS_REFERENCE__STRING__W_ALL_INDIRECT_REFS_ARE_STRINGS = ( asrt_rest.equals__w_str_rendering( is_string__all_indirect_refs_are_strings())) def is_sym_ref_to_string__w_all_indirect_refs_are_strings__usage( name_of_symbol: str) -> Assertion[SymbolUsage]: return asrt_sym_usage.matches_reference( asrt.equals(name_of_symbol), IS_REFERENCE__STRING__W_ALL_INDIRECT_REFS_ARE_STRINGS) def is_sym_ref_to_string__w_all_indirect_refs_are_strings( name_of_symbol: str, ) -> Assertion[SymbolReference]: return asrt_sym_usage.matches_reference__ref( asrt.equals(name_of_symbol), IS_REFERENCE__STRING__W_ALL_INDIRECT_REFS_ARE_STRINGS)
def reference_assertion__path( self, symbol_name: str) -> Assertion[SymbolReference]: return asrt_sym_ref.matches_reference_2( symbol_name, asrt_data_ref_restriction.equals__w_str_rendering( self.reference_restriction__path))
def matches_data_type_symbol_reference(symbol_name: str, restrictions: WithStrRenderingTypeRestrictions) -> Assertion[ SymbolReference]: return asrt_sym_ref.matches_reference_2(symbol_name, asrt_w_str_rend_rest.equals__w_str_rendering(restrictions))