def matches(self, item, mismatch_description=None):
"""Return whether the item is a valid to-many relationship."""
if mismatch_description is None:
mismatch_description = StringDescription()
if "data" not in item:
mismatch_description.append('missing key "data"')
return False
if not isinstance(item["data"], list):
mismatch_description.append(
"to-many relationship is not a `list`\n "
f"got: `{item.__class__.__name__}`")
return False
if not self.optional and not item["data"]:
mismatch_description.append(
"non-optional to-many relationship is ")
mismatch_description.append_description_of(item["data"])
return False
for index, data in enumerate(item["data"]):
if not super().matches(data):
mismatch_description.append(
f"to-many relationship at index {index}"
" does not match. Failed because: ")
super().matches(data, mismatch_description)
return False
return True
def matches(self, item, mismatch_description=None):
"""Return whether the item is a valid to-one relationship."""
if mismatch_description is None:
mismatch_description = StringDescription()
if "data" not in item:
mismatch_description.append('missing key "data"')
return False
if item["data"] is None:
if self.optional:
return True
mismatch_description.append("non-optional to-one relationship is ")
mismatch_description.append_description_of(item["data"])
return False
return super().matches(item["data"], mismatch_description)
class StringDescriptionTest(unittest.TestCase):
def setUp(self):
self.description = StringDescription()
def testLetsSelfDescribingObjectDescribeItself(self):
self.description.append_description_of(FakeSelfDescribing())
self.assertEqual("DESCRIPTION", str(self.description))
def testDescribesStringInQuotes(self):
self.description.append_description_of("FOO")
self.assertEqual("'FOO'", str(self.description))
def testWrapsNonSelfDescribingObjectInAngleBrackets(self):
self.description.append_description_of(42)
self.assertEqual("<42>", str(self.description))
def testShouldNotAddAngleBracketsIfObjectDescriptionAlreadyHasThem(self):
self.description.append_description_of(object())
expected = re.compile("<object object at 0x[0-9a-fA-F]+>")
self.assertTrue(expected.match(str(self.description)))
def testDescribeUnicodeStringAsUnicode(self):
self.description.append_description_of("\u05d0")
self.assertEqual("'\u05d0'", str(self.description))
def matches(self, item, mismatch_description=None):
"""Return whether the item is a json:api document."""
if mismatch_description is None:
mismatch_description = StringDescription()
if "data" not in item:
mismatch_description.append('missing key "data"')
return False
if not self.optional and not item["data"]:
mismatch_description.append('non-optional "data" is ')
mismatch_description.append_description_of(item["data"])
return False
if self.many:
if not isinstance(item["data"], list):
mismatch_description.append(
f'"data" is not a `list`\n got: `{item.__class__.__name__}`'
)
return False
for index, data in enumerate(item["data"]):
if not self._match_resource(
data, mismatch_description, index=index):
return False
elif not self._match_resource(item["data"], mismatch_description):
return False
return self._matches_includes(item, mismatch_description)
def assert_description(expected, matcher):
description = StringDescription()
description.append_description_of(matcher)
assert expected == str(description)
def testDescriptionIncludesMemoryAddress(self):
description = StringDescription()
expected = re.compile("same instance as " + ADDRESS_FORMAT + " 'abc'")
description.append_description_of(same_instance('abc'));
self.assertTrue(expected.match(str(description)))
def testDescriptionIncludesMemoryAddress(self):
description = StringDescription()
expected = re.compile("same instance as " + ADDRESS_FORMAT + " 'abc'")
description.append_description_of(same_instance("abc"))
self.assertTrue(expected.match(str(description)))
def assert_description(self, expected, matcher):
description = StringDescription()
description.append_description_of(matcher)
self.assertEqual(expected, str(description))
def has_properties(*keys_valuematchers, **kv_args):
"""Matches if an object has properties satisfying all of a dictionary
of string property names 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_properties({'foo':equal_to(1), 'bar':equal_to(2)})
has_properties({'foo':1, 'bar':2})
``has_properties`` also accepts a list of keyword arguments:
.. function:: has_properties(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_properties(foo=equal_to(1), bar=equal_to(2))
has_properties(foo=1, bar=2)
Finally, ``has_properties`` also accepts a list of alternating keys and their
value matchers:
.. function:: has_properties(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_properties('foo', equal_to(1), 'bar', equal_to(2))
has_properties('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_shortcut(base_dict[key])
except AttributeError:
raise ValueError(
"single-argument calls to has_properties must pass a dict as the argument"
)
else:
if len(keys_valuematchers) % 2:
raise ValueError("has_properties requires key-value pairs")
base_dict = {}
for index in range(int(len(keys_valuematchers) / 2)):
base_dict[keys_valuematchers[2 * index]] = wrap_shortcut(
keys_valuematchers[2 * index + 1])
for key, value in kv_args.items():
base_dict[key] = wrap_shortcut(value)
if len(base_dict) > 1:
description = StringDescription().append_text(
"an object with properties ")
for i, (property_name, property_value_matcher) in enumerate(
sorted(base_dict.items())):
description.append_description_of(property_name).append_text(
" matching ").append_description_of(property_value_matcher)
if i < len(base_dict) - 1:
description.append_text(" and ")
return described_as(
str(description),
AllOf(
*[
has_property(property_name, property_value_matcher)
for property_name, property_value_matcher in sorted(
base_dict.items())
],
describe_all_mismatches=True,
describe_matcher_in_mismatch=False,
),
)
else:
property_name, property_value_matcher = base_dict.popitem()
return has_property(property_name, property_value_matcher)
def assert_description(expected, matcher):
description = StringDescription()
description.append_description_of(matcher)
assert expected == str(description)
def assert_description(self, expected, matcher):
description = StringDescription()
description.append_description_of(matcher)
self.assertEqual(expected, str(description))
def testDescriptionIncludesMemoryAddress(self):
description = StringDescription()
expected = re.compile("same instance as 0x[0-9a-fA-F]+ 'abc'")
description.append_description_of(same_instance('abc'))
self.assertTrue(expected.match(str(description)))