def test_tree_of_transformations(self): # ARRANGE # to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'the_to_upper_transformer', string_transformers.to_uppercase()) keep_line_1 = StringTransformerSymbolContext.of_primitive( 'keep_line_1', string_transformers.keep_single_line(1)) keep_line_2 = StringTransformerSymbolContext.of_primitive( 'keep_line_2', string_transformers.keep_single_line(2)) equals_1st = StringMatcherSymbolContext.of_primitive( 'equals_1st', string_matchers.EqualsConstant('1ST\n')) equals_2nd = StringMatcherSymbolContext.of_primitive( 'equals_2nd', string_matchers.EqualsConstant('2ND\n')) model__original = '1st\n2nd\n' symbol_contexts = [ to_upper_transformer, keep_line_1, equals_1st, keep_line_2, equals_2nd, ] # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, args2.Transformed( to_upper_transformer.name__sym_ref_syntax, args2.Parentheses( args2.conjunction([ args2.Parentheses( args2.Transformed( keep_line_1.name__sym_ref_syntax, args2.SymbolReference(equals_1st.name), )), args2.Parentheses( args2.Transformed( keep_line_2.name__sym_ref_syntax, args2.SymbolReference(equals_2nd.name), )), ]))).as_arguments, model_constructor.of_str(self, model__original), arrangement_w_tcds(symbols=SymbolContext.symbol_table_of_contexts( symbol_contexts)), Expectation( ParseExpectation( symbol_references=SymbolContext. references_assertion_of_contexts(symbol_contexts)), ExecutionExpectation( main_result=asrt_matching_result.matches_value(True))))
def _file_contents_cases(self) -> InvalidDestinationFileTestCasesData: arbitrary_transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) symbols = arbitrary_transformer.symbol_table relativity_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE) src_file = relativity_conf.path_abs_stx_of_name('src-file.txt') contents_abs_stx_builder = string_source_abs_stx.TransformableAbsStxBuilder( string_source_abs_stx.StringSourceOfFileAbsStx(src_file)) src_file_in_hds_contents = relativity_conf.populator_for_relativity_option_root( DirContents([File.empty(src_file.name)])) file_contents_cases = [ NameAndValue( 'contents of existing file / without transformation', fs_abs_stx.FileContentsExplicitAbsStx( fs_abs_stx.ModificationType.CREATE, contents_abs_stx_builder.without_transformation())), NameAndValue( 'contents of existing file / with transformation', fs_abs_stx.FileContentsExplicitAbsStx( fs_abs_stx.ModificationType.CREATE, contents_abs_stx_builder.with_transformation( arbitrary_transformer.abstract_syntax))), ] return InvalidDestinationFileTestCasesData(file_contents_cases, symbols, src_file_in_hds_contents)
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): # ARRANGE # named_transformer = StringTransformerSymbolContext.of_primitive( 'the_transformer', every_line_empty()) original_file_contents = 'some\ntext' symbols = SymbolTable( {named_transformer.name: named_transformer.symbol_table_container}) expected_symbol_reference_to_transformer = is_reference_to_string_transformer( named_transformer.name) expected_symbol_usages = asrt.matches_sequence( [expected_symbol_reference_to_transformer]) self._check_with_source_variants( test_configuration.arguments_for( args( '{transform_option} {the_transformer} {maybe_not} {empty}', the_transformer=named_transformer.name, maybe_not=maybe_not. nothing__if_positive__not_option__if_negative)), model_constructor.of_str(self, original_file_contents), arrangement_w_tcds(post_population_action= MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=symbols), Expectation( ParseExpectation(symbol_references=expected_symbol_usages), ExecutionExpectation( main_result=maybe_not.pass__if_positive__fail__if_negative, ), ))
def test_transformation_SHOULD_apply_only_to_matcher_argument(self): to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'the_to_upper_transformer', string_transformers.to_uppercase()) model = contents_transformation.TransformedContentsSetup( original='text', transformed='TEXT', ) integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, args2.conjunction([ args2.Parentheses( args2.Transformed( to_upper_transformer.name, args2.Equals.eq_string(model.transformed)), ), args2.Equals.eq_string(model.original), ]).as_arguments, model_constructor.of_str(self, model.original), arrangement_w_tcds(symbols=to_upper_transformer.symbol_table), Expectation( ParseExpectation( symbol_references=asrt.matches_singleton_sequence( is_reference_to_string_transformer( to_upper_transformer.name))), ExecutionExpectation( main_result=asrt_matching_result.matches_value(True))))
def runTest(self): string_transformer = StringTransformerSymbolContext.of_primitive( 'the_string_transformer', string_transformers.arbitrary()) for case in string_matcher_failing_validation_cases.failing_validation_cases( ): with self.subTest(validation_case=case.name): symbol_context = case.value.symbol_context integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, args2.Transformed( string_transformer.name, args2.SymbolReference( symbol_context.name)).as_arguments, model_constructor.must_not_be_used, Arrangement( symbols=SymbolContext.symbol_table_of_contexts([ string_transformer, symbol_context, ])), Expectation( ParseExpectation( symbol_references=asrt.matches_sequence([ string_transformer.reference_assertion, symbol_context.reference_assertion, ]), ), ExecutionExpectation( validation=case.value.expectation, ), ), )
def test_superfluous_arguments(self): # ARRANGE # arbitrary_transformer_symbol = StringTransformerSymbolContext.of_arbitrary_value( 'TRANSFORMER_SYMBOL') src_file_relativity_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE) file_contents_builder = string_source_abs_stx.TransformableAbsStxBuilder( string_source_abs_stx.StringSourceOfFileAbsStx( src_file_relativity_conf.path_abs_stx_of_name('src-file.txt'))) file_contents_cases = [ NameAndValue('contents of existing file / without transformation', file_contents_builder.without_transformation()), NameAndValue( 'contents of existing file / with transformation', file_contents_builder.with_transformation( arbitrary_transformer_symbol.abstract_syntax)), ] for file_contents_case in file_contents_cases: valid_instruction_syntax = instr_abs_stx.create_w_explicit_contents( path_abs_stx.DefaultRelPathAbsStx('dst-file.txt'), file_contents_case.value, ) invalid_instruction_syntax = custom_abs_stx.SequenceAbsStx([ valid_instruction_syntax, custom_abs_stx.CustomAbstractSyntax.singleton( 'superfluous_argument') ]) with self.subTest(file_contents_variant=file_contents_case.name): # ACT & ASSERT # check_invalid_syntax__abs_stx(self, invalid_instruction_syntax)
def _sym_ctx_of(name: str, may_dep: bool) -> SymbolContext: return StringTransformerSymbolContext.of_primitive( name, string_transformers.StringTransformerFromLinesTransformation( name, lambda x: x, is_identity=False, transformation_may_depend_on_external_resources=may_dep, ))
def runTest(self): # ARRANGE # src_file = fs.File('source-file.txt', 'contents of source file') src_rel_opt_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE) expected_file = fs.File('a-file-name.txt', src_file.contents.upper()) dst_rel_opt_conf = conf_rel_non_hds(RelNonHdsOptionType.REL_ACT) to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', to_uppercase(), ) symbols = to_upper_transformer.symbol_table transformed_file_syntax = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfFileAbsStx( src_rel_opt_conf.path_abs_stx_of_name(src_file.name)), to_upper_transformer.abstract_syntax, ) instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_rel_opt_conf.path_abs_stx_of_name(expected_file.name), transformed_file_syntax, ) expected_non_hds_contents = dst_rel_opt_conf.assert_root_dir_contains_exactly( fs.DirContents([expected_file])) instruction_checker = self.conf.instruction_checker parser = self.conf.parser() for source_case in equivalent_source_variants__with_source_check__consume_last_line__abs_stx( instruction_syntax): with self.subTest(source_case.name): source = source_case.value.source # ACT # instruction = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # source_case.value.expectation.apply_with_message( self, source, 'source-after-parse') # ACT & ASSERT # instruction_checker.check( self, instruction, self.conf.arrangement( pre_contents_population_action= SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR, tcds_contents=src_rel_opt_conf. populator_for_relativity_option_root( DirContents([src_file])), symbols=symbols, ), self.conf.expect_success( symbol_usages=asrt.matches_sequence([ to_upper_transformer.reference_assertion, ]), main_side_effects_on_sds=expected_non_hds_contents, ))
def runTest(self): text_printed_by_program = 'single line of output' expected_file_contents = text_printed_by_program.upper() expected_file = fs.File('dst-file.txt', expected_file_contents) to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'TO_UPPER_CASE', to_uppercase(), ) symbols = to_upper_transformer.symbol_table dst_rel_opt_conf = conf_rel_non_hds(RelNonHdsOptionType.REL_TMP) program_syntax = string_source_abs_stx.StringSourceOfProgramAbsStx( ProcOutputFile.STDOUT, program_abs_stx.FullProgramAbsStx( program_abs_stx.ProgramOfPythonInterpreterAbsStx. of_execute_python_src_string( py_programs.single_line_pgm_that_prints_to( ProcOutputFile.STDOUT, text_printed_by_program)), transformation=to_upper_transformer.abstract_syntax, )) instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_rel_opt_conf.path_abs_stx_of_name(expected_file.name), program_syntax, ) instruction_checker = self.conf.instruction_checker parser = self.conf.parser() for source_case in equivalent_source_variants__with_source_check__consume_last_line__abs_stx( instruction_syntax): with self.subTest(source_case.name): source = source_case.value.source # ACT # instruction = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # source_case.value.expectation.apply_with_message( self, source, 'source-after-parse') # ACT & ASSERT # instruction_checker.check( self, instruction, self.conf.arrangement( pre_contents_population_action= SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR, symbols=symbols), self.conf.expect_success( symbol_usages=asrt.matches_sequence([ to_upper_transformer.reference_assertion, ]), main_side_effects_on_sds=non_hds_dir_contains_exactly( dst_rel_opt_conf.root_dir__non_hds, fs.DirContents([expected_file])), ))
def test__with_transformer(self): # ARRANGE # src_file = fs.File('source-file.txt', 'contents of source file') expected_file = fs.File('a-file-name.txt', src_file.contents.upper()) to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) src_rel_opt_conf = ALLOWED_SRC_FILE_RELATIVITIES__BEFORE_ACT[0] dst_rel_opt_conf = conf_rel_non_hds(RelNonHdsOptionType.REL_ACT) expected_non_hds_contents = self._expected_non_hds_contents( dst_rel_opt_conf, expected_file, src_rel_opt_conf, src_file, ) transformed_file_contents_abs_stx = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfFileAbsStx( src_rel_opt_conf.path_abs_stx_of_name(src_file.name)), to_upper_transformer.abstract_syntax, ) instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_rel_opt_conf.path_abs_stx_of_name(expected_file.file_name), transformed_file_contents_abs_stx, ) symbols = to_upper_transformer.symbol_table for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) with self.subTest(phase_is_after_act=phase_is_after_act): # ACT & ASSERT # checker.check__abs_stx__std_layouts_and_source_variants( self, instruction_syntax, Arrangement.phase_agnostic( tcds=TcdsArrangement( pre_population_action= SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR__PLAIN, tcds_contents=src_rel_opt_conf. populator_for_relativity_option_root( DirContents([src_file])), ), symbols=symbols, ), MultiSourceExpectation.phase_agnostic( main_result=IS_SUCCESS, main_side_effects_on_sds=expected_non_hds_contents, symbol_usages=to_upper_transformer.usages_assertion, ))
def _check_of_invalid_src_file( self, is_after_act_2_every_src_file_rel_conf: Callable[ [bool], Sequence[RelativityOptionConfiguration]], step_of_expected_failure: Step): # ARRANGE # transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) symbols = transformer.symbol_table dst_file_rel_conf = conf_rel_any(RelOptionType.REL_TMP) expectation_ = self._expect_failure_in(step_of_expected_failure) for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) for src_file_rel_conf in is_after_act_2_every_src_file_rel_conf( phase_is_after_act): contents_builder = string_source_abs_stx.TransformableAbsStxBuilder( string_source_abs_stx.StringSourceOfFileAbsStx( src_file_rel_conf.path_abs_stx_of_name( self.src_file_name))) for actual_src_file_variant in self.src_file_variants: for contents_arguments in contents_builder.with_and_without_transformer_cases( transformer.abstract_syntax): instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_file_rel_conf.path_abs_stx_of_name( 'dst-file.txt'), contents_arguments.value, ) # ACT & ASSERT # checker.check__abs_stx__std_layouts_and_source_variants( self, instruction_syntax, Arrangement.phase_agnostic( tcds=TcdsArrangement( pre_population_action= SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR__PLAIN, tcds_contents=src_file_rel_conf. populator_for_relativity_option_root( actual_src_file_variant.value), ), symbols=symbols, ), expectation_, sub_test_identifiers={ 'phase_is_after_act': phase_is_after_act, 'contents': contents_arguments.name, 'relativity_of_src_path': src_file_rel_conf.name, })
def runTest(self): # ARRANGE # to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) src_file = fs.File('src-file.txt', 'contents of source file') src_file_rel_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE) expected_contents = src_file.contents.upper() path_relativity_variants = PathRelativityVariants({src_file_rel_conf.relativity}, True) checker = integration_check.checker(RelOptionsConfiguration(path_relativity_variants, src_file_rel_conf.relativity)) src_file_symbol = ConstantSuffixPathDdvSymbolContext( 'SRC_FILE_SYMBOL', src_file_rel_conf.relativity, src_file.name, path_relativity_variants, ) string_source_syntax = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfFileAbsStx(src_file_symbol.abstract_syntax), to_upper_transformer.abstract_syntax, ) symbol_table = SymbolContext.symbol_table_of_contexts([ src_file_symbol, to_upper_transformer, ]) # ACT & ASSERT # checker.check__abs_stx__layouts__std_source_variants__wo_input( self, OptionallyOnNewLine(string_source_syntax), arrangement_w_tcds( symbols=symbol_table, hds_contents=src_file_rel_conf.populator_for_relativity_option_root__hds( DirContents([src_file])) ), MultiSourceExpectation.of_prim__const( asrt_string_source.pre_post_freeze__matches_str__const( expected_contents, may_depend_on_external_resources=True, ), symbol_references=asrt.matches_sequence([ src_file_symbol.reference_assertion__path_or_string, to_upper_transformer.reference_assertion, ]), ), )
def __init__( self, symbol_name: str, expectation: ValidationAssertions, actual: ValidationActual, ): self.actual = actual self._expectation = expectation self._symbol_context = StringTransformerSymbolContext.of_sdv( symbol_name, string_transformer_from_primitive_value( validator=ddv_validators.constant(actual))) self._expectation__bool = Expectation.corresponding_to(actual)
def runTest(self): # ARRANGE # symbol_1 = NameAndValue('symbol_1_name', 'added by 1st transformer') symbol_2 = NameAndValue('symbol_2_name', 'added by 2nd transformer') symbol_3 = NameAndValue('symbol_3_name', 'added by 3rd transformer') cases = [ NameAndValue('2 transformers', [ symbol_1, symbol_2, ]), NameAndValue('3 transformers', [ symbol_1, symbol_2, symbol_3, ]), ] for case in cases: sequenced_transformer_symbols = case.value arguments = st_args.syntax_for_sequence_of_transformers( [symbol.name for symbol in sequenced_transformer_symbols]) initial_line = 'initial line\n' initial_model_lines = [initial_line] expected_output_lines = [initial_line] + [ symbol.value + '\n' for symbol in sequenced_transformer_symbols ] symbol_contexts = [ StringTransformerSymbolContext.of_primitive( symbol.name, string_transformers.add_line(symbol.value)) for symbol in sequenced_transformer_symbols ] # ACT & ASSERT # with self.subTest(case.name): integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, Arguments(arguments), model_constructor.of_lines(self, initial_model_lines), arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( symbol_contexts)), expectation_of_successful_execution_2( output_lines=expected_output_lines, symbol_references=SymbolContext. references_assertion_of_contexts(symbol_contexts), may_depend_on_external_resources=False, is_identity_transformer=False, ))
def runTest(self): # ARRANGE # named_transformer = StringTransformerSymbolContext.of_primitive( _TRANSFORMER_SYMBOL_NAME, string_transformers.to_uppercase() ) contents_generator = contents_transformation.TransformedContentsSetup( original='some\ntext', transformed='SOME\nTEXT', ) symbols = self.rel_opt.symbols.in_arrangement() symbols.put(named_transformer.name, named_transformer.symbol_table_container) expected_symbol_reference_to_transformer = is_reference_to_string_transformer(named_transformer.name) expected_symbol_references = asrt.matches_sequence( [expected_symbol_reference_to_transformer] + self.rel_opt.symbols.usage_expectation_assertions() ) self._check_with_source_variants( test_configuration.arguments_for( args( '{transform_option} {transformer} {maybe_not} {equals} ' '{file_option} {relativity_option} expected.txt', transformer=named_transformer.name, maybe_not=self.not_opt.nothing__if_positive__not_option__if_negative, relativity_option=self.rel_opt.option_argument)), model_constructor.of_str(self, contents_generator.original), arrangement_w_tcds( tcds_contents=self.rel_opt.populator_for_relativity_option_root(DirContents([ File('expected.txt', contents_generator.transformed) ])), post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=symbols, ), Expectation( ParseExpectation( symbol_references=expected_symbol_references, ), ExecutionExpectation( main_result=self.not_opt.pass__if_positive__fail__if_negative, ), ), )
def _check_of_invalid_src_file( self, src_file_relativity: RelOptionType, validation: ValidationAssertions, ): # ARRANGE # checker = integration_check.checker(parse_check.rel_opts_conf_of_single(src_file_relativity)) expectation_ = MultiSourceExpectation( symbol_references=asrt.anything_goes(), execution=ExecutionExpectation( validation=validation ) ) src_file_rel_conf = conf_rel_any(src_file_relativity) transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) symbols = transformer.symbol_table contents_builder = string_source_abs_stx.TransformableAbsStxBuilder( string_source_abs_stx.StringSourceOfFileAbsStx( src_file_rel_conf.path_abs_stx_of_name(self.src_file_name) ) ) for actual_src_file_variant in self.src_file_variants: for contents_arguments in contents_builder.with_and_without_transformer_cases( transformer.abstract_syntax): with self.subTest(src_file_variant=actual_src_file_variant.name, contents=contents_arguments.name, relativity_of_src_path=src_file_rel_conf.option_argument): # ACT & ASSERT # checker.check__abs_stx__layouts__std_source_variants__wo_input( self, OptionallyOnNewLine(contents_arguments.value), arrangement_w_tcds( tcds_contents=src_file_rel_conf.populator_for_relativity_option_root( actual_src_file_variant.value), symbols=symbols, ), expectation_, )
def runTest(self): successful_transformer = StringTransformerSymbolContext.of_identity( 'successful_transformer') for case in validation_cases.failing_validation_cases( 'failing_transformer'): failing_symbol_context = case.value.symbol_context symbols = SymbolContext.symbol_table_of_contexts([ failing_symbol_context, successful_transformer, ]) order_cases = [ NameAndValue( '1st transformer fails', [failing_symbol_context.name, successful_transformer.name ]), NameAndValue( '2nd transformer fails', [successful_transformer.name, failing_symbol_context.name ]), ] for order_case in order_cases: arguments = st_args.syntax_for_sequence_of_transformers( order_case.value) expected_symbol_references = asrt.matches_sequence([ is_reference_to_string_transformer(symbol_name) for symbol_name in order_case.value ]) with self.subTest(validation_case=case.name, order_case=order_case.name): integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, Arguments(arguments), model_constructor.of_lines(self, []), arrangement_w_tcds(symbols=symbols), Expectation( ParseExpectation( symbol_references=expected_symbol_references), ExecutionExpectation( validation=case.value.expectation, ), prim_asrt__constant( is_identity_transformer(False)), ))
def test_w_transformation(self): str_added_by_transformer = '<string added by transformer>' transformer_symbol = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER', string_transformers.add(str_added_by_transformer), ) def contents_transformation(s: str) -> str: return s + str_added_by_transformer # ARRANGE # cases: List[NameAndValue[Case]] = [ NameAndValue('path (within soft quotes)', _path_case(contents_transformation)), NameAndValue('list (within soft quotes)', _list_case(contents_transformation)), ] for case in cases: syntax = TransformedStringSourceAbsStx( case.value.syntax, transformer_symbol.abstract_syntax, ) all_symbols = [case.value.symbol, transformer_symbol] # ACT & ASSERT # CHECKER.check__abs_stx__layouts__std_source_variants__wo_input( self, syntax, arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( all_symbols), ), MultiSourceExpectation.of_prim( symbol_references=asrt.matches_sequence([ references.is_reference_to__string( case.value.symbol.name), transformer_symbol.reference_assertion, ]), primitive=case.value.expectation_of_primitive, ), sub_test_identifiers={ 'case': case.name, })
def runTest(self): # ARRANGE # program_symbol = ProgramSymbolContext.of_arbitrary_value( 'PROGRAM_SYMBOL') const_true_int_matcher_symbol = IntegerMatcherSymbolContext.of_primitive_constant( 'CONST_TRUE_INT_MATCHER', result=True, ) string_transformer_that_reports_failure_if_applied = StringTransformerSymbolContext.of_primitive( 'STRING_TRANSFORMER_THAT_MUST_NOT_BE_USED', StringTransformerThatFailsTestIfApplied(self)) all_symbols = [ program_symbol, string_transformer_that_reports_failure_if_applied, const_true_int_matcher_symbol, ] # ACT & ASSERT # CHECKER.check__abs_stx( self, InstructionArguments( FullProgramAbsStx( program_symbol.abstract_syntax, transformation= string_transformer_that_reports_failure_if_applied. abstract_syntax), const_true_int_matcher_symbol.abstract_syntax, ), ArrangementPostAct2( symbols=SymbolContext.symbol_table_of_contexts(all_symbols), process_execution=ProcessExecutionArrangement( os_services_access.new_for_cmd_exe( CommandExecutorThatJustReturnsConstant(1), ), ), ), Expectation2( ParseExpectation( symbol_usages=SymbolContext.usages_assertion_of_contexts( all_symbols), ), ExecutionExpectation(main_result=asrt_pfh.is_pass()), ))
def test__with_transformer(self): # ARRANGE # src_file = fs.File('source-file.txt', 'contents of source file') expected_contents = src_file.contents.upper() to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) src_rel_opt_conf = conf_rel_any(RelOptionType.REL_TMP) transformed_file_contents_abs_stx = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfFileAbsStx( src_rel_opt_conf.path_abs_stx_of_name(src_file.name) ), to_upper_transformer.abstract_syntax, ) symbols = to_upper_transformer.symbol_table checker = integration_check.checker(parse_check.rel_opts_conf_of_single(src_rel_opt_conf.relativity)) # ACT & ASSERT # checker.check__abs_stx__layouts__std_source_variants__wo_input( self, OptionallyOnNewLine(transformed_file_contents_abs_stx), arrangement_w_tcds( tcds_contents=src_rel_opt_conf.populator_for_relativity_option_root( DirContents([src_file])), symbols=symbols, ), MultiSourceExpectation.of_prim__const( asrt_string_source.pre_post_freeze__matches_str__const( expected_contents, may_depend_on_external_resources=True, ), symbol_references=to_upper_transformer.references_assertion, ) )
def runTest(self): model__original = 'the model text' the_model_constructor = model_constructor.of_str(self, model__original) string_transformer = StringTransformerSymbolContext.of_primitive( 'THE_STRING_TRANSFORMER', string_transformers.to_uppercase()) sm_equals = StringMatcherSymbolContext.of_primitive( 'STRING_MATCHER_1', string_matchers.EqualsConstant(model__original.upper())) symbol = [ string_transformer, sm_equals, ] after_bin_op = 'after bin op' sm_conjunction = args2.conjunction([ args2.SymbolReference(sm_equals.name), args2.Custom(after_bin_op), ]) arguments = args2.Transformed(string_transformer.name__sym_ref_syntax, sm_conjunction) integration_check.CHECKER__PARSE_SIMPLE.check( self, source=arguments.as_remaining_source, input_=the_model_constructor, arrangement=arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts(symbol), ), expectation=Expectation( ParseExpectation(source=asrt_source.is_at_line( current_line_number=1, remaining_part_of_current_line=' '.join( [sm_conjunction.operator, after_bin_op])), symbol_references=SymbolContext. references_assertion_of_contexts(symbol)), ExecutionExpectation( main_result=asrt_matching_result.matches_value(True))), )
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): # ARRANGE # named_transformer = StringTransformerSymbolContext.of_primitive( 'the_transformer', every_line_empty()) checked_file = File('actual.txt', 'some\ntext') symbols = named_transformer.symbol_table expected_symbol_reference_to_transformer = is_reference_to_string_transformer( named_transformer.name) expected_symbol_usages = asrt.matches_sequence( [expected_symbol_reference_to_transformer]) # ACT & ASSERT # self._check_with_source_variants( arguments=arguments_for( sm_args.args( '{transform_option} {the_transformer} {maybe_not} {empty}', the_transformer=named_transformer.name, maybe_not=maybe_not. nothing__if_positive__not_option__if_negative)), model_constructor=integration_check.constant_relative_file_name( checked_file.name), arrangement=arrangement_w_tcds( non_hds_contents=single_file_in_current_dir(checked_file), symbols=symbols, ), expectation=Expectation( ParseExpectation(symbol_references=expected_symbol_usages), ExecutionExpectation( main_result=maybe_not.pass__if_positive__fail__if_negative, ), ))
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): # ARRANGE # string_to_prepend = '.' initial_model_contents = '\n' model_after_2_transformations = ''.join( [string_to_prepend, string_to_prepend, initial_model_contents]) initial_model = model_constructor.of_str(self, initial_model_contents) equals_expected_matcher = StringMatcherSymbolContext.of_primitive( 'EQUALS_EXPECTED', EqualsMatcherTestImpl(model_after_2_transformations)) prepend_transformer_symbol = StringTransformerSymbolContext.of_primitive( 'PREPEND_TRANSFORMER', string_transformers.of_line_transformer__w_preserved_line_ending( 'prepend to each line', lambda line: (line + string_to_prepend))) prepend_trans_arg = str_trans_syntax.syntax_for_transformer_option( prepend_transformer_symbol.name) trans_and_eq_expected_matcher_source = remaining_source( '{prepend_trans_arg} {equals_expected_matcher}'.format( prepend_trans_arg=prepend_trans_arg, equals_expected_matcher=equals_expected_matcher.name, )) # ACT & ASSERT # parser = sut.parsers().full prepend_and_equals_expected_matcher_sdv = parser.parse( trans_and_eq_expected_matcher_source) prepend_and_equals_expected_matcher = StringMatcherSymbolContext.of_sdv( 'PREPEND_AND_EQUALS_EXPECTED', prepend_and_equals_expected_matcher_sdv) symbols = SymbolContext.symbol_table_of_contexts([ equals_expected_matcher, prepend_transformer_symbol, prepend_and_equals_expected_matcher, ]) expected_symbol_references = asrt.matches_sequence([ is_reference_to_string_transformer( prepend_transformer_symbol.name), is_reference_to_string_matcher( prepend_and_equals_expected_matcher.name), ]) self._check_with_source_variants( test_configuration.arguments_for( args( '{prepend_trans_arg} {maybe_not} {prepend_and_equals_expected_matcher}', prepend_trans_arg=prepend_trans_arg, maybe_not=maybe_not. nothing__if_positive__not_option__if_negative, prepend_and_equals_expected_matcher= prepend_and_equals_expected_matcher.name)), initial_model, arrangement_w_tcds(symbols=symbols), Expectation( ParseExpectation( symbol_references=expected_symbol_references, ), ExecutionExpectation( main_result=maybe_not.pass__if_positive__fail__if_negative, ), ))
def runTest(self): non_zero_exit_code = 1 text_printed_by_program = 'the output from the program' py_file = File( 'exit-with-hard-coded-exit-code.py', py_programs.py_pgm_with_stdout_stderr_exit_code( stdout_output=text_printed_by_program, stderr_output='', exit_code=non_zero_exit_code, ), ) expected_file = fs.File( 'dst-file.txt', text_printed_by_program.upper(), ) to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'TO_UPPER_CASE', to_uppercase(), ) symbols = to_upper_transformer.symbol_table py_src_file_rel_opt_conf = rel_opt.conf_rel_any( RelOptionType.REL_HDS_CASE) dst_file_rel_opt_conf = conf_rel_non_hds(RelNonHdsOptionType.REL_TMP) program_string_source_syntax = string_source_abs_stx.StringSourceOfProgramAbsStx( ProcOutputFile.STDOUT, program_abs_stx.FullProgramAbsStx( program_abs_stx.ProgramOfPythonInterpreterAbsStx. of_execute_python_src_file( py_src_file_rel_opt_conf.path_abs_stx_of_name( py_file.name)), transformation=to_upper_transformer.abstract_syntax, ), ignore_exit_code=True, ) instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_file_rel_opt_conf.path_abs_stx_of_name(expected_file.name), program_string_source_syntax, ) instruction_checker = self.conf.instruction_checker parser = self.conf.parser() for source_case in equivalent_source_variants__with_source_check__consume_last_line__abs_stx( instruction_syntax): with self.subTest(source_case.name): source = source_case.value.source # ACT # instruction = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # source_case.value.expectation.apply_with_message( self, source, 'source-after-parse') # ACT & ASSERT # instruction_checker.check( self, instruction, self.conf.arrangement( pre_contents_population_action= SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR, symbols=symbols, tcds_contents=py_src_file_rel_opt_conf. populator_for_relativity_option_root( DirContents([py_file]))), self.conf.expect_success( symbol_usages=asrt.matches_sequence([ to_upper_transformer.reference_assertion, ]), main_side_effects_on_sds=non_hds_dir_contains_exactly( dst_file_rel_opt_conf.root_dir__non_hds, fs.DirContents([expected_file])), ))
def test_string_transformer_should_be_parsed_as_simple_expression(self): # ARRANGE # the_layout = LayoutSpec.of_default() src_rel_opt_conf = conf_rel_any(RelOptionType.REL_TMP) src_file = fs.File('source-file.txt', 'contents of source file') expected_contents = src_file.contents.upper() to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) str_trans__unused = StringTransformerSymbolReferenceAbsStx('UNUSED_TRANSFORMER') transformation_w_infix_op = str_trans_abs_stx.StringTransformerCompositionAbsStx( [ to_upper_transformer.abstract_syntax, str_trans__unused, ], within_parens=False, allow_elements_on_separate_lines=False, ) expected_remaining_tokens = TokenSequence.concat([ TokenSequence.singleton(str_trans_abs_stx.names.SEQUENCE_OPERATOR_NAME), str_trans__unused.tokenization(), ]) expected_remaining_source = expected_remaining_tokens.layout(the_layout) file_contents_syntax = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfFileAbsStx( src_rel_opt_conf.path_abs_stx_of_name(src_file.name) ), transformation_w_infix_op ) checker = integration_check.checker(parse_check.rel_opts_conf_of_single(src_rel_opt_conf.relativity)) # ACT & ASSERT # checker.check__abs_stx( self, file_contents_syntax, None, arrangement_w_tcds( tcds_contents=src_rel_opt_conf.populator_for_relativity_option_root( fs.DirContents([src_file]) ), symbols=to_upper_transformer.symbol_table ), Expectation.of_prim__const( parse=ParseExpectation( source=asrt_source.source_is_not_at_end( remaining_source=asrt.equals(expected_remaining_source) ), symbol_references=to_upper_transformer.references_assertion, ), primitive=asrt_string_source.pre_post_freeze__matches_str__const( expected_contents, may_depend_on_external_resources=True, ) ), the_layout )
def test_symbol_usages(self): # ARRANGE # to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) src_file = fs.File('src-file.txt', 'contents of source file') src_file_rel_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE) expected_dst_file = fs.File('dst-file-name.txt', src_file.contents.upper()) dst_file_symbol = ConstantSuffixPathDdvSymbolContext( 'DST_FILE_SYMBOL', RelOptionType.REL_TMP, expected_dst_file.name, sut.REL_OPT_ARG_CONF.options.accepted_relativity_variants, ) for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) src_file_rel_opt_conf = src_rel_opt_arg_conf_for_phase( phase_is_after_act) src_file_symbol = ConstantSuffixPathDdvSymbolContext( 'SRC_FILE_SYMBOL', src_file_rel_conf.relativity_option, src_file.name, src_file_rel_opt_conf.options.accepted_relativity_variants, ) transformed_file_contents = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfFileAbsStx( src_file_symbol.abstract_syntax), StringTransformerSymbolReferenceAbsStx( to_upper_transformer.name)) instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_file_symbol.abstract_syntax, transformed_file_contents, ) symbols = SymbolContext.symbol_table_of_contexts([ dst_file_symbol, src_file_symbol, to_upper_transformer, ]) with self.subTest(phase_is_after_act=phase_is_after_act): # ACT & ASSERT # checker.check__abs_stx__std_layouts_and_source_variants( self, instruction_syntax, Arrangement.phase_agnostic( symbols=symbols, tcds=TcdsArrangement( hds_contents=src_file_rel_conf. populator_for_relativity_option_root__hds( DirContents([src_file]))), ), MultiSourceExpectation.phase_agnostic( main_result=IS_SUCCESS, symbol_usages=asrt.matches_sequence([ dst_file_symbol. reference_assertion__path_or_string, src_file_symbol. reference_assertion__path_or_string, is_reference_to_string_transformer__usage( to_upper_transformer.name), ]), ), )
def test_unsatisfied(self): def mk_err_msg(symbol_name: str, value_type: ValueType) -> str: return symbol_name + ': ' + 'Value type of tested symbol is ' + str( value_type) def value_type_error_message_function( symbol_name: str, container: SymbolContainer) -> TextRenderer: sdv = container.sdv assert isinstance(sdv, SymbolDependentValue) # Type info for IDE return asrt_text_doc.new_single_string_text_for_test( mk_err_msg(symbol_name, container.value_type)) references = [] referenced_symbol_cases = [ NameAndValue( 'data symbol', TestDataSymbolContext.of('referenced_data_symbol', references, WithStrRenderingType.STRING)), NameAndValue( 'logic symbol', StringTransformerSymbolContext.of_sdv( 'referenced_logic_symbol', StringTransformerSdvConstantTestImpl( string_transformers.arbitrary(), references=[]))), ] for referenced_symbol_case in referenced_symbol_cases: restrictions_that_should_not_be_used = sut.ReferenceRestrictionsOnDirectAndIndirect( direct=ValueRestrictionThatRaisesErrorIfApplied(), indirect=ValueRestrictionThatRaisesErrorIfApplied(), ) value_type_of_referencing_symbol = WithStrRenderingType.STRING value_type_other_than_referencing_symbol = WithStrRenderingType.PATH references1 = [ reference_to(referenced_symbol_case.value, restrictions_that_should_not_be_used) ] referencing_symbol = TestDataSymbolContext.of( 'referencing_symbol', references1, value_type_of_referencing_symbol) symbol_table_entries = [ referencing_symbol, referenced_symbol_case.value ] symbol_table = SymbolContext.symbol_table_of_contexts( symbol_table_entries) cases = [ NEA( 'no restriction parts / default error message generator', asrt_data_rest.is_failure__of_direct_reference(), sut.OrReferenceRestrictions([]), ), NEA( 'no restriction parts / custom error message generator', asrt_data_rest.is_failure__of_direct_reference( message=asrt_text_doc.is_string_for_test_that_equals( mk_err_msg( referencing_symbol.name, W_STR_RENDERING_TYPE_2_VALUE_TYPE[ value_type_of_referencing_symbol])), ), sut.OrReferenceRestrictions( [], value_type_error_message_function), ), NEA( 'single direct: unsatisfied selector', asrt_data_rest.is_failure__of_direct_reference(), sut.OrReferenceRestrictions([ sut.OrRestrictionPart( value_type_other_than_referencing_symbol, sut.ReferenceRestrictionsOnDirectAndIndirect( direct=ValueRestrictionWithConstantResult. of_unconditionally_satisfied())), ]), ), NEA( 'single direct: satisfied selector, unsatisfied part-restriction', asrt_data_rest.is_failure__of_direct_reference(), sut.OrReferenceRestrictions([ sut.OrRestrictionPart( value_type_of_referencing_symbol, sut.ReferenceRestrictionsOnDirectAndIndirect( direct=ValueRestrictionWithConstantResult. of_err_msg_for_test('error message'))), ]), ), NEA( 'multiple direct: unconditionally unsatisfied selectors', asrt_data_rest.is_failure__of_direct_reference(), sut.OrReferenceRestrictions([ sut.OrRestrictionPart( value_type_other_than_referencing_symbol, sut.ReferenceRestrictionsOnDirectAndIndirect( direct=ValueRestrictionWithConstantResult. of_err_msg_for_test('error message'))), sut.OrRestrictionPart( value_type_other_than_referencing_symbol, sut.ReferenceRestrictionsOnDirectAndIndirect( direct=ValueRestrictionWithConstantResult. of_err_msg_for_test('error message'))) ]), ), NEA( 'multiple direct: unconditionally satisfied selectors, unconditionally satisfied restrictions', asrt_data_rest.is_failure__of_direct_reference(), sut.OrReferenceRestrictions([ sut.OrRestrictionPart( value_type_of_referencing_symbol, sut.ReferenceRestrictionsOnDirectAndIndirect( direct=ValueRestrictionWithConstantResult. of_err_msg_for_test('error message'))), sut.OrRestrictionPart( value_type_of_referencing_symbol, sut.ReferenceRestrictionsOnDirectAndIndirect( direct=ValueRestrictionWithConstantResult. of_err_msg_for_test('error message'))) ]), ), NEA( 'first: selector=satisfied, direct=satisfied, indirect=unsatisfied. second:satisfied ', asrt_data_rest.is_failure__of_indirect_reference( failing_symbol=asrt.equals( referenced_symbol_case.value.name), path_to_failing_symbol=asrt.equals([])), sut.OrReferenceRestrictions([ sut.OrRestrictionPart( value_type_of_referencing_symbol, sut.ReferenceRestrictionsOnDirectAndIndirect( direct=ValueRestrictionWithConstantResult. of_unconditionally_satisfied(), indirect=ValueRestrictionWithConstantResult. of_err_msg_for_test('error message'))), sut.OrRestrictionPart( value_type_of_referencing_symbol, sut.ReferenceRestrictionsOnDirectAndIndirect( direct=ValueRestrictionWithConstantResult. of_unconditionally_satisfied())), ]), ), ] for case in cases: with self.subTest( referenced_symbol_case_name=referenced_symbol_case. name, msg=case.name): actual = case.actual.is_satisfied_by( symbol_table, referencing_symbol.name, referencing_symbol.symbol_table_container) case.expected.apply_with_message(self, actual, 'return value')
program_w_complex_str_trans_wo_parentheses, ignore_exit_code=ignore_exit_code, ) with self.subTest(output_file=output_file, ignore_exit_code=ignore_exit_code): checker.check__abs_stx__wo_input( self, syntax, arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( symbols), tcds_contents=py_file_rel_conf. populator_for_relativity_option_root( DirContents([py_program_file]))), Expectation( ParseExpectation( source=asrt_source.source_is_not_at_end( remaining_source=asrt.equals( expected_remaining_source)), symbol_references=SymbolContext. references_assertion_of_contexts(symbols), )), the_layout, ) TO_UPPER_TRANSFORMER_SYMBOL = StringTransformerSymbolContext.of_primitive( 'TO_UPPER_TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), )
put, source_variants, OptionallyOnNewLine(ss_syntax), arrangement_w_tcds(), MultiSourceExpectation.of_prim__const( asrt_string_source.pre_post_freeze__matches_str__const( case.expected, may_depend_on_external_resources=False, )), sub_test_identifiers={'name': case.name}) def _check_transformed_w_constant_contents(put: unittest.TestCase, case: Case): str_added_by_transformer = '<string added by transformer>' transformer_symbol = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER', string_transformers.add(str_added_by_transformer), ) ss_syntax = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfStringAbsStx(case.syntax), transformer_symbol.abstract_syntax, ) CHECKER.check__abs_stx__layouts__source_variants__wo_input( put, equivalent_source_variants__for_expr_parse__s__nsc, OptionallyOnNewLine(ss_syntax), arrangement_w_tcds(symbols=transformer_symbol.symbol_table, ), MultiSourceExpectation.of_prim__const( symbol_references=transformer_symbol.references_assertion, primitive=asrt_string_source.pre_post_freeze__matches_str__const( case.expected + str_added_by_transformer,
def test_transformation_in_referenced_program_and_as_source_argument(self): # ARRANGE # valid_transformer = StringTransformerSymbolContext.of_arbitrary_value( 'VALID_TRANSFORMER', ) referenced_program__system_program = 'the-system-program' for validation_case in validation_cases.failing_validation_cases( 'INVALID_TRANSFORMER'): invalid_transformer_location_cases = [ ValidationCaseWAccumulation( 'in referenced program', of_referenced_program=validation_case.value.symbol_context, accumulated=valid_transformer, ), ValidationCaseWAccumulation( 'in referenced program', of_referenced_program=valid_transformer, accumulated=validation_case.value.symbol_context, ), ] for invalid_transformer_location_case in invalid_transformer_location_cases: referenced_program__sdv = program_sdvs.system_program( string_sdvs.str_constant( referenced_program__system_program), transformations=[ invalid_transformer_location_case. of_referenced_program.reference_sdv ]) referenced_program = ProgramSymbolContext.of_sdv( 'REFERENCED_PROGRAM', referenced_program__sdv) program_w_transformer = FullProgramAbsStx( ProgramOfSymbolReferenceAbsStx(referenced_program.name, ), transformation=invalid_transformer_location_case. accumulated.abstract_syntax, ) symbols__all = [ referenced_program, valid_transformer, validation_case.value.symbol_context, ] symbols__expected_references = [ referenced_program, invalid_transformer_location_case.accumulated ] with self.subTest(validation=validation_case.name, invalid_transformer_location= invalid_transformer_location_case.name): # ACT & ASSERT # CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_expr_parse__s__nsc, program_w_transformer, arrangement_wo_tcds( symbols=SymbolContext.symbol_table_of_contexts( symbols__all), ), MultiSourceExpectation.of_const( symbol_references=SymbolContext. references_assertion_of_contexts( symbols__expected_references), execution=ExecutionExpectation( validation=validation_case.value.expectation, ), primitive=asrt.anything_goes(), ))