Add is_mapping_with matcher

Author: ErwinJunge

README.rst

@@ -117,6 +117,18 @@ For instance, ``has_attrs(name="bob")`` is equivalent to ``has_attrs(name=equal_
           "b": equal_to(4),
       }))
 
+* ``is_mapping_with(**matchers)``: matches a mapping, such as a ``dict``, if it has the same keys with matching values.
+  An error will be raised if the mapping is missing any keys, but allows extra keys.
+  For instance:
+
+  .. code:: python
+
+      result = {"a": 1, "b": 4, "c": 5}
+      assert_that(result, is_mapping_with({
+          "a": equal_to(1),
+          "b": equal_to(4),
+      }))
+
 * ``anything``: matches all values.
 
 * ``is_instance(type)``: matches any value where ``isinstance(value, type)``.

precisely/__init__.py

@@ -5,7 +5,7 @@
 from .iterable_matchers import all_elements, contains_exactly, includes, is_sequence
 from .feature_matchers import has_feature
 from .function_matchers import raises
-from .mapping_matchers import is_mapping
+from .mapping_matchers import is_mapping, is_mapping_with
 from .results import indent as _indent
 
 
@@ -35,6 +35,7 @@
     "is_sequence",
     "has_feature",
     "is_mapping",
+    "is_mapping_with",
     "raises",
 ]
 

precisely/mapping_matchers.py

@@ -3,16 +3,21 @@
 from .results import matched, unmatched, indented_list
 
 
-def is_mapping(matchers):
+def is_mapping(matchers, allow_extra=False):
     return IsMappingMatcher(dict(
         (key, to_matcher(matcher))
         for key, matcher in matchers.items()
-    ))
+    ), allow_extra)
+
+
+def is_mapping_with(matchers):
+    return is_mapping(matchers, allow_extra=True)
 
 
 class IsMappingMatcher(Matcher):
-    def __init__(self, matchers):
+    def __init__(self, matchers, allow_extra):
         self._matchers = matchers
+        self._allow_extra = allow_extra
 
     def match(self, actual):
         undefined = object()
@@ -25,9 +30,10 @@ def match(self, actual):
             if not value_result.is_match:
                 return unmatched("value for key {0!r} mismatched:{1}".format(key, indented_list([value_result.explanation])))
 
-        extra_keys = set(actual.keys()) - set(self._matchers.keys())
-        if extra_keys:
-            return unmatched("had extra keys:{0}".format(indented_list(sorted(map(repr, extra_keys)))))
+        if not self._allow_extra:
+            extra_keys = set(actual.keys()) - set(self._matchers.keys())
+            if extra_keys:
+                return unmatched("had extra keys:{0}".format(indented_list(sorted(map(repr, extra_keys)))))
 
         return matched()
 

tests/is_mapping_with_tests.py

@@ -0,0 +1,43 @@
+from nose.tools import istest, assert_equal
+
+from precisely import equal_to, is_mapping_with
+from precisely.results import matched, unmatched
+
+
+@istest
+def matches_when_keys_and_values_match():
+    matcher = is_mapping_with({"a": equal_to(1), "b": equal_to(2)})
+    assert_equal(matched(), matcher.match({"a": 1, "b": 2}))
+
+
+@istest
+def values_are_coerced_to_matchers():
+    matcher = is_mapping_with({"a": 1, "b": 2})
+    assert_equal(matched(), matcher.match({"a": 1, "b": 2}))
+
+
+@istest
+def does_not_match_when_value_does_not_match():
+    matcher = is_mapping_with({"a": equal_to(1), "b": equal_to(2)})
+    assert_equal(
+        unmatched("value for key 'b' mismatched:\n * was 3"),
+        matcher.match({"a": 1, "b": 3, "c": 4}),
+    )
+
+
+@istest
+def does_not_match_when_keys_are_missing():
+    matcher = is_mapping_with({"a": equal_to(1), "b": equal_to(2)})
+    assert_equal(unmatched("was missing key: 'b'"), matcher.match({"a": 1}))
+
+
+@istest
+def matches_when_there_are_extra_keys():
+    matcher = is_mapping_with({"a": equal_to(1)})
+    assert_equal(matched(), matcher.match({"a": 1, "b": 1, "c": 1}))
+
+
+@istest
+def description_describes_keys_and_value_matchers():
+    matcher = is_mapping_with({"a": equal_to(1), "b": equal_to(2)})
+    assert_equal("mapping with items:\n * 'a': 1\n * 'b': 2", matcher.describe())