Add tests for the field cloning behavior and add failing tests for when .deconstruct() doesn't allow reconstructing the field 1:1

Refs feincms/django-prose-editor#41

Author: matthiask

README.rst

@@ -158,6 +158,20 @@ The ``to_attribute`` helper can also be used when filtering, for example:
         q |= Q(**{field: s})
     questions = Question.objects.filter(q)
 
+.. important::
+
+   **Fields with custom deconstruct() methods**
+
+   If you use fields with custom ``deconstruct()`` methods that modify field
+   parameters (such as ``ChoicesCharField`` from feincms3), be aware that
+   ``TranslatedField`` currently uses the output of ``deconstruct()`` to create
+   the translated fields. This means any parameter modifications in the field's
+   ``deconstruct()`` method will affect the translated fields.
+
+   For example, if your custom field's ``deconstruct()`` method changes the
+   ``choices`` parameter, the translated fields will use those modified choices
+   rather than the original ones.
+
 
 Changing field attributes per language
 ======================================

tests/testapp/admin.py

@@ -1,6 +1,7 @@
 from django.contrib import admin
 
 from testapp import models
+from testapp.field_types_models import CustomFieldModel, FieldTypesModel
 from translated_fields import TranslatedFieldAdmin
 
 
@@ -25,3 +26,18 @@ class ListDisplayModelAdmin(TranslatedFieldAdmin, admin.ModelAdmin):
 
     def stuff(self, instance):
         return "stuff"
+
+
+@admin.register(FieldTypesModel)
+class FieldTypesModelAdmin(TranslatedFieldAdmin, admin.ModelAdmin):
+    list_display = [
+        *FieldTypesModel.char_field.fields,
+        *FieldTypesModel.text_field.fields,
+    ]
+
+
+@admin.register(CustomFieldModel)
+class CustomFieldModelAdmin(TranslatedFieldAdmin, admin.ModelAdmin):
+    list_display = [
+        *CustomFieldModel.custom_choices.fields,
+    ]

tests/testapp/custom_fields.py

@@ -0,0 +1,22 @@
+from django.db import models
+
+
+class ChoicesCharField(models.CharField):
+    """
+    CharField with hardcoded default choices in deconstruct() method.
+
+    Similar to feincms3.utils.ChoicesCharField, this field sets a default set of
+    choices in the deconstruct method to avoid migrations when choices change.
+    """
+
+    def __init__(self, *args, **kwargs):
+        # Non-empty choices for get_*_display
+        kwargs.setdefault("choices", [("", "")])
+        super().__init__(*args, **kwargs)
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        # Always return hardcoded choices in deconstruct - this is what we want to test
+        # TranslatedField should preserve the runtime choices, not the ones from deconstruct
+        kwargs["choices"] = [("", "")]
+        return name, path, args, kwargs

tests/testapp/field_types_models.py

@@ -0,0 +1,116 @@
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+from testapp.custom_fields import ChoicesCharField
+from translated_fields import TranslatedField
+
+
+class RelatedModel(models.Model):
+    name = models.CharField(_("name"), max_length=100)
+
+    def __str__(self):
+        return self.name
+
+
+class FieldTypesModel(models.Model):
+    """Model to test various field types with TranslatedField."""
+
+    # CharField with max_length and choices
+    char_field = TranslatedField(
+        models.CharField(
+            _("char field"),
+            max_length=50,
+            choices=[("a", "Option A"), ("b", "Option B"), ("c", "Option C")],
+        )
+    )
+
+    # TextField with max_length and help_text
+    text_field = TranslatedField(
+        models.TextField(
+            _("text field"),
+            max_length=500,
+            help_text=_("This is a text field"),
+        )
+    )
+
+    # IntegerField with min/max values
+    int_field = TranslatedField(
+        models.IntegerField(
+            _("integer field"),
+            default=0,
+            help_text=_("Enter a number"),
+        )
+    )
+
+    # BooleanField with default
+    bool_field = TranslatedField(
+        models.BooleanField(
+            _("boolean field"),
+            default=True,
+        )
+    )
+
+    # ForeignKey to test relationship fields
+    foreign_key = TranslatedField(
+        models.ForeignKey(
+            RelatedModel,
+            on_delete=models.CASCADE,
+            verbose_name=_("related model"),
+            related_name="+",
+            null=True,
+            blank=True,
+        )
+    )
+
+    # URLField with validators
+    url_field = TranslatedField(
+        models.URLField(
+            _("URL field"),
+            max_length=200,
+        )
+    )
+
+    # EmailField
+    email_field = TranslatedField(
+        models.EmailField(
+            _("email field"),
+            max_length=100,
+        )
+    )
+
+    # DecimalField with decimal_places and max_digits
+    decimal_field = TranslatedField(
+        models.DecimalField(
+            _("decimal field"),
+            max_digits=10,
+            decimal_places=2,
+            default=0.0,
+        )
+    )
+
+    # DateField with auto_now_add
+    date_field = TranslatedField(
+        models.DateField(
+            _("date field"),
+            auto_now_add=True,
+        )
+    )
+
+    def __str__(self):
+        return self.char_field
+
+
+class CustomFieldModel(models.Model):
+    """Model with a custom field that has a custom deconstruct() method."""
+
+    # Custom field with hardcoded choices in deconstruct
+    custom_choices = TranslatedField(
+        ChoicesCharField(
+            _("custom choices field"),
+            max_length=10,
+            choices=[("a", "Option A"), ("b", "Option B"), ("c", "Option C")],
+        )
+    )
+
+    def __str__(self):
+        return self.custom_choices

