def test_fail_WHEN_invalid_components_of_invalid_type(self):
# ARRANGE #
assertion = sut.matches_node()
cases = [
NameAndValue('invalid type of header',
sut.Node(None,
None,
[],
[])
),
NameAndValue('invalid type of detail',
sut.Node('header',
None,
['not a Detail'],
[])
),
NameAndValue('invalid type of child',
sut.Node('header',
None,
[],
['not a Node'])
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
assert_that_assertion_fails(assertion, case.value)
def test_success_WHEN_actual_is_valid_node(self):
# ARRANGE #
assertion = sut.matches_node()
cases = [
NameAndValue('no details and no children',
sut.Node('header',
None,
[],
[])
),
NameAndValue('single valid detail',
sut.Node('header',
None,
[StringDetail('the string')],
[])
),
NameAndValue('single valid child',
sut.Node('header',
None,
[],
[sut.Node('child node', None, [], [])])
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
assertion.apply_without_message(self, case.value)
def _equals_empty_node(expected: Node) -> Assertion[Node]:
return asrt_d_tree.matches_node(
header=asrt.equals(expected.header),
data=asrt.equals(expected.data),
details=asrt.is_empty_sequence,
children=asrt.is_empty_sequence,
)
def test_succeed(self):
actual = sut.Node('expected header', None, [], [])
expectation = asrt_d_tree.matches_node(header=asrt.equals('expected header'))
assertion = sut.matches_node_renderer(rendered_node=expectation)
assertion.apply_without_message(self,
NodeRendererForTest(actual))
def test_fail(self):
actual = sut.Node('actual header', None, [], [])
expectation = asrt_d_tree.matches_node(header=asrt.equals('expected header'))
assertion = sut.matches_node_renderer(rendered_node=expectation)
assert_that_assertion_fails(assertion,
NodeRendererForTest(actual))
def _check_structure_of_primitive(self,
put: unittest.TestCase,
actual: PRIM_W_NODE_DESC,
message_builder: MessageBuilder,
):
structure_tree_of_primitive = actual.structure().render()
asrt_d_tree.matches_node().apply(
put,
structure_tree_of_primitive,
message_builder.for_sub_component('sanity of structure'),
)
structure_equals_ddv = asrt_d_tree.header_data_and_children_equal_as(self._structure_tree_of_ddv)
structure_equals_ddv.apply_with_message(
put,
structure_tree_of_primitive,
'structure of should be same as that of ddv',
)
def matches_value__w_header(
value: Assertion[bool],
header: Assertion[str],
details: Assertion[Sequence[Detail]] = asrt.anything_goes(),
children: Assertion[Sequence[Node]] = asrt.anything_goes(),
) -> Assertion[MatchingResult]:
return matches(value=value,
trace=asrt_trace_rendering.matches_node_renderer(
asrt_d_tree.matches_node(header=header,
data=value,
details=details,
children=children), ))
def test_succeed(self):
actual_rendered_node = _trace_for(False)
actual_result = MatchingResult(
actual_rendered_node.data,
NodeRendererForTest(actual_rendered_node))
renderer_assertion = asrt_trace_rendering.matches_node_renderer(
rendered_node=asrt_d_tree.matches_node(
header=asrt.equals(actual_rendered_node.header)))
assertion = sut.matches(trace=renderer_assertion)
assertion.apply_without_message(self, actual_result)
def check_ddv(self,
put: unittest.TestCase,
actual: FullDepsDdv[PRIM_W_NODE_DESC],
message_builder: MessageBuilder,
):
asrt.is_instance(self._expected_ddv_object_type).apply(
put,
actual,
message_builder.for_sub_component('object type'),
)
assert isinstance(actual, WithNodeDescription) # Type info for IDE
self._structure_tree_of_ddv = actual.structure().render()
asrt_d_tree.matches_node().apply(
put,
self._structure_tree_of_ddv,
message_builder.for_sub_component('sanity of structure'),
)
has_valid_description().apply(put, actual, message_builder)
def test_fail(self):
actual_rendered_node = Node('actual header', False, [], [])
actual_result = MatchingResult(
actual_rendered_node.data,
NodeRendererForTest(actual_rendered_node))
renderer_assertion = asrt_trace_rendering.matches_node_renderer(
rendered_node=asrt_d_tree.matches_node(
header=asrt.equals('expected header')))
assertion = sut.matches(trace=renderer_assertion)
assert_that_assertion_fails(assertion, actual_result)
def test_fail(self):
assertion = sut.matches_node(header=asrt.equals('expected header'))
assert_that_assertion_fails(assertion,
sut.Node('actual header', None, [], []))
def matches_pgm_as_detail__executable_file() -> Assertion[Detail]:
return asrt_d_tree.is_tree_detail(
asrt_d_tree.matches_node(
header=asrt.equals(commands.CommandDriverForExecutableFile.NAME)))
def test_succeed(self):
assertion = sut.matches_node(children=asrt.len_equals(0))
assertion.apply_without_message(self,
sut.Node('header', None, [], []))
def test_fail(self):
assertion = sut.matches_node(children=asrt.len_equals(1))
assert_that_assertion_fails(assertion,
sut.Node('header', None, [], []))
def test_succeed(self):
assertion = sut.matches_node(data=asrt.equals('expected data'))
assertion.apply_without_message(self,
sut.Node('header', 'expected data', [], []))
def test_fail(self):
assertion = sut.matches_node(data=asrt.equals('expected data'))
assert_that_assertion_fails(assertion,
sut.Node('header', 'actual data', [], []))
def test_succeed(self):
assertion = sut.matches_node(header=asrt.equals('expected header'))
assertion.apply_without_message(self,
sut.Node('expected header', None, [], []))