Fixed bug in 'clean_value'

Author: DamianB-BitFlipper

model_clone/tests/test_utils.py

@@ -0,0 +1,119 @@
+from django.test import TestCase
+
+from model_clone.utils import clean_value
+
+
+class CleanValueTestCase(TestCase):
+    def test_clean_value_with_single_digit(self):
+        """Test cleaning value with single digit suffix."""
+        result = clean_value("Test Copy 1", "Copy")
+        self.assertEqual(result, "Test")
+
+    def test_clean_value_with_multi_digit(self):
+        """Test cleaning value with multi-digit suffix."""
+        result = clean_value("Test Copy 10", "Copy")
+        self.assertEqual(result, "Test")
+
+        result = clean_value("Test Copy 123", "Copy")
+        self.assertEqual(result, "Test")
+
+    def test_clean_value_with_hyphen_separator(self):
+        """Test cleaning value with hyphen separator."""
+        result = clean_value("test-copy-1", "copy")
+        self.assertEqual(result, "test")
+
+        result = clean_value("test-copy-42", "copy")
+        self.assertEqual(result, "test")
+
+    def test_clean_value_case_insensitive(self):
+        """Test that cleaning is case insensitive."""
+        result = clean_value("Test COPY 1", "copy")
+        self.assertEqual(result, "Test")
+
+        result = clean_value("test copy 1", "COPY")
+        self.assertEqual(result, "test")
+
+    def test_clean_value_with_regex_special_characters(self):
+        """Test cleaning value when suffix contains regex special characters."""
+        result = clean_value("Test (Copy) 1", "(Copy)")
+        self.assertEqual(result, "Test")
+
+        result = clean_value("Test Copy+ 2", "Copy+")
+        self.assertEqual(result, "Test")
+
+        result = clean_value("Test Copy* 5", "Copy*")
+        self.assertEqual(result, "Test")
+
+        result = clean_value("Test Copy? 3", "Copy?")
+        self.assertEqual(result, "Test")
+
+        result = clean_value("Test Copy[1] 4", "Copy[1]")
+        self.assertEqual(result, "Test")
+
+    def test_clean_value_with_dots_and_brackets(self):
+        """Test cleaning with complex regex characters."""
+        result = clean_value("Test Copy.exe 1", "Copy.exe")
+        self.assertEqual(result, "Test")
+
+        result = clean_value("Test (v2.0) 15", "(v2.0)")
+        self.assertEqual(result, "Test")
+
+    def test_clean_value_no_match(self):
+        """Test that value is unchanged when pattern doesn't match."""
+        result = clean_value("Test Copy", "Copy")
+        self.assertEqual(result, "Test Copy")
+
+        result = clean_value("Test Different 1", "Copy")
+        self.assertEqual(result, "Test Different 1")
+
+        result = clean_value("Test Copy A", "Copy")
+        self.assertEqual(result, "Test Copy A")
+
+    def test_clean_value_partial_match(self):
+        """Test that partial matches are not cleaned."""
+        result = clean_value("Test Copying 1", "Copy")
+        self.assertEqual(result, "Test Copying 1")
+
+        result = clean_value("Test Copy Something 1", "Copy")
+        self.assertEqual(result, "Test Copy Something 1")
+
+    def test_clean_value_middle_of_string(self):
+        """Test that pattern in middle of string is not cleaned."""
+        result = clean_value("Test Copy 1 More", "Copy")
+        self.assertEqual(result, "Test Copy 1 More")
+
+    def test_clean_value_with_empty_suffix(self):
+        """Test behavior with empty suffix."""
+        result = clean_value("Test  1", "")
+        self.assertEqual(result, "Test")
+
+    def test_clean_value_with_space_before_suffix(self):
+        """Test cleaning when there's a space before suffix."""
+        result = clean_value("Test Copy 25", "Copy")
+        self.assertEqual(result, "Test")
+
+    def test_clean_value_with_hyphen_before_suffix(self):
+        """Test cleaning when there's a hyphen before suffix."""
+        result = clean_value("test-copy-99", "copy")
+        self.assertEqual(result, "test")
+
+    def test_clean_value_zero_digit(self):
+        """Test cleaning with zero as digit."""
+        result = clean_value("Test Copy 0", "Copy")
+        self.assertEqual(result, "Test")
+
+    def test_clean_value_leading_zeros(self):
+        """Test cleaning with leading zeros in digits."""
+        result = clean_value("Test Copy 001", "Copy")
+        self.assertEqual(result, "Test")
+
+        result = clean_value("Test Copy 010", "Copy")
+        self.assertEqual(result, "Test")
+
+    def test_clean_value_complex_example(self):
+        """Test with a complex real-world example."""
+        result = clean_value("my-awesome-slug-copy-42", "copy")
+        self.assertEqual(result, "my-awesome-slug")
+
+        result = clean_value("Product (v1.0) Copy 123", "(v1.0) Copy")
+        self.assertEqual(result, "Product")

