Finished

Test Name	Status
test_repr_with_violation_error_code (constraints.tests.CheckConstraintTests.test_repr_with_violation_error_code)	Fail
test_eq (constraints.tests.UniqueConstraintTests.test_eq)	Fail
test_repr_with_violation_error_code (constraints.tests.UniqueConstraintTests.test_repr_with_violation_error_code)	Fail
test_model_validation (constraints.tests.UniqueConstraintTests.test_model_validation)	Fail
test_validate (constraints.tests.UniqueConstraintTests.test_validate)	Fail
test_custom_violation_code_message (constraints.tests.BaseConstraintTests.test_custom_violation_code_message)	Pass
test_deconstruction (constraints.tests.BaseConstraintTests.test_deconstruction)	Pass
test_eq (constraints.tests.CheckConstraintTests.test_eq)	Pass
test_validate_custom_error (constraints.tests.CheckConstraintTests.test_validate_custom_error)	Pass
test_validate_conditon_custom_error (constraints.tests.UniqueConstraintTests.test_validate_conditon_custom_error)	Pass
test_constraint_sql (constraints.tests.BaseConstraintTests.test_constraint_sql)	Pass
test_contains_expressions (constraints.tests.BaseConstraintTests.test_contains_expressions)	Pass
test_create_sql (constraints.tests.BaseConstraintTests.test_create_sql)	Pass
test_custom_violation_error_message (constraints.tests.BaseConstraintTests.test_custom_violation_error_message)	Pass
test_custom_violation_error_message_clone (constraints.tests.BaseConstraintTests.test_custom_violation_error_message_clone)	Pass
test_default_violation_error_message (constraints.tests.BaseConstraintTests.test_default_violation_error_message)	Pass
test_deprecation (constraints.tests.BaseConstraintTests.test_deprecation)	Pass
test_name_required (constraints.tests.BaseConstraintTests.test_name_required)	Pass
test_positional_arguments (constraints.tests.BaseConstraintTests.test_positional_arguments)	Pass
test_remove_sql (constraints.tests.BaseConstraintTests.test_remove_sql)	Pass
test_validate (constraints.tests.BaseConstraintTests.test_validate)	Pass
test_abstract_name (constraints.tests.CheckConstraintTests.test_abstract_name)	Pass
test_database_constraint (constraints.tests.CheckConstraintTests.test_database_constraint)	Pass
test_database_constraint_unicode (constraints.tests.CheckConstraintTests.test_database_constraint_unicode)	Pass
test_deconstruction (constraints.tests.CheckConstraintTests.test_deconstruction)	Pass
test_invalid_check_types (constraints.tests.CheckConstraintTests.test_invalid_check_types)	Pass
test_name (constraints.tests.CheckConstraintTests.test_name)	Pass
test_repr (constraints.tests.CheckConstraintTests.test_repr)	Pass
test_repr_with_violation_error_message (constraints.tests.CheckConstraintTests.test_repr_with_violation_error_message)	Pass
test_validate (constraints.tests.CheckConstraintTests.test_validate)	Pass
test_validate_boolean_expressions (constraints.tests.CheckConstraintTests.test_validate_boolean_expressions)	Pass
test_validate_nullable_field_with_none (constraints.tests.CheckConstraintTests.test_validate_nullable_field_with_none)	Pass
test_validate_rawsql_expressions_noop (constraints.tests.CheckConstraintTests.test_validate_rawsql_expressions_noop)	Pass
test_condition_must_be_q (constraints.tests.UniqueConstraintTests.test_condition_must_be_q)	Pass
test_database_constraint (constraints.tests.UniqueConstraintTests.test_database_constraint)	Pass
test_database_constraint_with_condition (constraints.tests.UniqueConstraintTests.test_database_constraint_with_condition)	Pass
test_deconstruction (constraints.tests.UniqueConstraintTests.test_deconstruction)	Pass
test_deconstruction_with_condition (constraints.tests.UniqueConstraintTests.test_deconstruction_with_condition)	Pass
test_deconstruction_with_deferrable (constraints.tests.UniqueConstraintTests.test_deconstruction_with_deferrable)	Pass
test_deconstruction_with_expressions (constraints.tests.UniqueConstraintTests.test_deconstruction_with_expressions)	Pass
test_deconstruction_with_include (constraints.tests.UniqueConstraintTests.test_deconstruction_with_include)	Pass
test_deconstruction_with_opclasses (constraints.tests.UniqueConstraintTests.test_deconstruction_with_opclasses)	Pass
test_deferrable_with_condition (constraints.tests.UniqueConstraintTests.test_deferrable_with_condition)	Pass
test_deferrable_with_expressions (constraints.tests.UniqueConstraintTests.test_deferrable_with_expressions)	Pass
test_deferrable_with_include (constraints.tests.UniqueConstraintTests.test_deferrable_with_include)	Pass
test_deferrable_with_opclasses (constraints.tests.UniqueConstraintTests.test_deferrable_with_opclasses)	Pass
test_eq_with_condition (constraints.tests.UniqueConstraintTests.test_eq_with_condition)	Pass
test_eq_with_deferrable (constraints.tests.UniqueConstraintTests.test_eq_with_deferrable)	Pass
test_eq_with_expressions (constraints.tests.UniqueConstraintTests.test_eq_with_expressions)	Pass
test_eq_with_include (constraints.tests.UniqueConstraintTests.test_eq_with_include)	Pass
test_eq_with_opclasses (constraints.tests.UniqueConstraintTests.test_eq_with_opclasses)	Pass
test_expressions_and_fields_mutually_exclusive (constraints.tests.UniqueConstraintTests.test_expressions_and_fields_mutually_exclusive)	Pass
test_expressions_with_opclasses (constraints.tests.UniqueConstraintTests.test_expressions_with_opclasses)	Pass
test_invalid_defer_argument (constraints.tests.UniqueConstraintTests.test_invalid_defer_argument)	Pass
test_invalid_include_argument (constraints.tests.UniqueConstraintTests.test_invalid_include_argument)	Pass
test_invalid_opclasses_argument (constraints.tests.UniqueConstraintTests.test_invalid_opclasses_argument)	Pass
test_model_validation_constraint_no_code_error (constraints.tests.UniqueConstraintTests.test_model_validation_constraint_no_code_error)	Pass
Partial unique constraints are not ignored by	Pass
test_name (constraints.tests.UniqueConstraintTests.test_name)	Pass
test_opclasses_and_fields_same_length (constraints.tests.UniqueConstraintTests.test_opclasses_and_fields_same_length)	Pass
test_repr (constraints.tests.UniqueConstraintTests.test_repr)	Pass
test_repr_with_condition (constraints.tests.UniqueConstraintTests.test_repr_with_condition)	Pass
test_repr_with_deferrable (constraints.tests.UniqueConstraintTests.test_repr_with_deferrable)	Pass
test_repr_with_expressions (constraints.tests.UniqueConstraintTests.test_repr_with_expressions)	Pass
test_repr_with_include (constraints.tests.UniqueConstraintTests.test_repr_with_include)	Pass
test_repr_with_opclasses (constraints.tests.UniqueConstraintTests.test_repr_with_opclasses)	Pass
test_repr_with_violation_error_message (constraints.tests.UniqueConstraintTests.test_repr_with_violation_error_message)	Pass
test_requires_field_or_expression (constraints.tests.UniqueConstraintTests.test_requires_field_or_expression)	Pass
test_requires_name (constraints.tests.UniqueConstraintTests.test_requires_name)	Pass
test_validate_condition (constraints.tests.UniqueConstraintTests.test_validate_condition)	Pass
test_validate_expression (constraints.tests.UniqueConstraintTests.test_validate_expression)	Pass
test_validate_expression_condition (constraints.tests.UniqueConstraintTests.test_validate_expression_condition)	Pass
test_validate_expression_str (constraints.tests.UniqueConstraintTests.test_validate_expression_str)	Pass
test_validate_ordered_expression (constraints.tests.UniqueConstraintTests.test_validate_ordered_expression)	Pass

