Add ignore_pk option to Fixture and diff functions

Enhanced the Fixture class and diff utility to support an ignore_pk parameter, allowing records to be matched by field content instead of primary key. Updated tests to verify this new functionality.

Author: marianoeramirez

dbdiff/fixture.py

@@ -46,7 +46,7 @@ class Fixture(object):
 
     exclude = dict()
 
-    def __init__(self, relative_path, models=None, database=None):
+    def __init__(self, relative_path, models=None, database=None, ignore_pk=False):
         """
         Instanciate a FixtureDiff on a database.
 
@@ -58,10 +58,15 @@ def __init__(self, relative_path, models=None, database=None):
 
         database should be the name of the database to use, `default` by
         default.
+
+        ignore_pk when True, matches records by field content instead of
+        primary key. Records with the same content but different pks
+        are considered equal.
         """
         self.path = get_absolute_path(relative_path)
         self.models = models if models else self.parse_models()
         self.database = database or 'default'
+        self.ignore_pk = ignore_pk
 
     def parse_models(self):
         """Return the list of models inside the fixture file."""
@@ -91,12 +96,15 @@ def indent(self):
 
             return len(line) - len(line.lstrip(' '))
 
-    def diff(self, exclude=None):
+    def diff(self, exclude=None, ignore_pk=None):
         """
         Diff the fixture against a datadump of fixture models.
 
         If passed, exclude should be a list of field names to exclude from
         being diff'ed.
+
+        ignore_pk when True, matches records by field content instead of
+        primary key. Defaults to the instance's ignore_pk attribute.
         """
         fh, dump_path = tempfile.mkstemp('_dbdiff')
 
@@ -109,9 +117,13 @@ def diff(self, exclude=None):
         with open(self.path, 'r') as e, open(dump_path, 'r') as r:
             expected, result = json.load(e), json.load(r)
 
+        if ignore_pk is None:
+            ignore_pk = self.ignore_pk
+
         unexpected, missing, different = diff(
             get_tree(expected, exclude_final),
             get_tree(result, exclude_final),
+            ignore_pk=ignore_pk,
         )
 
         if not unexpected and not missing and not diff:

dbdiff/test.py

@@ -52,6 +52,7 @@ def test_db_import(self):
         Fixture(
             self.dbdiff_expected,
             models=self.dbdiff_models,
+            ignore_pk=getattr(self, 'dbdiff_ignore_pk', False),
         ).assertNoDiff(
             exclude=self.dbdiff_exclude,
         )

dbdiff/tests/test_utils.py

@@ -1,10 +1,43 @@
 import os
 
-from dbdiff.utils import get_absolute_path, get_model_names
+from dbdiff.utils import diff, get_absolute_path, get_model_names
 
 from django.contrib.auth.models import Group
 
 
+def test_diff_ignore_pk():
+    """With ignore_pk=True, records are matched by content, not pk."""
+    expected = {
+        'auth.group': {
+            1: {'name': 'testgroup', 'permissions': []},
+        },
+    }
+    result = {
+        'auth.group': {
+            99: {'name': 'testgroup', 'permissions': []},  # same content, diff pk
+        },
+    }
+    unexpected, missing, different = diff(expected, result, ignore_pk=True)
+    assert not unexpected and not missing and not different
+
+
+def test_diff_with_pk_by_default():
+    """With ignore_pk=False, same content but different pk yields missing/unexpected."""
+    expected = {
+        'auth.group': {
+            1: {'name': 'testgroup', 'permissions': []},
+        },
+    }
+    result = {
+        'auth.group': {
+            99: {'name': 'testgroup', 'permissions': []},
+        },
+    }
+    unexpected, missing, different = diff(expected, result, ignore_pk=False)
+    assert missing == {'auth.group': {1: {'name': 'testgroup', 'permissions': []}}}
+    assert unexpected == {'auth.group': {99: {'name': 'testgroup', 'permissions': []}}}
+
+
 def test_get_model_names():
     assert get_model_names([Group, 'auth.user']) == ['auth.group', 'auth.user']
 

dbdiff/utils.py

@@ -43,9 +43,18 @@ def _get_unexpected(expected, result):
     return unexpected
 
 
-def diff(expected, result):
-    """Return unexpected, missing and diff between expected and result."""
-    missing, diff = {}, {}
+def diff(expected, result, ignore_pk=False):
+    """Return unexpected, missing and diff between expected and result.
+
+    When ignore_pk is True, records are matched by their field values (content)
+    instead of primary key. Records with the same content but different pks
+    are considered matching.
+    """
+    missing, different = {}, {}
+
+    if ignore_pk:
+        unexpected, missing, different = _diff_by_content(expected, result)
+        return unexpected, missing, different
 
     unexpected = _get_unexpected(expected, result)
 
@@ -60,20 +69,50 @@ def diff(expected, result):
             if expected_fields == result_fields:
                 continue
 
-            diff.setdefault(model, {})
-            diff[model].setdefault(pk, {})
+            different.setdefault(model, {})
+            different[model].setdefault(pk, {})
 
             for expected_field, expected_value in expected_fields.items():
                 result_value = result_fields[expected_field]
 
                 if expected_value == result_value:
                     continue
 
-                diff[model][pk][expected_field] = (
+                different[model][pk][expected_field] = (
                     expected_value,
                     result_value
                 )
-    return unexpected, missing, diff
+    return unexpected, missing, different
+
+
+def _diff_by_content(expected, result):
+    """Diff by matching records on field content instead of primary key."""
+    unexpected, missing, different = {}, {}, {}
+
+    for model in set(expected.keys()) | set(result.keys()):
+        expected_list = list(expected.get(model, {}).items())
+        result_list = list(result.get(model, {}).items())
+        matched_result_indices = set()
+
+        for exp_pk, exp_fields in expected_list:
+            found = False
+            for i, (res_pk, res_fields) in enumerate(result_list):
+                if i in matched_result_indices:
+                    continue
+                if exp_fields == res_fields:
+                    matched_result_indices.add(i)
+                    found = True
+                    break
+            if not found:
+                missing.setdefault(model, {})
+                missing[model][exp_pk] = exp_fields
+
+        for i, (res_pk, res_fields) in enumerate(result_list):
+            if i not in matched_result_indices:
+                unexpected.setdefault(model, {})
+                unexpected[model][res_pk] = res_fields
+
+    return unexpected, missing, different
 
 
 def get_absolute_path(path):