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 is_section_item(self,
put: unittest.TestCase,
value,
message_builder: asrt.MessageBuilder = asrt.MessageBuilder()):
asrt.IsInstance(doc.SectionItem).apply(put, value, message_builder)
assert isinstance(value, doc.SectionItem)
asrt.sub_component('header',
doc.SectionItem.header.fget,
is_text
).apply(put, value, message_builder)
asrt.sub_component('tags',
doc.SectionItem.tags.fget,
asrt.is_instance_with(set,
asrt.on_transformed(list,
asrt.is_sequence_of(asrt.is_instance(str)))
)
).apply(put, value, message_builder)
asrt.sub_component('target',
doc.SectionItem.target.fget,
asrt.is_instance(core.CrossReferenceTarget)),
if isinstance(value, doc.Article):
is_article_contents.apply(put, value.contents,
message_builder.for_sub_component('article_contents'))
elif isinstance(value, doc.Section):
is_section_contents.apply(put, value.contents,
message_builder.for_sub_component('section_contents'))
else:
asrt.fail('Not a {}: {}'.format(str(doc.SectionItem), str(value)))
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 matches_document(
expected: Mapping[str, Sequence[Assertion[model.SectionContentElement]]]
) -> Assertion[model.Document]:
expected_section_2_assertion = {
section: asrt.matches_sequence(expected[section])
for section in expected.keys()
}
assertion_on_dict = asrt.matches_mapping(expected_section_2_assertion)
return asrt.on_transformed(doc_to_mapping, assertion_on_dict)
def test_symbol_table_is_passed_to_resolve_method(self):
# ARRANGE #
symbol_name = 'symbol_name'
symbol_value = 'the symbol value'
string_sdv = _StringSdvTestImpl(
resolve_string_via_symbol_table(symbol_name))
symbol_table = StringConstantSymbolContext(symbol_name,
symbol_value).symbol_table
is_expected_resolved_value = asrt.on_transformed(
_resolve_ddv, asrt.equals(symbol_value))
assertion = sut.matches_sdv(asrt.anything_goes(),
asrt.anything_goes(),
is_expected_resolved_value,
symbols=symbol_table)
# ACT & ASSERT #
assertion.apply_without_message(self, string_sdv)
def matches_resolver_of_logic_type(resolver_type: type,
logic_value_type: LogicValueType,
value_type: ValueType,
resolved_value: ValueAssertion = asrt.anything_goes(),
references: ValueAssertion[Sequence[SymbolReference]] = asrt.is_empty_sequence,
symbols: symbol_table.SymbolTable = None) -> ValueAssertion[Any]:
symbols = symbol_table.symbol_table_from_none_or_value(symbols)
def resolve_value(resolver: LogicValueResolver) -> LineMatcher:
return resolver.resolve(symbols)
return asrt.is_instance_with(resolver_type,
asrt.and_([
is_resolver_of_logic_type(logic_value_type,
value_type),
asrt.on_transformed(resolve_value,
resolved_value),
asrt.sub_component('references',
resolver_structure.get_references,
references),
]))
def sds_root_dir_does_not_exist() -> ValueAssertion[SandboxDirectoryStructure]:
return asrt.on_transformed(lambda sds: sds.root_dir,
file_does_not_exist())
def sds_root_dir_exists_and_has_sds_dirs() -> ValueAssertion[SandboxDirectoryStructure]:
return asrt.on_transformed(lambda sds: str(sds.root_dir),
is_sds_root_dir())
def rendered_text_matches(text: Assertion[str]) -> Assertion[TextRenderer]:
return asrt_renderer.is_renderer_of_major_blocks(
asrt.on_transformed(render_to_str.print_major_blocks, text))
def sds_root_dir_does_not_exist() -> Assertion[SandboxDs]:
return asrt.on_transformed(lambda sds: sds.root_dir,
file_does_not_exist())
def sds_root_dir_exists_and_has_sds_dirs() -> Assertion[SandboxDs]:
return asrt.on_transformed(lambda sds: str(sds.root_dir),
is_sds_root_dir())
def first_line(assertion: Assertion[str]) -> Assertion[str]:
return asrt.on_transformed(get_first_line, assertion)
def path_as_str(path: Assertion[str]) -> Assertion[pathlib.Path]:
return asrt.on_transformed(
str,
path,
)
def str_as_path(path: Assertion[pathlib.Path]) -> Assertion[str]:
return asrt.on_transformed(
pathlib.Path,
path,
)
def file_names_equals(
expected: Set[PurePosixPath]
) -> Assertion[Mapping[PurePosixPath, Optional[FileMatcher]]]:
return asrt.on_transformed(lambda d: d.keys(), asrt.equals(expected))