model_clone/utils.py

@@ -6,9 +6,7 @@
 from django.db.transaction import TransactionManagementError
 
 
-def create_copy_of_instance(
-    instance, attrs=None, exclude=(), save_new=True, using=None
-):
+def create_copy_of_instance(instance, attrs=None, exclude=(), save_new=True, using=None):
     """
     Clone an instance of `django.db.models.Model`.
 
@@ -113,9 +111,7 @@ def unpack_unique_constraints(opts, only_fields=()):
     :return: Flat list of fields.
     """
     fields = []
-    constraints = getattr(
-        opts, "total_unique_constraints", getattr(opts, "constraints", [])
-    )
+    constraints = getattr(opts, "total_unique_constraints", getattr(opts, "constraints", []))
     for constraint in constraints:
         fields.extend([f for f in constraint.fields if f in only_fields])
     return fields
@@ -149,7 +145,8 @@ def clean_value(value, suffix):
     :rtype: `str`
     """
     # type: (str, str) -> str
-    return re.sub(r"([\s-]?){}[\s-][\d]$".format(suffix), "", value, flags=re.I)
+    escaped_suffix = re.escape(suffix)
+    return re.sub(r"([\s-]?){}[\s-]\d+$".format(escaped_suffix), "", value, flags=re.I)
 
 
 @contextlib.contextmanager
@@ -243,9 +240,7 @@ def generate_value(value, suffix, transform, max_length, max_attempts):
         yield get_value(value, suffix, transform, max_length, i)
 
     raise StopIteration(
-        "CloneError: max unique attempts for {} exceeded ({})".format(
-            value, max_attempts
-        )
+        "CloneError: max unique attempts for {} exceeded ({})".format(value, max_attempts)
     )
 
 
@@ -298,19 +293,11 @@ def get_fields_and_unique_fields_from_cls(
         if not getattr(f, "primary_key", False):
             if clone_fields and not force and not getattr(f, "one_to_one", False):
                 valid = f.name in clone_fields
-            elif (
-                clone_excluded_fields
-                and not force
-                and not getattr(f, "one_to_one", False)
-            ):
+            elif clone_excluded_fields and not force and not getattr(f, "one_to_one", False):
                 valid = f.name not in clone_excluded_fields
             elif clone_o2o_fields and not force and getattr(f, "one_to_one", False):
                 valid = f.name in clone_o2o_fields
-            elif (
-                clone_excluded_o2o_fields
-                and not force
-                and getattr(f, "one_to_one", False)
-            ):
+            elif clone_excluded_o2o_fields and not force and getattr(f, "one_to_one", False):
                 valid = f.name not in clone_excluded_o2o_fields  # pragma: no cover
             else:
                 valid = True
@@ -333,9 +320,7 @@ def get_fields_and_unique_fields_from_cls(
         for f in fields
         if not f.auto_created
         and (
-            f.unique
-            or f.name in unique_field_names
-            or f.name in unique_constraint_field_names
+            f.unique or f.name in unique_field_names or f.name in unique_constraint_field_names
         )
     ]