def describe_to(self, description: Description) -> None: nested_matcher = isinstance(self.object, Matcher) if nested_matcher: description.append_text("<") description.append_description_of(self.object) if nested_matcher: description.append_text(">")
def describe_to(self, description: Description) -> None: if isinstance(self.times, IsAnything): description.append_text("call with") else: description.append_description_of(self.times).append_text(" call(s) with") self._optional_description(description)
def describe_mismatch(self, item: object, mismatch_description: Description) -> None: """ Describe the mismatch to the passed-in description. Args: item: the object that was tested. mismatch_description: the description that is being built. """ if item is None: mismatch_description.append_text("was None") return if not hasattr(item, self.method_name): mismatch_description.append_description_of(item).append_text( " did not have a ").append_description_of( self.method_name).append_text(" method") return mismatch_description.append_text("method ").append_description_of( self.method_name).append_text(" called with ").append_text( self.get_callargs_str()).append_text(" ") self.value_matcher.describe_mismatch(self.get_return_value(item), mismatch_description)
def describe_to(self, description: Description) -> None: # pragma: no cover description.append_text("a sequence containing ") for matcher in self.matchers[:-1]: description.append_description_of(matcher) description.append_text(" followed by ") description.append_description_of(self.matchers[-1])
def describe_mismatch(self, call: _Call, mismatch_description: Description) -> None: mismatch_description.append_text("got arguments (").append_text( ", ".join( chain((repr(a) for a in call[1]), (f"{k}={v!r}" for k, v in call[2].items())))).append_text(")")
def describe_mismatch(self, item: T, mismatch_description: Description) -> None: if not os.path.isfile(item): mismatch_description.append_text('%s was not a file' % item) else: mismatch_description.append_text('a file with contents %s' % read(item))
def describe_mismatch(self, item: T, mismatch_description: Description) -> None: super().describe_mismatch(item, mismatch_description) if not os.path.isdir(item): mismatch_description.append_text(' which is not a directory') else: mismatch_description.append_text(' which contains %s' % ', '.join(os.listdir(item)))
def describe_mismatch(self, json_string: str, description: Description) -> None: try: loads = json.loads(json_string) except ValueError: description.append_text("Got invalid JSON ").append_description_of( json_string) else: self.matcher.describe_mismatch(loads, description)
def describe_mismatch(self, matcher_under_test: Matcher[Any], description: Description) -> None: actual_message = StringDescription() if matcher_under_test.matches(self.value_not_to_match, actual_message): description.append_text("matched") return description.append_text("got message ").append_description_of( actual_message) self.append_diff(actual_message, description)
def describe_to(self, description: Description) -> None: description.append_text("email with") append_matcher_description(self.to_name, "to_name", description) append_matcher_description(self.to_address, "to_address", description) append_matcher_description(self.from_name, "from_name", description) append_matcher_description(self.from_address, "from_address", description) append_matcher_description(self.subject, "subject", description) append_matcher_description(self.body_text, "body_text", description)
def describe_field_match( field_matcher: Matcher[Any], field_name: str, actual_value: Any, match_description: Description, ) -> None: if not isinstance(field_matcher, IsAnything) and field_matcher.matches(actual_value): match_description.append_text(f" {field_name}: ") field_matcher.describe_match(actual_value, match_description)
def describe_to(self, description: Description) -> None: text_start = 0 for match in re.finditer(ARG_PATTERN, self.template): description.append_text(self.template[text_start : match.start()]) arg_index = int(match.group()[1:]) description.append_description_of(self.values[arg_index]) text_start = match.end() if text_start < len(self.template): description.append_text(self.template[text_start:])
def describe_match(self, item: Mapping[K, V], match_description: Description) -> None: key_matches = self._matching_keys(item) if len(key_matches) == 1: key, value = key_matches.popitem() match_description.append_text("value for ").append_description_of( key).append_text(" ") self.value_matcher.describe_mismatch(value, match_description) else: super().describe_match(item, match_description)
def describe_mismatch(self, conn: Connection, mismatch_description: Description) -> None: try: rows = self._get_rows(conn, self.select) self.row_matcher.describe_mismatch(rows, mismatch_description) except Exception as e: # noqa: B902 mismatch_description.append_text( "SQL statement ").append_description_of( self.select).append_text(" gives ").append_description_of( type(e).__name__).append_text( " ").append_description_of(e)
def describe_to(self, description: Description) -> None: description.append_text("URL with") append_matcher_description(self.scheme, "scheme", description) append_matcher_description(self.username, "username", description) append_matcher_description(self.password, "password", description) append_matcher_description(self.host, "host", description) append_matcher_description(self.port, "port", description) append_matcher_description(self.path, "path", description) append_matcher_description(self.path_segments, "path segments", description) append_matcher_description(self.query, "query", description) append_matcher_description(self.fragment, "fragment", description)
def describe_mismatch(self, actual_call: _Call, mismatch_description: Description) -> None: args = actual_call[2] if self.key in args: mismatch_description.append_text( "got mock.call with keyword argument ").append_description_of( self.key).append_text( " with value ").append_description_of(args[self.key]) else: mismatch_description.append_text( "got mock.call with without keyword argument " ).append_description_of(self.key)
def describe_to(self, description: Description) -> None: """ Describe this matcher to the passed in description. Args: description: the description that is being built. """ description.append_text("an object with a method '").append_text( self.method_name).append_text( "' whose return value when called with ").append_text( self.get_callargs_str()).append_text( " matches ").append_description_of(self.value_matcher)
def describe_mismatch(self, actual_call: _Call, mismatch_description: Description) -> None: args = actual_call[1] if len(args) > self.index: mismatch_description.append_text( "got mock.call with argument index ").append_description_of( self.index).append_text( " with value ").append_description_of(args[self.index]) else: mismatch_description.append_text( "got mock.call with without argument index " ).append_description_of(self.index)
def describe_to(self, description: Description) -> None: description.append_text("response with") append_matcher_description(self.status_code, "status_code", description) append_matcher_description(self.body, "body", description) append_matcher_description(self.content, "content", description) append_matcher_description(self.json, "json", description) append_matcher_description(self.headers, "headers", description) append_matcher_description(self.cookies, "cookies", description) append_matcher_description(self.elapsed, "elapsed", description) append_matcher_description(self.history, "history", description) append_matcher_description(self.url, "url", description) append_matcher_description(self.encoding, "encoding", description)
def describe_to(self, description: Description) -> None: description.append_text("tag with") if self.name != ANYTHING: description.append_text(" name matching ").append_description_of( self.name) if self.string != ANYTHING: description.append_text(" string matching ").append_description_of( self.string) if self.clazz != ANYTHING: description.append_text(" class matching ").append_description_of( self.clazz) if self.attributes != ANYTHING: description.append_text( " attributes matching ").append_description_of(self.attributes)
def describe_to(self, description: Description) -> None: description.append_text("HTML with tag") if self.name: description.append_text(" name=").append_description_of(self.name) if self.id_: description.append_text(" id=").append_description_of(self.id_) description.append_text(" matching ").append_description_of( self.tag_matcher)
def describe_mismatch(self, actual_email: str, mismatch_description: Description) -> None: email = self._parse_email(actual_email) mismatch_description.append_text("was email with") describe_field_mismatch(self.to_name, "to_name", email.to_name, mismatch_description) describe_field_mismatch(self.to_address, "to_address", email.to_address, mismatch_description) describe_field_mismatch(self.from_name, "from_name", email.from_name, mismatch_description) describe_field_mismatch(self.from_address, "from_address", email.from_address, mismatch_description) describe_field_mismatch(self.subject, "subject", email.subject, mismatch_description) describe_field_mismatch(self.body_text, "body", email.body_text, mismatch_description)
def describe_mismatch(self, item: object, mismatch_description: Description) -> None: if item is None: mismatch_description.append_text("was None") return if not hasattr(item, self.property_name): mismatch_description.append_description_of(item).append_text( " did not have the ").append_description_of( self.property_name).append_text(" property") return mismatch_description.append_text("property ").append_description_of( self.property_name).append_text(" ") value = getattr(item, self.property_name) self.value_matcher.describe_mismatch(value, mismatch_description)
def describe_to(self, description: Description) -> None: description.append_text( f"table with {'header ' if self.header_row else ''}row") if self.cells_matcher != ANYTHING: description.append_text(" cells matching ") self.cells_matcher.describe_to(description) if self.row_matcher != ANYTHING: description.append_text(" row matching ") self.row_matcher.describe_to(description) if self.index_matcher != ANYTHING: description.append_text(" index matching ") self.index_matcher.describe_to(description)
def describe_match(self, url: Union[furl, str], match_description: Description) -> None: url = furl(url) match_description.append_text("was URL with") describe_field_match(self.scheme, "scheme", url.scheme, match_description) describe_field_match(self.username, "username", url.username, match_description) describe_field_match(self.password, "password", url.password, match_description) describe_field_match(self.host, "host", url.host, match_description) describe_field_match(self.port, "port", url.port, match_description) describe_field_match(self.path, "path", url.path, match_description) describe_field_match(self.path_segments, "path segments", url.path.segments, match_description) describe_field_match(self.query, "query", url.query.params, match_description) describe_field_match(self.fragment, "fragment", url.fragment, match_description)
def describe_mismatch( self, actual: Union[Imposter, MountebankServer], description: Description ) -> None: description.append_text("found ").append_description_of(len(self.matching_requests)) description.append_text(" matching requests: ").append_description_of( self.matching_requests ) description.append_text(". All requests: ").append_description_of(self.all_requests)
def describe_match(self, response: Response, match_description: Description) -> None: match_description.append_text("was response with") describe_field_match(self.status_code, "status code", response.status_code, match_description) describe_field_match(self.body, "body", response.text, match_description) describe_field_match(self.content, "content", response.content, match_description) describe_field_match(self.json, "json", self._get_response_json(response), match_description) describe_field_match(self.headers, "headers", response.headers, match_description) describe_field_match(self.cookies, "cookies", response.cookies, match_description) describe_field_match(self.elapsed, "elapsed", response.elapsed, match_description) describe_field_match(self.history, "history", response.history, match_description) describe_field_match(self.url, "url", response.url, match_description) describe_field_match(self.encoding, "encoding", response.encoding, match_description)
def describe_mismatch(self, item, description: Description) -> None: if not callable(item): description.append_text("%s is not callable" % item) return function = None if self.function is None else self.function() if function is None or function is not item: self.function = ref(item) if not self._call_function(item): return if self.actual is None: description.append_text("No exception raised.") elif isinstance(self.actual, cast( type, self.expected)) and self.pattern is not None: description.append_text( 'Correct assertion type raised, but the expected pattern ("%s") not found.' % self.pattern) description.append_text('\n message was: "%s"' % str(self.actual)) else: description.append_text("%r of type %s was raised instead" % (self.actual, type(self.actual)))
def describe_to(self, description: Description) -> None: description.append_text("a dictionary containing {") first = True for key, value in self.value_matchers: if not first: description.append_text(", ") self.describe_keyvalue(key, value, description) first = False description.append_text("}")
def describe_mismatch( self, actual: Union[Imposter, MountebankServer], description: Description ) -> None: sent_email = self.get_sent_email(actual) matching_emails = self.get_matching_emails(sent_email) description.append_text("found ").append_description_of(len(matching_emails)) description.append_text(" matching emails: ").append_description_of(matching_emails) description.append_text(". All emails: ").append_description_of(sent_email)