Ticket #11595: fixture_validation.diff

django/db/models/fields/__init__.py

@@ -449 +449 @@
 
     empty_strings_allowed = False
     default_error_messages = {
-        'invalid': _(u'This value must be an integer.'),
+        'invalid': _('"%s" value must be an integer.'),
     }
     def __init__(self, *args, **kwargs):
         assert kwargs.get('primary_key', False) is True, "%ss must have primary_key=True." % self.__class__.__name__
@@ -465 +465 @@
         try:
             return int(value)
         except (TypeError, ValueError):
-            raise exceptions.ValidationError(self.error_messages['invalid'])
+            msg = self.error_messages['invalid'] % str(value)
+            raise exceptions.ValidationError(msg)
 
     def validate(self, value, model_instance):
         pass
@@ -487 +488 @@
 class BooleanField(Field):
     empty_strings_allowed = False
     default_error_messages = {
-        'invalid': _(u'This value must be either True or False.'),
+        'invalid': _('"%s" value must be either True or False.'),
     }
     description = _("Boolean (Either True or False)")
     def __init__(self, *args, **kwargs):
@@ -508 +509 @@
             return True
         if value in ('f', 'False', '0'):
             return False
-        raise exceptions.ValidationError(self.error_messages['invalid'])
+        msg = self.error_messages['invalid'] % str(value)
+        raise exceptions.ValidationError(msg)
 
     def get_prep_lookup(self, lookup_type, value):
         # Special-case handling for filters coming from a Web request (e.g. the
@@ -740 +742 @@
 class DecimalField(Field):
     empty_strings_allowed = False
     default_error_messages = {
-        'invalid': _(u'This value must be a decimal number.'),
+        'invalid': _('"%s" value must be a decimal number.'),
     }
     description = _("Decimal number")
 
@@ -757 +759 @@
         try:
             return decimal.Decimal(value)
         except decimal.InvalidOperation:
-            raise exceptions.ValidationError(self.error_messages['invalid'])
+            msg = self.error_messages['invalid'] % str(value)
+            raise exceptions.ValidationError(msg)
 
     def _format(self, value):
         if isinstance(value, basestring) or value is None:
@@ -835 +838 @@
 class FloatField(Field):
     empty_strings_allowed = False
     default_error_messages = {
-        'invalid': _("This value must be a float."),
+        'invalid': _('"%s" value must be a float.'),
     }
     description = _("Floating point number")
 
@@ -853 +856 @@
         try:
             return float(value)
         except (TypeError, ValueError):
-            raise exceptions.ValidationError(self.error_messages['invalid'])
+            msg = self.error_messages['invalid'] % str(value)
+            raise exceptions.ValidationError(msg)
 
     def formfield(self, **kwargs):
         defaults = {'form_class': forms.FloatField}
@@ -863 +867 @@
 class IntegerField(Field):
     empty_strings_allowed = False
     default_error_messages = {
-        'invalid': _("This value must be an integer."),
+        'invalid': _('"%s" value must be an integer.'),
     }
     description = _("Integer")
 
@@ -887 +891 @@
         try:
             return int(value)
         except (TypeError, ValueError):
-            raise exceptions.ValidationError(self.error_messages['invalid'])
+            msg = self.error_messages['invalid'] % str(value)
+            raise exceptions.ValidationError(msg)
 
     def formfield(self, **kwargs):
         defaults = {'form_class': forms.IntegerField}
@@ -925 +930 @@
 class NullBooleanField(Field):
     empty_strings_allowed = False
     default_error_messages = {
-        'invalid': _("This value must be either None, True or False."),
+        'invalid': _('"%s" value must be either None, True or False.'),
     }
     description = _("Boolean (Either True, False or None)")
 
@@ -948 +953 @@
             return True
         if value in ('f', 'False', '0'):
             return False
-        raise exceptions.ValidationError(self.error_messages['invalid'])
+        msg = self.error_messages['invalid'] % str(value)
+        raise exceptions.ValidationError(msg)
 
     def get_prep_lookup(self, lookup_type, value):
         # Special-case handling for filters coming from a Web request (e.g. the

tests/modeltests/validation/test_error_messages.py

@@ +1 @@
+from django.core.exceptions import ValidationError
+from django.utils.unittest import TestCase
+from django.db import models
+
+
+class ValidationMessagesTest(TestCase):
+
+    def test_autofield_field_raises_error_message(self):
+        f = models.AutoField(primary_key=True)
+        self.assertRaises(ValidationError, f.clean, 'foo', None)
+        try:
+            f.clean('foo', None)
+        except ValidationError, e:
+            self.assertEqual(e.messages, [u"'foo' value must be an integer."])
+
+    def test_integer_field_raises_error_message(self):
+        f = models.IntegerField()
+        self.assertRaises(ValidationError, f.clean, 'foo', None)
+        try:
+            f.clean('foo', None)
+        except ValidationError, e:
+            self.assertEqual(e.messages, [u"'foo' value must be an integer."])
+
+    def test_boolean_field_raises_error_message(self):
+        f = models.BooleanField()
+        self.assertRaises(ValidationError, f.clean, 'foo', None)
+        try:
+            f.clean('foo', None)
+        except ValidationError, e:
+            self.assertEqual(e.messages,
+                        [u"'foo' value must be either True or False."])
+
+    def test_float_field_raises_error_message(self):
+        f = models.FloatField()
+        self.assertRaises(ValidationError, f.clean, 'foo', None)
+        try:
+            f.clean('foo', None)
+        except ValidationError, e:
+            self.assertEqual(e.messages, [u"'foo' value must be a float."])
+
+    def test_decimal_field_raises_error_message(self):
+        f = models.DecimalField()
+        self.assertRaises(ValidationError, f.clean, 'foo', None)
+        try:
+            f.clean('foo', None)
+        except ValidationError, e:
+            self.assertEqual(e.messages,
+                        [u"'foo' value must be a decimal number."])
+
+    def test_null_boolean_field_raises_error_message(self):
+        f = models.NullBooleanField()
+        self.assertRaises(ValidationError, f.clean, 'foo', None)
+        try:
+            f.clean('foo', None)
+        except ValidationError, e:
+            self.assertEqual(e.messages,
+                        [u"'foo' value must be either None, True or False."])

tests/modeltests/validation/tests.py

@@ -9 +9 @@
 from modeltests.validation.test_unique import (GetUniqueCheckTests,
     PerformUniqueChecksTest)
 from modeltests.validation.test_custom_messages import CustomMessagesTest
+from modeltests.validation.test_error_messages import ValidationMessagesTest
 
 
 class BaseModelValidationTests(ValidationTestCase):