Winner

Finished

Test Name	Status
test_deconstruction (constraints.tests.BaseConstraintTests.test_deconstruction)	Fail
test_constraint_sql (constraints.tests.BaseConstraintTests.test_constraint_sql)	Fail
test_contains_expressions (constraints.tests.BaseConstraintTests.test_contains_expressions)	Fail
test_create_sql (constraints.tests.BaseConstraintTests.test_create_sql)	Fail
test_custom_violation_error_message (constraints.tests.BaseConstraintTests.test_custom_violation_error_message)	Fail
test_custom_violation_error_message_clone (constraints.tests.BaseConstraintTests.test_custom_violation_error_message_clone)	Fail
test_default_violation_error_message (constraints.tests.BaseConstraintTests.test_default_violation_error_message)	Fail
test_deprecation (constraints.tests.BaseConstraintTests.test_deprecation)	Fail
test_positional_arguments (constraints.tests.BaseConstraintTests.test_positional_arguments)	Fail
test_remove_sql (constraints.tests.BaseConstraintTests.test_remove_sql)	Fail
test_validate (constraints.tests.BaseConstraintTests.test_validate)	Fail
test_custom_violation_code_message (constraints.tests.BaseConstraintTests.test_custom_violation_code_message)	Pass
test_eq (constraints.tests.CheckConstraintTests.test_eq)	Pass
test_repr_with_violation_error_code (constraints.tests.CheckConstraintTests.test_repr_with_violation_error_code)	Pass
test_validate_custom_error (constraints.tests.CheckConstraintTests.test_validate_custom_error)	Pass
test_eq (constraints.tests.UniqueConstraintTests.test_eq)	Pass
test_repr_with_violation_error_code (constraints.tests.UniqueConstraintTests.test_repr_with_violation_error_code)	Pass
test_validate_conditon_custom_error (constraints.tests.UniqueConstraintTests.test_validate_conditon_custom_error)	Pass
test_name_required (constraints.tests.BaseConstraintTests.test_name_required)	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 (constraints.tests.UniqueConstraintTests.test_model_validation)	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 (constraints.tests.UniqueConstraintTests.test_validate)	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

     violation_error_message = 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
+        if violation_error_code is not None:
+            self.violation_error_code = violation_error_code
+        else:
+            self.violation_error_code = self.default_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_code(self):
+        return self.violation_error_code
     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
+            and self.violation_error_code != self.default_violation_error_code
+        ):
+            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):
+    default_violation_error_code = "invalid"
+    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())
+                raise ValidationError(self.get_violation_error_message(), code=self.get_violation_error_code())
         except FieldError:
             pass
     def __repr__(self):
+        return "<%s: check=%s name=%s%s>" % (
+        return "<%s: check=%s name=%s%s%s>" % (
             self.__class__.__qualname__,
             self.check,
             repr(self.name),
                 or self.violation_error_message == self.default_violation_error_message
                 else " violation_error_message=%r" % self.violation_error_message
             ),
+            (
+                ""
+                if self.violation_error_code is None
+                or self.violation_error_code == self.default_violation_error_code
+                else " violation_error_code=%r" % self.violation_error_code
+            ),
+        )
     def __eq__(self, other):
                 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)
 class UniqueConstraint(BaseConstraint):
+    default_violation_error_code = "unique"
     def __init__(
         self,
         *expressions,
         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):
+        )
     def __repr__(self):
+        return "<%s:%s%s%s%s%s%s%s%s>" % (
+        return "<%s:%s%s%s%s%s%s%s%s%s>" % (
             self.__class__.__qualname__,
             "" if not self.fields else " fields=%s" % repr(self.fields),
             "" if not self.expressions else " expressions=%s" % repr(self.expressions),
                 or self.violation_error_message == self.default_violation_error_message
                 else " violation_error_message=%r" % self.violation_error_message
             ),
+            (
+                ""
+                if self.violation_error_code is None
+                or self.violation_error_code == self.default_violation_error_code
+                else " violation_error_code=%r" % self.violation_error_code
+            ),
+        )
     def __eq__(self, other):
                 and self.opclasses == other.opclasses
                 and self.expressions == other.expressions
                 and self.violation_error_message == other.violation_error_message
+                and self.violation_error_code == other.violation_error_code
+            )
         return super().__eq__(other)
         if not self.condition:
             if queryset.exists():
                 if self.expressions:
+                    raise ValidationError(self.get_violation_error_message())
+                    raise ValidationError(self.get_violation_error_message(), code=self.get_violation_error_code())
                 # When fields are defined, use the unique_error_message() for
                 # backward compatibility.
                 for model, constraints in instance.get_constraints():
                 if (self.condition & Exists(queryset.filter(self.condition))).check(
                     against, using=using
                 ):
+                    raise ValidationError(self.get_violation_error_message())
+                    raise ValidationError(self.get_violation_error_message(), code=self.get_violation_error_code())
             except FieldError:
                 pass

Winner

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed