def test_action(what_to_do: int, message: str): if what_to_do == DO_HARD_ERROR: raise sut.PfhHardErrorException(asrt_text_doc.new_single_string_text_for_test(message)) if what_to_do == DO_FAIL: raise sut.PfhFailException(asrt_text_doc.new_single_string_text_for_test(message)) if what_to_do != DO_SUCCESS: raise ValueError('unexpected what_to_do: ' + str(what_to_do))
def new_w_defaults_of_hard_error( may_depend_on_external_resources: bool, as_str: Callable[[], str] = do_raise( HardErrorException( asrt_text_doc.new_single_string_text_for_test( 'should not be called'))), as_lines: Callable[[], Iterator[str]] = do_raise( HardErrorException( asrt_text_doc.new_single_string_text_for_test( 'should not be called'))), as_file: Callable[[DirFileSpace], Path] = do_raise( HardErrorException( asrt_text_doc.new_single_string_text_for_test( 'should not be called'))), write_to: Callable[[TextIO], None] = do_raise( HardErrorException( asrt_text_doc.new_single_string_text_for_test( 'should not be called'))), ) -> 'StringSourceContentsData': def _may_depend_on_external_resources() -> bool: return may_depend_on_external_resources return StringSourceContentsData( may_depend_on_external_resources=_may_depend_on_external_resources, as_str=as_str, as_lines=as_lines, as_file=as_file, write_to=write_to, )
def _new_em(message: str, how_to_fix: Optional[str] = None) -> ErrorMessageWithFixTip: return ErrorMessageWithFixTip( asrt_text_doc.new_single_string_text_for_test(message), ( None if how_to_fix is None else asrt_text_doc.new_single_string_text_for_test(how_to_fix) ) )
def matches_w_trace(self, model: FileMatcherModel) -> MatchingResult: if not isinstance(model, FileMatcherModel): raise HardErrorException( text_doc_assertions.new_single_string_text_for_test( 'Model is not a {}: {}'.format(type(FileMatcherModel), model))) if not model.file_type_access.is_type(FileType.DIRECTORY): raise HardErrorException( text_doc_assertions.new_single_string_text_for_test( 'Test failure: File is not a directory')) return matching_result.of(True)
def test_WHEN_given_validator_fails_post_setup_THEN_main_SHOULD_report_hard_error(self): # ARRANGE # environment = fake_post_sds_environment() the_error_message = 'the error message' assertion_part = PartForValidation(SdvValidatorThat( post_setup_return_value=asrt_text_doc.new_single_string_text_for_test(the_error_message)) ) instruction = sut.AssertionInstructionFromAssertionPart(assertion_part, lambda env: 'argument to assertion_part') is_validation_success = asrt_svh.is_success() main_result_is_hard_error = asrt_pfh.is_hard_error( asrt_text_doc.is_single_pre_formatted_text_that_equals(the_error_message) ) # ACT & ASSERT # pre_sds_result = instruction.validate_pre_sds(environment) is_validation_success.apply_with_message(self, pre_sds_result, 'pre sds validation should succeed') post_sds_result = instruction.validate_post_setup(environment) is_validation_success.apply_with_message(self, post_sds_result, 'post setup validation should succeed') main_result = instruction.main(environment, optionally_from_proc_exe_settings(None, environment.proc_exe_settings), self.the_os_services) main_result_is_hard_error.apply_with_message(self, main_result, 'main should fail')
def test_middle_instruction_fails(self): recording_media = RecordingMedia() instruction_executor = InstructionExecutorThatRecordsInstructionNameAndFailsFor( instruction_with_name('Middle instruction'), recording_media.new_recorder_with_header('instruction executor'), PartialInstructionControlledFailureInfo( PartialControlledFailureEnum.FAIL, asrt_text_doc.new_single_string_text_for_test('fail message'))) phase_contents = SectionContents(( new_instruction_element(Line(1, '1'), TestInstruction('First instruction')), new_instruction_element(Line(2, '2'), TestInstruction('Middle instruction')), new_instruction_element(Line(3, '3'), TestInstruction('Last instruction')), )) self._standard_test( recording_media, phase_contents, instruction_executor, asrt_failure.is_present_with( ExecutionFailureStatus.FAIL, equals_single_line_source_location_path(Line(2, '2')), asrt_failure_details.is_failure_message_of('fail message')), [ 'instruction header for source line number: 1', 'instruction executor: First instruction', 'instruction header for source line number: 2', 'instruction executor: Middle instruction', ])
def check(self, environment: InstructionEnvironmentForPostSdsStep, os_services: OsServices, arg: int): if arg == 1: raise pfh_exception.PfhFailException(asrt_text_doc.new_single_string_text_for_test(self.ERROR_MESSAGE)) else: return arg + 1
def test_fail_due_to_unexpected_hard_error_exception(self): self._check_source_and_exe_variants__failing_assertions( ParserThatGives(instruction_embryo_that__phase_agnostic( main=do_raise(HardErrorException(new_single_string_text_for_test('hard error message')))) ), Arrangement.phase_agnostic(), MultiSourceExpectation.phase_agnostic( main_result=asrt.anything_goes() ), )
def test_succeed_due_to_expected_hard_error_exception(self): self._check_source_and_exe_variants( ParserThatGives(instruction_embryo_that__phase_agnostic( main=do_raise(HardErrorException(new_single_string_text_for_test('hard error message')))) ), Arrangement.phase_agnostic(), MultiSourceExpectation.phase_agnostic( main_raises_hard_error=True ), )
def is_satisfied_by(self, symbol_table: SymbolTable, symbol_name: str, value: SymbolContainer) -> Optional[ErrorMessageWithFixTip]: self.visited.update([symbol_name]) error_message = self.symbol_container_2_result(value) return ( ErrorMessageWithFixTip(asrt_text_doc.new_single_string_text_for_test(error_message)) if error_message else None)
def test_success_WHEN_actual_is_expected(self): # ARRANGE # expected_err_msg = 'expected error message' cases = [ NEA( 'fail', sut.failure_message_is( asrt_text_doc.is_string_for_test( asrt.equals(expected_err_msg))), pfh.new_pfh_fail( asrt_text_doc.new_single_string_text_for_test( expected_err_msg)), ), NEA( 'fail/const msg', sut.failure_message_is( asrt_text_doc.is_string_for_test( asrt.equals(expected_err_msg))), pfh.new_pfh_fail__str(expected_err_msg), ), NEA( 'hard error', sut.failure_message_is( asrt_text_doc.is_string_for_test( asrt.equals(expected_err_msg))), pfh.new_pfh_hard_error( asrt_text_doc.new_single_string_text_for_test( expected_err_msg)), ), NEA( 'hard error/const msg', sut.failure_message_is( asrt_text_doc.is_string_for_test( asrt.equals(expected_err_msg))), pfh.new_pfh_hard_error__str(expected_err_msg), ), ] for case in cases: with self.subTest(case.name): # ACT & ASSERT # case.expected.apply_without_message(self, case.actual)
def test_success_WHEN_actual_is_expected(self): # ARRANGE # cases = [ NEA( 'SUCCESS', svh.SuccessOrValidationErrorOrHardErrorEnum.SUCCESS, svh.new_svh_success(), ), NEA( 'VALIDATION_ERROR', svh.SuccessOrValidationErrorOrHardErrorEnum.VALIDATION_ERROR, svh.new_svh_validation_error( asrt_text_doc.new_single_string_text_for_test( 'validation msg')), ), NEA( 'VALIDATION_ERROR/const msg', svh.SuccessOrValidationErrorOrHardErrorEnum.VALIDATION_ERROR, svh.new_svh_validation_error__str('validation msg'), ), NEA( 'HARD_ERROR', svh.SuccessOrValidationErrorOrHardErrorEnum.HARD_ERROR, svh.new_svh_hard_error( asrt_text_doc.new_single_string_text_for_test( 'hard err msg')), ), NEA( 'HARD_ERROR/const msg', svh.SuccessOrValidationErrorOrHardErrorEnum.HARD_ERROR, svh.new_svh_hard_error__str('hard err msg'), ), ] for case in cases: with self.subTest(case.name): assertion = sut.status_is(case.expected) # ACT & ASSERT # assertion.apply_without_message(self, case.actual)
def test_success_WHEN_actual_is_not_pass(self): # ARRANGE # cases = [ NameAndValue( 'fail', pfh.new_pfh_fail( asrt_text_doc.new_single_string_text_for_test( 'failure msg'))), NameAndValue('fail/const msg', pfh.new_pfh_fail__str('failure msg')), NameAndValue( 'hard error', pfh.new_pfh_hard_error( asrt_text_doc.new_single_string_text_for_test( 'hard error msg'))), NameAndValue('hard error/const msg', pfh.new_pfh_hard_error__str('hard error msg')), ] assertion = sut.is_pass() for case in cases: with self.subTest(case.name): # ACT # assert_that_assertion_fails(assertion, case.value)
def test_success_WHEN_actual_is_not_success(self): # ARRANGE # cases = [ NameAndValue( 'VALIDATION_ERROR', svh.new_svh_validation_error( asrt_text_doc.new_single_string_text_for_test( 'failure msg'))), NameAndValue('VALIDATION_ERROR/const msg', svh.new_svh_validation_error__str('failure msg')), NameAndValue( 'HARD_ERROR', svh.new_svh_hard_error( asrt_text_doc.new_single_string_text_for_test( 'hard error msg'))), NameAndValue('HARD_ERROR/const msg', svh.new_svh_hard_error__str('hard error msg')), ] assertion = sut.is_success() for case in cases: with self.subTest(case.name): # ACT # assert_that_assertion_fails(assertion, case.value)
def test_success_WHEN_actual_is_expected(self): # ARRANGE # cases = [ NEA( 'pass', sut.status_is(pfh.PassOrFailOrHardErrorEnum.PASS), pfh.new_pfh_pass(), ), NEA( 'fail', sut.status_is(pfh.PassOrFailOrHardErrorEnum.FAIL), pfh.new_pfh_fail( asrt_text_doc.new_single_string_text_for_test('fail msg')), ), NEA( 'fail/const msg', sut.status_is(pfh.PassOrFailOrHardErrorEnum.FAIL), pfh.new_pfh_fail__str('fail msg'), ), NEA( 'hard error', sut.status_is(pfh.PassOrFailOrHardErrorEnum.HARD_ERROR), pfh.new_pfh_hard_error( asrt_text_doc.new_single_string_text_for_test( 'hard err msg')), ), NEA( 'hard error/const msg', sut.status_is(pfh.PassOrFailOrHardErrorEnum.HARD_ERROR), pfh.new_pfh_hard_error__str('hard err msg'), ), ] for case in cases: with self.subTest(case.name): # ACT & ASSERT # case.expected.apply_without_message(self, case.actual)
def test_WHEN_given_validator_fails_pre_sds_THEN_validation_SHOULD_fail_pre_sds(self): # ARRANGE # environment = fake_post_sds_environment() the_error_message = 'the error message' assertion_part = PartForValidation(SdvValidatorThat( pre_sds_return_value=asrt_text_doc.new_single_string_text_for_test(the_error_message)) ) instruction = sut.AssertionInstructionFromAssertionPart(assertion_part, lambda env: 'argument to assertion_part') # ACT # actual = instruction.validate_pre_sds(environment) # ASSERT # assertion = asrt_svh.is_validation_error( asrt_text_doc.is_single_pre_formatted_text_that_equals(the_error_message) ) assertion.apply_without_message(self, actual)
def test_WHEN_a_validator_fails_pre_sds_THEN_validation_SHOULD_fail_pre_sds(self): # ARRANGE # the_error_message = 'the error message' assertion_part_with_successful_validation = PartForValidation(SdvValidatorThat()) assertion_part_with_unsuccessful_validation = PartForValidation(SdvValidatorThat( pre_sds_return_value=asrt_text_doc.new_single_string_text_for_test(the_error_message)) ) sequence_checker = sut.SequenceOfCooperativeAssertionParts([assertion_part_with_successful_validation, assertion_part_with_unsuccessful_validation]) validation_environment = self.environment.path_resolving_environment_pre_or_post_sds # ACT # actual = sequence_checker.validator.validate_pre_sds_if_applicable(validation_environment) # ASSERT # asrt_text_doc.is_string_for_test_that_equals(the_error_message).apply_without_message( self, actual, )
def runTest(self): CHECKER.check__w_source_variants( self, command_line( 'program', ).as_str, Arrangement.phase_agnostic( os_services=os_services_access.new_for_cmd_exe( CommandExecutorThatRaisesHardError( asrt_text_doc.new_single_string_text_for_test('the error message') ), ), tcds=TcdsArrangement(), ), MultiSourceExpectation.phase_agnostic( main_raises_hard_error=True ), )
def test_pass__value_from_td(self): message_str = 'error message' the_error_message = asrt_text_doc.new_single_string_text_for_test(message_str) cases = [ NEA('no assertion on error message', asrt.anything_goes(), sh.new_sh_hard_error(the_error_message), ), NEA('assertion on error message', asrt_text_doc.is_single_pre_formatted_text_that_equals(message_str), sh.new_sh_hard_error(the_error_message), ), ] for case in cases: with self.subTest(case.name): # ARRANGE # assertion = sut.is_hard_error(case.expected) # ACT # assertion.apply_without_message(self, case.actual)
def test_success_WHEN_actual_is_expected(self): # ARRANGE # assertion = sut.is_hard_error__with_arbitrary_message() expected_err_msg = 'expected error message' cases = [ NameAndValue( 'hard error', pfh.new_pfh_hard_error( asrt_text_doc.new_single_string_text_for_test( expected_err_msg)), ), NameAndValue( 'hard error/const msg', pfh.new_pfh_hard_error__str(expected_err_msg), ), ] for case in cases: with self.subTest(case.name): # ACT & ASSERT # assertion.apply_without_message(self, case.value)
def test_fail__value_from_td(self): message_str = 'error message' the_error_message = asrt_text_doc.new_single_string_text_for_test(message_str) cases = [ NEA('is success', asrt.anything_goes(), sh.new_sh_success(), ), NEA('assertion on error message fails', asrt_text_doc.is_single_pre_formatted_text_that_equals( message_str + ' - part of message not in actual' ), sh.new_sh_hard_error(the_error_message), ), ] for case in cases: with self.subTest(case.name): # ARRANGE # assertion = sut.is_hard_error(case.expected) # ACT # assert_that_assertion_fails(assertion, case.actual)
def runTest(self): hard_error_message = 'the err msg' with self.config.program_that_exits_with_code(0) as setup: self._check( setup.act_phase_instructions, arrangement_w_tcds( symbol_table=setup.symbols, hds_contents=_hds_pop_of(setup), process_execution=ProcessExecutionArrangement( os_services=os_services_access.new_for_cmd_exe( CommandExecutorThatRaisesHardError( asrt_text_doc.new_single_string_text_for_test( hard_error_message))), process_execution_settings=proc_exe_env_for_test( environ=setup.environ), )), expectation=Expectation.hard_error_from_execute( symbol_usages=setup.symbol_usages, error_message=asrt_text_doc. is_single_pre_formatted_text_that_equals( hard_error_message), ))
def test_single_failing_instruction_executor__status_hard_error(self): recording_media = RecordingMedia() instruction_executor = InstructionExecutorThatRecordsInstructionNameAndFailsFor( any_instruction, recording_media.new_recorder_with_header('instruction executor'), PartialInstructionControlledFailureInfo( PartialControlledFailureEnum.HARD_ERROR, asrt_text_doc.new_single_string_text_for_test( 'hard error message'))) phase_contents = SectionContents( (new_instruction_element(Line(1, '1'), TestInstruction('The instruction')), )) self._standard_test( recording_media, phase_contents, instruction_executor, asrt_failure.is_present_with( ExecutionFailureStatus.HARD_ERROR, equals_single_line_source_location_path(Line(1, '1')), asrt_failure_details.is_failure_message_of( 'hard error message')), [ 'instruction header for source line number: 1', 'instruction executor: The instruction' ])
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 test_hard_error_exception_from_executor_execute_SHOULD_be_handled( self): # ARRANGE # act_phase_instructions = [] hard_error_message = 'the err msg' actor = sut.ActorFromParts( ParserWithConstantResult(SymbolUserWithConstantSymbolReferences( ())), sut.UnconditionallySuccessfulValidatorConstructor(), _ExecutorConstructorForConstant( ExecutorThat(execute_initial_action=do_raise( HardErrorException( asrt_text_doc.new_single_string_text_for_test( hard_error_message))))), ) arrangement = arrangement_w_tcds() expectation = Expectation.hard_error_from_execute( error_message=asrt_text_doc. is_single_pre_formatted_text_that_equals(hard_error_message)) # ACT & ASSERT # check_execution(self, actor, act_phase_instructions, arrangement, expectation)
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))
def freeze(self): raise HardErrorException( asrt_text_doc.new_single_string_text_for_test( 'freeze not allowed here'))
def may_depend_on_external_resources() -> bool: raise HardErrorException( asrt_text_doc.new_single_string_text_for_test('hard err msg'))
def of_err_msg_for_test( error_message: str = 'unconditional error') -> ValueRestriction: return ValueRestrictionWithConstantResult( ErrorMessageWithFixTip( asrt_text_doc.new_single_string_text_for_test(error_message)))
def unconditionally_unsuccessful_validator() -> Optional[TextRenderer]: return asrt_text_doc.new_single_string_text_for_test('the err msg')