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_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 is_single_validator_with(expectations: Sequence[NameAndValue[ValueAssertion[PreOrPostSdsValidator]]] ) -> ValueAssertion[Sequence[PreOrPostSdsValidator]]: return asrt.and_([ asrt.len_equals(1), asrt.on_transformed(pre_or_post_validation.all_of, asrt.all_named(expectations)) ])
def matches_section_documentation(name: ValueAssertion = asrt.anything_goes()) -> ValueAssertion: return asrt.is_instance_with(SectionDocumentation, asrt.and_([ asrt.sub_component('name', lambda sec_doc: sec_doc.name.plain, name), ]))
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 matches( status: ValueAssertion[FullExeResultStatus] = asrt.anything_goes(), has_sds: ValueAssertion[bool] = asrt.anything_goes(), sds: ValueAssertion[Optional[SandboxDirectoryStructure]] = asrt.anything_goes(), has_action_to_check_outcome: ValueAssertion[bool] = asrt.anything_goes(), action_to_check_outcome: ValueAssertion[Optional[ActionToCheckOutcome]] = asrt.anything_goes(), failure_info: ValueAssertion[Optional[FailureInfo]] = asrt.anything_goes(), ) -> ValueAssertion[FullExeResult]: return asrt.and_([ asrt.sub_component('status', FullExeResult.status.fget, status), asrt.sub_component('has_sds', FullExeResult.has_sds.fget, has_sds), asrt.sub_component('sds', FullExeResult.sds.fget, sds), asrt.sub_component('has_action_to_check_outcome', FullExeResult.has_action_to_check_outcome.fget, has_action_to_check_outcome), asrt.sub_component('action_to_check_outcome', FullExeResult.action_to_check_outcome.fget, action_to_check_outcome), asrt.sub_component('failure_info', FullExeResult.failure_info.fget, failure_info), ])
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_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 is_existing_sds_with_post_execution_w_only_exitcode_result_files(exit_code: int) \ -> ValueAssertion[SandboxDirectoryStructure]: return asrt.and_([ sds_root_dir_exists_and_has_sds_dirs(), asrt.sub_component('result-dir', SandboxDirectoryStructure.result_dir.fget, DirContainsExactly(DirContents([ File(RESULT_FILE__EXITCODE, str(exit_code)) ]))) ])
def equals_path_relativity_variants(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 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 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 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 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 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 contents_raises_hard_error(may_depend_on_external_resources: Assertion[bool], structure: Assertion[NodeRenderer] = asrt_trace_rendering.matches_node_renderer(), ) -> Assertion[StringSource]: return asrt.and_([ has_structure_description(structure), contents_matches( asrt.and_( [asrt_str_src_contents.external_dependencies(may_depend_on_external_resources)] + [ asrt.named( contents_case.name, RaisesHardErrorAsLastAction( contents_case.value ) ) for contents_case in properties_access.ALL_CASES__WO_LINES_ITER_CHECK ]), ), ])
def matches2(status: FullExeResultStatus, sds: ValueAssertion[FullExeResult], action_to_check_outcome: ValueAssertion[FullExeResult], failure_info: ValueAssertion[Optional[FailureInfo]] = asrt.anything_goes() ) -> ValueAssertion[FullExeResult]: return asrt.and_([ matches(status=asrt.is_(status), failure_info=failure_info), sds, action_to_check_outcome, ])
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 matches2( status: Optional[ExecutionFailureStatus], sds: Assertion[PartialExeResult], action_to_check_outcome: Assertion[PartialExeResult], failure_info: Assertion[Optional[FailureInfo]] = asrt.anything_goes() ) -> Assertion[PartialExeResult]: return asrt.and_([ matches(status=asrt.is_(status), failure_info=failure_info), sds, action_to_check_outcome, ])
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 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 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 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 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 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 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 matches_reference(assertion_on_name: Assertion[str] = asrt.anything_goes(), assertion_on_restrictions: Assertion[ReferenceRestrictions] = asrt.anything_goes() ) -> Assertion[SymbolReference]: return asrt.and_([ asrt.sub_component('name', SymbolReference.name.fget, assertion_on_name), asrt.sub_component('restrictions', SymbolReference.restrictions.fget, assertion_on_restrictions) ])
def matches_instruction_info( assertion_on_description: Assertion[str], assertion_on_instruction: Assertion[model.Instruction], ) -> Assertion[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 is_string_lines( strings: Assertion[Sequence[str]] = asrt.anything_goes(), ) -> Assertion[LineObject]: return asrt.is_instance_with__many( StringLinesObject, [ asrt.sub_component( 'strings', StringLinesObject.strings.fget, asrt.and_( [asrt.is_sequence_of(asrt.is_instance(str)), strings])), ], )
def matches_line_sequence( first_line_number: Assertion[int] = asrt.anything_goes(), lines: Assertion[Sequence[str]] = asrt.anything_goes(), ) -> Assertion[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 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 equals_name_with_gender(name: NameWithGender) -> Assertion[NameWithGender]: return asrt.is_instance_with( Name, asrt.and_([ asrt.sub_component('determinator_word', NameWithGender.determinator_word.fget, asrt.equals(name.determinator_word)), asrt.sub_component('singular', NameWithGender.singular.fget, asrt.equals(name.singular)), asrt.sub_component('plural', NameWithGender.plural.fget, asrt.equals(name.plural)), ]))
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 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 matches_recording(string: ValueAssertion[str] = asrt.anything_goes(), file_location_info: ValueAssertion[FileLocationInfo] = asrt.anything_goes() ) -> ValueAssertion[Recording]: return asrt.and_([ asrt.sub_component('string', Recording.string.fget, string ), asrt.sub_component('file_location_info', Recording.file_location_info.fget, file_location_info, ), ])
def type_is_mem_buff() -> Assertion[sut.SpooledTextFile]: return asrt.and_([ asrt.sub_component( 'is_mem_buff', sut.SpooledTextFile.is_mem_buff.fget, asrt.equals(True), ), asrt.sub_component( 'is_file_on_disk', sut.SpooledTextFile.is_file_on_disk.fget, asrt.equals(False), ), ])
def equals_name_with_gender(name: NameWithGender) -> ValueAssertion[NameWithGender]: return asrt.is_instance_with(Name, asrt.and_([ asrt.sub_component('determinator_word', NameWithGender.determinator_word.fget, asrt.equals(name.determinator_word)), asrt.sub_component('singular', NameWithGender.singular.fget, asrt.equals(name.singular)), asrt.sub_component('plural', NameWithGender.plural.fget, asrt.equals(name.plural)), ]))
def equals_list_format(expected: lists.Format) -> Assertion: return asrt.is_instance_with( lists.Format, asrt.and_([ asrt.sub_component('list_type', lists.Format.list_type.fget, asrt.equals(expected.list_type)), asrt.sub_component('custom_indent_spaces', lists.Format.custom_indent_spaces.fget, asrt.equals(expected.custom_indent_spaces)), asrt.sub_component('custom_separations', lists.Format.custom_separations.fget, asrt.equals(expected.custom_separations)), ]))
def matches_container(assertion_on_resolver: ValueAssertion[rs.SymbolValueResolver], assertion_on_source: ValueAssertion[LineSequence] = asrt_line_source.is_line_sequence(), ) -> ValueAssertion[rs.SymbolContainer]: return asrt.is_instance_with( rs.SymbolContainer, asrt.and_([ asrt.sub_component('source', rs.SymbolContainer.definition_source.fget, assertion_on_source), asrt.sub_component('resolver', rs.SymbolContainer.resolver.fget, assertion_on_resolver) ]))
def matches_file_source_error(maybe_section_name: ValueAssertion[str], location_path: Sequence[SourceLocation]) -> ValueAssertion[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 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 matches_instruction( source: Assertion[line_source.LineSequence] = asrt.anything_goes(), instruction_info: Assertion[InstructionInfo] = asrt.anything_goes(), ) -> Assertion[ParsedSectionElement]: return asrt.is_instance_with( ParsedInstruction, asrt.and_([ asrt.sub_component('source', ParsedInstruction.source.fget, source), asrt.sub_component('instruction_info', ParsedInstruction.instruction_info.fget, instruction_info), ]))
def is_tree_detail( tree: Assertion[Node[Any]] = asrt.anything_goes(), ) -> Assertion[Detail]: return asrt.is_instance_with__many( TreeDetail, [ asrt.sub_component( 'tree', TreeDetail.tree.fget, asrt.is_not_none_and(asrt.and_([_MatchesNode(), tree])), ), ], )
def matches_recording(string: Assertion[str] = asrt.anything_goes(), file_location_info: Assertion[FileLocationInfo] = asrt.anything_goes() ) -> Assertion[Recording]: return asrt.and_([ asrt.sub_component('string', Recording.string.fget, string ), asrt.sub_component('file_location_info', Recording.file_location_info.fget, file_location_info, ), ])
def is_open_mem_buff_with_contents( position: int, remaining_contents: str, full_contents: str) -> Assertion[sut.SpooledTextFile]: return asrt.and_([ is_open(), type_is_mem_buff(), asrt.sub_component( 'mem_buff', sut.SpooledTextFile.mem_buff.fget, asrt.equals(full_contents), ), is_at_pos_with_remaining_contents(position, remaining_contents), ])
def visit_header_value_list(self, expected: HeaderContentList): self._assert_is_type(HeaderContentList) actual = self.actual assertions = asrt.is_instance_with( lists.HeaderContentList, asrt.and_([ asrt.sub_component('list-format', lists.HeaderContentList.list_format.fget, equals_list_format(expected.list_format)), asrt.sub_component('list-items', lists.HeaderContentList.items.fget, equals_list_items(expected.items)), ])) assertions.apply(self.put, actual, self.message_builder)
def equals_path_relativity(expected: SpecificPathRelativity) -> Assertion: return asrt.is_instance_with(SpecificPathRelativity, asrt.and_([ asrt.sub_component('is_absolute', SpecificPathRelativity.is_absolute.fget, asrt.equals(expected.is_absolute)), asrt.sub_component('is_relative', SpecificPathRelativity.is_relative.fget, asrt.equals(expected.is_relative)), asrt.sub_component('relativity_type', SpecificPathRelativity.relativity_type.fget, asrt.equals(expected.relativity_type)), ]) )
def equals_path_relativity(expected: SpecificPathRelativity) -> ValueAssertion: return asrt.is_instance_with(SpecificPathRelativity, asrt.and_([ asrt.sub_component('is_absolute', SpecificPathRelativity.is_absolute.fget, asrt.equals(expected.is_absolute)), asrt.sub_component('is_relative', SpecificPathRelativity.is_relative.fget, asrt.equals(expected.is_relative)), asrt.sub_component('relativity_type', SpecificPathRelativity.relativity_type.fget, asrt.equals(expected.relativity_type)), ]) )
def equals_container(expected: rs.SymbolContainer, ignore_source_line: bool = True) -> ValueAssertion[rs.SymbolContainer]: component_assertions = [] if not ignore_source_line: component_assertions.append(asrt.sub_component('source', rs.SymbolContainer.definition_source.fget, equals_line_sequence(expected.definition_source))) expected_resolver = expected.resolver assert isinstance(expected_resolver, DataValueResolver), 'All actual values must be DataValueResolver' component_assertions.append(asrt.sub_component('resolver', rs.SymbolContainer.resolver.fget, equals_resolver(expected_resolver))) return asrt.is_instance_with(rs.SymbolContainer, asrt.and_(component_assertions))
def is_string_detail( to_string_object: Assertion[ToStringObject] = asrt.anything_goes(), ) -> Assertion[Detail]: return asrt.is_instance_with__many( StringDetail, [ asrt.sub_component( 'string', StringDetail.string.fget, asrt.and_([ asrt_to_string.matches(asrt.anything_goes()), to_string_object, ])), ], )
def is_reference_restrictions__value_type( expected: Sequence[ValueType]) -> Assertion[ReferenceRestrictions]: """ Assertion on a :class:`ReferenceRestrictions`, that it is a :class:`TypeCategoryRestriction`, with a given :class:`TypeCategory`. """ return asrt.is_instance_with( ValueTypeRestriction, asrt.and_([ asrt.sub_component('value_type', _get_value_types__as_list, asrt.equals(list(expected))), ]), )
def matches_non_instruction( source: Assertion[line_source.LineSequence] = asrt.anything_goes(), element_type: Assertion[ElementType] = asrt.anything_goes(), ) -> Assertion[ParsedSectionElement]: return asrt.is_instance_with( ParsedNonInstructionElement, asrt.and_([ asrt.sub_component('source', ParsedNonInstructionElement.source.fget, source), asrt.sub_component('element_type', ParsedNonInstructionElement.element_type.fget, element_type), ]))
def test_populate_result_dir_with_act_result(self): act_result = SubProcessResult( exitcode=72, stdout='the stdout', stderr='the stderr', ) result_dir_contains_files_corresponding_to_act_result = asrt_tcds_contents.dir_contains_exactly( RelOptionType.REL_RESULT, DirContents([ File(sds.RESULT_FILE__EXITCODE, str(act_result.exitcode)), File(sds.RESULT_FILE__STDOUT, str(act_result.stdout)), File(sds.RESULT_FILE__STDERR, str(act_result.stderr)), ]) ) all_tcds_dirs_but_result_dir_are_empty = asrt.and_([ dir_is_empty(tcds_dir) for tcds_dir in RelOptionType if tcds_dir is not RelOptionType.REL_RESULT ]) self._check___single_and_multi( utils.single_line_arguments(), ARBITRARY_MODEL, parser_of_matcher_that_is_an_assertion_on_tcds( self, asrt.and_([ result_dir_contains_files_corresponding_to_act_result, all_tcds_dirs_but_result_dir_are_empty, ] ) ), arrangement_w_tcds( act_result=ActResultProducerFromActResult(act_result) ), Expectation(), )
def test_tcds_directories_are_empty(self): all_tcds_dirs_are_empty = asrt.and_([ dir_is_empty(tcds_dir) for tcds_dir in RelOptionType ]) self._check___single_and_multi( utils.single_line_arguments(), ARBITRARY_MODEL, parser_of_matcher_that_is_an_assertion_on_tcds( self, all_tcds_dirs_are_empty, ), arrangement_w_tcds(), is_expectation_of_execution_result_of(True))
def matches_file_inclusion_directive( source: Assertion[line_source.LineSequence] = asrt.anything_goes(), files_to_include: Assertion[Sequence[pathlib.Path]] = asrt.anything_goes(), ) -> Assertion[ParsedSectionElement]: return asrt.is_instance_with( ParsedFileInclusionDirective, asrt.and_([ asrt.sub_component('source', ParsedFileInclusionDirective.source.fget, source), asrt.sub_component( 'files_to_include', ParsedFileInclusionDirective.files_to_include.fget, files_to_include), ]))
def matches_source_location(source: Assertion[LineSequence] = asrt.anything_goes(), file_path_rel_referrer: Assertion[Optional[pathlib.Path]] = asrt.anything_goes(), ) -> Assertion[SourceLocation]: return asrt.is_instance_with( SourceLocation, asrt.and_([ asrt.sub_component( 'source', SourceLocation.source.fget, asrt.is_instance_with(LineSequence, source)), asrt.sub_component( 'file_path_rel_referrer', SourceLocation.file_path_rel_referrer.fget, asrt.is_optional_instance_with(pathlib.Path, file_path_rel_referrer)), ]))
def matches_file_access_error( erroneous_path: Path, location_path: Sequence[SourceLocation], section_name: Optional[str]) -> Assertion[FileAccessError]: return asrt.and_([ asrt.sub_component('erroneous_path', FileAccessError.erroneous_path.fget, asrt.equals(erroneous_path)), asrt.sub_component('message', FileAccessError.message.fget, asrt.is_not_none), asrt.sub_component('location_path', FileAccessError.location_path.fget, equals_source_location_sequence(location_path)), asrt.sub_component('maybe_section_name', FileAccessError.maybe_section_name.fget, asrt.equals(section_name)), ])
def matches__on_direct_and_indirect( assertion_on_direct: Assertion[ValueRestriction] = asrt.anything_goes(), assertion_on_indirect: Assertion[ValueRestriction] = asrt.anything_goes(), ) -> Assertion[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_indirect), ]))
def is_at_pos_with_remaining_contents( position: int, remaining_contents: str, ) -> Assertion[sut.SpooledTextFile]: return asrt.and_([ asrt.sub_component( 'tell', sut.SpooledTextFile.tell, asrt.equals(position), ), asrt.sub_component( 'read (remaining contents)', sut.SpooledTextFile.read, asrt.equals(remaining_contents), ), ])
def equals__or(expected: OrReferenceRestrictions) -> Assertion: expected_sub_restrictions = [ asrt.is_instance_with( OrRestrictionPart, asrt.and_([ asrt.sub_component('selector', OrRestrictionPart.selector.fget, asrt.equals(part.selector)), asrt.sub_component( 'restriction', OrRestrictionPart.restriction.fget, _equals_on_direct_and_indirect(part.restriction)), ])) for part in expected.parts ] return asrt.is_instance_with( OrReferenceRestrictions, asrt.sub_component('parts', OrReferenceRestrictions.parts.fget, asrt.matches_sequence(expected_sub_restrictions)))