Ridges.AI

 class BaseConstraint:
     default_violation_error_message = _("Constraint “%(name)s” is violated.")
     violation_error_message = None
+    violation_error_code = None
     # RemovedInDjango60Warning: When the deprecation ends, replace with:
+    # def __init__(self, *, name, violation_error_message=None):
+    def __init__(self, *args, name=None, violation_error_message=None):
+    # def __init__(self, *, name, violation_error_message=None, violation_error_code=None):
+    def __init__(self, *args, name=None, violation_error_message=None, violation_error_code=None):
         # RemovedInDjango60Warning.
         if name is None and not args:
             raise TypeError(
             self.violation_error_message = violation_error_message
         else:
             self.violation_error_message = self.default_violation_error_message
+        self.violation_error_code = violation_error_code
         # RemovedInDjango60Warning.
         if args:
             warnings.warn(
                 RemovedInDjango60Warning,
                 stacklevel=2,
+            )
+            for arg, attr in zip(args, ["name", "violation_error_message"]):
+            for arg, attr in zip(args, ["name", "violation_error_message", "violation_error_code"]):
                 if arg:
                     setattr(self, attr, arg)
     def get_violation_error_message(self):
         return self.violation_error_message % {"name": self.name}
+    def get_violation_error_details(self):
+        """Return a dict with message and code for ValidationError."""
+        details = {"message": self.get_violation_error_message()}
+        if self.violation_error_code is not None:
+            details["code"] = self.violation_error_code
+        return details
     def deconstruct(self):
         path = "%s.%s" % (self.__class__.__module__, self.__class__.__name__)
         path = path.replace("django.db.models.constraints", "django.db.models")
             and self.violation_error_message != self.default_violation_error_message
         ):
             kwargs["violation_error_message"] = self.violation_error_message
