fix error with unhashable types and compare_dicts (piccolo-orm#182)

Author: dantownsend

piccolo/apps/migrations/auto/diffable_table.py

@@ -20,8 +20,29 @@ def compare_dicts(dict_1, dict_2) -> t.Dict[str, t.Any]:
     """
     Returns a new dictionary which only contains key, value pairs which are in
     the first dictionary and not the second.
+
+    For example:
+        dict_1 = {'a': 1, 'b': 2}
+        dict_2 = {'a': 1}
+        returns {'b': 2}
+
+        dict_1 = {'a': 2, 'b': 2}
+        dict_2 = {'a': 1}
+        returns {'a': 2, 'b': 2}
+
     """
-    return dict(set(dict_1.items()) - set(dict_2.items()))
+    output = {}
+
+    for key, value in dict_1.items():
+
+        dict_2_value = dict_2.get(key, ...)
+        if dict_2_value is ...:
+            output[key] = value
+        else:
+            if dict_2_value != value:
+                output[key] = value
+
+    return output
 
 
 @dataclass

tests/apps/migrations/auto/test_diffable_table.py

@@ -4,16 +4,75 @@
     DiffableTable,
     compare_dicts,
 )
-from piccolo.columns import Varchar
+from piccolo.columns import OnDelete, Varchar
 
 
 class TestCompareDicts(TestCase):
-    def test_compare_dicts(self):
+    def test_simple(self):
+        """
+        Make sure that simple values are compared properly.
+        """
         dict_1 = {"a": 1, "b": 2}
         dict_2 = {"a": 1, "b": 3}
         response = compare_dicts(dict_1, dict_2)
         self.assertEqual(response, {"b": 2})
 
+    def test_missing_keys(self):
+        """
+        Make sure that if one dictionary has keys that the other doesn't,
+        it works as expected.
+        """
+        dict_1 = {"a": 1}
+        dict_2 = {"b": 2, "c": 3}
+        response = compare_dicts(dict_1, dict_2)
+        self.assertEqual(response, {"a": 1})
+
+    def test_list_value(self):
+        """
+        Make sure list values work correctly.
+        """
+        dict_1 = {"a": 1, "b": [1]}
+        dict_2 = {"a": 1, "b": [2]}
+        response = compare_dicts(dict_1, dict_2)
+        self.assertEqual(response, {"b": [1]})
+
+    def test_dict_value(self):
+        """
+        Make sure dictionary values work correctly.
+        """
+        dict_1 = {"a": 1, "b": {"x": 1}}
+        dict_2 = {"a": 1, "b": {"x": 1}}
+        response = compare_dicts(dict_1, dict_2)
+        self.assertEqual(response, {})
+
+        dict_1 = {"a": 1, "b": {"x": 1}}
+        dict_2 = {"a": 1, "b": {"x": 2}}
+        response = compare_dicts(dict_1, dict_2)
+        self.assertEqual(response, {"b": {"x": 1}})
+
+    def test_none_values(self):
+        """
+        Make sure there are no edge cases when using None values.
+        """
+        dict_1 = {"a": None, "b": 1}
+        dict_2 = {"a": None}
+        response = compare_dicts(dict_1, dict_2)
+        self.assertEqual(response, {"b": 1})
+
+    def test_enum_values(self):
+        """
+        Make sure Enum values can be compared correctly.
+        """
+        dict_1 = {"a": OnDelete.cascade}
+        dict_2 = {"a": OnDelete.cascade}
+        response = compare_dicts(dict_1, dict_2)
+        self.assertEqual(response, {})
+
+        dict_1 = {"a": OnDelete.set_default}
+        dict_2 = {"a": OnDelete.cascade}
+        response = compare_dicts(dict_1, dict_2)
+        self.assertEqual(response, {"a": OnDelete.set_default})
+
 
 class TestDiffableTable(TestCase):
     def test_subtract(self):