def test(self): # ARRANGE # reg_ex_pattern = 'const_pattern' arguments = st_args.syntax_for_filter_transformer(str( lm_args.Contents(sm_args.Matches(reg_ex_pattern))) ) lines = [ reg_ex_pattern + '\n', 'non matching line', ] expected_lines = [ reg_ex_pattern + '\n', ] # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, Arguments(arguments), model_constructor.of_lines(self, lines), arrangement_w_tcds(), expectation_of_successful_filter_execution( output_lines=expected_lines, symbol_references=asrt.is_empty_sequence, ) )
def runTest(self): # ARRANGE # for case in validation_cases.failing_validation_cases(): line_matcher_symbol_context = case.value.symbol_context line_matcher_arg = lm_args.SymbolReference(line_matcher_symbol_context.name) arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg)) with self.subTest(case.name): # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, Arguments(arguments), model_constructor.of_lines(self, []), arrangement_wo_tcds( symbols=line_matcher_symbol_context.symbol_table ), Expectation( ParseExpectation( symbol_references=line_matcher_symbol_context.references_assertion ), ExecutionExpectation( validation=case.value.expectation, ) ) )
def test_SHOULD_not_be_identity_transformer(self): # ARRANGE # matcher = LineMatcherSymbolContext.of_primitive_constant( 'line_matcher_symbol', False, ) line_matcher_arg = lm_args.SymbolReference(matcher.name) arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg)) # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, Arguments(arguments), model_constructor.of_lines(self, []), arrangement_w_tcds( symbols=matcher.symbol_table ), expectation_of_successful_filter_execution( symbol_references=asrt.matches_singleton_sequence( matcher.reference_assertion ), output_lines=[], ) )
def runTest(self): # ARRANGE # arguments = names.IDENTITY_TRANSFORMER_NAME model_content_lines = ['the model contents line 1'] # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, Arguments(arguments), model_constructor.of_lines(self, model_content_lines), arrangement_w_tcds(), Expectation( ParseExpectation( symbol_references=asrt.is_empty_sequence, ), ExecutionExpectation( main_result=asrt_string_source.pre_post_freeze__matches_lines__identical( asrt.equals(model_content_lines), may_depend_on_external_resources=asrt.equals(False), ) ), prim_asrt__constant(is_identity_transformer(True)), adv=freeze_check.first_invoked_method_of_source_model__is_freeze, ) )
def check__w_access_of_all_model_properties( put: unittest.TestCase, range_expr: Sequence[range_args.Range], input_and_expected: InputAndExpectedWExtDeps, ): arguments = args.filter_line_nums__multi(range_expr) for source_may_depend_on_external_resources in [False, True]: with put.subTest(may_depend_on_external_resources= source_may_depend_on_external_resources): integration_check.CHECKER__PARSE_SIMPLE.check( put, arguments.as_remaining_source, model_constructor.of_lines( put, input_and_expected.input, may_depend_on_external_resources= source_may_depend_on_external_resources, ), arrangement_w_tcds(), integration_check.expectation_of_successful_execution( symbol_references=asrt.is_empty_sequence, output_lines=input_and_expected.expected.lines, may_depend_on_external_resources=input_and_expected. expected.may_dep_on_ext_rsrc( source_may_depend_on_external_resources), frozen_may_depend_on_external_resources=asrt.anything_goes( ), is_identity_transformer=False, ))
def test_regular_expression_SHOULD_be_matched(self): # ARRANGE # input_lines = [ 'Exactly', ] expected_lines = [ 'is what I want', ] for line_filter_case in LINE_FILTER_CASES: for preserve_new_lines in [False, True]: source = ReplaceRegexAbsStx.of_str( '[E][x][a][c][t][l][y]', quoting.surrounded_by_str('is what I want', QuoteType.HARD), preserve_new_lines=preserve_new_lines, lines_filter=line_filter_case.value.syntax, ) # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants( self, source, model_constructor.of_lines(self, input_lines), arrangement_w_tcds( symbols=line_filter_case.value.symbol_table, ), expectation_of_successful_replace_execution__multi( symbol_references=line_filter_case.value. references_assertion, may_depend_on_external_resources=line_filter_case. value.may_depend_on_external_resources, output_lines=expected_lines, ), sub_test_identifiers={ 'preserve_new_lines': preserve_new_lines, })
def runTest(self): # ARRANGE # symbol_in_regex = StringConstantSymbolContext( 'symbol_in_regex', 'plain string pattern', default_restrictions=asrt_regex.is_reference_restrictions__regex()) symbol_in_replacement = StringConstantSymbolContext( 'symbol_in_replacement', 'the replacement', default_restrictions=asrt_ref_rest.is__w_str_rendering(), ) input_lines = [ symbol_in_regex.str_value, ] expected_lines = [ symbol_in_replacement.str_value, ] quoting_cases = [ None, QuoteType.SOFT, ] for line_filter_case in LINE_FILTER_CASES: all_symbols = line_filter_case.value.symbols + [ symbol_in_regex, symbol_in_replacement, ] for preserve_new_lines in [False, True]: for quoting_variant in quoting_cases: source = ReplaceRegexAbsStx( StringLiteralAbsStx( symbol_in_regex.name__sym_ref_syntax, quoting_variant), symbol_in_replacement.abstract_syntax, preserve_new_lines=preserve_new_lines, lines_filter=line_filter_case.value.syntax, ) # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants( self, source, model_constructor.of_lines(self, input_lines), arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( all_symbols), ), expectation_of_successful_replace_execution__multi( symbol_references=SymbolContext. references_assertion_of_contexts(all_symbols), may_depend_on_external_resources=line_filter_case. value.may_depend_on_external_resources, output_lines=expected_lines, ), sub_test_identifiers={ 'preserve_new_lines': preserve_new_lines, 'quoting': quoting_variant, 'line_filtering': line_filter_case.name, })
def test_no_lines(self): integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, Arguments(self.config.arguments), model_constructor.of_lines(self, []), arrangement_w_tcds(), expectation_of_successful_execution_2( symbol_references=asrt.is_empty_sequence, output_lines=[], may_depend_on_external_resources=False, is_identity_transformer=False, adv=freeze_check. first_invoked_method_of_source_model__is_freeze, ))
def runTest(self): # ARRANGE # py_file = File('stdin-to-upper.py', _PGM_THAT_OUTPUTS_STDIN_IN_UPPER_CASE) py_file_rel_opt_conf = rel_opt.conf_rel_any(RelOptionType.REL_TMP) py_file_conf = py_file_rel_opt_conf.named_file_conf(py_file.name) program_symbol = ProgramSymbolContext.of_sdv( 'PROGRAM_THAT_EXECUTES_PY_FILE', program_sdvs.interpret_py_source_file_that_must_exist(py_file_conf.path_sdv) ) input_model_lines = [ 'the\n', 'input\n', 'model', ] expected_output_model_lines = list(map(str.upper, input_model_lines)) for with_ignored_exit_code in [False, True]: with self.subTest(with_ignored_exit_code=with_ignored_exit_code): # ACT && ASSERT # integration_check.CHECKER__PARSE_FULL.check__w_source_variants_for_full_line_parser( self, args.syntax_for_run( program_args.symbol_ref_command_elements(program_symbol.name), ignore_exit_code=with_ignored_exit_code, ), model_constructor.of_lines(self, input_model_lines), arrangement_w_tcds( tcds_contents=py_file_rel_opt_conf.populator_for_relativity_option_root( DirContents([py_file]) ), symbols=program_symbol.symbol_table, ), MultiSourceExpectation( symbol_references=program_symbol.references_assertion, execution=ExecutionExpectation( main_result=asrt_string_source.pre_post_freeze__matches_lines( asrt.equals(expected_output_model_lines), may_depend_on_external_resources=asrt.equals(True), frozen_may_depend_on_external_resources=asrt.anything_goes(), ) ), primitive=prim_asrt__constant( asrt_string_transformer.is_identity_transformer(False) ), ), )
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 _check( self, pattern: str, replacement_str: str, lines_selector: LineMatcherSymbolContext, input_lines__wo_nl: List[str], output_lines__wo_nl: List[str], ): # ARRANGE # input_lines = with_appended_new_lines(input_lines__wo_nl) output_lines = with_appended_new_lines(output_lines__wo_nl) pattern_symbol = StringConstantSymbolContext( 'PATTERN_SYMBOL', pattern, default_restrictions=asrt_regex.is_reference_restrictions__regex(), ) replacement_symbol = StringConstantSymbolContext( 'REPLACEMENT_SYMBOL', replacement_str, default_restrictions=asrt_ref_rest.is__w_str_rendering(), ) all_symbol = [lines_selector, pattern_symbol, replacement_symbol] for preserve_new_lines in [False, True]: syntax = ReplaceRegexAbsStx( pattern_symbol.abstract_syntax, replacement_symbol.abstract_syntax, preserve_new_lines=preserve_new_lines, lines_filter=lines_selector.abstract_syntax, ) # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants( self, syntax, model_constructor.of_lines(self, input_lines), arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( all_symbol), ), expectation_of_successful_replace_execution__multi( symbol_references=SymbolContext. references_assertion_of_contexts(all_symbol), output_lines=output_lines, may_depend_on_external_resources=True, ), sub_test_identifiers={ 'preserve_new_lines': preserve_new_lines, })
def _check( put: unittest.TestCase, input_lines: List[str], expected_lines: List[str], ): integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( put, Arguments(args.strip_space()), model_constructor.of_lines(put, input_lines), arrangement_w_tcds(), expectation_of_successful_execution_2( symbol_references=asrt.is_empty_sequence, output_lines=expected_lines, may_depend_on_external_resources=False, is_identity_transformer=False, adv=freeze_check.first_invoked_method_of_source_model__is_freeze, ))
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 runTest(self): input_lines = ['1st\n', '2nd\n', '3rd\n'] range_expr = '1+1' evaluated_expr = 2 expected_output_lines = input_lines[:evaluated_expr] arguments = single_line_arguments(range_expr) integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants_for_full_line_parser_2( self, arguments.as_arguments, model_constructor.of_lines(self, input_lines, may_depend_on_external_resources=False), arrangement_w_tcds(), integration_check.expectation_of_successful_execution_2( symbol_references=asrt.is_empty_sequence, output_lines=expected_output_lines, may_depend_on_external_resources=False, is_identity_transformer=False, ))
def _check_lines_for_constant_regex__equivalent_for_preserve_new_lines( self, lines_for: Callable[[str], List[str]], source_cases: List[TransformationCase], ): for line_filter_case in LINE_FILTER_CASES: for preserve_new_lines in [False, True]: for source_case in source_cases: source = ReplaceRegexAbsStx.of_str( source_case.regex, source_case.replacement, preserve_new_lines=preserve_new_lines, lines_filter=line_filter_case.value.syntax, ) # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants( self, source, model_constructor.of_lines( self, lines_for(source_case.regex)), arrangement_w_tcds( symbols=line_filter_case.value.symbol_table, ), MultiSourceExpectation( symbol_references=line_filter_case.value. references_assertion, execution=ExecutionExpectation( main_result=asrt_string_source. pre_post_freeze__matches_lines__identical( asrt.equals( lines_for(source_case.replacement)), may_depend_on_external_resources=asrt. equals(line_filter_case.value. may_depend_on_external_resources), )), adv=freeze_check. first_invoked_method_of_source_model__is_freeze, ), sub_test_identifiers={ 'preserve_new_lines': preserve_new_lines, 'source': repr(source.as_str__default()), 'line_filter_case': line_filter_case.name, })
def runTest(self): # ARRANGE # input_lines = ['1\n', '2\n', '3\n'] single_range_1_symbol = StringIntConstantSymbolContext( 'RANGE_SYMBOL_1', 1, default_restrictions=IS_RANGE_EXPR_STR_REFERENCE_RESTRICTIONS, ) single_range_2_symbol = StringIntConstantSymbolContext( 'RANGE_SYMBOL_2', 3, default_restrictions=IS_RANGE_EXPR_STR_REFERENCE_RESTRICTIONS, ) symbols = [single_range_1_symbol, single_range_2_symbol] expected_output_lines = [ input_lines[single_range_1_symbol.int_value - 1], input_lines[single_range_2_symbol.int_value - 1] ] arguments = args.filter_line_nums__multi([ range_args.SingleLineRange( single_range_1_symbol.name__sym_ref_syntax), range_args.SingleLineRange( single_range_2_symbol.name__sym_ref_syntax), ]) integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants_for_full_line_parser_2( self, arguments.as_arguments, model_constructor.of_lines(self, input_lines, may_depend_on_external_resources=False), arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts(symbols), ), integration_check.expectation_of_successful_execution_2( symbol_references=SymbolContext. references_assertion_of_contexts(symbols), output_lines=expected_output_lines, may_depend_on_external_resources=False, is_identity_transformer=False, ))
def runTest(self): # ARRANGE # input_lines = ['1\n', '2\n', '3\n'] expected_output_lines = input_lines[:2] range_expr = StringSymbolContext.of_constant( 'RANGE_SYMBOL', '2', default_restrictions=IS_RANGE_EXPR_STR_REFERENCE_RESTRICTIONS, ) integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants_for_full_line_parser_2( self, single_line_arguments( range_expr.name__sym_ref_syntax).as_arguments, model_constructor.of_lines(self, input_lines, may_depend_on_external_resources=False), arrangement_w_tcds(symbols=range_expr.symbol_table, ), integration_check.expectation_of_successful_execution_2( symbol_references=range_expr.references_assertion, output_lines=expected_output_lines, may_depend_on_external_resources=False, is_identity_transformer=False, ))
def runTest(self): # ARRANGE # model = ['the line'] line_matcher__constant_false = LineMatcherSymbolContextOfPrimitiveConstant( 'MATCHER', False, ) after_bin_op = 'after bin op' lm_argument = lm_args.And([ lm_args.SymbolReference(line_matcher__constant_false.name), lm_args.Custom(after_bin_op), ]) arguments = st_args.syntax_for_filter_transformer(lm_argument.as_str) # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check( self, source=remaining_source(arguments), input_=model_constructor.of_lines(self, model), arrangement=arrangement_w_tcds( symbols=line_matcher__constant_false.symbol_table, ), expectation=expectation_of_successful_execution( source=asrt_source.is_at_line( current_line_number=1, remaining_part_of_current_line=lm_argument.operator_name + ' ' + after_bin_op, ), symbol_references=line_matcher__constant_false.references_assertion, output_lines=[], may_depend_on_external_resources=True, frozen_may_depend_on_external_resources=asrt.anything_goes(), is_identity_transformer=False, ) )
def test_other_scenarios(self): cases = [ NameAndValue( 'trailing new lines should be removed from line matcher model, but not from transformer output', (line_matcher_from_predicates(line_contents_predicate=lambda x: x == 'X'), ['X\n'], ['X\n']) ), NameAndValue( 'line numbers should be paired with lines in order of iterator (1)', (is_identical_to(1, 'i'), with_appended_new_lines([ 'i', 'ii', ]), with_appended_new_lines(['i']) ) ), NameAndValue( 'line numbers should be paired with lines in order of iterator (2)', (is_identical_to(2, 'ii'), with_appended_new_lines([ 'i', 'ii', ]), with_appended_new_lines(['ii']) ) ), NameAndValue( 'line numbers should be propagated to line matcher', (line_matcher_from_predicates(line_num_predicate=lambda x: x in {1, 3}), with_appended_new_lines([ 'i', 'ii', 'iii', 'iv', ]), with_appended_new_lines([ 'i', 'iii', ]) ) ), ] line_matcher_name = 'the_line_matcher_symbol_name' line_matcher_arg = lm_args.SymbolReference(line_matcher_name) arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg)) for case in cases: matcher, input_lines, expected_output_lines = case.value with self.subTest(case_name=case.name): # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, Arguments(arguments), model_constructor.of_lines(self, input_lines), arrangement_w_tcds( symbols=LineMatcherSymbolContext.of_primitive( line_matcher_name, matcher, ).symbol_table, ), expectation_of_successful_filter_execution( output_lines=expected_output_lines, symbol_references=asrt.matches_singleton_sequence( references.is_reference_to_line_matcher(line_matcher_name) ) ) )
def model(self, may_depend_on_external_resources: bool) -> ModelConstructor: model_lines = ['{}\n'.format(n + 1) for n in range(10)] return model_constructor.of_lines(self, model_lines, may_depend_on_external_resources)
def test_insertion_of_new_line_into_a_line_SHOULD_split_that_line(self): # ARRANGE # input_lines = [ 'P\n', '---\n', 'aPbPc\n', '---\n', 'P', ] expected_lines = [ '\n', '\n', '---\n', 'a\n', 'b\n', 'c\n', '---\n', '\n', ] replacement_string_cases = [ NameAndValue( 'literate new line', '\n', ), NameAndValue( 'new line escape sequence, as interpreted by Python replace', r'\n', ), ] for line_filter_case in LINE_FILTER_CASES: for preserve_new_lines in [False, True]: for case in replacement_string_cases: with self.subTest(case.name, preserve_new_lines=preserve_new_lines, line_filtering=line_filter_case.name): nl_string_symbol = StringConstantSymbolContext( 'NL', case.value, default_restrictions=asrt_regex. is_reference_restrictions__regex(), ) all_symbols = line_filter_case.value.symbols + [ nl_string_symbol ] source = ReplaceRegexAbsStx( StringLiteralAbsStx('P'), nl_string_symbol.abstract_syntax, preserve_new_lines=preserve_new_lines, lines_filter=line_filter_case.value.syntax, ) # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check__abs_stx( self, source, model_constructor.of_lines(self, input_lines), arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( all_symbols)), expectation_of_successful_replace_execution( symbol_references=SymbolContext. references_assertion_of_contexts(all_symbols), may_depend_on_external_resources=line_filter_case .value.may_depend_on_external_resources, output_lines=expected_lines, ))