def test_not_matches(self):
cases = [
NEA(
'default/not an exception',
expected=sut.matches_exception(),
actual=err_descr.of_message(rend_comb.ConstantSequenceR([])),
),
NEA(
'custom/message',
expected=sut.matches_exception(
message=asrt_renderer.is_renderer_of_minor_blocks(
asrt.len_equals(1))),
actual=err_descr.of_exception(
ValueError('an exception'),
message=rend_comb.ConstantSequenceR([])),
),
NEA(
'custom/exception',
expected=sut.matches_exception(
exception=asrt.is_instance(NotImplementedError)),
actual=err_descr.of_exception(ValueError('an exception')),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected, case.actual)
def test_not_matches(self):
cases = [
NIE(
'default assertion/not a renderer',
input_value=MajorBlock([]),
expected_value=sut.is_renderer_of_major_blocks(),
),
NIE(
'default assertion/not a sequence',
input_value=rend_comb.ConstantR(MajorBlock([])),
expected_value=sut.is_renderer_of_major_blocks(),
),
NIE(
'default assertion/not a major block',
input_value=rend_comb.ConstantSequenceR([MinorBlock([])]),
expected_value=sut.is_renderer_of_major_blocks(),
),
NIE(
'default assertion/invalid contents of block',
input_value=rend_comb.ConstantSequenceR(
[MajorBlock(['not a minor block'])]),
expected_value=sut.is_renderer_of_major_blocks(),
),
NIE(
'custom assertion/unexpected number of blocks',
input_value=rend_comb.ConstantSequenceR([]),
expected_value=sut.is_renderer_of_major_blocks(
asrt.len_equals(1)),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected_value,
case.input_value)
def test_not_matches(self):
cases = [
NEA(
'default/not an external process error',
expected=sut.matches_external_process(),
actual=err_descr.of_message(rend_comb.ConstantSequenceR([])),
),
NEA(
'custom/message',
expected=sut.matches_external_process(
message=asrt_renderer.is_renderer_of_minor_blocks(
asrt.len_equals(1))),
actual=err_descr.of_external_process_error2(
self._EPR, message=rend_comb.ConstantSequenceR([])),
),
NEA(
'custom/external-process-error',
expected=sut.matches_external_process(
external_process_error=asrt.sub_component(
'exit_code', ExternalProcessError.exit_code.fget,
asrt.equals(self._EPR.exit_code + 1))),
actual=err_descr.of_external_process_error2(
self._EPR, message=rend_comb.ConstantSequenceR([])),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected, case.actual)
def test_not_matches(self):
cases = [
NIE(
'default assertion/not a renderer',
input_value=self._LINE_ELEMENT,
expected_value=sut.is_renderer_of_line_elements(),
),
NIE(
'default assertion/not a sequence',
input_value=rend_comb.ConstantR(self._LINE_ELEMENT),
expected_value=sut.is_renderer_of_line_elements(),
),
NIE(
'default assertion/not a line element',
input_value=rend_comb.ConstantSequenceR([MajorBlock([])]),
expected_value=sut.is_renderer_of_line_elements(),
),
NIE(
'default assertion/invalid contents of line element',
input_value=rend_comb.ConstantSequenceR([
LineElement(StringLineObject('string'), 'not properties')
]),
expected_value=sut.is_renderer_of_line_elements(),
),
NIE(
'custom assertion/unexpected number of blocks',
input_value=rend_comb.ConstantSequenceR([]),
expected_value=sut.is_renderer_of_line_elements(
asrt.len_equals(1)),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected_value,
case.input_value)
class TestAccessorErrorMatches(unittest.TestCase):
_ERROR_INFO_WITH_DESCRIPTION = sut.ErrorInfo(
error_description.of_message(rend_comb.ConstantSequenceR([])))
def test_matches(self):
accessor_error = sut.AccessorError(
sut.AccessErrorType.PRE_PROCESS_ERROR,
self._ERROR_INFO_WITH_DESCRIPTION)
cases = [
NEA(
'default',
actual=accessor_error,
expected=sut.accessor_error_matches(),
),
NEA(
'error',
actual=accessor_error,
expected=sut.accessor_error_matches(
error=asrt.is_(accessor_error.error)),
),
NEA(
'error_info',
actual=accessor_error,
expected=sut.accessor_error_matches(
error_info=asrt.is_(accessor_error.error_info)),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
def test_matches(self):
cases = [
NEA(
'default',
expected=sut.matches_message(),
actual=err_descr.of_message(rend_comb.ConstantSequenceR([])),
),
NEA(
'custom',
expected=sut.matches_message(
asrt_renderer.is_renderer_of_minor_blocks(
asrt.len_equals(0))),
actual=err_descr.of_message(rend_comb.ConstantSequenceR([])),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
def test_expect_post_validation_succeeds(self):
self._check_raises_test_error__single_and_multi(
_constant_line_matcher_type_parser_of_matcher_ddv(
sdv_ddv.MatcherDdvOfConstantMatcherTestImpl(
constant.MatcherWithConstantResult(True),
ConstantDdvValidator(
post_sds_result=rend_comb.ConstantSequenceR([])))
),
is_expectation_of_execution_result_of(True),
)
def test_matches(self):
cases = [
err_descr.of_message(rend_comb.ConstantSequenceR([])),
err_descr.of_exception(ValueError('an exception')),
err_descr.of_external_process_error2(
ExternalProcessError(1, 'output on stderr')),
]
for error_description in cases:
with self.subTest(str(type(error_description))):
sut.is_any_error_description().apply_without_message(
self, error_description)
class FullExeResultRenderer(MajorBlocksRenderer):
_EMPTY = rend_comb.ConstantSequenceR([])
def __init__(self, full_result: FullExeResult):
self._result = full_result
def render_sequence(self) -> Sequence[MajorBlock]:
return self._renderer().render_sequence()
def _renderer(self) -> SequenceRenderer[MajorBlock]:
return (failure_info.FailureInfoRenderer(self._result.failure_info)
if self._result.is_failure else self._EMPTY)
def test_matches(self):
cases = [
NIE(
'default assertion/empty list of blocks',
input_value=rend_comb.ConstantSequenceR([]),
expected_value=sut.is_renderer_of_minor_blocks(),
),
NIE(
'default assertion/non-empty list of blocks',
input_value=rend_comb.ConstantSequenceR([MinorBlock([])]),
expected_value=sut.is_renderer_of_minor_blocks(),
),
NIE(
'custom assertion',
input_value=rend_comb.ConstantSequenceR([MinorBlock([])]),
expected_value=sut.is_renderer_of_minor_blocks(
asrt.len_equals(1)),
),
]
for case in cases:
with self.subTest(case.name):
case.expected_value.apply_without_message(
self, case.input_value)
def _blocks(self) -> SequenceRenderer[MajorBlock]:
return rend_comb.ConstantSequenceR(
[block.render() for block in self._report.blocks()])
def plain_line_elements_of_string_lines(
lines: Sequence[str]) -> SequenceRenderer[LineElement]:
return rend_comb.ConstantSequenceR(
[LineElement(text_struct.StringLineObject(line)) for line in lines])
from exactly_lib_test.test_case.test_resources import error_description_assertions as asrt_err_descr
from exactly_lib_test.test_resources.test_of_test_resources_util import assert_that_assertion_fails
from exactly_lib_test.test_resources.test_utils import NIE, NEA
from exactly_lib_test.test_resources.value_assertions import value_assertion as asrt
def suite() -> unittest.TestSuite:
return unittest.TestSuite([
unittest.makeSuite(TestErrorInfoMatches),
unittest.makeSuite(TestResultMatches),
unittest.makeSuite(TestResultIsAccessError),
])
_ERROR_DESCRIPTION_OF_EMPTY_MESSAGE = error_description.of_message(
rend_comb.ConstantSequenceR([]))
class TestErrorInfoMatches(unittest.TestCase):
_SECTION_NAME = 'a section name'
def test_matches(self):
cases = [
NIE(
'default assertion',
input_value=ErrorInfo(_ERROR_DESCRIPTION_OF_EMPTY_MESSAGE),
expected_value=sut.error_info_matches(),
),
NIE(
'description',
input_value=ErrorInfo(_ERROR_DESCRIPTION_OF_EMPTY_MESSAGE),
