def runTest(self): # ARRANGE # checked_dir = Dir.empty('the-checked-dir') fsm_1 = FilesMatcherSymbolContextOfPrimitiveConstant('fsm_1', True) fsm_2 = FilesMatcherSymbolContextOfPrimitiveConstant('fsm_2', False) symbols = [fsm_1, fsm_2] rel_conf = rel_opt_conf.conf_rel_any(RelOptionType.REL_ACT) arguments = args.recursive( rel_conf.path_argument_of_rel_name(checked_dir.name), fsm_args.disjunction([fsm_1.argument, fsm_2.argument]), ) is_pass = fsm_1.result_value or fsm_2.result_value # ACT # & ASSERT # INSTRUCTION_CHECKER.check_2( self, arguments.as_remaining_source, ArrangementPostAct2( symbols=SymbolContext.symbol_table_of_contexts(symbols), tcds=TcdsArrangementPostAct( tcds_contents=rel_conf. populator_for_relativity_option_root( DirContents([checked_dir])))), Expectation2( ParseExpectation( source=asrt_source.source_is_at_end, symbol_usages=SymbolContext.usages_assertion_of_contexts( symbols), ), ExecutionExpectation( main_result=asrt_pfh.is_non_hard_error(is_pass), ), ))
def runTest(self): # ARRANGE # sm_1 = StringMatcherSymbolContextOfPrimitiveConstant('sm_1', True) sm_2 = StringMatcherSymbolContextOfPrimitiveConstant('sm_2', False) symbols = [sm_1, sm_2] matcher_syntax = StringMatcherInfixOpAbsStx.disjunction([ sm_1.abstract_syntax, sm_2.abstract_syntax, ]) is_pass = sm_1.result_value or sm_2.result_value # ACT & ASSERT # self.configuration.checker.check__abs_stx__source_variants( self, self.configuration.syntax_for_matcher(matcher_syntax), self.configuration.arrangement_for_contents( actual_contents='', symbols=SymbolContext.symbol_table_of_contexts(symbols), post_sds_population_action= MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, ).as_arrangement_2(), MultiSourceExpectation( symbol_usages=SymbolContext.usages_assertion_of_contexts( symbols), execution=ExecutionExpectation( main_result=asrt_pfh.is_non_hard_error(is_pass), ), ))
def test_stdin_is_contents_of_string_source_WHEN_program_defines_single_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( ): all_symbols = list( pgm_and_args_case.symbols) + [CONST_TRUE_INT_MATCHER_SYMBOL] with self.subTest(pgm_and_args_case.name): # ACT & ASSERT # CHECKER.check__abs_stx__source_variants( self, InstructionArguments( test_setup.program_w_stdin_syntax( pgm_and_args_case.pgm_and_args), CONST_TRUE_INT_MATCHER_SYMBOL.abstract_syntax, ), ArrangementPostAct2( symbols=SymbolContext.symbol_table_of_contexts( all_symbols), process_execution=test_setup. proc_exe_env__w_stdin_check, tcds=TcdsArrangementPostAct( tcds_contents=pgm_and_args_case.tcds, ), ), MultiSourceExpectation( symbol_usages=SymbolContext. usages_assertion_of_contexts(all_symbols), execution=ExecutionExpectation( main_result=asrt_pfh.is_pass()), ), )
def test_stdin_is_concatenation_of_string_sources_WHEN_program_defines_multiple_stdin( self): # ARRANGE # test_setup = MultipleStdinOfProgramTestSetup(self, exit_code=0) all_symbols = [ test_setup.program_symbol, CONST_TRUE_INT_MATCHER_SYMBOL ] # ACT & ASSERT # CHECKER.check__abs_stx__source_variants( self, InstructionArguments( test_setup.program_w_stdin_syntax, CONST_TRUE_INT_MATCHER_SYMBOL.abstract_syntax, ), ArrangementPostAct2( symbols=SymbolContext.symbol_table_of_contexts(all_symbols), process_execution=test_setup.proc_exe_env__w_stdin_check, ), MultiSourceExpectation( symbol_usages=SymbolContext.usages_assertion_of_contexts( all_symbols), execution=ExecutionExpectation(main_result=asrt_pfh.is_pass()), ), )
def _execution_expectation_of( expected: ExecutionResult) -> ExecutionExpectation: if isinstance(expected, FullExecutionResult): return ExecutionExpectation( main_result=asrt_pfh.is_non_hard_error(expected.is_match)) elif isinstance(expected, ValidationFailure): return ExecutionExpectation( validation_pre_sds=_mk_validation_assertion( expected.expectation.passes_pre_sds), validation_post_sds=_mk_validation_assertion( expected.expectation.passes_post_sds), ) raise ValueError('Unknown {}: {}'.format( str(type(ExecutionResult)), expected, ))
def test_invalid_arguments_with_symbol_references(self): symbol_name = SymbolWithReferenceSyntax('symbol_name') operand_arg_with_symbol_ref_list = [ IntegerMatcherComparisonAbsStx.of_cmp_op( comparators.EQ, StringSymbolAbsStx(symbol_name.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: full_syntax = self._conf().arguments_constructor.apply( operand_arg_with_symbol_ref) with self.subTest(argument=full_syntax.as_str__default(), invalid_symbol_value=invalid_symbol_value): self._check( full_syntax, ArrangementPostAct2(symbols=symbol.symbol_table), MultiSourceExpectation( symbol_usages=asrt.matches_sequence([ symbol. reference_assertion__string__w_all_indirect_refs_are_strings ]), execution=ExecutionExpectation( validation_pre_sds=svh_asrt. is_validation_error(), ), ), )
def runTest(self): file_in_root = File.empty('file-in-root.txt') files_in_root_dir = [file_in_root] file_matcher_symbol = FileMatcherSymbolContext.of_primitive_constant( 'FILE_MATCHER_SYMBOL', True, ) file_matcher_cases = [ NInpArr( 'wo file matcher', None, (), ), NInpArr( 'w file matcher', file_matcher_symbol.abstract_syntax, [file_matcher_symbol], ), ] relativity_cases = [ rel_opt_conf.conf_rel_any(RelOptionType.REL_TMP), rel_opt_conf.conf_rel_any(RelOptionType.REL_HDS_CASE), ] for expectation_type in ExpectationType: for file_matcher_case in file_matcher_cases: for rel_conf in relativity_cases: with self.subTest(relativity=rel_conf.relativity, file_matcher=file_matcher_case.name, expectation_type=expectation_type): CHECKER.check__abs_stx__source_variants( self, InstructionArguments( rel_conf.path_abs_stx_of_name__c([ file_in_root.name, 'path-to-check' ]), expectation_type=expectation_type, file_matcher=file_matcher_case.input, ), ArrangementPostAct2( symbols=SymbolContext.symbol_table_of_contexts(file_matcher_case.arrangement), tcds=TcdsArrangementPostAct( tcds_contents=rel_conf.populator_for_relativity_option_root( DirContents(files_in_root_dir) ) ) ), MultiSourceExpectation( symbol_usages=SymbolContext.usages_assertion_of_contexts(file_matcher_case.arrangement), execution=ExecutionExpectation( main_result=pfh_assertions.is_pass_of_fail( expectation_type is ExpectationType.NEGATIVE ) ) ) )
def runTest(self): # ARRANGE # files_matcher_name = 'the_files_matcher' checked_dir_location = RelOptionType.REL_ACT checked_dir = Dir.empty('checked-dir') matcher_argument = SymbolReferenceArgument(files_matcher_name).as_str tcds = TcdsArrangementPostAct( TcdsPopulatorForRelOptionType(checked_dir_location, DirContents([checked_dir]))) source_cases = [ NameAndValue( 'All arguments on separate lines', Arguments(checked_dir.name, [ reserved_words.COLON, args.RECURSION_OPTION_STR, matcher_argument ]), ), NameAndValue( 'Empty lines between arguments', Arguments(checked_dir.name, [ '', reserved_words.COLON, '', args.RECURSION_OPTION_STR, '', matcher_argument, ]), ), ] execution_cases = [ NExArr( 'matcher gives ' + str(matcher_result), ExecutionExpectation( main_result=asrt_pfh.is_non_hard_error(matcher_result)), ArrangementPostAct2( tcds, symbols=FilesMatcherSymbolContext.of_primitive_constant( files_matcher_name, matcher_result).symbol_table)) for matcher_result in [False, True] ] # ACT & ASSERT # for source_case in source_cases: with self.subTest(source_case=source_case.name): INSTRUCTION_CHECKER.check_multi__with_source_variants( self, SourceArrangement.new_w_arbitrary_fs_location( source_case.value), symbol_usages=asrt.matches_singleton_sequence( is_reference_to_files_matcher__usage( files_matcher_name)), execution=execution_cases, )
def runTest(self): self.configuration.checker.check__abs_stx__source_variants( self, self.configuration.syntax_for_matcher(EmptyAbsStx()), self.configuration.arrangement_for_contents( 'contents that makes the file non-empty', post_sds_population_action= MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, ).as_arrangement_2(), MultiSourceExpectation(execution=ExecutionExpectation( main_result=asrt_pfh.is_fail(), )), )
def runTest(self): # ARRANGE # actual_file_name = 'actual' invalid_file_cases = [ NameAndValue( 'file does not exist', [], ), NameAndValue( 'file is a dir', [Dir.empty(actual_file_name)], ), NameAndValue( 'sym-link to dir', [ Dir.empty('a-dir'), fs.sym_link(actual_file_name, 'a-dir') ], ), NameAndValue( 'broken sym-link', [fs.sym_link(actual_file_name, 'non-existing-target')], ), ] for invalid_file_case in invalid_file_cases: for rel_conf in RELATIVITY_OPTION_CONFIGURATIONS_FOR_ACTUAL_FILE: with self.subTest(invalid_cause=invalid_file_case, path_variant=rel_conf.name): CHECKER.check__abs_stx__source_variants( self, InstructionArgumentsAbsStx( rel_conf.path_abs_stx_of_name(actual_file_name), EmptyAbsStx(), ), ArrangementPostAct2( symbols=rel_conf.symbols.in_arrangement(), tcds=TcdsArrangementPostAct( tcds_contents=rel_conf.populator_for_relativity_option_root( DirContents(invalid_file_case.value)), post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, ) ), MultiSourceExpectation( symbol_usages=rel_conf.symbols.usages_expectation(), execution=ExecutionExpectation.validation_corresponding_to_dsp__post_sds_as_hard_error( rel_conf.directory_structure_partition, ) ), )
def execution_cases( self ) -> Sequence[NExArr[ExecutionExpectation, ArrangementPostAct2]]: return [ NExArr( 'pre sds validation', ExecutionExpectation( validation_pre_sds=asrt_svh.is_validation_error( asrt_text_doc.is_string_for_test_that_equals( self.err_msg_from_validator)), ), self._arrangement( DdvValidatorThat(pre_sds_return_value=asrt_text_doc. new_single_string_text_for_test( self.err_msg_from_validator)))), NExArr( 'post sds validation', ExecutionExpectation(main_result=asrt_pfh.is_hard_error( asrt_text_doc.is_string_for_test_that_equals( self.err_msg_from_validator)), ), self._arrangement( DdvValidatorThat(post_setup_return_value=asrt_text_doc. new_single_string_text_for_test( self.err_msg_from_validator)))), ]
def runTest(self): # ARRANGE # actual_file_name = 'actual' file_type_cases = [ NameAndValue( 'regular file', [fs.File.empty(actual_file_name)], ), NameAndValue( 'sym-link to regular file', [ fs.File.empty('a-regular-file'), fs.sym_link(actual_file_name, 'a-regular-file') ], ), ] for file_type_case in file_type_cases: for rel_conf in RELATIVITY_OPTION_CONFIGURATIONS_FOR_ACTUAL_FILE: for matcher_result in [False, True]: matcher_symbol = StringMatcherSymbolContextOfPrimitiveConstant('STRING_MATCHER', matcher_result) all_symbols = list(rel_conf.symbols.contexts_for_arrangement()) + [matcher_symbol] with self.subTest(file_type=file_type_case, path_variant=rel_conf.name, matcher_result=matcher_result): CHECKER.check__abs_stx__source_variants( self, InstructionArgumentsAbsStx( rel_conf.path_abs_stx_of_name(actual_file_name), matcher_symbol.abstract_syntax, ), ArrangementPostAct2( symbols=SymbolContext.symbol_table_of_contexts(all_symbols), tcds=TcdsArrangementPostAct( tcds_contents=rel_conf.populator_for_relativity_option_root( DirContents(file_type_case.value)), post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, ) ), MultiSourceExpectation( symbol_usages=SymbolContext.usages_assertion_of_contexts(all_symbols), execution=ExecutionExpectation( main_result=asrt_pfh.is_pass_of_fail(matcher_symbol.result_value) ) ), )
def runTest(self): for validation_case in validation_cases.failing_validation_cases(): invalid_matcher = validation_case.value.symbol_context self.configuration.checker.check__abs_stx__source_variants( self, self.configuration.syntax_for_matcher(invalid_matcher.abstract_syntax), self.configuration.arrangement_for_contents( '', post_sds_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=invalid_matcher.symbol_table, ).as_arrangement_2(), MultiSourceExpectation( symbol_usages=invalid_matcher.usages_assertion, execution=ExecutionExpectation.validation_corresponding_to__post_sds_as_hard_error( validation_case.value.actual, ) ), )
def runTest(self): test_setup = test_setups__proc_exe_set.TimeoutTestSetup( self, expected_timeout=72) # ACT & ASSERT # CHECKER.check__abs_stx( self, InstructionArguments( test_setup.valid_program_wo_sym_refs(), CONST_TRUE_INT_MATCHER_SYMBOL.abstract_syntax, ), ArrangementPostAct2( symbols=CONST_TRUE_INT_MATCHER_SYMBOL.symbol_table, process_execution=test_setup.proc_exe_arr__w_settings_check, ), Expectation2( ParseExpectation(symbol_usages=CONST_TRUE_INT_MATCHER_SYMBOL. usages_assertion), ExecutionExpectation(main_result=asrt_pfh.is_pass()), ))
def test_invalid_arguments_without_symbol_references(self): test_cases = [ IntegerMatcherComparisonAbsStx.of_cmp_op__str(comparators.EQ, 'a'), IntegerMatcherComparisonAbsStx.of_cmp_op__str( comparators.GT, '1.5'), ] for condition_syntax in test_cases: with self.subTest(condition_syntax.as_str__default()): instr_arg = self._conf().arguments_constructor.apply( condition_syntax) self._check( instr_arg, ArrangementPostAct2(), MultiSourceExpectation( symbol_usages=asrt.is_empty_sequence, execution=ExecutionExpectation( validation_pre_sds=svh_asrt.is_validation_error(), ), ), )
def runTest(self): # ARRANGE # for matcher_result in [False, True]: matcher = StringMatcherSymbolContextOfPrimitiveConstant('STRING_MATCHER', matcher_result) with self.subTest(matcher_result=matcher_result): # ACT & ASSERT # self.configuration.checker.check__abs_stx__source_variants( self, self.configuration.syntax_for_matcher(matcher.abstract_syntax), self.configuration.arrangement_for_contents( actual_contents='', symbols=matcher.symbol_table, post_sds_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, ).as_arrangement_2(), MultiSourceExpectation( symbol_usages=matcher.usages_assertion, execution=ExecutionExpectation( main_result=asrt_pfh.is_non_hard_error(matcher.result_value), ), ) )
def runTest(self): # ARRANGE # test_setup = StdinCheckWithProgramWExitCode0ForSuccess() # ACT & ASSERT # CHECKER.check__abs_stx( self, InstructionArguments( test_setup.program_that_checks_stdin__syntax( 'the contents of stdin'), CONST_TRUE_INT_MATCHER_SYMBOL.abstract_syntax, ), ArrangementPostAct2( symbols=CONST_TRUE_INT_MATCHER_SYMBOL.symbol_table, tcds=TcdsArrangementPostAct( tcds_contents=test_setup.tcds_contents, )), Expectation2( ParseExpectation(symbol_usages=CONST_TRUE_INT_MATCHER_SYMBOL. usages_assertion, ), execution=ExecutionExpectation(main_result=asrt_pfh.is_pass()), ), )
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, ) all_symbols = [program_symbol, const_true_int_matcher_symbol, ] hard_error_message = 'the err msg' # ACT & ASSERT # CHECKER.check__abs_stx( self, InstructionArguments( program_symbol.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( CommandExecutorThatRaisesHardError( asrt_text_doc.new_single_string_text_for_test(hard_error_message) ), ), ), ), Expectation2( ParseExpectation( symbol_usages=SymbolContext.usages_assertion_of_contexts(all_symbols), ), ExecutionExpectation( main_result=asrt_pfh.is_hard_error( asrt_text_doc.is_string_for_test_that_equals(hard_error_message) ) ), ) )
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 runTest(self): error_message = 'the error message' matcher_that_raises_hard_error = StringMatcherSymbolContext.of_primitive( 'STRING_MATCHER', matchers.MatcherThatReportsHardError(error_message) ) self.configuration.checker.check__abs_stx__source_variants( self, self.configuration.syntax_for_matcher(matcher_that_raises_hard_error.abstract_syntax), self.configuration.arrangement_for_contents( '', post_sds_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=matcher_that_raises_hard_error.symbol_table, ).as_arrangement_2(), MultiSourceExpectation( symbol_usages=matcher_that_raises_hard_error.usages_assertion, execution=ExecutionExpectation( main_result=pfh_assertions.is_hard_error( asrt_text_doc.is_string_for_test_that_equals(error_message) ), ) ), )
from exactly_lib_test.impls.instructions.assert_.test_resources.instruction_check import MultiSourceExpectation, \ ExecutionExpectation from exactly_lib_test.test_case.result.test_resources import pfh_assertions IS_PASS = MultiSourceExpectation() IS_FAIL = MultiSourceExpectation(execution=ExecutionExpectation( main_result=pfh_assertions.is_fail__with_arbitrary_message()))
def expectation(self) -> ExecutionExpectation: return ExecutionExpectation( main_result=asrt_pfh.is_hard_error__with_arbitrary_message(), )
for case in test_data.cases() ]) # ACT & ASSERT # INSTRUCTION_CHECKER.check_multi( self, SourceArrangement.new_w_arbitrary_fs_location( arguments.as_arguments), ParseExpectation(symbol_usages=asrt.matches_singleton_sequence( is_reference_to_files_matcher__usage( model_checker_symbol_name))), execution=[ NExArr( contents_case.name, ExecutionExpectation(), ArrangementPostAct2( tcds=TcdsArrangementPostAct( tcds_contents=tcds_populators. TcdsPopulatorForRelOptionType( checked_dir_location, DirContents([ Dir(checked_dir_name, contents_case.actual) ]))), symbols=SymbolTable({ model_checker_symbol_name: model_checker.matcher__sym_tbl_container( self, checked_dir_path, contents_case.expected) })), ) for contents_case in contents_cases ],