Finished

Test Name	Status
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_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_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 (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

 class BaseConstraint:
     default_violation_error_message = _("Constraint “%(name)s” is violated.")
+    default_violation_error_code = None
     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
+        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)
             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):
+    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.violation_error_code)
         except FieldError:
             pass
     def __repr__(self):
+        return "<%s: check=%s name=%s%s>" % (
+        base_parts = [
             self.__class__.__qualname__,
             self.check,
             repr(self.name),
+            (
+                ""
+                if self.violation_error_message is None
+                or self.violation_error_message == self.default_violation_error_message
+                else " violation_error_message=%r" % self.violation_error_message
+            ),
+        )
+        ]
+        extra_parts = []
+        if (
+            self.violation_error_message is not None
+            and self.violation_error_message != self.default_violation_error_message
+        ):
+            extra_parts.append("violation_error_message=%r" % self.violation_error_message)
+        if (
+            self.violation_error_code is not None
+            and self.violation_error_code != self.default_violation_error_code
+        ):
+            extra_parts.append("violation_error_code=%r" % self.violation_error_code)
+        if extra_parts:
+            return "<%s: check=%s name=%s %s>" % (
+                base_parts[0],
+                base_parts[1],
+                base_parts[2],
+                " ".join(extra_parts),
+            )
+        else:
+            return "<%s: check=%s name=%s>" % tuple(base_parts)
     def __eq__(self, other):
         if isinstance(other, CheckConstraint):
                 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):
+        )
     def __repr__(self):
+        return "<%s:%s%s%s%s%s%s%s%s>" % (
+            self.__class__.__qualname__,
+        parts = [
+            self.__class__.__qualname__ + ":",
             "" if not self.fields else " fields=%s" % repr(self.fields),
             "" if not self.expressions else " expressions=%s" % repr(self.expressions),
             " name=%s" % repr(self.name),
             "" if self.deferrable is None else " deferrable=%r" % self.deferrable,
             "" if not self.include else " include=%s" % repr(self.include),
             "" if not self.opclasses else " opclasses=%s" % repr(self.opclasses),
+            (
+                ""
+                if self.violation_error_message is None
+                or self.violation_error_message == self.default_violation_error_message
+                else " violation_error_message=%r" % self.violation_error_message
+            ),
+        )
+        ]
+        if (
+            self.violation_error_message is not None
+            and self.violation_error_message != self.default_violation_error_message
+        ):
+            parts.append(" violation_error_message=%r" % self.violation_error_message)
+        if (
+            self.violation_error_code is not None
+            and self.violation_error_code != self.default_violation_error_code
+        ):
+            parts.append(" violation_error_code=%r" % self.violation_error_code)
+        return "<%s>" % "".join(parts)
     def __eq__(self, other):
         if isinstance(other, UniqueConstraint):
                 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.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.violation_error_code)
             except FieldError:
                 pass

impossible

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed