Add test coverage

Author: glennmatthews

diffsync/__init__.py

@@ -460,18 +460,18 @@ def sync_from(
         source: "DiffSync",
         diff_class: Type[Diff] = Diff,
         flags: DiffSyncFlags = DiffSyncFlags.NONE,
-        callback: Optional[Callable[[int, int], None]] = None,
+        callback: Optional[Callable[[Text, int, int], None]] = None,
     ):
         """Synchronize data from the given source DiffSync object into the current DiffSync object.
 
         Args:
             source (DiffSync): object to sync data from into this one
             diff_class (class): Diff or subclass thereof to use to calculate the diffs to use for synchronization
             flags (DiffSyncFlags): Flags influencing the behavior of this sync.
-            callback (function): Function with parameters (current, total), to be called at intervals as the
-                calculation of the diff proceeds.
+            callback (function): Function with parameters (stage, current, total), to be called at intervals as the
+                calculation of the diff and subsequent sync proceed.
         """
-        diff = self.diff_from(source, diff_class=diff_class, flags=flags)
+        diff = self.diff_from(source, diff_class=diff_class, flags=flags, callback=callback)
         syncer = DiffSyncSyncer(diff=diff, src_diffsync=source, dst_diffsync=self, flags=flags, callback=callback)
         result = syncer.perform_sync()
         if result:
@@ -482,16 +482,16 @@ def sync_to(
         target: "DiffSync",
         diff_class: Type[Diff] = Diff,
         flags: DiffSyncFlags = DiffSyncFlags.NONE,
-        callback: Optional[Callable[[int, int], None]] = None,
+        callback: Optional[Callable[[Text, int, int], None]] = None,
     ):
         """Synchronize data from the current DiffSync object into the given target DiffSync object.
 
         Args:
             target (DiffSync): object to sync data into from this one.
             diff_class (class): Diff or subclass thereof to use to calculate the diffs to use for synchronization
             flags (DiffSyncFlags): Flags influencing the behavior of this sync.
-            callback (function): Function with parameters (current, total), to be called at intervals as the
-                calculation of the diff proceeds.
+            callback (function): Function with parameters (stage, current, total), to be called at intervals as the
+                calculation of the diff and subsequent sync proceed.
         """
         target.sync_from(self, diff_class=diff_class, flags=flags, callback=callback)
 
