def runTest(self): failure_message = 'failure' failing_validation_result = asrt_validation.new_single_string_text_for_test( failure_message) line_matcher_symbol_name = 'line_matcher_with_failing_validation' asserted_symbol_references = asrt.matches_sequence( [is_reference_to_line_matcher(line_matcher_symbol_name)]) validation_cases = [ NEA('failure pre sds', expected=Expectation( ParseExpectation( symbol_references=asserted_symbol_references, ), ExecutionExpectation( validation=ValidationAssertions.pre_sds_fails( asrt.equals(failure_message)), ), ), actual=ConstantDdvValidator( pre_sds_result=failing_validation_result)), NEA('failure post sds', expected=Expectation( ParseExpectation( symbol_references=asserted_symbol_references, ), ExecutionExpectation(validation=ValidationAssertions. post_sds_fails__w_any_msg(), ), ), actual=ConstantDdvValidator( post_sds_result=failing_validation_result)), ] for case in validation_cases: symbols = LineMatcherSymbolContext.of_sdv( line_matcher_symbol_name, successful_matcher_with_validation(case.actual)).symbol_table for quantifier in Quantifier: arguments_constructor = arguments_building.ImplicitActualFileArgumentsConstructor( CommonArgumentsConstructor(), arguments_building. LineMatchesAssertionArgumentsConstructor( quantifier, line_matcher_symbol_name)) for expectation_type in ExpectationType: arguments = arguments_constructor.apply(expectation_type) source = test_configuration.arguments_for( arguments).as_remaining_source with self.subTest(case=case.name, expectation_type=expectation_type, quantifier=quantifier): self._check(source=source, model=model_constructor.arbitrary(self), arrangement=Arrangement(symbols=symbols), expectation=case.expected)
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 runTest(self): # ARRANGE # model = model_constructor.of_str(self, 'string with at least one line') line_matcher = LineMatcherSymbolContextOfPrimitiveConstant( 'MATCHER', True, ) after_bin_op = 'after bin op' lm_argument = lm_args.And([ lm_args.SymbolReference(line_matcher.name), lm_args.Custom(after_bin_op), ]) for quantifier in Quantifier: arguments = args2.Quantification(quantifier, lm_argument.as_str) with self.subTest(quantifier): # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check( self, source=arguments.as_remaining_source, input_=model, arrangement=arrangement_w_tcds( symbols=line_matcher.symbol_table, ), expectation=Expectation( ParseExpectation(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. references_assertion), ExecutionExpectation( main_result=asrt_matching_result.matches_value( line_matcher.result_value))), )
def test_stdin_is_devnull_WHEN_program_do_not_define_stdin(self): # ARRANGE # test_setup = NoStdinTestSetup(self, exit_code=0) for output_file in ProcOutputFile: for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference( ): for ignore_exit_code in [False, True]: with self.subTest(output_file=output_file, program=pgm_and_args_case.name, ignore_exit_code=ignore_exit_code): # ACT & ASSERT # CHECKER.check__abs_stx__wo_input( self, StringSourceOfProgramAbsStx( output_file, pgm_and_args_case.pgm_and_args, ignore_exit_code, ), arrangement_w_tcds( symbols=pgm_and_args_case.symbol_table, process_execution=test_setup. proc_exe_env__w_stdin_check, tcds_contents=pgm_and_args_case.tcds, ), Expectation.of_prim__const( parse=ParseExpectation( symbol_references=pgm_and_args_case. references_assertion, ), primitive=IS_EMPTY_STRING_SOURCE, ))
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): regex_lines = ['1.3', '4.*6'] here_doc_of_reg_ex = here_document_as_elements(regex_lines) actual_contents = lines_content(['123', '456', '789']) for transformer_option_arguments in TRANSFORMER_OPTION_ALTERNATIVES_ELEMENTS: with self.subTest(maybe_with_transformer_option=transformer_option_arguments): argument_elements = ArgumentElements(transformer_option_arguments + maybe_not.empty__if_positive__not_option__if_negative + [matcher_options.MATCHES_ARGUMENT, FULL_MATCH_ARGUMENT] ).followed_by(here_doc_of_reg_ex) self._check( argument_elements.as_remaining_source, model_constructor.of_str(self, actual_contents), arrangement_w_tcds(), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(1 + len(here_doc_of_reg_ex.following_lines)) ), ExecutionExpectation( main_result=maybe_not.fail__if_positive__pass_if_negative ), ), )
def test_validation_should_fail_pre_sds_when_regex_is_invalid(self): for regex_case in failing_regex_validation_cases(): arguments = self.conf.arguments(NameRegexVariant.of(regex_case.regex_string)) for expectation_type in ExpectationType: with self.subTest(expectation_type=expectation_type, validation_case=regex_case.case_name): integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, arguments= arguments.as_arguments, input_= ARBITRARY_MODEL, arrangement= arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts(regex_case.symbols) ), expectation= Expectation( ParseExpectation( symbol_references=asrt.matches_sequence(regex_case.reference_assertions), ), ExecutionExpectation( validation=regex_case.expectation ), ) )
def test_invalid_arguments_with_symbol_references(self): symbol_name = SymbolWithReferenceSyntax('symbol_name') operand_arg_with_symbol_ref_list = [ ' {op} {sym}'.format(op=comparators.EQ.name, sym=symbol_name), ] invalid_symbol_values = [ 'not_a_number', '1.5', '72 87', ] for invalid_symbol_value in invalid_symbol_values: symbol = StringConstantSymbolContext(symbol_name.name, invalid_symbol_value) for operand_arg_with_symbol_ref in operand_arg_with_symbol_ref_list: arguments = self._conf().arguments_constructor.apply( operand_arg_with_symbol_ref) with self.subTest(argument=arguments, invalid_symbol_value=invalid_symbol_value): for source in equivalent_source_variants__for_expression_parser( self, Arguments(arguments)): self._check( source, Arrangement(symbols=symbol.symbol_table), Expectation( ParseExpectation( symbol_references=asrt.matches_sequence([ symbol. reference_assertion__string__w_all_indirect_refs_are_strings ]), ), ExecutionExpectation( validation=asrt_validation. ValidationAssertions. pre_sds_fails__w_any_msg(), ), ), )
def _check( self, arguments: ArgumentElements, expected_result: bool, all_symbols: Sequence[NameAndValue[MatcherWTrace[MODEL]]], expected_trace: tree.Node[bool], ): conf = self.configuration helper = self._asrt_helper conf.checker_for_parser_of_full_expr().check__w_source_variants( self, arguments.as_arguments, conf.arbitrary_model, Arrangement(symbols=SymbolContext.symbol_table_of_contexts([ conf.mk_logic_type_context_of_primitive(sym.name, sym.value) for sym in all_symbols ]), ), Expectation( ParseExpectation(symbol_references=helper.is_sym_refs_to( [sym.name for sym in all_symbols]), ), ExecutionExpectation(main_result=asrt_matching_result.matches( value=asrt.equals(expected_result), trace=trace_equals(expected_trace)))), )
def runTest(self): # ARRANGE # helper = IntegrationCheckHelper() # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check( self, source=fsm_args.Prune( fm_args.Type(FileType.SYMLINK), helper.files_matcher_sym_ref_arg(), ).as_remaining_source, input_=helper.model_constructor_for_checked_dir__recursive(), arrangement=helper.arrangement_for_contents_of_model( checked_dir_contents=PRUNE_TYPE_SYM_LINK.actual, files_matcher_symbol_value=model_checker.matcher( self, helper.dir_arg.path_sdv, PRUNE_TYPE_SYM_LINK.expected, ), ), expectation=Expectation( ParseExpectation( symbol_references=helper.symbol_references_expectation(), ), EXECUTION_IS_PASS, ), )
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 runTest(self): # ARRANGE # name_of_referenced_symbol = 'FILE_MATCHER_WITH_VALIDATION_FAILURE' selection_is_empty_arguments = fsm_args.Selection( fm_args2.SymbolReference(name_of_referenced_symbol), args.Empty()) for case in validation_cases.failing_validation_cases( name_of_referenced_symbol): symbol_context = case.value.symbol_context selection_is_empty_source = selection_is_empty_arguments.as_remaining_source # ACT & ASSERT # with self.subTest(case.name): integration_check.CHECKER__PARSE_FULL.check( self, selection_is_empty_source, model.arbitrary_model(), arrangement_w_tcds(symbols=symbol_context.symbol_table, ), Expectation( ParseExpectation(symbol_references=symbol_context. references_assertion, ), ExecutionExpectation( validation=case.value.expectation, ), ), )
def _check_( self, instruction_source: ParseSource, model: ModelConstructor, etc: ExpectationTypeConfigForNoneIsSuccess, main_result_for_positive_expectation: PassOrFail, root_dir_of_dir_contents: RelativityOptionConfiguration, contents_of_relativity_option_root: DirContents = empty_dir_contents(), test_case_name: str = '', following_symbols_setup: SymbolsArrEx = SymbolsArrEx.empty()): with self.put.subTest(case_name=test_case_name, expectation_type=etc.expectation_type.name, arguments=instruction_source.source_string): integration_check.CHECKER__PARSE_FULL.check( self.put, instruction_source, model, arrangement_w_tcds( pre_population_action=MAKE_CWD_OUTSIDE_OF_EVERY_REL_OPT_DIR, tcds_contents=root_dir_of_dir_contents. populator_for_relativity_option_root( contents_of_relativity_option_root), symbols=_symbol_table_of(root_dir_of_dir_contents.symbols, following_symbols_setup), ), Expectation( ParseExpectation(symbol_references=following_symbols_setup. expected_references_assertion, ), ExecutionExpectation(main_result=etc.main_result( main_result_for_positive_expectation), ), ))
def test_stdin_contains_model_contents_WHEN_program_do_not_define_stdin( self): # ARRANGE # test_setup = SingleStdinOfProgramTestSetup(self, exit_code=0) for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference( ): with self.subTest(pgm_and_args_case.name): # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx( self, RunProgramAbsStx(pgm_and_args_case.pgm_and_args, ), model_constructor.of_str( self, test_setup.STRING_SOURCE_CONTENTS), arrangement_w_tcds( symbols=pgm_and_args_case.symbol_table, process_execution=test_setup. proc_exe_env__w_stdin_check, tcds_contents=pgm_and_args_case.tcds, ), Expectation( ParseExpectation(symbol_references=pgm_and_args_case. references_assertion, ), execution=EXECUTION_OUTPUT_IS_EMPTY, primitive=PRIMITIVE_IS_NOT_IDENTITY_TRANSFORMATION, ))
def _check_variants_with_expectation_type( self, args_variant_constructor: InstructionArgumentsVariantConstructor, expected_result_of_positive_test: PassOrFail, actual_file_contents: str, symbols: SymbolTable = None, expected_symbol_references: Assertion[Sequence[SymbolReference]] = asrt.is_empty_sequence): for expectation_type in ExpectationType: etc = expectation_type_config__non_is_success(expectation_type) with self.subTest(expectation_type=expectation_type): args_variant = args_variant_constructor.construct(expectation_type) complete_instruction_arguments = test_configuration.arguments_for(args_variant) for source in equivalent_source_variants__for_expression_parser( self, complete_instruction_arguments): integration_check.CHECKER__PARSE_FULL.check( self, source, model_constructor.of_str(self, actual_file_contents), Arrangement( tcds=TcdsArrangement( 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=etc.main_result(expected_result_of_positive_test), ), ) )
def test_access_of_sub_dir_for_failure_message_rendering(self): # ARRANGE # root_1__file = File.empty('f-1') root_2__dir = Dir('d-2', []) arguments = args.matches_full( fc_args.FilesCondition([fc_args.FileCondition(root_1__file.name)]) ) checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'checked-dir') # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, arguments.as_arguments, input_=model_constructor__recursive(checked_dir.path_sdv), arrangement=Arrangement( tcds=checked_dir.tcds_arrangement_dir_with_contents([ root_1__file, root_2__dir, ]) ), expectation=Expectation( parse=ParseExpectation( symbol_references=asrt.is_empty_sequence, ), execution=PRIM_AND_EXE_EXPECTATION__NON_MATCH.execution, primitive=PRIM_AND_EXE_EXPECTATION__NON_MATCH.primitive, ), )
def _check(self, expected_contents: str, actual_contents: str, may_depend_on_external_resources: bool, expected_result: bool, ): string_source_symbol_with_expected = StringSourceSymbolContext.of_primitive_constant( 'EXPECTED_CONTENTS_SYMBOL', expected_contents, ) integration_check.CHECKER__PARSE_SIMPLE.check( self, args2.Equals.eq_string( string_source_symbol_with_expected.name__sym_ref_syntax ).as_remaining_source, model_constructor.of_str( self, actual_contents, may_depend_on_external_resources=may_depend_on_external_resources, ), arrangement_w_tcds( symbols=string_source_symbol_with_expected.symbol_table ), Expectation( ParseExpectation( symbol_references=string_source_symbol_with_expected.references_assertion, ), execution=ExecutionExpectation( main_result=asrt_matching_result.matches_value( expected_result ) ), ), )
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): expected_content_line_template = 'expected content line, with {symbol} ref' def expected_content(symbol_content: str) -> str: return expected_content_line_template.format(symbol=symbol_content) symbol = StringConstantSymbolContext('symbol_name', 'the symbol value') self._check( test_configuration.source_for( args('{maybe_not} {equals} <<EOF', maybe_not=maybe_not.nothing__if_positive__not_option__if_negative), [expected_content(symbol.name__sym_ref_syntax), 'EOF', 'following line']), model_constructor.of_str(self, lines_content([expected_content(symbol.str_value)])), arrangement_w_tcds( post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=symbol.symbol_table), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(3), symbol_references=asrt.matches_sequence([ symbol.reference_assertion__w_str_rendering ]), ), ExecutionExpectation( main_result=maybe_not.pass__if_positive__fail__if_negative, ), ), )
def runTest(self): # ARRANGE # helper = IntegrationCheckHelper() # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check( self, source=fsm_args.Prune( matcher_argument.Constant(False), helper.files_matcher_sym_ref_arg(), ).as_remaining_source, input_=helper.model_constructor_for_checked_dir__recursive(), arrangement=helper.arrangement_for_contents_of_model( checked_dir_contents= BROKEN_SYM_LINKS_SHOULD_BE_TREATED_AS_NON_DIR_FILES.actual, files_matcher_symbol_value=model_checker.matcher( self, helper.dir_arg.path_sdv, BROKEN_SYM_LINKS_SHOULD_BE_TREATED_AS_NON_DIR_FILES. expected, ), ), expectation=Expectation( ParseExpectation( symbol_references=helper.symbol_references_expectation(), ), EXECUTION_IS_PASS, ), )
def runTest(self): # ARRANGE # checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'a-dir') unconditionally_hard_error_file_matcher = FileMatcherSymbolContext.of_primitive( 'unconditionally_hard_error_file_matcher', matchers.MatcherThatReportsHardError()) file_in_model = 'a-file' # ACT & ASSERT # check_non_full_and_full( self, fc_args.FilesCondition([ fc_args.FileCondition( file_in_model, fm_args.SymbolReferenceWReferenceSyntax( unconditionally_hard_error_file_matcher.name)), ]), model_constructor__non_recursive(checked_dir.path_sdv), Arrangement( symbols=unconditionally_hard_error_file_matcher.symbol_table, tcds=checked_dir.tcds_arrangement_dir_with_contents( [File.empty(file_in_model)])), Expectation( ParseExpectation( symbol_references=asrt.matches_singleton_sequence( unconditionally_hard_error_file_matcher. reference_assertion)), ExecutionExpectation( is_hard_error=asrt_text_doc.is_any_text())), )
def runTest(self): # ARRANGE # helper = IntegrationCheckHelper() arguments = fsm_args.Prune( fm_args.SymbolReference(NAME_STARTS_WITH__P1.name), helper.files_matcher_sym_ref_arg(), ).as_arguments # ACT & ASSERT # for depth, nie in COMBINATION_OF_PRUNE_AND_DEPTH_LIMITATIONS: with self.subTest(data=nie.name, depth=depth): integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, arguments=arguments, input_=helper.model_constructor_for_checked_dir__recursive( min_depth=depth, max_depth=depth), arrangement=helper.arrangement_for_contents_of_model( checked_dir_contents=nie.actual, files_matcher_symbol_value=model_checker.matcher( self, helper.dir_arg.path_sdv, nie.expected, ), additional_symbols=[NAME_STARTS_WITH__P1], ), expectation=Expectation( ParseExpectation( symbol_references=asrt.matches_sequence([ NAME_STARTS_WITH__P1.reference_assertion, helper.symbol_reference_assertion, ]), )), )
def test_stdin_is_devnull_WHEN_program_do_not_define_stdin(self): # ARRANGE # test_setup = NoStdinTestSetup(self, exit_code=0) for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference(): with self.subTest(pgm_and_args_case.name): # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx( self, abstract_syntaxes.RunProgramAbsStx( pgm_and_args_case.pgm_and_args, abstract_syntaxes.PathArgumentPositionLast() ), integration_check.ARBITRARY_MODEL, arrangement_w_tcds( symbols=pgm_and_args_case.symbol_table, process_execution=test_setup.proc_exe_env__w_stdin_check, tcds_contents=pgm_and_args_case.tcds, ), Expectation( ParseExpectation( symbol_references=pgm_and_args_case.references_assertion, ), execution=ExecutionExpectation( main_result=asrt_matching_result.matches_value(True) ), ) )
def runTest(self): # ARRANGE # helper = IntegrationCheckHelper() actual_contents = [ Dir('P1-matches', [ File.empty('file-in-pruned-dir'), ]) ] arguments = conjunction([ Parentheses( fsm_args.Prune( fm_args.SymbolReference(NAME_STARTS_WITH__P1.name), fsm_args.NumFiles(int_condition(comparators.EQ, 1)))), fsm_args.NumFiles(int_condition(comparators.EQ, 2)), ]) # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, arguments=arguments.as_arguments, input_=helper.model_constructor_for_checked_dir__recursive(), arrangement=Arrangement( symbols=NAME_STARTS_WITH__P1.symbol_table, tcds=helper.dir_arg.tcds_arrangement_dir_with_contents( actual_contents)), expectation=Expectation( ParseExpectation(symbol_references=asrt.matches_sequence([ NAME_STARTS_WITH__P1.reference_assertion, ])), EXECUTION_IS_PASS, ))
def test_glob_pattern(self): match_anything_glob_pattern_string_symbol = StringSymbolContext.of_constant( 'glob_pattern_symbol', '*', default_restrictions=glob_pattern.is_reference_restrictions__glob_pattern_string() ) arguments = self.conf.arguments( NameGlobPatternVariant(match_anything_glob_pattern_string_symbol.name__sym_ref_syntax) ) integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, arguments= arguments.as_arguments, input_= ARBITRARY_MODEL, arrangement=arrangement_wo_tcds( symbols=match_anything_glob_pattern_string_symbol.symbol_table ), expectation=Expectation( ParseExpectation( symbol_references=asrt.matches_sequence([ match_anything_glob_pattern_string_symbol.reference_assertion, ]), ), ExecutionExpectation( main_result=asrt_matching_result.matches_value__w_header( asrt.equals(True), asrt.equals(self.conf.node_name) ) ), ) )
def test(self): symbol_name = 'the_string_matcher' for quantifier in Quantifier: arguments = args.Quantification( quantifier, fm_args.SymbolReference(symbol_name)) for case in validation_cases.failing_validation_cases(symbol_name): symbol_context = case.value.symbol_context with self.subTest(quantifier=quantifier, validation_case=case.name): integration_check.CHECKER__PARSE_FULL.check( self, source=remaining_source(str(arguments)), input_=arbitrary_model(), arrangement= Arrangement( symbols=symbol_context.symbol_table ), expectation= Expectation( ParseExpectation( symbol_references=symbol_context.references_assertion, ), ExecutionExpectation( validation=case.value.expectation, ), ), )
def runTest(self): # ARRANGE # model_contents = 'the contents of stdin of program' stdin_string_source_syntax = string_source_abs_stx.StringSourceOfStringAbsStx.of_str_hard( model_contents, ) for output_file in ProcOutputFile: for ignore_exit_code in [False, True]: with self.subTest(output_file=output_file, ignore_exit_code=ignore_exit_code): test_setup = StdinCheckViaCopyToOutputFileTestSetup( output_file) # ACT & ASSERT # CHECKER.check__abs_stx__wo_input( self, StringSourceOfProgramAbsStx( output_file, FullProgramAbsStx( test_setup.program_that_copies_stdin_syntax(), stdin=stdin_string_source_syntax), ignore_exit_code, ), arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( test_setup.symbols), ), Expectation.of_prim__const( parse=ParseExpectation( symbol_references=SymbolContext. references_assertion_of_contexts( test_setup.symbols)), primitive=asrt_string_source. pre_post_freeze__identical( asrt_contents.matches__str( asrt.equals(model_contents))), ), )
def test_result_SHOULD_be_true_iff_exit_code_is_0(self): # ARRANGE # program_symbol_name = 'PROGRAM_THAT_EXECUTES_PY_FILE' exit_code_symbol_name = 'EXIT_CODE_SYMBOL' # ACT && ASSERT # integration_check.CHECKER__PARSE_FULL.check_multi( self, args.RunProgram( program_args.symbol_ref_command_elements( program_symbol_name, arguments=[ symbol_reference_syntax_for_name(exit_code_symbol_name) ], )).as_arguments, ParseExpectation( source=asrt_source.is_at_end_of_line(1), symbol_references=asrt.matches_sequence([ is_reference_to_program(program_symbol_name), is_reference_to__w_str_rendering(exit_code_symbol_name), ]), ), integration_check.ARBITRARY_MODEL, test_cases.exit_code_exe_cases( program_symbol_name, exit_code_symbol_name, ), )
def runTest(self): # ARRANGE # files_matcher = FilesMatcherSymbolContextOfPrimitiveConstant( 'MATCHER', True, ) after_bin_op = 'after bin op' # ACT & ASSERT # fsm_argument = fsm_args.conjunction([ fsm_args.SymbolReference(files_matcher.name), fsm_args.Custom(after_bin_op), ]) integration_check.CHECKER__PARSE_SIMPLE.check( self, source=args.DirContents(fsm_argument, ).as_remaining_source, input_=integration_check.current_directory(), arrangement=arrangement_w_tcds( symbols=files_matcher.symbol_table, ), expectation=Expectation( ParseExpectation( source=asrt_source.is_at_line( current_line_number=1, remaining_part_of_current_line=fsm_argument.operator + ' ' + after_bin_op), symbol_references=files_matcher.references_assertion), ExecutionExpectation( main_result=asrt_matching_result.matches_value( files_matcher.result_value))), )
def runTest(self): lines = ['1', '2', '3'] actual_number_of_lines = len(lines) integer_matcher = IntegerMatcherSymbolContext.of_primitive( 'INTEGER_MATCHER', matchers.matcher( comparators.EQ, actual_number_of_lines, )) integration_check.CHECKER__PARSE_SIMPLE.check( self, args.NumLines( integer_matcher.name__sym_ref_syntax).as_remaining_source, model_constructor.of_str(self, lines_content(lines)), arrangement_w_tcds(symbols=integer_matcher.symbol_table, ), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(1), symbol_references=integer_matcher.references_assertion, ), ExecutionExpectation( main_result=asrt_matching_result.matches_value(True)), ), )
def runTest(self): after_lhs_expression = logic.AND_OPERATOR_NAME + ' after bin op' integer_matcher = IntegerMatcherSymbolContextOfPrimitiveConstant( 'MATCHER_SYMBOL', True, ) complex_expression = ' '.join( (integer_matcher.name__sym_ref_syntax, after_lhs_expression)) integration_check.CHECKER__PARSE_SIMPLE.check( self, args.NumLines(complex_expression).as_remaining_source, model_constructor.arbitrary(self), arrangement_w_tcds(symbols=integer_matcher.symbol_table, ), Expectation( ParseExpectation( source=asrt_source.is_at_line( current_line_number=1, remaining_part_of_current_line=after_lhs_expression, ), symbol_references=integer_matcher.references_assertion, ), ExecutionExpectation( main_result=asrt_matching_result.matches_value( integer_matcher.result_value)), ), )
def test_file_matcher_SHOULD_be_parsed_as_full_expression(self): # ARRANGE # file_name = 'file-name' fm_1 = FileMatcherSymbolContextOfPrimitiveConstant( 'file_matcher_1', False) fm_2 = FileMatcherSymbolContextOfPrimitiveConstant( 'file_matcher_2', True) symbols = [fm_1, fm_2] arguments = args.FilesCondition([ args.FileCondition( file_name, fm_args.disjunction([fm_1.argument, fm_2.argument])) ]) expected_result = fm_1.result_value or fm_2.result_value # ACT & ASSERT # CHECKER.check__w_source_variants( self, arguments=arguments.as_arguments, input_=None, arrangement=arrangement_wo_tcds( symbols=SymbolContext.symbol_table_of_contexts(symbols)), expectation=Expectation( ParseExpectation(symbol_references=SymbolContext. references_assertion_of_contexts(symbols)), primitive=prim_asrt__constant( asrt_primitive.files_matches({ PurePosixPath(file_name): asrt_primitive.is_matcher_that_gives(expected_result) }))))