def equals_container(
expected: SymbolContainer,
ignore_source_line: bool = True) -> Assertion[SymbolContainer]:
"""
:param expected: Must contain a data type value
"""
component_assertions = [
asrt.sub_component('value_type', SymbolContainer.value_type.fget,
asrt.is_(expected.value_type)),
]
if not ignore_source_line:
component_assertions.append(
asrt.sub_component(
'definition_source', SymbolContainer.definition_source.fget,
equals_line_sequence(expected.definition_source)))
component_assertions.append(
asrt.sub_component(
'source_location', SymbolContainer.source_location.fget,
asrt.is_none_or_instance_with(
SourceLocationInfo,
asrt_src_loc.is_valid_source_location_info())), )
expected_sdv = expected.sdv
assert isinstance(expected_sdv,
DataTypeSdv), 'All actual values must be DataTypeSdv'
component_assertions.append(
asrt.sub_component('sdv', SymbolContainer.sdv.fget,
equals_data_type_sdv(expected_sdv)))
return asrt.is_instance_with(SymbolContainer,
asrt.and_(component_assertions))
def equals_list_resolver_element(expected: list_resolver.Element,
symbols: SymbolTable = None) -> ValueAssertion:
if symbols is None:
symbols = symbol_table_with_values_matching_references(list(expected.references))
expected_resolved_value_list = expected.resolve(symbols)
assertion_on_resolved_value = asrt.matches_sequence(
[equals_string_value(sv) for sv in expected_resolved_value_list])
component_assertions = [
asrt.sub_component('references',
lambda x: list(x.references),
equals_symbol_references(list(expected.references))),
asrt.sub_component('resolved value',
lambda x: x.resolve(symbols),
assertion_on_resolved_value),
]
symbol_reference_assertion = asrt.is_none
if expected.symbol_reference_if_is_symbol_reference is not None:
symbol_reference_assertion = equals_symbol_reference(expected.symbol_reference_if_is_symbol_reference)
symbol_reference_component_assertion = asrt.sub_component('symbol_reference_if_is_symbol_reference',
lambda x: x.symbol_reference_if_is_symbol_reference,
symbol_reference_assertion)
component_assertions.append(symbol_reference_component_assertion)
return asrt.is_instance_with(
list_resolver.Element,
asrt.and_(component_assertions))
def test_false__with_message_builder(self):
with self.assertRaises(TestException):
value = ['not none']
sut.sub_component('component name', lambda x: x[0],
sut.ValueIsNone()).apply(
self.put, value,
sut.MessageBuilder('message head'))
def is_failure__of_indirect_reference(
failing_symbol: Assertion[str] = asrt.is_instance(str),
path_to_failing_symbol: Assertion[Sequence[str]] = asrt.is_instance(list),
error_message: Assertion[TextRenderer] = asrt_text_doc.is_any_text(),
meaning_of_failure: Assertion[
Optional[TextRenderer]] = asrt.is_none_or_instance_with(
SequenceRenderer, asrt_text_doc.is_any_text()),
) -> Assertion[Failure]:
return asrt.is_instance_with(
FailureOfIndirectReference,
asrt.and_([
asrt.sub_component('failing_symbol',
FailureOfIndirectReference.failing_symbol.fget,
failing_symbol),
asrt.sub_component(
'path_to_failing_symbol',
FailureOfIndirectReference.path_to_failing_symbol.fget,
path_to_failing_symbol),
asrt.sub_component(
'error', FailureOfIndirectReference.error.fget,
asrt_val_rest.matches_value_restriction_failure(
error_message)),
asrt.sub_component(
'meaning_of_failure',
FailureOfIndirectReference.meaning_of_failure.fget,
meaning_of_failure),
]))
def equals(expected: Element) -> Assertion[Element]:
return asrt.and_([
asrt.sub_component(
'tag',
_get_element_tag,
asrt.equals(expected.tag),
),
asrt.sub_component(
'attributes',
_get_element_attrib,
asrt.equals(expected.attrib),
),
asrt.sub_component(
'text',
_get_element_text,
_text_assertion__none_eq_empty_str(expected.text),
),
asrt.sub_component(
'tail',
_get_element_tail,
_text_assertion__none_eq_empty_str(expected.tail),
),
asrt.sub_component(
'children',
_get_element_children,
asrt.matches_sequence__named([
NameAndValue(repr(child.tag), equals(child))
for child in list(expected)
]),
),
])
def assert_source(is_at_eof: Assertion[bool] = asrt.anything_goes(),
is_at_eol: Assertion[bool] = asrt.anything_goes(),
is_at_eol__except_for_space: Assertion[bool] = asrt.anything_goes(),
has_current_line: Assertion[bool] = asrt.anything_goes(),
current_line_number: Assertion[int] = asrt.anything_goes(),
current_line_text: Assertion[str] = asrt.anything_goes(),
column_index: Assertion[int] = asrt.anything_goes(),
remaining_part_of_current_line: Assertion[str] = asrt.anything_goes(),
remaining_source: Assertion[str] = asrt.anything_goes(),
) -> Assertion[ParseSource]:
return asrt.And([
asrt.is_instance(ParseSource, 'Value to apply assertions on must be a {}'.format(ParseSource)),
asrt.sub_component('is_at_eof', ParseSource.is_at_eof.fget, is_at_eof),
asrt.sub_component('has_current_line', ParseSource.has_current_line.fget, has_current_line),
asrt.Or([
asrt.sub_component('has_current_line', ParseSource.has_current_line.fget, asrt.equals(False)),
# The following must only be checked if has_current_line (because of precondition of ParseSource):
asrt.And([
asrt.sub_component('is_at_eol', ParseSource.is_at_eol.fget, is_at_eol),
asrt.sub_component('is_at_eol__except_for_space', ParseSource.is_at_eol__except_for_space.fget,
is_at_eol__except_for_space),
asrt.sub_component('current_line_number', ParseSource.current_line_number.fget, current_line_number),
asrt.sub_component('column_index', ParseSource.column_index.fget, column_index),
asrt.sub_component('current_line_text', ParseSource.current_line_text.fget, current_line_text),
asrt.sub_component('remaining_part_of_current_line', ParseSource.remaining_part_of_current_line.fget,
remaining_part_of_current_line),
])
]),
asrt.sub_component('remaining_source', ParseSource.remaining_source.fget, remaining_source),
])
def type_is_file_on_disk(
path_of_file_on_disk: Assertion[pathlib.Path],
fileno: Assertion[int] = asrt.anything_goes(),
) -> Assertion[sut.SpooledTextFile]:
return asrt.and_([
asrt.sub_component(
'is_mem_buff',
sut.SpooledTextFile.is_mem_buff.fget,
asrt.equals(False),
),
asrt.sub_component(
'is_file_on_disk',
sut.SpooledTextFile.is_file_on_disk.fget,
asrt.equals(True),
),
asrt.sub_component(
'fileno',
sut.SpooledTextFile.fileno,
asrt.is_instance_with(int, fileno),
),
asrt.sub_component(
'path_of_file_on_disk',
sut.SpooledTextFile.path_of_file_on_disk.fget,
path_of_file_on_disk,
),
])
def is_line(description: str = '') -> Assertion[Any]:
return asrt.is_instance_with(
Line,
asrt.And([
asrt.sub_component('line_number', Line.line_number.fget,
asrt.is_instance(int)),
asrt.sub_component('text', Line.text.fget, asrt.is_instance(str))
]), description)
def test_false__with_message_builder(self):
with self.assertRaises(TestException):
value = ['not none']
sut.sub_component('component name',
lambda x: x[0],
sut.ValueIsNone()).apply(self.put,
value,
sut.MessageBuilder('message head'))
def assert_instruction(first_line_number: int,
source_string: str) -> ValueAssertion:
return asrt.And([
asrt.sub_component('first_line_number', Instruction.first_line_number.fget,
asrt.Equals(first_line_number)),
asrt.sub_component('source_string', Instruction.source_string.fget,
asrt.Equals(source_string))
])
def test_true(self):
value = [None]
sut.sub_component('component name', lambda x: x[0],
sut.ValueIsNone()).apply(self.put, value)
sut.sub_component('component name', lambda x: x[0],
sut.ValueIsNone()).apply(
self.put, value,
sut.MessageBuilder('message head'))
def equals_line(expected: Line) -> Assertion[Any]:
return asrt.is_instance_with(
Line,
asrt.And([
asrt.sub_component('line_number', Line.line_number.fget,
asrt.equals(expected.line_number)),
asrt.sub_component('text', Line.text.fget,
asrt.equals(expected.text))
]))
def is_name() -> Assertion:
return asrt.is_instance_with(
Name,
asrt.and_([
asrt.sub_component('singular', Name.singular.fget,
asrt.is_instance(str)),
asrt.sub_component('plural', Name.plural.fget,
asrt.is_instance(str)),
]))
def equals_name(name: Name) -> Assertion:
return asrt.is_instance_with(
Name,
asrt.and_([
asrt.sub_component('singular', Name.singular.fget,
asrt.equals(name.singular)),
asrt.sub_component('plural', Name.plural.fget,
asrt.equals(name.plural)),
]))
def assert_instruction(first_line_number: int,
source_string: str) -> Assertion:
return asrt.And([
asrt.sub_component('first_line_number',
Instruction.first_line_number.fget,
asrt.Equals(first_line_number)),
asrt.sub_component('source_string', Instruction.source_string.fget,
asrt.Equals(source_string))
])
def equals_simple_phase_step(
expected: SimplePhaseStep) -> Assertion[SimplePhaseStep]:
assert isinstance(expected, SimplePhaseStep), 'Must be SimplePhaseStep'
return asrt.and_([
asrt.sub_component('phase', SimplePhaseStep.phase.fget,
asrt.is_(expected.phase)),
asrt.sub_component('step', SimplePhaseStep.step.fget,
asrt.equals(expected.step)),
])
def matches(value: Assertion[bool] = asrt.is_instance(bool),
trace: Assertion[NodeRenderer[bool]] = asrt_trace_rendering.
matches_node_renderer()) -> Assertion[MatchingResult]:
return asrt.is_instance_with__many(MatchingResult, [
asrt.sub_component('value', MatchingResult.value.fget,
asrt.is_instance_with(bool, value)),
asrt.sub_component('trace', MatchingResult.trace.fget,
asrt.is_instance_with(NodeRenderer, trace)),
])
def equals_test_case_reference(
expected: TestCaseFileReference) -> Assertion[TestCaseFileReference]:
return asrt.is_instance_with__many(TestCaseFileReference, [
asrt.sub_component('file_path', TestCaseFileReference.file_path.fget,
asrt.equals(expected.file_path)),
asrt.sub_component('path_relativity_root_dir',
TestCaseFileReference.path_relativity_root_dir.fget,
asrt.equals(expected.path_relativity_root_dir)),
])
def matches_regex_resolver(
primitive_value: Callable[[HomeAndSds], ValueAssertion[Pattern]] = lambda tcds: asrt.anything_goes(),
references: ValueAssertion[Sequence[SymbolReference]] = asrt.is_empty_sequence,
dir_dependencies: DirDependencies = DirDependencies.NONE,
validation: ValidationExpectation = all_validations_passes(),
symbols: symbol_table.SymbolTable = None,
tcds: HomeAndSds = fake_home_and_sds(),
) -> ValueAssertion[RegexResolver]:
symbols = symbol_table.symbol_table_from_none_or_value(symbols)
def resolve_value(resolver: RegexResolver):
return resolver.resolve(symbols)
def on_resolve_primitive_value(tcds_: HomeAndSds) -> ValueAssertion[Pattern]:
return asrt.is_instance_with(RE_PATTERN_TYPE,
primitive_value(tcds_))
resolved_value_assertion = matches_multi_dir_dependent_value(
dir_dependencies,
on_resolve_primitive_value,
tcds,
)
def validation_is_successful(value: RegexValue) -> bool:
validator = value.validator()
return (validator.validate_pre_sds_if_applicable(tcds.hds) is None and
validator.validate_post_sds_if_applicable(tcds) is None)
return asrt.is_instance_with(
RegexResolver,
asrt.and_([
asrt.sub_component(
'references',
resolver_structure.get_references,
references),
asrt.sub_component(
'resolved value',
resolve_value,
asrt.and_([
asrt.sub_component(
'validator',
lambda value: value.validator(),
asrt.is_instance_with(PreOrPostSdsValueValidator,
PreOrPostSdsValueValidationAssertion(
tcds,
validation))
),
asrt.if_(
validation_is_successful,
resolved_value_assertion
),
]),
)
])
)
def equals_phase(expected: Phase) -> Assertion[Phase]:
assert isinstance(expected, Phase), 'Must be Phase'
return asrt.and_([
asrt.sub_component('the_enum', Phase.the_enum.fget,
asrt.equals(expected.the_enum)),
asrt.sub_component('section_name', Phase.section_name.fget,
asrt.equals(expected.section_name)),
asrt.sub_component('identifier', Phase.identifier.fget,
asrt.equals(expected.identifier)),
])
def matches_element_properties(
indentation: Assertion[Indentation] = matches_indentation(),
text_style: Assertion[Optional[TextStyle]] = matches_text_style(),
) -> Assertion[ElementProperties]:
return asrt.is_instance_with__many(ElementProperties, [
asrt.sub_component('indentation', ElementProperties.indentation.fget,
indentation),
asrt.sub_component('text_style', ElementProperties.text_style.fget,
text_style),
])
def equals_line(expected: Line) -> ValueAssertion[Any]:
return asrt.is_instance_with(Line,
asrt.And([
asrt.sub_component('line_number',
Line.line_number.fget,
asrt.equals(expected.line_number)),
asrt.sub_component('text',
Line.text.fget,
asrt.equals(expected.text))
]))
def path_relativity_variants_equals(expected: PathRelativityVariants) -> ValueAssertion:
return asrt.is_instance_with(PathRelativityVariants,
asrt.And([
asrt.sub_component('rel_option_types',
PathRelativityVariants.rel_option_types.fget,
asrt.equals(expected.rel_option_types)),
asrt.sub_component('absolute',
PathRelativityVariants.absolute.fget,
asrt.equals(expected.absolute)),
]))
def accessor_error_matches(
error: Assertion[AccessErrorType] = asrt.anything_goes(),
error_info: Assertion[ErrorInfo] = result_assertions.
error_info_matches()) -> Assertion[AccessorError]:
return asrt.is_instance_with__many(AccessorError, [
asrt.sub_component('error', AccessorError.error.fget,
asrt.is_instance_with(AccessErrorType, error)),
asrt.sub_component('error_info', AccessorError.error_info.fget,
asrt.is_instance_with(ErrorInfo, error_info)),
])
def path_relativity_variants_equals(expected: PathRelativityVariants) -> Assertion:
return asrt.is_instance_with(PathRelativityVariants,
asrt.And([
asrt.sub_component('rel_option_types',
PathRelativityVariants.rel_option_types.fget,
asrt.equals(expected.rel_option_types)),
asrt.sub_component('absolute',
PathRelativityVariants.absolute.fget,
asrt.equals(expected.absolute)),
]))
def is_name() -> ValueAssertion:
return asrt.is_instance_with(Name,
asrt.and_([
asrt.sub_component('singular',
Name.singular.fget,
asrt.is_instance(str)),
asrt.sub_component('plural',
Name.plural.fget,
asrt.is_instance(str)),
]))
def equals_entity_type_names(entity_type_names: EntityTypeNames) -> Assertion:
return asrt.is_instance_with(
EntityTypeNames,
asrt.and_([
asrt.sub_component('identifier', EntityTypeNames.identifier.fget,
asrt.equals(entity_type_names.identifier)),
asrt.sub_component('name', EntityTypeNames.name.fget,
equals_name_with_gender(
entity_type_names.name)),
]))
def equals_simple_phase_step(expected: SimplePhaseStep) -> ValueAssertion[SimplePhaseStep]:
assert isinstance(expected, SimplePhaseStep), 'Must be SimplePhaseStep'
return asrt.and_([
asrt.sub_component('phase',
SimplePhaseStep.phase.fget,
asrt.is_(expected.phase)),
asrt.sub_component('step',
SimplePhaseStep.step.fget,
asrt.equals(expected.step)),
])
def test_true(self):
value = [None]
sut.sub_component('component name',
lambda x: x[0],
sut.ValueIsNone()).apply(self.put, value)
sut.sub_component('component name',
lambda x: x[0],
sut.ValueIsNone()).apply(self.put,
value,
sut.MessageBuilder('message head'))
def assert_token(token_type: ValueAssertion = asrt.anything_goes(),
string: ValueAssertion = asrt.anything_goes(),
source_string: ValueAssertion = asrt.anything_goes()) -> ValueAssertion:
return asrt.And([
asrt.is_instance(Token, 'Value to apply assertions on must be a {}'.format(
Token)),
asrt.sub_component('type', Token.type.fget, token_type),
asrt.sub_component('string', Token.string.fget, string),
asrt.sub_component('source_string', Token.source_string.fget, source_string),
])
def equals_name(name: Name) -> ValueAssertion:
return asrt.is_instance_with(Name,
asrt.and_([
asrt.sub_component('singular',
Name.singular.fget,
asrt.equals(name.singular)),
asrt.sub_component('plural',
Name.plural.fget,
asrt.equals(name.plural)),
]))
def assert_token_stream(
source: ValueAssertion[str] = asrt.anything_goes(),
remaining_source: ValueAssertion[str] = asrt.anything_goes(),
remaining_part_of_current_line: ValueAssertion[str] = asrt.anything_goes(),
remaining_source_after_head: ValueAssertion[str] = asrt.anything_goes(),
is_null: ValueAssertion[bool] = asrt.anything_goes(),
head_token: ValueAssertion[Token] = asrt.anything_goes(),
look_ahead_state: ValueAssertion[LookAheadState] = asrt.anything_goes(),
position: ValueAssertion[int] = asrt.anything_goes()) -> ValueAssertion:
return asrt.is_instance_with(
TokenStream,
asrt.and_([
asrt.sub_component('source', TokenStream.source.fget, source),
asrt.sub_component('remaining_source',
TokenStream.remaining_source.fget,
remaining_source),
asrt.sub_component('remaining_part_of_current_line',
TokenStream.remaining_part_of_current_line.fget,
remaining_part_of_current_line),
asrt.sub_component('position', TokenStream.position.fget, position),
asrt.sub_component('look_ahead_state', TokenStream.look_ahead_state.fget, look_ahead_state),
asrt.sub_component('is_null', TokenStream.is_null.fget, is_null),
asrt.or_([
asrt.sub_component('is_null', TokenStream.is_null.fget, asrt.is_true),
# The following must only be checked if not is_null (because of precondition):
asrt.and_([
asrt.sub_component('head_token', TokenStream.head.fget, head_token),
asrt.sub_component('remaining_source_after_head',
TokenStream.remaining_source_after_head.fget, remaining_source_after_head),
])
]),
]))
def matches_file_inclusion_directive(
files_to_include: Assertion[Sequence[pathlib.Path]] = asrt.anything_goes(),
source: Assertion[LineSequence] = asrt.anything_goes(),
) -> Assertion[ParsedFileInclusionDirective]:
return asrt.and_([
asrt.sub_component('files_to_include',
ParsedFileInclusionDirective.files_to_include.fget,
files_to_include),
asrt.sub_component('source', ParsedFileInclusionDirective.source.fget,
source),
])
def is_hard_error(assertion_on_error_message: ValueAssertion = asrt.anything_goes()
) -> ValueAssertion[sh.SuccessOrHardError]:
return is_sh_and(asrt.And([
asrt.sub_component('is_hard_error',
sh.SuccessOrHardError.is_hard_error.fget,
asrt.equals(True,
'Status is expected to be hard-error')),
asrt.sub_component('error message',
sh.SuccessOrHardError.failure_message.fget,
assertion_on_error_message)
]))
def equals(
exit_code: int,
stderr_contents: Optional[str]) -> Assertion[ExecutionResultAndStderr]:
return asrt.is_instance_with__many(ExecutionResultAndStderr, [
asrt.sub_component('stderr',
ExecutionResultAndStderr.stderr_contents.fget,
asrt.equals(stderr_contents)),
asrt.sub_component('exit_code',
ExecutionResultAndStderr.exit_code.fget,
asrt.equals(exit_code)),
])
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 is_line(description: str = '') -> ValueAssertion[Any]:
return asrt.is_instance_with(Line,
asrt.And([
asrt.sub_component('line_number',
Line.line_number.fget,
asrt.is_instance(int)),
asrt.sub_component('text',
Line.text.fget,
asrt.is_instance(str))
]),
description)
def file_source_error_equals_line(
line: Line, maybe_section_name: Assertion[str] = asrt.anything_goes()
) -> Assertion[FileSourceError]:
return asrt.and_([
asrt.sub_component('maybe_section_name',
FileSourceError.maybe_section_name.fget,
maybe_section_name),
asrt.sub_component('source', FileSourceError.source.fget,
equals_line_sequence(
line_sequence_from_line(line))),
])
def has(timeout: ValueAssertion[Optional[int]] = asrt.anything_goes(),
test_case_status: ValueAssertion[TestCaseStatus] = asrt.anything_goes(),
) -> ValueAssertion[ConfigurationBuilder]:
return asrt.and_([
asrt.sub_component('timeout',
ConfigurationBuilder.timeout_in_seconds.fget,
timeout),
asrt.sub_component('test-case-status',
ConfigurationBuilder.test_case_status.fget,
test_case_status),
])
def equals_list_item(expected: HeaderContentListItem) -> Assertion:
return asrt.is_instance_with(
HeaderContentListItem,
asrt.and_([
asrt.sub_component('header', HeaderContentListItem.header.fget,
equals_text(expected.header)),
asrt.sub_component(
'content_paragraph_items',
HeaderContentListItem.content_paragraph_items.fget,
equals_paragraph_items(expected.content_paragraph_items)),
]))
def matches_instruction_info(assertion_on_description: ValueAssertion[str],
assertion_on_instruction: ValueAssertion[model.Instruction],
) -> ValueAssertion[model.InstructionInfo]:
return asrt.and_([
asrt.sub_component('description',
model.InstructionInfo.description.fget,
assertion_on_description),
asrt.sub_component('instruction',
model.InstructionInfo.instruction.fget,
assertion_on_instruction),
])
def file_source_error_equals_line(line: Line,
maybe_section_name: ValueAssertion[str] = asrt.anything_goes()
) -> ValueAssertion[FileSourceError]:
return asrt.and_([
asrt.sub_component('maybe_section_name',
FileSourceError.maybe_section_name.fget,
maybe_section_name),
asrt.sub_component('source',
FileSourceError.source.fget,
equals_line_sequence(line_sequence_from_line(line))),
])
def equals_test_case_reference(expected: TestCaseFileReference) -> ValueAssertion[TestCaseFileReference]:
return asrt.and_([
asrt.sub_component('file_path',
TestCaseFileReference.file_path.fget,
asrt.equals(expected.file_path)
),
asrt.sub_component('file_reference_relativity_root_dir',
TestCaseFileReference.file_reference_relativity_root_dir.fget,
asrt.equals(expected.file_reference_relativity_root_dir)
),
])
def result_for_executed_status_matches(
full_result_status: FullExeResultStatus) -> Assertion[Result]:
def get_full_result_status(result: Result) -> FullExeResultStatus:
return result.execution_result.status
return asrt.and_([
asrt.sub_component('status', Result.status.fget,
asrt.equals(Status.EXECUTED)),
asrt.sub_component('full_result/status', get_full_result_status,
asrt.equals(full_result_status)),
])
def result_matches(
hds: Assertion[HomeDs] = asrt.anything_goes(),
sds: Assertion[SandboxDs] = asrt.anything_goes(),
partial_result: Assertion[PartialExeResult] = asrt.anything_goes(),
) -> Assertion[Result]:
return asrt.and_([
asrt.sub_component('hds', Result.hds.fget, hds),
asrt.sub_component('sds', Result.sds.fget, sds),
asrt.sub_component('partial_result', Result.partial_result.fget,
partial_result),
])
def matches_reference(assertion_on_name: ValueAssertion[str] = asrt.anything_goes(),
assertion_on_restrictions: ValueAssertion[ReferenceRestrictions] = asrt.anything_goes()
) -> ValueAssertion[su.SymbolReference]:
return asrt.and_([
asrt.sub_component('name',
su.SymbolReference.name.fget,
assertion_on_name),
asrt.sub_component('restrictions',
su.SymbolReference.restrictions.fget,
assertion_on_restrictions)
])
def matches_source_location(source: ValueAssertion[LineSequence] = asrt.anything_goes(),
file_path_rel_referrer: ValueAssertion[pathlib.Path] = asrt.anything_goes(),
) -> ValueAssertion[SourceLocation]:
return asrt.is_instance_with(SourceLocation,
asrt.and_([
asrt.sub_component('source',
SourceLocation.source.fget,
source),
asrt.sub_component('file_path_rel_referrer',
SourceLocation.file_path_rel_referrer.fget,
file_path_rel_referrer),
]))
def is_value_failure(message: ValueAssertion) -> ValueAssertion:
return asrt.is_instance_with(
ValueRestrictionFailure,
asrt.and_([
asrt.sub_component('message',
ValueRestrictionFailure.message.fget,
message),
asrt.sub_component('message',
ValueRestrictionFailure.how_to_fix.fget,
asrt.is_instance(str)),
])
)
def equals_entity_type_names(entity_type_names: EntityTypeNames) -> ValueAssertion:
return asrt.is_instance_with(EntityTypeNames,
asrt.and_([
asrt.sub_component('identifier',
EntityTypeNames.identifier.fget,
asrt.equals(entity_type_names.identifier)
),
asrt.sub_component('name',
EntityTypeNames.name.fget,
equals_name_with_gender(entity_type_names.name)
),
]))
def matches_file_inclusion_directive(
files_to_include: ValueAssertion[Sequence[pathlib.Path]] = asrt.anything_goes(),
source: ValueAssertion[LineSequence] = asrt.anything_goes(),
) -> ValueAssertion[ParsedFileInclusionDirective]:
return asrt.and_([
asrt.sub_component('files_to_include',
ParsedFileInclusionDirective.files_to_include.fget,
files_to_include),
asrt.sub_component('source',
ParsedFileInclusionDirective.source.fget,
source),
])
def matches_line_sequence(first_line_number: ValueAssertion[int] = asrt.anything_goes(),
lines: ValueAssertion[Sequence[str]] = asrt.anything_goes(),
) -> ValueAssertion[LineSequence]:
return asrt.is_instance_with(LineSequence,
asrt.and_([
asrt.sub_component('first_line_number',
LineSequence.first_line_number.fget,
first_line_number),
asrt.sub_component('lines',
LineSequence.lines.fget,
lines),
]))
def is_hard_error(
assertion_on_error_message: Assertion[TextRenderer] = asrt_text_doc.
is_any_text()) -> Assertion[sh.SuccessOrHardError]:
return is_sh_and(
asrt.And([
asrt.sub_component(
'is_hard_error', sh.SuccessOrHardError.is_hard_error.fget,
asrt.equals(True, 'Status is expected to be hard-error')),
asrt.sub_component('failure_message',
sh.SuccessOrHardError.failure_message.fget,
assertion_on_error_message)
]))
def matches(
message: Assertion[TextRenderer]) -> Assertion[ErrorMessageWithFixTip]:
return asrt.is_instance_with(
ErrorMessageWithFixTip,
asrt.and_([
asrt.sub_component('message', ErrorMessageWithFixTip.message.fget,
message),
asrt.sub_component(
'how_to_fix', ErrorMessageWithFixTip.how_to_fix.fget,
asrt.is_none_or_instance_with(Renderer,
asrt_text_doc.is_any_text())),
]))
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 matches_file_source_error(
maybe_section_name: Assertion[str],
location_path: Sequence[SourceLocation]) -> Assertion[FileSourceError]:
return asrt.and_([
asrt.sub_component('maybe_section_name',
FileSourceError.maybe_section_name.fget,
maybe_section_name),
asrt.sub_component('message', FileSourceError.message.fget,
asrt.is_not_none),
asrt.sub_component('location_path', FileSourceError.location_path.fget,
equals_source_location_sequence(location_path)),
])
def equals_shell_command_driver(expected: CommandDriverForShell) -> ValueAssertion[CommandDriver]:
return asrt.is_instance_with_many(CommandDriverForShell,
[
asrt.sub_component('shell_command_line',
CommandDriverForShell.shell_command_line.fget,
asrt.equals(expected.shell_command_line)
),
asrt.sub_component('shell',
_get_is_shell,
asrt.equals(True)
),
])
def matches_source_location_path(
source_location: ValueAssertion[SourceLocation] = asrt.anything_goes(),
file_inclusion_chain: ValueAssertion[Sequence[SourceLocation]] = asrt.anything_goes(),
) -> ValueAssertion[SourceLocationPath]:
return asrt.is_instance_with(SourceLocationPath,
asrt.and_([
asrt.sub_component('location',
SourceLocationPath.location.fget,
source_location),
asrt.sub_component('file_inclusion_chain',
SourceLocationPath.file_inclusion_chain.fget,
file_inclusion_chain),
]))
def equals_phase(expected: Phase) -> ValueAssertion[Phase]:
assert isinstance(expected, Phase), 'Must be Phase'
return asrt.and_([
asrt.sub_component('the_enum',
Phase.the_enum.fget,
asrt.equals(expected.the_enum)),
asrt.sub_component('section_name',
Phase.section_name.fget,
asrt.equals(expected.section_name)),
asrt.sub_component('identifier',
Phase.identifier.fget,
asrt.equals(expected.identifier)),
])
def equals_executable_file_command_driver(expected: CommandDriverForExecutableFile
) -> ValueAssertion[CommandDriver]:
return asrt.is_instance_with_many(CommandDriverForExecutableFile,
[
asrt.sub_component('executable_file',
CommandDriverForExecutableFile.executable_file.fget,
asrt.equals(expected.executable_file)
),
asrt.sub_component('shell',
_get_is_shell,
asrt.equals(False)
),
])
def equals_system_program_command_driver(expected: CommandDriverForSystemProgram
) -> ValueAssertion[CommandDriver]:
return asrt.is_instance_with_many(CommandDriverForSystemProgram,
[
asrt.sub_component('executable_file',
CommandDriverForSystemProgram.program.fget,
asrt.equals(expected.program)
),
asrt.sub_component('shell',
_get_is_shell,
asrt.equals(False)
),
])