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 is_single_validator_with(expectations: Sequence[NameAndValue[ValueAssertion[PreOrPostSdsValidator]]]
) -> ValueAssertion[Sequence[PreOrPostSdsValidator]]:
return asrt.and_([
asrt.len_equals(1),
asrt.on_transformed(pre_or_post_validation.all_of,
asrt.all_named(expectations))
])
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)
def _check(self,
operand_result: bool,
mk_expr: Callable[[Sequence[StringMatcherArg]], StringMatcherArg],
):
# ARRANGE #
operand_that_accesses_model_contents = StringMatcherSymbolContext.of_primitive(
'ACCESSES_MODEL_CONTENTS',
matcher_that_accesses_contents_and_gives_constant(operand_result),
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check(
self,
mk_expr(
[
args2.SymbolReference(operand_that_accesses_model_contents.name),
args2.SymbolReference(operand_that_accesses_model_contents.name)
]
).as_remaining_source,
MakeModelWithContentsOnlyAccessibleAfterFreeze(self).construct,
arrangement_w_tcds(
symbols=operand_that_accesses_model_contents.symbol_table,
),
Expectation(
ParseExpectation(
symbol_references=asrt.len_equals(2)
)
),
)
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 = [
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 is_single_validator_with(
expectations: Sequence[NameAndValue[Assertion[DdvValidator]]]
) -> Assertion[Sequence[DdvValidator]]:
return asrt.and_([
asrt.len_equals(1),
asrt.on_transformed(ddv_validators.all_of,
asrt.all_named(expectations))
])
def test_success(self):
# ARRANGE #
reference = data_symbol_utils.symbol_reference('symbol_name')
string_resolver = _StringResolverTestImpl(resolve_constant(STRING_VALUE), [reference])
assertion = sut.matches_resolver(sut.is_resolver_of_string_type(),
asrt.len_equals(1),
asrt.is_(STRING_VALUE),
asrt.is_(string_resolver))
# ACT & ASSERT #
assertion.apply_without_message(self, string_resolver)
def _equals_target_info_node__shallow(expected: TargetInfoNode,
mk_equals_cross_ref_id) -> Assertion:
return asrt.And([
_is_TargetInfoNodeObject_shallow,
asrt.sub_component(
'target_info', TargetInfoNode.data.fget,
equals_target_info(expected.data, mk_equals_cross_ref_id)),
asrt.sub_component(
'children', TargetInfoNode.children.fget,
asrt.len_equals(len(expected.children), 'Number of children'))
])
def _equals_target_info_node__shallow(expected: TargetInfoNode,
mk_equals_cross_ref_id) -> ValueAssertion:
return asrt.And([
_is_TargetInfoNodeObject_shallow,
asrt.sub_component('target_info',
TargetInfoNode.data.fget,
equals_target_info(expected.data,
mk_equals_cross_ref_id)),
asrt.sub_component('children',
TargetInfoNode.children.fget,
asrt.len_equals(len(expected.children), 'Number of children'))
])
def test_success(self):
# ARRANGE #
path_symbol = PathDdvSymbolContext(
'symbol_name', path_ddvs.of_rel_option(RelOptionType.REL_ACT))
reference = data_references.reference_to__on_direct_and_indirect(
path_symbol.name)
path_sdv = PathSdvTestImplWithConstantPathAndSymbolReferences(
path_symbol.ddv, [reference])
assertion = sut.matches_sdv(asrt.is_instance(PathSdv),
asrt.len_equals(1),
asrt.is_(path_symbol.ddv),
asrt.is_(path_sdv),
symbols=path_symbol.symbol_table)
# ACT & ASSERT #
assertion.apply_without_message(self, path_sdv)
def _apply(self,
put: unittest.TestCase,
value: str,
message_builder: MessageBuilder,
):
unquoted = shlex.split(value)
num_quoted_elements = asrt.len_equals(1)
num_quoted_elements.apply(
put,
unquoted,
message_builder.for_sub_component('number of quoted elements')
)
self._unquoted.apply(
put,
unquoted[0],
message_builder.for_sub_component('unquoted')
)
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_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 test_not_matches(self):
expected_command = system_program_command('program', [])
expected_stdin = [string_sources.string_source_that_must_not_be_used()]
expected_transformer = IdentityStringTransformer()
assertion = sut.matches_program(
command=asrt.is_(expected_command),
stdin=asrt.len_equals(len(expected_stdin)),
transformer=asrt.matches_singleton_sequence(
asrt.is_(expected_transformer)),
)
actual_command = system_program_command('program', [])
actual_stdin = ()
actual_transformer = ()
cases = [
NameAndValue(
'unexpected command',
Program(command=actual_command,
stdin=expected_stdin,
transformation=[expected_transformer])),
NameAndValue(
'unexpected stdin',
Program(command=expected_command,
stdin=actual_stdin,
transformation=[expected_transformer])),
NameAndValue(
'unexpected transformer',
Program(command=expected_command,
stdin=expected_stdin,
transformation=actual_transformer)),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(assertion, case.value)
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 symbol_table_is_empty() -> Assertion[InstructionEnvironmentForPreSdsStep]:
return _symbol_table_names_set(asrt.len_equals(0))
def symbol_table_is_empty() -> ValueAssertion:
return _symbol_table_names_set(asrt.len_equals(0))