def post_sds_fails(expected_err_msg: Assertion[str] = asrt.anything_goes()
) -> 'ValidationAssertions':
return ValidationAssertions(
pre_sds=asrt.is_none,
post_sds=asrt.is_not_none_and(
asrt_text_doc.is_string_for_test(expected_err_msg)),
)
def expect_failing_validation_post_setup(
self,
assertion_on_error_message: Assertion[str] = asrt.anything_goes(),
symbol_usages: Assertion[
Sequence[SymbolUsage]] = asrt.is_empty_sequence,
):
return Expectation(main_result=asrt_sh.is_hard_error(
asrt_text_doc.is_string_for_test(assertion_on_error_message)),
symbol_usages=symbol_usages)
def test_hard_error(self):
# ARRANGE #
error_message = 'hard error'
# ACT #
actual = sut.translate_pfh_exception_to_pfh(test_action, DO_HARD_ERROR, error_message)
# ASSERT #
expectation = asrt_pfh.is_hard_error(
asrt_text_doc.is_string_for_test(asrt.equals(error_message))
)
expectation.apply_without_message(self, actual)
def test_fail_error(self):
# ARRANGE #
error_message = 'validation error'
# ACT #
actual = sut.translate_pfh_exception_to_pfh(test_action, DO_FAIL, error_message)
# ASSERT #
expectation = asrt_pfh.is_fail(
asrt_text_doc.is_string_for_test(asrt.equals(error_message))
)
expectation.apply_without_message(self, actual)
def _apply(self, put: unittest.TestCase, value: FailureDetails,
message_builder: MessageBuilder):
put.assertIsNotNone(value, message_builder.apply('must not be none'))
put.assertIsInstance(value, FailureDetails,
message_builder.apply('type of object'))
if self._error_message_or_none is not None:
message_comp_builder = message_builder.for_sub_component(
'failure message')
put.assertIsNotNone(value.failure_message, message_comp_builder)
asrt_text_doc.is_string_for_test(
self._error_message_or_none).apply(
put, value.failure_message,
message_comp_builder.for_sub_component('text-doc'))
self._exception_or_none.apply(
put, value.exception,
message_builder.for_sub_component('exception'))
def expect_hard_error_of_main(
self,
assertion_on_error_message: Assertion[str] = asrt.anything_goes(),
symbol_usages: Assertion[
Sequence[SymbolUsage]] = asrt.is_empty_sequence,
):
return Expectation(
main_result=pfh_assertions.is_hard_error(
asrt_text_doc.is_string_for_test(assertion_on_error_message)),
symbol_usages=symbol_usages,
)
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 expect_hard_error_of_main(
self,
assertion_on_error_message: Assertion[str] = asrt.anything_goes(),
symbol_usages: Assertion[
Sequence[SymbolUsage]] = asrt.is_empty_sequence,
):
"""
Expectation that the result should be HARD_ERROR,
both for assert- and non-assert phase instructions.
"""
return self.expect_failure_of_main(
asrt_text_doc.is_string_for_test(assertion_on_error_message))
def test_return_pfh_fail_WHEN_PfhFailException_is_raised(self):
# ARRANGE #
assertion_part_that_raises = PartThatRaisesFailureExceptionIfArgumentIsEqualToOne()
# ACT #
actual = assertion_part_that_raises.check_and_return_pfh(self.environment,
self.the_os_services,
1)
# ASSERT #
assertion = asrt_pfh.is_fail(
is_string_for_test(
asrt.equals(PartThatRaisesFailureExceptionIfArgumentIsEqualToOne.ERROR_MESSAGE))
)
assertion.apply_without_message(self, actual)
def test_unsuccessful_WHEN_actual_is_not_expected(self):
# ARRANGE #
expected_err_msg = 'expected error message'
actual_err_msg = 'actual 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__str(actual_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__str(actual_err_msg),
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
assert_that_assertion_fails(case.expected, case.actual)
def test_return_pfh_fail_WHEN_PfhFailException_is_raised(self):
# ARRANGE #
environment = fake_post_sds_environment()
assertion_part_that_raises = PartThatRaisesFailureExceptionIfArgumentIsEqualToOne()
instruction = sut.AssertionInstructionFromAssertionPart(assertion_part_that_raises,
lambda env: 1)
# ACT #
actual = instruction.main(environment,
optionally_from_proc_exe_settings(None, environment.proc_exe_settings),
self.the_os_services)
# ASSERT #
assertion = asrt_pfh.is_fail(
asrt_text_doc.is_string_for_test(
asrt.equals(PartThatRaisesFailureExceptionIfArgumentIsEqualToOne.ERROR_MESSAGE))
)
assertion.apply_without_message(self, actual)
def test_argument_getter_SHOULD_be_given_environment_as_argument(self):
# ARRANGE #
environment = fake_post_sds_environment()
assertion_part = PartThatRaisesFailureExceptionIfArgumentIsEqualToOne()
def argument_getter_that_depends_on_environment(env: InstructionEnvironmentForPostSdsStep) -> int:
return 1 if env is environment else 0
instruction = sut.AssertionInstructionFromAssertionPart(assertion_part,
argument_getter_that_depends_on_environment)
# ACT #
actual = instruction.main(environment,
optionally_from_proc_exe_settings(None, environment.proc_exe_settings),
self.the_os_services)
# ASSERT #
assertion = asrt_pfh.is_fail(
asrt_text_doc.is_string_for_test(
asrt.equals(PartThatRaisesFailureExceptionIfArgumentIsEqualToOne.ERROR_MESSAGE)
)
)
assertion.apply_without_message(self, actual)
def matches_validation_failure(
message: Assertion[str]) -> ValidationResultAssertion:
return asrt_text_doc.is_string_for_test(message)
def assertion_from_actual(
actual: Optional[str]) -> Assertion[Optional[TextRenderer]]:
return (asrt.is_none if actual is None else asrt.is_not_none_and(
asrt_text_doc.is_string_for_test(asrt.equals(actual))))
def is_hard_error(error_message: Assertion[str] = asrt.anything_goes()
) -> Optional[Assertion[TextRenderer]]:
return asrt_text_doc.is_string_for_test(
asrt.is_instance_with(str, error_message))
