def __init__(self,
main_method_type: MainMethodType,
validation: ValidationAssertions = ValidationAssertions.all_passes(),
main_result: Assertion[T] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(),
side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(),
side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(),
main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
instruction_environment:
Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(),
setup_settings: Assertion[Optional[SettingsBuilderAssertionModel]] = asrt.is_none,
):
self.main_method_type = main_method_type
self.validation = validation
self.main_result = main_result
self.main_raises_hard_error = main_raises_hard_error
self.proc_exe_settings = proc_exe_settings
self.instruction_settings = instruction_settings
self.main_side_effects_on_sds = main_side_effects_on_sds
self.side_effects_on_tcds = side_effects_on_tcds
self.side_effects_on_hds = side_effects_on_hds
self.main_side_effect_on_environment_variables = main_side_effect_on_environment_variables
self.instruction_application_environment = instruction_environment
self.setup_settings = setup_settings
def phase_agnostic_2(
validation: ValidationAssertions = ValidationAssertions.all_passes(),
main_result: Assertion[T] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence,
symbols_after_main: Assertion[SymbolTable] = asrt.anything_goes(),
main_side_effects_on_files: TcdsExpectation = TcdsExpectation(),
main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
instruction_environment:
Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(),
) -> 'MultiSourceExpectation[T]':
return MultiSourceExpectation.phase_agnostic(
validation,
main_result,
main_raises_hard_error,
symbol_usages,
symbols_after_main,
main_side_effects_on_files.sds,
main_side_effects_on_files.tcds,
main_side_effects_on_files.case_home,
main_side_effect_on_environment_variables,
proc_exe_settings,
instruction_settings,
instruction_environment,
)
def phase_agnostic(
validation: ValidationAssertions = ValidationAssertions.all_passes(),
main_result: Assertion[T] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(),
side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(),
side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(),
main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
instruction_environment:
Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(),
) -> 'ExecutionExpectation[T]':
return ExecutionExpectation(
MainMethodType.PHASE_AGNOSTIC,
validation,
main_result,
main_raises_hard_error,
main_side_effects_on_sds,
side_effects_on_tcds,
side_effects_on_hds,
main_side_effect_on_environment_variables,
proc_exe_settings,
instruction_settings,
instruction_environment,
asrt.is_none,
)
def phase_agnostic_3(
validation: ValidationAssertions = validation_utils.ValidationAssertions.all_passes(),
main_result: Assertion[T] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence,
symbols_after_main: Assertion[SymbolTable] = asrt.anything_goes(),
main_side_effects_on_files: TcdsExpectation = TcdsExpectation(),
source: Assertion[ParseSource] = asrt.anything_goes(),
main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
assertion_on_instruction_environment:
Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(),
) -> 'Expectation[T]':
return Expectation(
MainMethodType.PHASE_AGNOSTIC,
validation_pre_sds=validation.pre_sds,
validation_post_sds=validation.post_sds,
main_result=main_result,
main_raises_hard_error=main_raises_hard_error,
symbol_usages=symbol_usages,
symbols_after_main=symbols_after_main,
main_side_effects_on_sds=main_side_effects_on_files.sds,
side_effects_on_tcds=main_side_effects_on_files.tcds,
side_effects_on_hds=main_side_effects_on_files.case_home,
source=source,
proc_exe_settings=proc_exe_settings,
instruction_settings=instruction_settings,
main_side_effect_on_environment_variables=main_side_effect_on_environment_variables,
assertion_on_instruction_environment=assertion_on_instruction_environment,
setup_settings=asrt.is_none,
)
def setup_phase_aware(
validation: ValidationAssertions = ValidationAssertions.all_passes(),
main_result: Assertion[T] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence,
symbols_after_main: Assertion[SymbolTable] = asrt.anything_goes(),
main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(),
side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(),
side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(),
main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
instruction_environment:
Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(),
setup_settings: Assertion[Optional[SettingsBuilderAssertionModel]] = asrt.is_none,
) -> 'MultiSourceExpectation[T]':
return MultiSourceExpectation(
MainMethodType.SETUP_PHASE_AWARE,
validation,
main_result,
main_raises_hard_error,
symbol_usages,
symbols_after_main,
main_side_effects_on_sds,
side_effects_on_tcds,
side_effects_on_hds,
main_side_effect_on_environment_variables,
proc_exe_settings,
instruction_settings,
instruction_environment,
setup_settings,
)
def test_matches(self):
cases = [
NEA(
'empty list of line elements',
expected=sut.matches_line_element(
asrt.is_instance(LineObjectForTest), ),
actual=LineElement(LineObjectForTest()),
),
NEA(
'line object',
expected=sut.matches_line_element(
asrt.is_instance(LineObjectForTest)),
actual=LineElement(LineObjectForTest()),
),
NEA(
'element properties',
expected=sut.matches_line_element(
asrt.anything_goes(),
properties=asrt.is_instance(ElementProperties),
),
actual=LineElement(LineObjectForTest(),
ELEMENT_PROPERTIES__NEUTRAL),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
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 test_not_matches(self):
cases = [
NEA(
'actual is empty list of line elements',
expected=sut.matches_major_block(
asrt.not_(asrt.is_empty_sequence)),
actual=MajorBlock([]),
),
NEA(
'actual element is unexpected',
expected=sut.matches_major_block(
asrt.matches_sequence(
[asrt.not_(asrt.is_instance(MinorBlock))])),
actual=MajorBlock([MinorBlock([])]),
),
NEA(
'unexpected element properties',
expected=sut.matches_major_block(
asrt.anything_goes(),
properties=asrt.not_(asrt.is_instance(ElementProperties))),
actual=MajorBlock(
[MinorBlock([], ELEMENT_PROPERTIES__NEUTRAL)]),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected, case.actual)
def __init__(
self,
validation_post_sds: Assertion[svh.SuccessOrValidationErrorOrHardError] =
svh_assertions.is_success(),
validation_pre_sds: Assertion[svh.SuccessOrValidationErrorOrHardError] =
svh_assertions.is_success(),
main_result: Assertion[pfh.PassOrFailOrHardError] = pfh_assertions.is_pass(),
symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence,
main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(),
main_side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(),
source: Assertion[ParseSource] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings)
):
super().__init__(
symbol_usages,
ExecutionExpectation(
validation_post_sds,
validation_pre_sds,
main_result,
main_raises_hard_error,
main_side_effects_on_sds,
main_side_effects_on_tcds,
proc_exe_settings,
instruction_settings,
)
)
self.source = source
self.symbol_usages = symbol_usages
def __new__(cls,
validation_post_sds: Assertion[svh.SuccessOrValidationErrorOrHardError] =
svh_assertions.is_success(),
validation_pre_sds: Assertion[svh.SuccessOrValidationErrorOrHardError] =
svh_assertions.is_success(),
main_result: Assertion[pfh.PassOrFailOrHardError] = pfh_assertions.is_pass(),
main_raises_hard_error: bool = False,
main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(),
main_side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings)
):
return tuple.__new__(cls, (
validation_post_sds,
validation_pre_sds,
main_result,
main_raises_hard_error,
main_side_effects_on_sds,
main_side_effects_on_tcds,
proc_exe_settings,
instruction_settings
))
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 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 is_line_sequence(description: str = '') -> Assertion[LineSequence]:
return asrt.is_instance_with(
LineSequence,
asrt.And([
asrt.sub_component('line_number',
LineSequence.first_line_number.fget,
asrt.is_instance(int)),
asrt.sub_component_sequence('lines', LineSequence.lines.fget,
asrt.is_instance(str))
]), description)
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 check(self,
put: unittest.TestCase,
actual: FullDepsSdv[StringSource],
message_builder: MessageBuilder,
):
asrt.is_instance(StringSourceSdv).apply(
put,
actual,
message_builder
)
def _resolve_primitive_value(self, transformer_value: StringTransformerValue) -> StringTransformer:
ret_val = transformer_value.value_of_any_dependency(self.tcds)
asrt.is_instance(StringTransformer).apply_with_message(self.put,
ret_val,
'primitive value')
assert isinstance(ret_val, StringTransformer)
return ret_val
def _resolve_value(self, transformer_resolver: StringTransformerResolver) -> StringTransformerValue:
transformer_value = transformer_resolver.resolve(self.arrangement.symbols)
asrt.is_instance(StringTransformerValue).apply_with_message(self.put,
transformer_value,
'resolved value')
assert isinstance(transformer_value, StringTransformerValue)
return transformer_value
def check(self,
put: unittest.TestCase,
actual: FullDepsSdv[PRIMITIVE],
message_builder: MessageBuilder,
):
asrt.is_instance(FullDepsSdv).apply(put,
actual,
message_builder.for_sub_component('type'))
assert isinstance(actual, FullDepsSdv) # Type info for IDE
self._is_valid_sdv.apply(put, actual, message_builder)
def is_xpass(sds: Assertion[Optional[SandboxDs]] = asrt.is_instance(SandboxDs),
action_to_check_outcome: Assertion[
Optional[ActionToCheckOutcome]] = asrt.is_instance(
ActionToCheckOutcome)) -> Assertion[FullExeResult]:
return matches(status=asrt.is_(FullExeResultStatus.XPASS),
failure_info=asrt.is_none,
has_sds=asrt.equals(True),
sds=sds,
has_action_to_check_outcome=asrt.equals(True),
action_to_check_outcome=action_to_check_outcome)
def check(self,
put: unittest.TestCase,
actual: FullDepsSdv[FilesCondition],
message_builder: MessageBuilder,
):
asrt.is_instance(FilesConditionSdv).apply(
put,
actual,
message_builder
)
def is_line_sequence(description: str = '') -> ValueAssertion[Any]:
return asrt.is_instance_with(LineSequence,
asrt.And([
asrt.sub_component('line_number',
LineSequence.first_line_number.fget,
asrt.is_instance(int)),
asrt.sub_component_list('lines',
LineSequence.lines.fget,
asrt.is_instance(str))
]),
description)
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 is_xpass(sds: ValueAssertion[Optional[SandboxDirectoryStructure]] =
asrt.is_instance(SandboxDirectoryStructure),
action_to_check_outcome: ValueAssertion[Optional[ActionToCheckOutcome]] =
asrt.is_instance(ActionToCheckOutcome)
) -> ValueAssertion[FullExeResult]:
return matches(status=asrt.is_(FullExeResultStatus.XPASS),
failure_info=asrt.is_none,
has_sds=asrt.equals(True),
sds=sds,
has_action_to_check_outcome=asrt.equals(True),
action_to_check_outcome=action_to_check_outcome)
def _resolve_adv(
self, ddv: FullDepsDdv[PRIMITIVE], message_builder: MessageBuilder
) -> ApplicationEnvironmentDependentValue[PRIMITIVE]:
adv = ddv.value_of_any_dependency(self.tcds)
asrt.is_instance(ApplicationEnvironmentDependentValue).apply(
self.put,
adv,
message_builder,
)
return adv
def _resolve_ddv(
self,
sdv: FullDepsSdv[PRIMITIVE],
message_builder: asrt.MessageBuilder,
) -> FullDepsDdv[PRIMITIVE]:
ddv = sdv.resolve(self.arrangement.symbols)
asrt.is_instance(FullDepsDdv).apply(self.put, ddv, message_builder)
assert isinstance(ddv, FullDepsDdv)
return ddv
def _apply(self, put: unittest.TestCase, value,
message_builder: asrt.MessageBuilder):
asrt.is_instance(DependenciesAwareDdv).apply(put, value,
message_builder)
assert isinstance(value, DependenciesAwareDdv) # Type info for IDE
self._check_resolving_dependencies(put, value, message_builder)
self._check_sub_class_properties(put, value, self.tcds,
message_builder)
self._check_resolved_value(put, value, self.tcds, message_builder)
def _apply(self,
put: unittest.TestCase,
value,
message_builder: asrt.MessageBuilder):
asrt.is_instance(DirDependentValue).apply(put, value, message_builder)
assert isinstance(value, DirDependentValue) # Type info for IDE
self._check_resolving_dependencies(put, value, message_builder)
self._check_sub_class_properties(put, value, self.tcds, message_builder)
self._check_resolved_value(put, value, self.tcds, message_builder)
def _parse(self) -> StringTransformerResolver:
resolver = self.parser.parse(self.source)
asrt.is_instance(StringTransformerResolver).apply_with_message(self.put,
resolver,
'resolver')
assert isinstance(resolver, StringTransformerResolver)
self.expectation.source.apply_with_message(self.put,
self.source,
'source after parse')
return resolver
def check_primitive(self,
put: unittest.TestCase,
actual: PRIM_W_NODE_DESC,
message_builder: MessageBuilder,
):
asrt.is_instance(self._expected_primitive_object_type).apply(
put,
actual,
message_builder.for_sub_component('object type'),
)
self._check_structure_of_primitive(put, actual, message_builder)
def check_primitive(self,
put: unittest.TestCase,
actual: PRIM_W_DETAIL_DESC,
message_builder: MessageBuilder,
):
asrt.is_instance(self._expected_primitive_object_type).apply(
put,
actual,
message_builder.for_sub_component('object type'),
)
self._check_sanity_of_details_renderer(put, message_builder, actual)
def _apply(self,
put: unittest.TestCase,
value: Program,
message_builder: MessageBuilder):
asrt.is_instance(Program).apply(put, value, message_builder.for_sub_component('class'))
assert isinstance(value, Program)
self.command.apply(put, value.command, message_builder.for_sub_component('command'))
self.stdin.apply(put, value.stdin, message_builder.for_sub_component('stdin'))
self.transformer.apply(put, value.transformation, message_builder.for_sub_component('transformation'))
def test_fail_due_to_fail_of_side_effects_on_instruction_settings(self):
with self.assertRaises(utils.TestError):
self._check(
utils.ParserThatGives(SUCCESSFUL_INSTRUCTION),
single_line_source(), sut.Arrangement(),
sut.Expectation(instruction_settings=asrt.not_(
asrt.is_instance(InstructionSettings))))
def check_exception(self,
root_path: pathlib.Path,
actual: Exception,
put: unittest.TestCase):
put.assertIsInstance(actual, SuiteParseError)
expected_source = single_line_sequence(2, self.file_inclusion_line)
expectation = matches_suite_parse_error(
suite_file=asrt.equals(self.root_suite_based_at(root_path)),
maybe_section_name=asrt.equals(phase_names.SETUP.plain),
source=equals_line_sequence(expected_source),
source_location=equals_source_location_path(
SourceLocationPath(
SourceLocation(
expected_source,
self.root_suite_file,
),
[]
)
),
document_parser_exception=asrt.is_instance(sec_doc_exceptions.FileAccessError),
)
expectation.apply(put, actual)
def test_builtin(self):
# ACT #
actual = sut.defined_at_line__err_msg_lines(None)
# ASSERT #
is_list_of_strings = asrt.is_sequence_of(asrt.is_instance(str))
is_list_of_strings.apply_without_message(self, actual)
def expect_success(self,
main_side_effects_on_sds: Assertion = asrt.anything_goes(),
symbol_usages: Assertion = asrt.is_empty_sequence,
source: Assertion[ParseSource] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
):
return ic.Expectation(
source=source,
symbol_usages=symbol_usages,
main_side_effects_on_sds=main_side_effects_on_sds,
proc_exe_settings=proc_exe_settings,
instruction_settings=instruction_settings,
)
def _apply(self, put: unittest.TestCase, value: Program,
message_builder: MessageBuilder):
asrt.is_instance(Program).apply(
put, value, message_builder.for_sub_component('class'))
assert isinstance(value, Program)
self.command.apply(put, value.command,
message_builder.for_sub_component('command'))
self.stdin.apply(put, value.stdin,
message_builder.for_sub_component('stdin'))
self.transformer.apply(
put, value.transformation,
message_builder.for_sub_component('transformation'))
def test_builtin(self):
# ACT #
actual = sut.defined_at_line__err_msg_lines(None)
# ASSERT #
is_list_of_strings = asrt.is_sequence_of(asrt.is_instance(str))
is_list_of_strings.apply_without_message(self, 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 check_exception(self,
root_path: pathlib.Path,
actual: Exception,
put: unittest.TestCase):
put.assertIsInstance(actual, SuiteParseError)
expected_source = single_line_sequence(1, '[invalid-section]')
expectation = matches_suite_parse_error(
suite_file=asrt.equals(self.root_suite_based_at(root_path)),
maybe_section_name=asrt.is_none,
source=equals_line_sequence(expected_source),
source_location=equals_source_location_path(
SourceLocationPath(
SourceLocation(
expected_source,
Path('main.suite'),
),
[]
)
),
document_parser_exception=asrt.is_instance(sec_doc_exceptions.FileSourceError),
)
expectation.apply(put, actual)
def _apply(self,
put: unittest.TestCase,
value: SymbolDependentValue,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(value, SymbolDependentValue,
message_builder.apply("SDV type"))
self.sdv_type.apply(put, value, message_builder)
references__actual = value.references
references__message_builder = message_builder.for_sub_component('references')
asrt.is_sequence_of(asrt.is_instance(SymbolReference)).apply(
put,
references__actual,
references__message_builder
)
self.references.apply(put, references__actual,
references__message_builder)
self.custom.apply(put, value, message_builder)
ddv = value.resolve(self.symbols)
self.ddv.apply(put, ddv,
message_builder.for_sub_component('ddv'))
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 test_matches(self):
cases = [
NEA(
'empty list of blocks',
expected=sut.matches_major_block(asrt.is_empty_sequence),
actual=MajorBlock([]),
),
NEA(
'non-empty list of blocks',
expected=sut.matches_major_block(
asrt.matches_sequence([asrt.is_instance(MinorBlock)])),
actual=MajorBlock([MinorBlock([])]),
),
NEA(
'test of element properties',
expected=sut.matches_major_block(
asrt.anything_goes(),
properties=sut.matches_element_properties(
indentation=sut.matches_indentation(
level=asrt.equals(72))),
),
actual=MajorBlock([],
ElementProperties(Indentation(72, ''),
TEXT_STYLE__NEUTRAL)),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
def test_symbols_after_main(self):
self._check(
PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION,
single_line_source(),
ArrangementWithSds(),
sut.Expectation(symbols_after_main=asrt.is_instance(SymbolTable)),
)
def matches_string_matcher_resolver(primitive_value: ValueAssertion[StringMatcher] = asrt.anything_goes(),
references: ValueAssertion = asrt.is_empty_sequence,
symbols: symbol_table.SymbolTable = None,
tcds: HomeAndSds = fake_home_and_sds(),
) -> ValueAssertion[LogicValueResolver]:
symbols = symbol_table.symbol_table_from_none_or_value(symbols)
def resolve_value(resolver: LogicValueResolver):
return resolver.resolve(symbols)
def resolve_primitive_value(value: StringMatcherValue):
return value.value_of_any_dependency(tcds)
resolved_value_assertion = asrt.is_instance_with_many(
StringMatcherValue,
[
asrt.sub_component('resolving dependencies',
lambda sm_value: sm_value.resolving_dependencies(),
asrt.is_set_of(asrt.is_instance(DirectoryStructurePartition))),
asrt.sub_component('primitive value',
resolve_primitive_value,
asrt.is_instance_with(StringMatcher,
primitive_value))
])
return asrt.is_instance_with(
StringMatcherResolver,
asrt.and_([
is_resolver_of_logic_type(LogicValueType.STRING_MATCHER,
ValueType.STRING_MATCHER),
asrt.sub_component('references',
resolver_structure.get_references,
references),
asrt.sub_component('validator',
lambda resolver: resolver.validator,
asrt.is_instance(PreOrPostSdsValidator)
),
asrt.sub_component('resolved value',
resolve_value,
resolved_value_assertion
),
])
)
def test_fail__failing_assertion_on_value_restriction(self):
# ARRANGE #
actual_symbol_name = 'actual value name'
actual = SymbolReference(actual_symbol_name,
r.ReferenceRestrictionsOnDirectAndIndirect(vr.AnyDataTypeRestriction()))
assertion = exactly_lib_test.symbol.test_resources.symbol_usage_assertions.matches_reference(
assertion_on_restrictions=asrt.is_instance(r.OrReferenceRestrictions))
assert_that_assertion_fails(assertion, actual)
def test_assertion_on_instruction_environment(self):
self._check(
PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION,
single_line_source(),
ArrangementWithSds(),
sut.Expectation(
assertion_on_instruction_environment=asrt.is_instance(InstructionEnvironmentForPostSdsStep)),
)
def test_type_of_objects_given_to_assertion(self):
self._check(
PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION,
single_line_source(),
sut.Arrangement(),
sut.Expectation(
settings_builder=asrt.is_instance_with(
sut.SettingsBuilderAssertionModel,
asrt.and_([
asrt.sub_component('SettingsBuilder',
sut.SettingsBuilderAssertionModel.actual.fget,
asrt.is_instance(SetupSettingsBuilder)),
asrt.sub_component('environment',
sut.SettingsBuilderAssertionModel.environment.fget,
asrt.is_instance(InstructionEnvironmentForPostSdsStep)),
]))),
)
def _expect_failure_in(step_of_expected_failure: Step) -> Expectation:
symbol_usages_expectation = asrt.is_sequence_of(asrt.is_instance(SymbolReference))
if step_of_expected_failure is Step.VALIDATE_PRE_SDS:
return Expectation(validation_pre_sds=IS_FAILURE_OF_VALIDATION,
symbol_usages=symbol_usages_expectation)
else:
return Expectation(main_result=IS_FAILURE,
symbol_usages=symbol_usages_expectation)
def is_failure(status: FullExeResultStatus,
failure_info: ValueAssertion[Optional[FailureInfo]] = asrt.is_instance(FailureInfo),
sds: ValueAssertion[Optional[SandboxDirectoryStructure]] = asrt.anything_goes(),
action_to_check_outcome: ValueAssertion[Optional[ActionToCheckOutcome]] = asrt.anything_goes(),
) -> ValueAssertion[FullExeResult]:
return matches(status=asrt.is_(status),
sds=sds,
action_to_check_outcome=action_to_check_outcome,
failure_info=failure_info)
def test_user_defined(self):
# ARRANGE #
sli = SourceLocationInfo(Path.cwd(),
SOURCE_LOCATION_PATH_WITH_INCLUSIONS_AND_FILE_NAMES)
# ACT #
actual = sut.defined_at_line__err_msg_lines(sli)
# ASSERT #
is_list_of_strings = asrt.is_sequence_of(asrt.is_instance(str))
is_list_of_strings.apply_without_message(self, actual)
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 is_failure_of_indirect_reference(
failing_symbol: ValueAssertion = asrt.is_instance(str),
path_to_failing_symbol: ValueAssertion = asrt.is_instance(list),
error_message: ValueAssertion = asrt.is_instance(str),
meaning_of_failure: ValueAssertion = asrt.is_instance(str)) -> ValueAssertion:
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,
is_value_failure(error_message)),
asrt.sub_component('meaning_of_failure_of_indirect_reference',
FailureOfIndirectReference.meaning_of_failure.fget,
meaning_of_failure),
]))
def test_pass(self):
# ARRANGE #
symbol_name = 'symbol name'
symbol_reference = SymbolReference(symbol_name,
r.ReferenceRestrictionsOnDirectAndIndirect(
vr.AnyDataTypeRestriction()))
assertion = exactly_lib_test.symbol.test_resources.symbol_usage_assertions.matches_reference(
asrt.is_(symbol_name),
asrt.is_instance(r.ReferenceRestrictionsOnDirectAndIndirect))
# ACT & ASSERT #
assertion.apply_without_message(self, symbol_reference)
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 _apply(self,
put: unittest.TestCase,
value,
message_builder: asrt.MessageBuilder):
assert_is_file_selector_type = asrt.is_instance(FileMatcher, self.description)
assert_is_file_selector_type.apply_with_message(put, value,
'Value must be a ' + str(FileMatcher))
checker = _StructureChecker(put,
message_builder,
self.expected,
self.description
)
checker.visit(value)
def _apply(self,
put: unittest.TestCase,
actual,
message_builder: asrt.MessageBuilder):
assert_is_file_selector_type = asrt.is_instance(FileMatcherValue, self.description)
assert_is_file_selector_type.apply_with_message(put, actual,
'Value must be a ' + str(FileMatcherValue))
assert isinstance(actual, FileMatcherValue)
assertion_on_primitive_value = equals_file_matcher(self.expected, self.description)
assertion_on_primitive_value.apply(put,
actual.value_of_any_dependency(self.TCDS),
message_builder)
def _apply(self,
put: unittest.TestCase,
actual,
message_builder: asrt.MessageBuilder):
assert_is_line_matcher_type = asrt.is_instance(LineMatcher, self.description)
assert_is_line_matcher_type.apply_with_message(put, actual,
'Value must be a ' + str(LineMatcher))
assert isinstance(actual, LineMatcher) # Type info for IDE
checker = _EqualityChecker(put,
message_builder,
actual,
self.description
)
checker.visit(self.expected)
def matches_restrictions_on_direct_and_indirect(
assertion_on_direct: ValueAssertion = asrt.anything_goes(),
assertion_on_every: ValueAssertion = asrt.anything_goes(),
meaning_of_failure_of_indirect_reference: ValueAssertion = asrt.is_instance(str),
) -> ValueAssertion[ReferenceRestrictions]:
return asrt.is_instance_with(
ReferenceRestrictionsOnDirectAndIndirect,
asrt.and_([
asrt.sub_component('direct',
ReferenceRestrictionsOnDirectAndIndirect.direct.fget,
assertion_on_direct),
asrt.sub_component('indirect',
ReferenceRestrictionsOnDirectAndIndirect.indirect.fget,
assertion_on_every),
asrt.sub_component('meaning_of_failure_of_indirect_reference',
ReferenceRestrictionsOnDirectAndIndirect.meaning_of_failure_of_indirect_reference.fget,
meaning_of_failure_of_indirect_reference)
])
)
def runTest(self):
conf = self.configuration
test_case = TestCaseGeneratorWithExtraInstrsBetweenRecordingInstr() \
.add(conf.phase,
conf.instruction_that_returns([element_reference('undefined symbol')]))
execute_test_case_with_recording(
self,
Arrangement(test_case),
Expectation(
asrt_result.matches2(
PartialExeResultStatus.VALIDATION_ERROR,
asrt_result.has_no_sds(),
asrt_result.has_no_action_to_check_outcome(),
ExpectedFailureForInstructionFailure.new_with_message_assertion(
conf.step,
test_case.the_extra(conf.phase)[0].source,
asrt.is_instance(str)),
),
conf.expected_steps_before_failing_instruction,
)
)
def _resolve(self,
resolver: FileMatcherResolver,
environment: PathResolvingEnvironmentPreOrPostSds) -> Tuple[FileMatcherValue, FileMatcher]:
resolver_health_check = resolver_assertions.matches_resolver_of_file_matcher(
resolved_value=matches_file_matcher_value(
tcds=environment.home_and_sds
),
references=asrt.is_sequence_of(asrt.is_instance(SymbolReference)),
symbols=environment.symbols)
resolver_health_check.apply_with_message(self.put, resolver,
'resolver structure')
matcher_value = resolver.resolve(environment.symbols)
assert isinstance(matcher_value, FileMatcherValue)
matcher = matcher_value.value_of_any_dependency(environment.home_and_sds)
assert isinstance(matcher, FileMatcher)
return matcher_value, matcher
