160 lines
5.6 KiB
Python
160 lines
5.6 KiB
Python
from typing import Any, Hashable, Mapping, Optional, TypeVar, Union, overload
|
|
|
|
from hamcrest.core.base_matcher import BaseMatcher
|
|
from hamcrest.core.description import Description
|
|
from hamcrest.core.helpers.wrap_matcher import wrap_matcher
|
|
from hamcrest.core.matcher import Matcher
|
|
|
|
__author__ = "Jon Reid"
|
|
__copyright__ = "Copyright 2011 hamcrest.org"
|
|
__license__ = "BSD, see License.txt"
|
|
|
|
K = TypeVar("K", bound=Hashable)
|
|
V = TypeVar("V")
|
|
|
|
|
|
class IsDictContainingEntries(BaseMatcher[Mapping[K, V]]):
|
|
def __init__(self, value_matchers) -> None:
|
|
self.value_matchers = sorted(value_matchers.items())
|
|
|
|
def _not_a_dictionary(
|
|
self, item: Mapping[K, V], mismatch_description: Optional[Description]
|
|
) -> bool:
|
|
if mismatch_description:
|
|
mismatch_description.append_description_of(item).append_text(" is not a mapping object")
|
|
return False
|
|
|
|
def matches(
|
|
self, item: Mapping[K, V], mismatch_description: Optional[Description] = None
|
|
) -> bool:
|
|
for key, value_matcher in self.value_matchers:
|
|
|
|
try:
|
|
if not key in item:
|
|
if mismatch_description:
|
|
mismatch_description.append_text("no ").append_description_of(
|
|
key
|
|
).append_text(" key in ").append_description_of(item)
|
|
return False
|
|
except TypeError:
|
|
return self._not_a_dictionary(item, mismatch_description)
|
|
|
|
try:
|
|
actual_value = item[key]
|
|
except TypeError:
|
|
return self._not_a_dictionary(item, mismatch_description)
|
|
|
|
if not value_matcher.matches(actual_value):
|
|
if mismatch_description:
|
|
mismatch_description.append_text("value for ").append_description_of(
|
|
key
|
|
).append_text(" ")
|
|
value_matcher.describe_mismatch(actual_value, mismatch_description)
|
|
return False
|
|
|
|
return True
|
|
|
|
def describe_mismatch(self, item: Mapping[K, V], mismatch_description: Description) -> None:
|
|
self.matches(item, mismatch_description)
|
|
|
|
def describe_keyvalue(self, index: int, value: V, description: Description) -> None:
|
|
"""Describes key-value pair at given index."""
|
|
description.append_description_of(index).append_text(": ").append_description_of(value)
|
|
|
|
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("}")
|
|
|
|
|
|
# Keyword argument form
|
|
@overload
|
|
def has_entries(**keys_valuematchers: Union[Matcher[V], V]) -> Matcher[Mapping[str, V]]:
|
|
...
|
|
|
|
|
|
# Key to matcher dict form
|
|
@overload
|
|
def has_entries(keys_valuematchers: Mapping[K, Union[Matcher[V], V]]) -> Matcher[Mapping[K, V]]:
|
|
...
|
|
|
|
|
|
# Alternating key/matcher form
|
|
@overload
|
|
def has_entries(*keys_valuematchers: Any) -> Matcher[Mapping[Any, Any]]:
|
|
...
|
|
|
|
|
|
def has_entries(*keys_valuematchers, **kv_args):
|
|
"""Matches if dictionary contains entries satisfying a dictionary of keys
|
|
and corresponding value matchers.
|
|
|
|
:param matcher_dict: A dictionary mapping keys to associated value matchers,
|
|
or to expected values for
|
|
:py:func:`~hamcrest.core.core.isequal.equal_to` matching.
|
|
|
|
Note that the keys must be actual keys, not matchers. Any value argument
|
|
that is not a matcher is implicitly wrapped in an
|
|
:py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for
|
|
equality.
|
|
|
|
Examples::
|
|
|
|
has_entries({'foo':equal_to(1), 'bar':equal_to(2)})
|
|
has_entries({'foo':1, 'bar':2})
|
|
|
|
``has_entries`` also accepts a list of keyword arguments:
|
|
|
|
.. function:: has_entries(keyword1=value_matcher1[, keyword2=value_matcher2[, ...]])
|
|
|
|
:param keyword1: A keyword to look up.
|
|
:param valueMatcher1: The matcher to satisfy for the value, or an expected
|
|
value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching.
|
|
|
|
Examples::
|
|
|
|
has_entries(foo=equal_to(1), bar=equal_to(2))
|
|
has_entries(foo=1, bar=2)
|
|
|
|
Finally, ``has_entries`` also accepts a list of alternating keys and their
|
|
value matchers:
|
|
|
|
.. function:: has_entries(key1, value_matcher1[, ...])
|
|
|
|
:param key1: A key (not a matcher) to look up.
|
|
:param valueMatcher1: The matcher to satisfy for the value, or an expected
|
|
value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching.
|
|
|
|
Examples::
|
|
|
|
has_entries('foo', equal_to(1), 'bar', equal_to(2))
|
|
has_entries('foo', 1, 'bar', 2)
|
|
|
|
"""
|
|
if len(keys_valuematchers) == 1:
|
|
try:
|
|
base_dict = keys_valuematchers[0].copy()
|
|
for key in base_dict:
|
|
base_dict[key] = wrap_matcher(base_dict[key])
|
|
except AttributeError:
|
|
raise ValueError(
|
|
"single-argument calls to has_entries must pass a dict as the argument"
|
|
)
|
|
else:
|
|
if len(keys_valuematchers) % 2:
|
|
raise ValueError("has_entries requires key-value pairs")
|
|
base_dict = {}
|
|
for index in range(int(len(keys_valuematchers) / 2)):
|
|
base_dict[keys_valuematchers[2 * index]] = wrap_matcher(
|
|
keys_valuematchers[2 * index + 1]
|
|
)
|
|
|
|
for key, value in kv_args.items():
|
|
base_dict[key] = wrap_matcher(value)
|
|
|
|
return IsDictContainingEntries(base_dict)
|