Add assert_dict_equal() (#14)

Author: srittau

NEWS.rst

@@ -1,6 +1,11 @@
 News in asserts 0.8.4
 =====================
 
+API Additions
+-------------
+
+* Add ``assert_dict_equal()``.
+
 Improvements
 ------------
 

asserts/__init__.py

@@ -290,6 +290,71 @@ def assert_not_almost_equal(first, second, msg_fmt="{msg}",
                             places=places, delta=delta))
 
 
+def assert_dict_equal(first, second, key_msg_fmt="{msg}",
+                      value_msg_fmt="{msg}"):
+    """Fail unless first dictionary equals second.
+
+    The dictionaries are considered equal, if they both contain the same
+    keys, and their respective values are also equal.
+
+    >>> assert_equal({"foo": 5}, {"foo": 5})
+    >>> assert_equal({"foo": 5}, {})
+    Traceback (most recent call last):
+        ...
+    AssertionError: key 'foo' missing from right dict
+
+    The following key_msg_fmt arguments are supported, if the keys do not
+    match:
+    * msg - the default error message
+    * first - the first dict
+    * second - the second dict
+    * missing_keys - list of keys missing from right
+    * extra_keys - list of keys missing from left
+
+    The following value_msg_fmt arguments are supported, if a value does not
+    match:
+    * msg - the default error message
+    * first - the first dict
+    * second - the second dict
+    * key - the key where the value does not match
+    * first_value - the value in the first dict
+    * second_value - the value in the second dict
+    """
+    first_keys = set(first.keys())
+    second_keys = set(second.keys())
+    missing_keys = list(first_keys - second_keys)
+    extra_keys = list(second_keys - first_keys)
+    if missing_keys or extra_keys:
+        if missing_keys:
+            if len(missing_keys) == 1:
+                msg = "key {!r} missing from right dict".format(missing_keys[0])
+            else:
+                keys = ", ".join(sorted(repr(k) for k in missing_keys))
+                msg = "keys {} missing from right dict".format(keys)
+        else:
+            if len(extra_keys) == 1:
+                msg = "extra key {!r} in right dict".format(extra_keys[0])
+            else:
+                keys = ", ".join(sorted(repr(k) for k in extra_keys))
+                msg = "extra keys {} in right dict".format(keys)
+        if key_msg_fmt:
+            msg = key_msg_fmt.format(
+                msg=msg, first=first, second=second,
+                missing_keys=missing_keys, extra_keys=extra_keys)
+        raise AssertionError(msg)
+    for key in first:
+        first_value = first[key]
+        second_value = second[key]
+        msg = "key '{}' differs: {!r} != {!r}".format(
+            key, first_value, second_value)
+        if value_msg_fmt:
+            msg = value_msg_fmt.format(
+                msg=msg, first=first, second=second,
+                key=key, first_value=first_value, second_value=second_value)
+        msg = msg.replace("{", "{{").replace("}", "}}")
+        assert_equal(first_value, second_value, msg_fmt=msg)
+
+
 def assert_less(first, second, msg_fmt="{msg}"):
     """Fail if first is not less than second.
 

asserts/__init__.pyi

@@ -46,6 +46,7 @@ def assert_equal(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...
 def assert_not_equal(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...
 def assert_almost_equal(first: float, second: float, msg_fmt: Text = ..., places: int = ..., delta: float = ...) -> None: ...
 def assert_not_almost_equal(first: float, second: float, msg_fmt: Text = ..., places: int = ..., delta: float = ...) -> None: ...
+def assert_dict_equal(first: dict, second: dict, key_msg_fmt: Text = ..., value_msg_fmt: Text = ...) -> None: ...
 def assert_less(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...
 def assert_less_equal(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...
 def assert_greater(first: Any, second: Any, msg_fmt: Text = ...) -> None: ...

test_asserts.py

@@ -37,7 +37,7 @@
     assert_raises_errno,
     assert_succeeds,
     assert_warns,
-    assert_warns_regex)
+    assert_warns_regex, assert_dict_equal)
 
 
 class _DummyObject(object):
@@ -365,6 +365,74 @@ def test_not_assert_almost_equal__delta_lt_0(self):
         else:
             raise AssertionError("ValueError not raised")
 
+    # assert_dict_equal()
+
+    def test_assert_dict_equal__empty_dicts(self):
+        assert_dict_equal({}, {})
+
+    def test_assert_dict_equal__dicts_are_equal(self):
+        assert_dict_equal({"foo": 5}, {"foo": 5})
+
+    def test_assert_dict_equal__one_key_missing_from_right(self):
+        with _assert_raises_assertion("key 'foo' missing from right dict"):
+            assert_dict_equal({"bar": 10, "foo": 5}, {"bar": 10})
+
+    def test_assert_dict_equal__multiple_keys_missing_from_right(self):
+        with _assert_raises_assertion(
+                "keys 'bar', 'foo' missing from right dict"):
+            assert_dict_equal({"foo": 5, "bar": 10, "baz": 15}, {"baz": 15})
+
+    def test_assert_dict_equal__one_key_missing_from_left(self):
+        with _assert_raises_assertion("extra key 'foo' in right dict"):
+            assert_dict_equal({"bar": 10}, {"bar": 10, "foo": 5})
+
+    def test_assert_dict_equal__multiple_keys_missing_from_left(self):
+        with _assert_raises_assertion("extra keys 'bar', 'foo' in right dict"):
+            assert_dict_equal({"baz": 15}, {"foo": 5, "bar": 10, "baz": 15})
+
+    def test_assert_dict_equal__values_do_not_match(self):
+        with _assert_raises_assertion("key 'foo' differs: 15 != 10"):
+            assert_dict_equal({"foo": 15}, {"foo": 10})
+
+    def test_assert_dict_equal__not_string_keys(self):
+        with _assert_raises_assertion("key 10 missing from right dict"):
+            assert_dict_equal({10: "foo"}, {})
+        with _assert_raises_assertion(
+                "keys 'foo', 5 missing from right dict"):
+            assert_dict_equal({5: "", "foo": ""}, {})
+        with _assert_raises_assertion("extra key 10 in right dict"):
+            assert_dict_equal({}, {10: "foo"})
+        with _assert_raises_assertion("extra keys 'foo', 5 in right dict"):
+            assert_dict_equal({}, {5: "", "foo": ""})
+
+    def test_assert_dict_equal__message_precedence(self):
+        with _assert_raises_assertion("key 'foo' missing from right dict"):
+            assert_dict_equal({"foo": "", "bar": "", "baz": 5},
+                              {"bar": "", "baz": 10, "extra": ""})
+        with _assert_raises_assertion("extra key 'extra' in right dict"):
+            assert_dict_equal({"bar": "", "baz": 5},
+                              {"bar": "", "baz": 10, "extra": ""})
+
+    def test_assert_dict_equal__custom_key_message(self):
+        with _assert_raises_assertion(
+                "key 'foo' missing from right dict;"
+                "{'foo': ''};{'bar': ''};['foo'];['bar']"):
+            assert_dict_equal(
+                {"foo": ""}, {"bar": ""},
+                key_msg_fmt="{msg};{first!r};{second!r};"
+                            "{missing_keys!r};{extra_keys!r}"
+            )
+
+    def test_assert_dict_equal__custom_value_message(self):
+        with _assert_raises_assertion(
+                "key 'foo' differs: 5 != 10;{'foo': 5};{'foo': 10};"
+                "'foo';5;10"):
+            assert_dict_equal(
+                {"foo": 5}, {"foo": 10},
+                value_msg_fmt="{msg};{first!r};{second!r};"
+                              "{key!r};{first_value};{second_value}"
+            )
+
     # assert_less()
 
     def test_assert_less(self):