tests/testapp/test_custom_field_debug.py

@@ -0,0 +1,52 @@
+import sys
+
+import pytest
+
+from testapp.custom_fields import ChoicesCharField
+from testapp.field_types_models import CustomFieldModel
+
+
+@pytest.mark.django_db
+def test_custom_field_inspection():
+    """Debug test to understand what's happening with custom field choices."""
+    # Output directly to stderr so we can see it in pytest output
+    # Original field before TranslatedField processing
+    original_field = ChoicesCharField(
+        "Original field",
+        max_length=10,
+        choices=[("a", "Option A"), ("b", "Option B"), ("c", "Option C")],
+    )
+
+    # Check original field deconstruct
+    name, path, args, kwargs = original_field.deconstruct()
+    print(
+        f"\nOriginal field deconstruct: {name}, {path}, {args}, {kwargs}",
+        file=sys.stderr,
+    )
+
+    # Get the translated field instances
+    custom_en = CustomFieldModel._meta.get_field("custom_choices_en")
+    custom_de = CustomFieldModel._meta.get_field("custom_choices_de")
+
+    # Check their actual class and attributes
+    print(f"Field class EN: {custom_en.__class__.__name__}", file=sys.stderr)
+    print(f"Field choices EN: {custom_en.choices}", file=sys.stderr)
+
+    print(f"Field class DE: {custom_de.__class__.__name__}", file=sys.stderr)
+    print(f"Field choices DE: {custom_de.choices}", file=sys.stderr)
+
+    # Check their deconstruct values
+    name_en, path_en, args_en, kwargs_en = custom_en.deconstruct()
+    print(
+        f"Translated EN deconstruct: {name_en}, {path_en}, {args_en}, {kwargs_en}",
+        file=sys.stderr,
+    )
+
+    name_de, path_de, args_de, kwargs_de = custom_de.deconstruct()
+    print(
+        f"Translated DE deconstruct: {name_de}, {path_de}, {args_de}, {kwargs_de}",
+        file=sys.stderr,
+    )
+
+    # Add assertions to make it pass
+    assert True

tests/testapp/test_custom_fields.py

