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