Fix: SerializerMethodField as HiddenField in unique_together

Corrects an issue where a `SerializerMethodField` that shares its name
with a model field involved in a `unique_together` constraint (or
`UniqueConstraint`) could be incorrectly treated as a `HiddenField`.

This typically occurred if the underlying model field was nullable or had
a default value, and the `SerializerMethodField` was not being correctly
prioritized during the uniqueness metadata processing.

The `ModelSerializer.get_uniqueness_extra_kwargs` method has been updated
to ensure that if a field name corresponding to a model field in a
uniqueness constraint is explicitly declared as a `SerializerMethodField`
on the serializer, it is not converted into a `HiddenField`.

A test case has been added to `tests/test_model_serializer.py`
(`TestSerializerMethodFieldInUniqueTogether`) to verify this behavior.

NOTE: Due to persistent timeouts in the testing environment, I could not complete full
test suite verification. Multiple attempts to run
tests (full suite, specific module, specific class) timed out.
The implemented fix is based on code analysis and the added specific test case logic.
Relying on CI/CD pipeline for full test validation.

Author: google-labs-jules[bot]

rest_framework/serializers.py

@@ -1483,6 +1483,12 @@ def get_uniqueness_extra_kwargs(self, field_names, declared_fields, extra_kwargs
         hidden_fields = {}
         uniqueness_extra_kwargs = {}
 
+        # Identify declared SerializerMethodFields to prevent them from becoming HiddenFields
+        serializer_method_field_names = {
+            name for name, field_instance in declared_fields.items()
+            if isinstance(field_instance, SerializerMethodField)
+        }
+
         for unique_constraint_name in unique_constraint_names:
             # Get the model field that is referred too.
             unique_constraint_field = model._meta.get_field(unique_constraint_name)
@@ -1507,8 +1513,10 @@ def get_uniqueness_extra_kwargs(self, field_names, declared_fields, extra_kwargs
             elif default is not empty:
                 # The corresponding field is not present in the
                 # serializer. We have a default to use for it, so
-                # add in a hidden field that populates it.
-                hidden_fields[unique_constraint_name] = HiddenField(default=default)
+                # add in a hidden field that populates it,
+                # unless it's a SerializerMethodField.
+                if unique_constraint_name not in serializer_method_field_names:
+                    hidden_fields[unique_constraint_name] = HiddenField(default=default)
 
         # Update `extra_kwargs` with any new options.
         for key, value in uniqueness_extra_kwargs.items():

tests/test_model_serializer.py

@@ -1346,6 +1346,32 @@ class Meta:
         fields = ('name',)
 
 
+# --- Test models and serializers for SerializerMethodField in unique_together ---
+class UniqueTestModel(models.Model):
+    name = models.CharField(max_length=100)
+    description = models.CharField(max_length=100, null=True, blank=True)
+    other_field = models.CharField(max_length=100, default="default_value")
+
+    class Meta:
+        unique_together = [("name", "description")]
+
+    def __str__(self):
+        return f"{self.name} - {self.description or 'No description'}"
+
+
+class UniqueTestModelSerializer(serializers.ModelSerializer):
+    description = serializers.SerializerMethodField()
+
+    class Meta:
+        model = UniqueTestModel
+        fields = ["name", "description", "other_field"]
+
+    def get_description(self, obj):
+        if obj.description:
+            return f"Serialized: {obj.description}"
+        return "Serialized: No description provided"
+
+
 class Issue6110Test(TestCase):
     def test_model_serializer_custom_manager(self):
         instance = Issue6110ModelSerializer().create({'name': 'test_name'})
@@ -1395,3 +1421,85 @@ class Meta:
         serializer.save()
 
         self.assertEqual(instance.char_field, 'value changed by signal')
+
+
+# --- Test case for SerializerMethodField in unique_together ---
+class TestSerializerMethodFieldInUniqueTogether(TestCase):
+    def test_serializer_method_field_not_hidden_in_unique_together(self):
+        # 1. Instantiate the serializer
+        serializer = UniqueTestModelSerializer()
+
+        # 2. Assert that the 'description' field is not a HiddenField
+        self.assertFalse(
+            isinstance(serializer.fields['description'], serializers.HiddenField),
+            "Field 'description' should not be a HiddenField."
+        )
+
+        # 3. Assert that 'description' is a SerializerMethodField
+        self.assertTrue(
+            isinstance(serializer.fields['description'], serializers.SerializerMethodField),
+            "Field 'description' should be a SerializerMethodField."
+        )
+
+        # 4. Assert that the 'description' field is present in the serializer's output
+        instance = UniqueTestModel.objects.create(name="TestName", description="TestDesc")
+        serializer_output = UniqueTestModelSerializer(instance).data
+        self.assertIn("description", serializer_output)
+        self.assertEqual(serializer_output["description"], "Serialized: TestDesc")
+
+        instance_no_desc = UniqueTestModel.objects.create(name="TestNameNoDesc")
+        serializer_output_no_desc = UniqueTestModelSerializer(instance_no_desc).data
+        self.assertEqual(serializer_output_no_desc["description"], "Serialized: No description provided")
+
+        # 5. Perform a validation test
+        # Create an initial instance
+        UniqueTestModel.objects.create(name="UniqueName", description="UniqueDesc")
+
+        # Attempt to validate data that would violate unique_together
+        invalid_data = {"name": "UniqueName", "description": "UniqueDesc", "other_field": "some_value"}
+        serializer_invalid = UniqueTestModelSerializer(data=invalid_data)
+        with self.assertRaises(serializers.ValidationError) as context:
+            serializer_invalid.is_valid(raise_exception=True)
+        self.assertIn("non_field_errors", context.exception.detail) # Check for unique_together error
+        self.assertTrue(any("unique test model with this name and description already exists" in str(err)
+                            for err_list in context.exception.detail.values() for err in err_list))
+
+
+        # Attempt to validate data that would violate unique_together (with null description)
+        UniqueTestModel.objects.create(name="UniqueNameNull", description=None)
+        invalid_data_null = {"name": "UniqueNameNull", "description": None, "other_field": "some_value"}
+        serializer_invalid_null = UniqueTestModelSerializer(data=invalid_data_null)
+
+        with self.assertRaises(serializers.ValidationError) as context_null:
+            serializer_invalid_null.is_valid(raise_exception=True)
+
+        self.assertIn("non_field_errors", context_null.exception.detail)
+        self.assertTrue(any("unique test model with this name and description already exists" in str(err)
+                            for err_list in context_null.exception.detail.values() for err in err_list))
+
+
+        # Attempt to validate valid data
+        valid_data = {"name": "NewName", "description": "NewDesc", "other_field": "another_value"}
+        serializer_valid = UniqueTestModelSerializer(data=valid_data)
+        self.assertTrue(serializer_valid.is_valid(raise_exception=True))
+        self.assertEqual(serializer_valid.validated_data['name'], "NewName")
+        # Note: 'description' from SerializerMethodField won't be in validated_data for writes by default.
+        # The key here is that the serializer construction and unique_together validation works.
+        # The model's description field will be None or the provided value during create/update.
+
+        # Validate data where description is not provided (should use model field's null=True)
+        valid_data_no_desc = {"name": "NameOnly"} # description and other_field will use defaults or be None
+        serializer_valid_no_desc = UniqueTestModelSerializer(data=valid_data_no_desc)
+        self.assertTrue(serializer_valid_no_desc.is_valid(raise_exception=True))
+        self.assertIsNone(serializer_valid_no_desc.validated_data.get('description'))
+        self.assertEqual(serializer_valid_no_desc.validated_data['other_field'], "default_value") # check other_field default
+
+        # Check saving the instance
+        saved_instance = serializer_valid_no_desc.save()
+        self.assertEqual(saved_instance.name, "NameOnly")
+        self.assertIsNone(saved_instance.description)
+        self.assertEqual(saved_instance.other_field, "default_value")
+
+        # Check that SerializerMethodField value is used in representation after save
+        output_after_save = UniqueTestModelSerializer(saved_instance).data
+        self.assertEqual(output_after_save['description'], "Serialized: No description provided")