@@ -0,0 +1,136 @@
+import pytest
+from django.forms import modelform_factory
+from django.utils.translation import override
+
+from testapp.field_types_models import CustomFieldModel
+
+
+@pytest.mark.django_db
+def test_custom_field_choices_actual_behavior():
+    """
+    Test to demonstrate the current behavior with custom field deconstruct.
+
+    This test confirms what actually happens (not what we want to happen).
+    """
+    # Get the runtime field instances
+    custom_en = CustomFieldModel._meta.get_field("custom_choices_en")
+    custom_de = CustomFieldModel._meta.get_field("custom_choices_de")
+
+    # The actual current behavior - choices are taken from deconstruct() [("", "")]
+    # rather than the original [("a", "Option A"), ("b", "Option B"), ("c", "Option C")]
+    actual_choices = [("", "")]
+
+    # These assertions show what actually happens (would pass)
+    assert custom_en.choices == actual_choices
+    assert custom_de.choices == actual_choices
+
+    # Get the deconstruct() values to confirm this behavior
+    name_en, path_en, args_en, kwargs_en = custom_en.deconstruct()
+    name_de, path_de, args_de, kwargs_de = custom_de.deconstruct()
+
+    # Confirm that deconstruct() returns the same hardcoded choices
+    assert kwargs_en["choices"] == actual_choices
+    assert kwargs_de["choices"] == actual_choices
+
+
+@pytest.mark.xfail(
+    reason="TranslatedField doesn't handle custom deconstruct correctly yet"
+)
+@pytest.mark.django_db
+def test_custom_field_choices_preserved():
+    """
+    Test that choices from custom fields with custom deconstruct methods are preserved.
+
+    This is currently an expected failure because TranslatedField doesn't properly
+    handle fields with custom deconstruct methods that modify field parameters.
+
+    The issue is in translated_fields/fields.py line 82:
+        _n, _p, args, kwargs = self._field.deconstruct()
+
+    When using a field with a custom deconstruct() method that modifies parameters like 'choices',
+    those modifications affect the translated fields that are created.
+
+    A possible fix would be to store the original parameters before deconstruct() is called,
+    or to copy the field's __dict__ attributes directly instead of using deconstruct().
+    """
+    # Get the runtime field instances
+    custom_en = CustomFieldModel._meta.get_field("custom_choices_en")
+    custom_de = CustomFieldModel._meta.get_field("custom_choices_de")
+
+    # The runtime choices should be the ones we specified at field creation time,
+    # not the hardcoded ones from deconstruct()
+    expected_choices = [("a", "Option A"), ("b", "Option B"), ("c", "Option C")]
+
+    # Check the field choices match what we defined, not what deconstruct() returns
+    assert custom_en.choices == expected_choices
+    assert custom_de.choices == expected_choices
+
+
+@pytest.mark.xfail(
+    reason="TranslatedField doesn't handle custom deconstruct correctly yet"
+)
+@pytest.mark.django_db
+def test_custom_field_form_generation():
+    """
+    Test that forms generated from custom fields have the correct choices.
+
+    This fails for the same reason as test_custom_field_choices_preserved:
+    the choices from the original field definition are not preserved when
+    deconstruct() replaces them with hardcoded values.
+    """
+    form_class = modelform_factory(CustomFieldModel, fields="__all__")
+    form = form_class()
+
+    # Form field choices should include the default empty choice plus our defined choices
+    expected_form_choices = [
+        ("", "---------"),
+        ("a", "Option A"),
+        ("b", "Option B"),
+        ("c", "Option C"),
+    ]
+
+    # Check that form fields have the expected choices
+    assert form.fields["custom_choices_en"].choices == expected_form_choices
+    assert form.fields["custom_choices_de"].choices == expected_form_choices
+
+
+@pytest.mark.xfail(
+    reason="TranslatedField doesn't handle custom deconstruct correctly yet"
+)
+@pytest.mark.django_db
+def test_custom_field_model_usage():
+    """
+    Test using the custom field with a model instance.
+
+    This fails because the get_FOO_display() method relies on the correct choices
+    being set on the field. Since the choices are replaced with [("", "")] during
+    field creation, the display values don't match what we expect.
+    """
+    # Create a model instance with values for the custom field
+    model = CustomFieldModel.objects.create(
+        custom_choices_en="a",
+        custom_choices_de="b",
+    )
+
+    # Check that the values are correctly stored and the choices behavior works
+    with override("en"):
+        assert model.custom_choices == "a"
+        assert model.get_custom_choices_display() == "Option A"
+
+    with override("de"):
+        assert model.custom_choices == "b"
+        assert model.get_custom_choices_display() == "Option B"
+
+
+@pytest.mark.parametrize("option", ["a", "b", "c"])
+@pytest.mark.django_db
+def test_custom_field_valid_options(option):
+    """Test that valid choice options can be saved."""
+    # This test should pass even if the choices aren't preserved correctly
+    # as long as the field validation isn't overly strict
+    model = CustomFieldModel()
+    model.custom_choices_en = option
+    model.custom_choices_de = option
+    model.save()
+    assert model.custom_choices_en == option
+    assert model.custom_choices_de == option