@@ -526,15 +526,15 @@ def diff_from(
         source: "DiffSync",
         diff_class: Type[Diff] = Diff,
         flags: DiffSyncFlags = DiffSyncFlags.NONE,
-        callback: Optional[Callable[[int, int], None]] = None,
+        callback: Optional[Callable[[Text, int, int], None]] = None,
     ) -> Diff:
         """Generate a Diff describing the difference from the other DiffSync to this one.
 
         Args:
             source (DiffSync): Object to diff against.
             diff_class (class): Diff or subclass thereof to use for diff calculation and storage.
             flags (DiffSyncFlags): Flags influencing the behavior of this diff operation.
-            callback (function): Function with parameters (current, total), to be called at intervals as the
+            callback (function): Function with parameters (stage, current, total), to be called at intervals as the
                 calculation of the diff proceeds.
         """
         differ = DiffSyncDiffer(
@@ -547,15 +547,15 @@ def diff_to(
         target: "DiffSync",
         diff_class: Type[Diff] = Diff,
         flags: DiffSyncFlags = DiffSyncFlags.NONE,
-        callback: Optional[Callable[[int, int], None]] = None,
+        callback: Optional[Callable[[Text, int, int], None]] = None,
     ) -> Diff:
         """Generate a Diff describing the difference from this DiffSync to another one.
 
         Args:
             target (DiffSync): Object to diff against.
             diff_class (class): Diff or subclass thereof to use for diff calculation and storage.
             flags (DiffSyncFlags): Flags influencing the behavior of this diff operation.
-            callback (function): Function with parameters (current, total), to be called at intervals as the
+            callback (function): Function with parameters (stage, current, total), to be called at intervals as the
                 calculation of the diff proceeds.
         """
         return target.diff_from(self, diff_class=diff_class, flags=flags, callback=callback)

diffsync/helpers.py

@@ -22,7 +22,7 @@
 from .diff import Diff, DiffElement
 from .enum import DiffSyncModelFlags, DiffSyncFlags, DiffSyncStatus
 from .exceptions import ObjectNotFound, ObjectNotCreated, ObjectNotUpdated, ObjectNotDeleted, ObjectCrudException
-from .utils import intersection
+from .utils import intersection, symmetric_difference
 
 if TYPE_CHECKING:  # pragma: no cover
     # For type annotation purposes, we have a circular import loop between __init__.py and this file.
@@ -41,7 +41,7 @@ def __init__(  # pylint: disable=too-many-arguments
         dst_diffsync: "DiffSync",
         flags: DiffSyncFlags,
         diff_class: Type[Diff] = Diff,
-        callback: Optional[Callable[[int, int], None]] = None,
+        callback: Optional[Callable[[str, int, int], None]] = None,
     ):
         """Create a DiffSyncDiffer for calculating diffs between the provided DiffSync instances."""
         self.src_diffsync = src_diffsync
@@ -62,7 +62,7 @@ def incr_models_processed(self, delta: int = 1):
         if delta:
             self.models_processed += delta
             if self.callback:
-                self.callback(self.models_processed, self.total_models)
+                self.callback("diff", self.models_processed, self.total_models)
 
     def calculate_diffs(self) -> Diff:
         """Calculate diffs between the src and dst DiffSync objects and return the resulting Diff."""
@@ -73,6 +73,16 @@ def calculate_diffs(self) -> Diff:
 
         self.logger.info("Beginning diff calculation")
         self.diff = self.diff_class()
+
+        skipped_types = symmetric_difference(self.dst_diffsync.top_level, self.src_diffsync.top_level)
+        # This won't count everything, since these top-level types may have child types which are
+        # implicitly also skipped as well, but we don't want to waste too much time on this calculation.
+        for skipped_type in skipped_types:
+            if skipped_type in self.dst_diffsync.top_level:
+                self.incr_models_processed(len(self.dst_diffsync.get_all(skipped_type)))
+            elif skipped_type in self.src_diffsync.top_level:
+                self.incr_models_processed(len(self.src_diffsync.get_all(skipped_type)))
+
         for obj_type in intersection(self.dst_diffsync.top_level, self.src_diffsync.top_level):
             diff_elements = self.diff_object_list(
                 src=self.src_diffsync.get_all(obj_type), dst=self.dst_diffsync.get_all(obj_type),
@@ -170,15 +180,19 @@ def diff_object_pair(
         log = self.logger.bind(model=model, unique_id=unique_id)
         if self.flags & DiffSyncFlags.SKIP_UNMATCHED_SRC and not dst_obj:
             log.debug("Skipping unmatched source object")
+            self.incr_models_processed()
             return None
         if self.flags & DiffSyncFlags.SKIP_UNMATCHED_DST and not src_obj:
             log.debug("Skipping unmatched dest object")
+            self.incr_models_processed()
             return None
         if src_obj and src_obj.model_flags & DiffSyncModelFlags.IGNORE:
             log.debug("Skipping due to IGNORE flag on source object")
+            self.incr_models_processed()
             return None
         if dst_obj and dst_obj.model_flags & DiffSyncModelFlags.IGNORE:
             log.debug("Skipping due to IGNORE flag on dest object")
+            self.incr_models_processed()
             return None
 
         diff_element = DiffElement(
@@ -224,6 +238,11 @@ def diff_child_objects(
             for child_type, child_fieldname in src_mapping.items():
                 if child_type in dst_mapping:
                     children_mapping[child_type] = child_fieldname
+                else:
+                    self.incr_models_processed(len(getattr(src_obj, child_fieldname)))
+            for child_type, child_fieldname in dst_mapping.items():
+                if child_type not in src_mapping:
+                    self.incr_models_processed(len(getattr(dst_obj, child_fieldname)))
         elif src_obj:
             children_mapping = src_obj.get_children_mapping()
         elif dst_obj:
@@ -257,7 +276,7 @@ def __init__(  # pylint: disable=too-many-arguments
         src_diffsync: "DiffSync",
         dst_diffsync: "DiffSync",
         flags: DiffSyncFlags,
-        callback: Optional[Callable[[int, int], None]] = None,
+        callback: Optional[Callable[[str, int, int], None]] = None,
     ):
         """Create a DiffSyncSyncer instance, ready to call `perform_sync()` against."""
         self.diff = diff
@@ -280,7 +299,7 @@ def incr_elements_processed(self, delta: int = 1):
         if delta:
             self.elements_processed += delta
             if self.callback:
-                self.callback(self.elements_processed, self.total_elements)
+                self.callback("sync", self.elements_processed, self.total_elements)
 
     def perform_sync(self) -> bool:
         """Perform data synchronization based on the provided diff.

diffsync/utils.py

@@ -25,6 +25,11 @@ def intersection(lst1, lst2) -> List:
     return lst3
 
 
+def symmetric_difference(lst1, lst2) -> List:
+    """Calculate the symmetric difference of two lists."""
+    return sorted(set(lst1) ^ set(lst2))
+
+
 class OrderedDefaultDict(OrderedDict):
     """A combination of collections.OrderedDict and collections.DefaultDict behavior."""
 

tests/unit/test_diff.py

@@ -49,6 +49,12 @@ def test_diff_dict_with_no_diffs():
     assert diff.dict() == {}
 
 
+def test_diff_len_with_no_diffs():
+    diff = Diff()
+
+    assert len(diff) == 0
+
+
 def test_diff_children():
     """Test the basic functionality of the Diff class when adding child elements."""
     diff = Diff()
@@ -117,6 +123,11 @@ def test_diff_dict_with_diffs(diff_with_children):
     }
 
 
+def test_diff_len_with_diffs(diff_with_children):
+    assert len(diff_with_children) == 5
+    assert len(diff_with_children) == sum(count for count in diff_with_children.summary().values())
+
+
 def test_order_children_default(backend_a, backend_b):
     """Test that order_children_default is properly called when calling get_children."""
 

tests/unit/test_diff_element.py

@@ -57,6 +57,11 @@ def test_diff_element_dict_with_no_diffs():
     assert element.dict() == {}
 
 
+def test_diff_element_len_with_no_diffs():
+    element = DiffElement("interface", "eth0", {"device_name": "device1", "name": "eth0"})
+    assert len(element) == 1
+
+
 def test_diff_element_attrs():
     """Test the basic functionality of the DiffElement class when setting and retrieving attrs."""
     element = DiffElement("interface", "eth0", {"device_name": "device1", "name": "eth0"})
@@ -111,6 +116,13 @@ def test_diff_element_dict_with_diffs():
     assert element.dict() == {"-": {"description": "your interface"}, "+": {"description": "my interface"}}
 
 
+def test_diff_element_len_with_diffs():
+    element = DiffElement("interface", "eth0", {"device_name": "device1", "name": "eth0"})
+    element.add_attrs(source={"interface_type": "ethernet", "description": "my interface"})
+    element.add_attrs(dest={"description": "your interface"})
+    assert len(element) == 1
+
+
 def test_diff_element_dict_with_diffs_no_attrs():
     element = DiffElement("interface", "eth0", {"device_name": "device1", "name": "eth0"})
     element.add_attrs(source={})
@@ -172,3 +184,8 @@ def test_diff_element_dict_with_child_diffs(diff_element_with_children):
             "lo1": {"-": {"description": "Loopback 1"}},
         },
     }
+
+
+def test_diff_element_len_with_child_diffs(diff_element_with_children):
+    assert len(diff_element_with_children) == 5
+    assert len(diff_element_with_children) == sum(count for count in diff_element_with_children.summary().values())

tests/unit/test_diffsync.py

@@ -43,6 +43,10 @@ def test_diffsync_str_with_no_data(generic_diffsync):
     assert generic_diffsync.str() == ""
 
 
+def test_diffsync_len_with_no_data(generic_diffsync):
+    assert len(generic_diffsync) == 0
+
+
 def test_diffsync_diff_self_with_no_data_has_no_diffs(generic_diffsync):
     assert generic_diffsync.diff_from(generic_diffsync).has_diffs() is False
     assert generic_diffsync.diff_to(generic_diffsync).has_diffs() is False
@@ -285,6 +289,10 @@ def test_diffsync_str_with_data(backend_a):
     )
 
 
+def test_diffsync_len_with_data(backend_a):
+    assert len(backend_a) == 23
+
+
 def test_diffsync_diff_self_with_data_has_no_diffs(backend_a):
     # Self diff should always show no diffs!
     assert backend_a.diff_from(backend_a).has_diffs() is False
@@ -328,6 +336,24 @@ def test_diffsync_diff_from_with_custom_diff_class(backend_a, backend_b):
     assert diff_ba.is_complete is True
 
 
+def test_diffsync_diff_with_callback(backend_a, backend_b):
+    last_value = {"current": 0, "total": 0}
+
+    def callback(stage, current, total):
+        assert stage == "diff"
+        last_value["current"] = current
+        last_value["total"] = total
+
+    expected = len(backend_a) + len(backend_b)
+
+    backend_a.diff_from(backend_b, callback=callback)
+    assert last_value == {"current": expected, "total": expected}
+
+    last_value = {"current": 0, "total": 0}
+    backend_a.diff_to(backend_b, callback=callback)
+    assert last_value == {"current": expected, "total": expected}
+
+
 def test_diffsync_sync_from(backend_a, backend_b):
     backend_a.sync_complete = mock.Mock()
     backend_b.sync_complete = mock.Mock()
@@ -368,6 +394,20 @@ def test_diffsync_sync_from(backend_a, backend_b):
         backend_a.get_by_uids(["nyc", "sfo"], "device")
 
 
+def test_diffsync_sync_with_callback(backend_a, backend_b):
+    last_value = {"current": 0, "total": 0}
+
+    def callback(stage, current, total):
+        assert stage in ("diff", "sync")
+        last_value["current"] = current
+        last_value["total"] = total
+
+    expected = len(backend_a.diff_from(backend_b))
+
+    backend_a.sync_from(backend_b, callback=callback)
+    assert last_value == {"current": expected, "total": expected}
+
+
 def check_successful_sync_log_sanity(log, src, dst, flags):
     """Given a successful sync, make sure the captured structlogs are correct at a high level."""
     # All logs generated during the sync should include the src, dst, and flags data