Adding more tests for skipping stuff

Author: seperman

README.md

@@ -9,12 +9,15 @@
 Deep Difference of dictionaries, iterables, strings and other objects. It will recursively look for all the changes.
 Tested on Python 2.7, 3.3, 3.4, 3.5, Pypy, Pypy3
 
-## Pycon 2016
+## Table of Contents
 
-I was honored to give a talk about how DeepDiff does what it does at Pycon 2016. Please check out the video and let me know what you think:
-
-[Diff It To Dig It Video](https://www.youtube.com/watch?v=J5r99eJIxF4)
-And here is more info: <http://zepworks.com/blog/diff-it-to-digg-it/>
+- [Installation](#Installation)
+- [Importing](#Importing)
+- [Supported data types](#supported-data-types)
+- [Type Change](#type-of-an-item-has-changed)
+- [Value Change](#value-of-an-item-has-changed)
+- [Item added or removed](#item-added-or-removed)
+- [String difference](#string-difference)
 
 ##Installation
 
@@ -73,7 +76,7 @@ int, string, dictionary, list, tuple, set, frozenset, OrderedDict, NamedTuple an
 {'values_changed': {'root[2]': {'new_value': 4, 'old_value': 2}}}
 ```
 
-### Item added and/or removed
+### Item added or removed
 
 ```python
 >>> t1 = {1:1, 2:2, 3:3, 4:4}
@@ -328,6 +331,14 @@ Example in DeepDiff for the same operation:
 ```
 
 
+## Pycon 2016
+
+I was honored to give a talk about how DeepDiff does what it does at Pycon 2016. Please check out the video and let me know what you think:
+
+[Diff It To Dig It Video](https://www.youtube.com/watch?v=J5r99eJIxF4)
+And here is more info: <http://zepworks.com/blog/diff-it-to-digg-it/>
+
+
 ##Documentation
 
 <http://deepdiff.readthedocs.org/en/latest/>

deepdiff/deepdiff.py

@@ -144,6 +144,11 @@ class DeepDiff(RemapDict):
 
         For Decimals, Python's format rounds 2.5 to 2 and 3.5 to 4 (to the closest even number)
 
+    verbose_level : int >= 0, default = 1.
+        Higher verbose level shows you more details.
+        For example verbose level 1 shows what dictionary item are added or removed.
+        And verbose level 2 shows the value of the items that are added or removed too.
+
     **Returns**
 
         A DeepDiff object that has already calculated the difference of the 2 items.
@@ -358,6 +363,7 @@ def __init__(self, t1, t2,
         self.report_repetition = report_repetition
         self.exclude_paths = set(exclude_paths)
         self.exclude_types = set(exclude_types)
+        self.exclude_types_tuple = tuple(exclude_types)  # we need tuple for checking isinstance
         self.verbose_level = verbose_level
 
         if significant_digits is not None and significant_digits < 0:
@@ -367,7 +373,8 @@ def __init__(self, t1, t2,
         self.update({"type_changes": {}, "dictionary_item_added": self.__set_or_dict(),
                      "dictionary_item_removed": self.__set_or_dict(),
                      "values_changed": {}, "unprocessed": [], "iterable_item_added": {}, "iterable_item_removed": {},
-                     "attribute_added": set([]), "attribute_removed": set([]), "set_item_removed": set([]),
+                     "attribute_added": self.__set_or_dict(), "attribute_removed": self.__set_or_dict(),
+                     "set_item_removed": set([]),
                      "set_item_added": set([]), "repetition_change": {}})
 
         self.__diff(t1, t2, parents_ids=frozenset({id(t1)}))
@@ -382,12 +389,16 @@ def __set_or_dict(self):
 
     def __extend_result_list(self, keys, parent, report_obj, print_as_attribute=False, obj=None):
         key_text = "%s{}".format(INDEX_VS_ATTRIBUTE[print_as_attribute])
-        for i in keys:
-            if self.__skip_this(i, None, parent="{}['{}']".format(parent, i)):
-                continue
-            else:
-                i = "'%s'" % i if not print_as_attribute and isinstance(i, strings) else i
-                report_obj.add(key_text % (parent, i))
+        for key in keys:
+            key_formatted = "'%s'" % key if not print_as_attribute and isinstance(key, strings) else key
+            key_in_report = key_text % (parent, key_formatted)
+
+            item = obj[key] if obj else key
+            if not self.__skip_this(item, None, key_in_report):
+                if obj and self.verbose_level >= 2:
+                    report_obj[key_in_report] = obj[key]
+                else:
+                    report_obj.add(key_in_report)
 
     @staticmethod
     def __add_to_frozen_set(parents_ids, item_id):
@@ -414,6 +425,16 @@ def __diff_obj(self, t1, t2, parent, parents_ids=frozenset({}), is_namedtuple=Fa
 
         self.__diff_dict(t1, t2, parent, parents_ids, print_as_attribute=True)
 
+    def __skip_this(self, t1, t2, parent):
+        skip = False
+        if parent in self.exclude_paths:
+            skip = True
+        else:
+            if isinstance(t1, self.exclude_types_tuple) or isinstance(t2, self.exclude_types_tuple):
+                skip = True
+
+        return skip
+
     def __diff_dict(self, t1, t2, parent, parents_ids=frozenset({}), print_as_attribute=False):
         """Difference of 2 dictionaries"""
         if print_as_attribute:
@@ -435,11 +456,11 @@ def __diff_dict(self, t1, t2, parent, parents_ids=frozenset({}), print_as_attrib
 
         if t_keys_added:
             self.__extend_result_list(keys=t_keys_added, parent=parent,
-                                      report_obj=self[item_added_key], print_as_attribute=print_as_attribute)
+                                      report_obj=self[item_added_key], print_as_attribute=print_as_attribute, obj=t2)
 
         if t_keys_removed:
             self.__extend_result_list(keys=t_keys_removed, parent=parent,
-                                      report_obj=self[item_removed_key], print_as_attribute=print_as_attribute)
+                                      report_obj=self[item_removed_key], print_as_attribute=print_as_attribute, obj=t1)
 
         self.__diff_common_children(
             t1, t2, t_keys_intersect, print_as_attribute, parents_ids, parent, parent_text)
@@ -603,6 +624,35 @@ def __diff_unhashable_iterable(self, t1, t2, parent):
         self["iterable_item_removed"].update(items_removed)
         self["iterable_item_added"].update(items_added)
 
+    def __diff_numbers(self, t1, t2, parent):
+        """Diff Numbers"""
+
+        if self.significant_digits is not None and isinstance(t1, (float, complex, Decimal)):
+            # Bernhard10: I use string formatting for comparison, to be consistent with usecases where
+            # data is read from files that were previousely written from python and
+            # to be consistent with on-screen representation of numbers.
+            # Other options would be abs(t1-t2)<10**-self.significant_digits
+            # or math.is_close (python3.5+)
+            # Note that abs(3.25-3.251) = 0.0009999999999998899 < 0.001
+            # Note also that "{:.3f}".format(1.1135) = 1.113, but "{:.3f}".format(1.11351) = 1.114
+            # For Decimals, format seems to round 2.5 to 2 and 3.5 to 4 (to closest even number)
+            t1_s = ("{:.%sf}" % self.significant_digits).format(t1)
+            t2_s = ("{:.%sf}" % self.significant_digits).format(t2)
+            if t1_s != t2_s:
+                self["values_changed"][parent] = RemapDict(
+                    old_value=t1, new_value=t2)
+        else:
+            if t1 != t2:
+                self["values_changed"][parent] = RemapDict(
+                    old_value=t1, new_value=t2)
+
+    def __diff_types(self, t1, t2, parent):
+        """Diff types"""
+
+        self["type_changes"][parent] = RemapDict(old_type=type(t1), new_type=type(t2))
+        if self.verbose_level:
+            self["type_changes"][parent].update(old_value=t1, new_value=t2)
+
     def __diff(self, t1, t2, parent="root", parents_ids=frozenset({})):
         """The main diff method"""
 
@@ -613,32 +663,13 @@ def __diff(self, t1, t2, parent="root", parents_ids=frozenset({})):
             return
 
         if type(t1) != type(t2):
-            self["type_changes"][parent] = RemapDict(old_type=type(t1), new_type=type(t2))
-            if self.verbose_level:
-                self["type_changes"][parent].update(old_value=t1, new_value=t2)
+            self.__diff_types(t1, t2, parent)
 
         elif isinstance(t1, strings):
             self.__diff_str(t1, t2, parent)
 
         elif isinstance(t1, numbers):
-            if self.significant_digits is not None and isinstance(t1, (float, complex, Decimal)):
-                # Bernhard10: I use string formatting for comparison, to be consistent with usecases where
-                # data is read from files that were previousely written from python and
-                # to be consistent with on-screen representation of numbers.
-                # Other options would be abs(t1-t2)<10**-self.significant_digits
-                # or math.is_close (python3.5+)
-                # Note that abs(3.25-3.251) = 0.0009999999999998899 < 0.001
-                # Note also that "{:.3f}".format(1.1135) = 1.113, but "{:.3f}".format(1.11351) = 1.114
-                # For Decimals, format seems to round 2.5 to 2 and 3.5 to 4 (to closest even number)
-                t1_s = ("{:.%sf}" % self.significant_digits).format(t1)
-                t2_s = ("{:.%sf}" % self.significant_digits).format(t2)
-                if t1_s != t2_s:
-                    self["values_changed"][parent] = RemapDict(
-                        old_value=t1, new_value=t2)
-            else:
-                if t1 != t2:
-                    self["values_changed"][parent] = RemapDict(
-                        old_value=t1, new_value=t2)
+            self.__diff_numbers(t1, t2, parent)
 
         elif isinstance(t1, MutableMapping):
             self.__diff_dict(t1, t2, parent, parents_ids)
@@ -661,18 +692,6 @@ def __diff(self, t1, t2, parent="root", parents_ids=frozenset({})):
 
         return
 
-    def __skip_this(self, t1, t2, parent):
-        skip = False
-        if parent in self.exclude_paths:
-            skip = True
-        else:
-            for exclude_type in self.exclude_types:
-                if isinstance(t1, exclude_type) or isinstance(t2, exclude_type):
-                    skip = True
-                    break
-
-        return skip
-
 
 if __name__ == "__main__":
     if not py3:

tests.py

@@ -20,7 +20,7 @@
 
 
 class CustomClass:
-    def __init__(self, a, b):
+    def __init__(self, a, b=None):
         self.a = a
         self.b = b
 
@@ -63,6 +63,14 @@ def test_item_added_and_removed(self):
         }
         self.assertEqual(ddiff, result)
 
+    def test_item_added_and_removed_verbose(self):
+        t1 = {1: 1, 3: 3, 4: 4}
+        t2 = {1: 1, 3: 3, 5: 5, 6: 6}
+        ddiff = DeepDiff(t1, t2, verbose_level=2)
+        result = {'dictionary_item_removed': {'root[4]': 4},
+                  'dictionary_item_added': {'root[6]': 6, 'root[5]': 5}}
+        self.assertEqual(ddiff, result)
+
     def test_diffs_dates(self):
         t1 = datetime.date(2016, 8, 8)
         t2 = datetime.date(2016, 8, 7)
@@ -392,16 +400,10 @@ def test_named_tuples(self):
         self.assertEqual(ddiff, result)
 
     def test_custom_objects_change(self):
-        class ClassA(object):
-            a = 1
-
-            def __init__(self, b):
-                self.b = b
-
-        t1 = ClassA(1)
-        t2 = ClassA(2)
+        t1 = CustomClass(1)
+        t2 = CustomClass(2)
         ddiff = DeepDiff(t1, t2)
-        result = {'values_changed': {'root.b': {'old_value': 1, 'new_value': 2}}}
+        result = {'values_changed': {'root.a': {'old_value': 1, 'new_value': 2}}}
         self.assertEqual(ddiff, result)
 
     def test_custom_objects_slot_change(self):
@@ -418,7 +420,7 @@ def __init__(self, x, y):
         result = {'values_changed': {'root.y': {'old_value': 1, 'new_value': 2}}}
         self.assertEqual(ddiff, result)
 
-    def test_custom_objects_add_and_remove(self):
+    def get_custom_objects_add_and_remove(self):
         class ClassA(object):
             a = 1
 
@@ -430,12 +432,24 @@ def __init__(self, b):
         t2 = ClassA(2)
         t2.c = "new attribute"
         del t2.d
+        return t1, t2
+
+    def test_custom_objects_add_and_remove(self):
+        t1, t2 = self.get_custom_objects_add_and_remove()
         ddiff = DeepDiff(t1, t2)
         result = {'attribute_added': {'root.c'}, 'values_changed': {
             'root.b': {'new_value': 2, 'old_value': 1}}, 'attribute_removed': {'root.d'}}
         self.assertEqual(ddiff, result)
 
-    def test_custom_objects_add_and_remove_method(self):
+    def test_custom_objects_add_and_remove_verbose(self):
+        t1, t2 = self.get_custom_objects_add_and_remove()
+        ddiff = DeepDiff(t1, t2, verbose_level=2)
+        result = {'attribute_added': {'root.c': 'new attribute'},
+                  'attribute_removed': {'root.d': 10},
+                  'values_changed': {'root.b': {'new_value': 2, 'old_value': 1}}}
+        self.assertEqual(ddiff, result)
+
+    def get_custom_object_with_added_removed_methods(self):
         class ClassA(object):
 
             def method_a(self):
@@ -452,13 +466,24 @@ def method_c(self):
 
         t2.method_b = method_b
         t2.method_a = method_c
-        ddiff = DeepDiff(t1, t2)
         # Note that we are comparing ClassA instances. method_a originally was in ClassA
         # But we also added another version of it to t2. So it comes up as
         # added attribute.
+        return t1, t2
+
+    def test_custom_objects_add_and_remove_method(self):
+        t1, t2 = self.get_custom_object_with_added_removed_methods()
+        ddiff = DeepDiff(t1, t2)
+
         result = {'attribute_added': {'root.method_a', 'root.method_b'}}
         self.assertEqual(ddiff, result)
 
+    def test_custom_objects_add_and_remove_method_verbose(self):
+        t1, t2 = self.get_custom_object_with_added_removed_methods()
+        ddiff = DeepDiff(t1, t2, verbose_level=2)
+        self.assertTrue('root.method_a' in ddiff['attribute_added'])
+        self.assertTrue('root.method_b' in ddiff['attribute_added'])
+
     def test_set_of_custom_objects(self):
         member1 = CustomClass(13, 37)
         member2 = CustomClass(13, 37)
@@ -758,15 +783,9 @@ def test_skip_path4(self):
         self.assertTrue('dictionary_item_removed' not in ddiff, {})
 
     def test_skip_custom_object_path(self):
-        class ClassA(object):
-            a = 1
-
-            def __init__(self, b):
-                self.b = b
-
-        t1 = ClassA(1)
-        t2 = ClassA(2)
-        ddiff = DeepDiff(t1, t2, exclude_paths=['root.b'])
+        t1 = CustomClass(1)
+        t2 = CustomClass(2)
+        ddiff = DeepDiff(t1, t2, exclude_paths=['root.a'])
         result = {}
         self.assertEqual(ddiff, result)
 
@@ -777,3 +796,29 @@ def test_skip_list_path(self):
         ddiff = DeepDiff(t1, t2, exclude_paths=['root[1]'])
         result = {}
         self.assertEqual(ddiff, result)
+
+    def test_skip_dictionary_path(self):
+
+        t1 = {1: {2: "a"}}
+        t2 = {1: {}}
+        ddiff = DeepDiff(t1, t2, exclude_paths=['root[1][2]'])
+        result = {}
+        self.assertEqual(ddiff, result)
+
+    def test_skip_dictionary_path_with_custom_object(self):
+        obj1 = CustomClass(1)
+        obj2 = CustomClass(2)
+
+        t1 = {1: {2: obj1}}
+        t2 = {1: {2: obj2}}
+        ddiff = DeepDiff(t1, t2, exclude_paths=['root[1][2].a'])
+        result = {}
+        self.assertEqual(ddiff, result)
+
+    def test_skip_str_type_in_dictionary(self):
+
+        t1 = {1: {2: "a"}}
+        t2 = {1: {}}
+        ddiff = DeepDiff(t1, t2, exclude_types=[str])
+        result = {}
+        self.assertEqual(ddiff, result)