class _Describer(Generic[FILE_SPEC], DetailsRenderer): EMPTY_RENDERER = details.String(' '.join((syntax.FILE_LIST_BEGIN, syntax.FILE_LIST_END))) BEGIN_BRACE_RENDERER = details.String(syntax.FILE_LIST_BEGIN) END_BRACE_RENDERER = details.String(syntax.FILE_LIST_END) def __init__(self, files: Sequence[FILE_SPEC]): self._files = files def render(self) -> Sequence[Detail]: return self._renderer().render() def _renderer(self) -> DetailsRenderer: return ( self.EMPTY_RENDERER if len(self._files) == 0 else self._renderer_of_non_empty() ) def _renderer_of_non_empty(self) -> DetailsRenderer: entries_renderer = details.SequenceRenderer([ file_spec.describer for file_spec in self._files ]) return details.SequenceRenderer([ self.BEGIN_BRACE_RENDERER, details.IndentedRenderer(entries_renderer), self.END_BRACE_RENDERER, ])
def _trace_builder(self, actual: str) -> TraceBuilder: ret_val = TraceBuilder(self.name) ret_val.append_details( custom_details.expected(details.String(repr(self._expected)))) ret_val.append_details( custom_details.actual(details.String(repr(actual)))) return ret_val
def new_structure_builder_for(program: ToStringObject, arguments: List[ToStringObject]) -> StructureBuilder: return _structure_builder_w_argument_list( CommandDriverForSystemProgram._NAME, details.String(program), arguments, )
def __init__(self, int_expression: StringDdv, custom_integer_validator: Optional[CustomIntegerValidator] = None): self._describer = details.String(strings.AsToStringObject(int_expression.describer())) self._primitive_value_computer = _PrimitiveValueComputer(int_expression) self._validator = _IntegerDdvValidator(self._primitive_value_computer, custom_integer_validator)
def __init__(self, operator: ComparisonOperator): self._config = comparison_matcher.IntModelConstructionConfig( comparison_matcher.Config( syntax_elements.INTEGER_SYNTAX_ELEMENT.singular_name, operator, lambda x: details.String(x), ))
def __init__(self, lines_selector: Optional[LineMatcher], preserve_new_lines: bool, compiled_regular_expression: Pattern[str], replacement: str, ): super().__init__() str_replacer = ( _StrReplacerExcludingNewLines(compiled_regular_expression, replacement) if preserve_new_lines else _StrReplacerIncludingNewLines(compiled_regular_expression, replacement) ) self._replacer_applier = ( _ReplacerApplierWoLineMatcherSelector(str_replacer) if lines_selector is None else _ReplacerApplierWLineMatcherSelector(lines_selector, str_replacer) ) self._structure_renderer = _StructureRendererForReplace( lines_selector, preserve_new_lines, custom_details.PatternRenderer(compiled_regular_expression), details.String(replacement), )
def new_structure_builder_for(command_line: ToStringObject, arguments: List[ToStringObject]) -> StructureBuilder: ret_val = StructureBuilder(CommandDriverForShell.NAME).append_details(details.String(command_line)) if arguments: ret_val.append_child(_ArgumentListRenderer(arguments)) return ret_val
def structure(self) -> StructureRenderer: return _StructureRendererForReplace( self._lines_selector, self._preserve_new_lines, self._regex.describer(), details.String(strings.AsToStringObject(self._replacement.describer())), )
def matches_w_trace(self, model: StringSource) -> MatchingResult: actual = model.contents().as_str if self.expected == actual: return self._new_tb().build_result(True) else: err_msg = 'not eq to "{}": "{}"'.format(self.expected, actual) return (self._new_tb().append_details( details.String(err_msg)).build_result(False))
def _file( path: Renderer[str], mb_matcher: Optional[TSD], ) -> DetailsRenderer: path_string = path.render() return (details.String(path_string) if mb_matcher is None else details.HeaderAndValue( path_string, custom_details.WithTreeStructure(mb_matcher)))
def _result_for_exception(self, path: DescribedPath, ex: Exception) -> MatchingResult: tb = (self.__tb_with_expected().append_details( details.HeaderAndValue( types.PATH_TYPE_INFO.singular_name.capitalize(), custom_details.PathDdvDetailsRenderer( path.describer))).append_details( details.HeaderAndValue('Error', details.String(ex)))) return tb.build_result(False)
def _result_for_unexpected_type( self, actual: Optional[file_properties.FileType]) -> MatchingResult: actual_type_description = ( 'unknown' if actual is None else file_properties.TYPE_INFO[actual].description) tb = self.__tb_with_expected().append_details( custom_details.actual(details.String(actual_type_description))) return tb.build_result(False)
def matches_w_trace(self, model: StringSource) -> MatchingResult: first_line = self._first_line(model) if first_line != '': return (self._new_tb().append_details( custom_details.actual( details.String(repr(first_line) + '...'))).build_result(False)) else: return self._new_tb().build_result(True)
def __init__(self, file_type: file_properties.FileType): super().__init__() self._file_type = file_type self._is_follow_sym_links = file_type is not file_properties.FileType.SYMLINK self._renderer_of_expected_value = details.String( file_properties.TYPE_INFO[self._file_type].description) self._renderer_of_expected = custom_details.expected( self._renderer_of_expected_value)
def render(self) -> Node[bool]: file_spec_renderer = custom_details.HeaderAndValue( NON_MATCHING_MATCHER, details.String(self._non_matching_path) ) return Node(self._name, False, file_spec_renderer.render(), (self._non_match_result.trace.render(),) )
def __init__( self, matcher: Callable[[MODEL, str], bool], glob_pattern: str, ): super().__init__() self._matcher = matcher self._glob_pattern = glob_pattern self._renderer_of_expected = custom_details.expected( details.String(str_constructor.Repr(glob_pattern)))
def _too_few_files(self) -> Tuple[str, DetailsRenderer]: return ( common.NUM_FILES_LESS, ( custom_details.string_list(self._consumed_file_names()) if self._fetch_of_expected_plus_1 else details.String(common.NO_FILES__ACTUAL) ) )
def __init__( self, is_ignore_case: bool, string: StringDdv, ): self._describer = custom_details.regex( is_ignore_case, details.String( string_rendering.AsToStringObject(string.describer()))) self._validator = _ValidatorWhichCreatesRegex(is_ignore_case, string)
def _renderer(self) -> DetailsRenderer: header_parts = [ _FORMATTED_FILE_TYPE_TOKENS[self._file_type], self._file_name ] if self._contents_description is not None: header_parts.append( syntax.MODIFICATION_VARIANT_TOKENS[self._modification_type]) header = ' '.join(header_parts) return (details.String(header) if self._contents_description is None else details.HeaderAndValue( header, self._contents_description))
def _all_match(self, tb: TraceBuilder, tot_num_elements: int) -> MatchingResult: actual = details.String( str_constructor.FormatPositional( 'Every {} matches ({} tested)', self._conf.setup.rendering.type_name, tot_num_elements, )) expected = custom_details.TreeStructure( self._conf.predicate.structure()) return (tb.append_details( custom_details.expected(expected)).append_details( custom_details.actual(actual)).build_result(True))
def render(self) -> Node[bool]: renderer = custom_details.ExpectedAndActual( _expected_file_names_renderer(self._applier.files_condition), custom_details.string_list(_files_in_model_list(self._actual)), details.HeaderAndValue( common.UNEXPECTED_NAME, details.String(self._unexpected_file.relative_to_root_dir), ) ) return Node(self._applier.name, False, renderer.render(), (), )
def _render(self) -> StructureRenderer: ranges = [ ( repr(r) if r == '' or r.isspace() else r ) for r in [str(r) for r in self._ranges] ] range_list = ' '.join(ranges) return renderers.NodeRendererFromParts( self._name, None, (details.String(range_list),), (), )
def render(self) -> Node[bool]: get_explanation_and_actual = ( self._too_few_files if len(self._fetch_of_expected_plus_1) < len(self._files_condition.files.keys()) else self._too_many_files ) explanation, actual = get_explanation_and_actual() expected_and_actual = custom_details.ExpectedAndActual( self._expected(), actual, details.String(explanation), ) return Node(self._name, False, expected_and_actual.render(), (), )
def describer(self) -> DetailsRenderer: return details.String(type(self))
def render(self) -> Sequence[Detail]: renderer = details.String(option_syntax.option_syntax(self._option)) return renderer.render()
def _explanation_when_no_element_matcher_trace( self, explanation: ToStringObject) -> DetailsRenderer: return custom_details.ExpectedAndActual( custom_details.TreeStructure(self._conf.predicate.structure()), details.String(explanation), )
def structure_for(self, arguments: ListDdv) -> StructureBuilder: return commands.CommandDriverForExecutableFile.new_structure_builder_for( details.String( strings.AsToStringObject(self._exe_file.describer().value)), _arguments_as_to_string_objects(arguments), )
def _structure(self) -> StructureRenderer: return self.new_structure_tree( details.String(str_constructor.Repr(self._glob_pattern)))
def matches_w_trace(self, model: MODEL) -> MatchingResult: tb = self._new_tb_with_expected().append_details( custom_details.actual( details.String(str_constructor.Repr(str(model))))) return tb.build_result(self._matcher(model, self._glob_pattern))
def structure(self) -> StructureRenderer: return MatchesGlobPattern.new_structure_tree( details.String( str_constructor.Repr( string_rendering.AsToStringObject( self._glob_pattern.describer()))))