+        if self.violation_error_code is not None:
+            kwargs["violation_error_code"] = self.violation_error_code
         return (path, (), kwargs)
     def clone(self):
 class CheckConstraint(BaseConstraint):
+    def __init__(self, *, check, name, violation_error_message=None):
+    def __init__(self, *, check, name, violation_error_message=None, violation_error_code=None):
         self.check = check
         if not getattr(check, "conditional", False):
             raise TypeError(
                 "CheckConstraint.check must be a Q instance or boolean expression."
+            )
+        super().__init__(name=name, violation_error_message=violation_error_message)
+        super().__init__(name=name, violation_error_message=violation_error_message, violation_error_code=violation_error_code)
     def _get_check_sql(self, model, schema_editor):
         query = Query(model=model, alias_cols=False)
         against = instance._get_field_value_map(meta=model._meta, exclude=exclude)
         try:
             if not Q(self.check).check(against, using=using):
+                raise ValidationError(self.get_violation_error_message())
+                error_details = self.get_violation_error_details()
+                raise ValidationError(error_details["message"], code=error_details.get("code"))
         except FieldError:
             pass
                 self.name == other.name
                 and self.check == other.check
                 and self.violation_error_message == other.violation_error_message
+                and self.violation_error_code == other.violation_error_code
+            )
         return super().__eq__(other)
         include=None,
         opclasses=(),
         violation_error_message=None,
+        violation_error_code=None,
     ):
         if not name:
             raise ValueError("A unique constraint must be named.")
             F(expression) if isinstance(expression, str) else expression
             for expression in expressions
+        )
+        super().__init__(name=name, violation_error_message=violation_error_message)
+        super().__init__(name=name, violation_error_message=violation_error_message, violation_error_code=violation_error_code)
     @property
     def contains_expressions(self):
         if not self.condition:
             if queryset.exists():
                 if self.expressions:
+                    raise ValidationError(self.get_violation_error_message())
+                # When fields are defined, use the unique_error_message() for
+                # backward compatibility.
+                for model, constraints in instance.get_constraints():
+                    for constraint in constraints:
+                        if constraint is self:
+                            raise ValidationError(
+                                instance.unique_error_message(model, self.fields)
+                            )
+                    error_details = self.get_violation_error_details()
+                    raise ValidationError(error_details["message"], code=error_details.get("code"))
+                # When fields are defined, use the violation error details
+                # for consistency with custom error codes.
+                error_details = self.get_violation_error_details()
+                raise ValidationError(error_details["message"], code=error_details.get("code"))
         else:
             against = instance._get_field_value_map(meta=model._meta, exclude=exclude)
             try:
                 if (self.condition & Exists(queryset.filter(self.condition))).check(
                     against, using=using
                 ):
+                    raise ValidationError(self.get_violation_error_message())
+                    error_details = self.get_violation_error_details()
+                    raise ValidationError(error_details["message"], code=error_details.get("code"))
             except FieldError:
                 pass

api

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed