Ticket #5335: form_error_append_r16741.diff

docs/ref/forms/validation.txt

@@ -137 +137 @@
 display itself in different ways. So you can treat ``_errors`` as a dictionary
 mapping field names to lists.
 
-If you want to add a new error to a particular field, you should check whether
-the key already exists in ``self._errors`` or not. If not, create a new entry
-for the given key, holding an empty ``ErrorList`` instance. In either case,
-you can then append your error message to the list for the field name in
-question and it will be displayed when the form is displayed.
+If you want to add a new error to a particular field, you can append your error
+message to the list for the field name in question by using ``append()``.
+Django will check if the key already exists, otherwise it will create an empty
+``ErrorList`` instance. Then the error message will be displayed when the form
+is displayed.
 
 There is an example of modifying ``self._errors`` in the following section.
 
@@ -337 +337 @@
                 # We know these are not in self._errors now (see discussion
                 # below).
                 msg = u"Must put 'help' in subject when cc'ing yourself."
-                self._errors["cc_myself"] = self.error_class([msg])
-                self._errors["subject"] = self.error_class([msg])
+                self._errors["cc_myself"].append(msg)
+                self._errors["subject"].append(msg)
 
                 # These fields are no longer valid. Remove them from the
                 # cleaned data.
@@ -350 +350 @@
 
 As you can see, this approach requires a bit more effort, not withstanding the
 extra design effort to create a sensible form display. The details are worth
-noting, however. Firstly, earlier we mentioned that you might need to check if
-the field name keys already exist in the ``_errors`` dictionary. In this case,
-since we know the fields exist in ``self.cleaned_data``, they must have been
-valid when cleaned as individual fields, so there will be no corresponding
-entries in ``_errors``.
+noting, however. Firstly, we mentioned that in order to add errors to the
+fields, you just need to ``append()`` your error message in the ``_errors``
+dictionary.
 
 Secondly, once we have decided that the combined data in the two fields we are
 considering aren't valid, we must remember to remove them from the

tests/regressiontests/forms/tests/util.py

@@ -1 +1 @@
 # -*- coding: utf-8 -*-
 from django.core.exceptions import ValidationError
+from django import forms
 from django.forms.util import *
 from django.utils.translation import ugettext_lazy
 from django.utils.unittest import TestCase
@@ -59 +60 @@
                          '<ul class="errorlist"><li>nameExample of link: &lt;a href=&quot;http://www.example.com/&quot;&gt;example&lt;/a&gt;</li></ul>')
         self.assertEqual(str(ErrorDict({'name': mark_safe(example)})),
                          '<ul class="errorlist"><li>nameExample of link: <a href="http://www.example.com/">example</a></li></ul>')
+
+
+class AppendingFieldErrorMessagesTestCase(TestCase):
+
+    def test_errors_messages_can_be_appended_to_fields_error_list(self):
+        error_msg = "Field1 can't be greather than field2."
+        class TestForm(forms.Form):
+            field1 = forms.IntegerField()
+            field2 = forms.IntegerField()
+
+            def clean(self):
+                if self.cleaned_data['field1'] > self.cleaned_data['field2']:
+                    self._errors['field1'].append(error_msg)
+
+        form = TestForm({'field1': 3, 'field2': 2})
+        form.is_valid()
+        self.assertEqual(form.errors['field1'], [error_msg])
+        self.assertEqual(form.errors['field2'], [])
+
+    def test_appending_error_messages_to_fields_errors_list_dont_overwrite_other_messages(self):
+        class TestForm(forms.Form):
+            password = forms.CharField()
+            confirm_password = forms.CharField()
+
+            def clean_password(self):
+                value = self.cleaned_data['password']
+                if len(value) < 6:
+                    raise forms.ValidationError("Password must be longer than 6 characters.")
+                return value
+
+            def clean(self):
+                if self.cleaned_data.get('password') != self.cleaned_data.get('confirm_password'):
+                    self._errors['password'].append("Passwords don't match.")
+
+        form = TestForm({'password': 'small', 'confirm_password': 'smal'})
+        form.is_valid()
+        self.assertEqual(form.errors['password'], ["Password must be longer than 6 characters.", "Passwords don't match."])
+        self.assertEqual(form.errors['confirm_password'], [])
+

django/forms/util.py

@@ -33 +33 @@
     def as_text(self):
         return u'\n'.join([u'* %s\n%s' % (k, u'\n'.join([u'  * %s' % force_unicode(i) for i in v])) for k, v in self.items()])
 
+    def __getitem__(self, field):
+        return self.setdefault(field, ErrorList())
+
 class ErrorList(list, StrAndUnicode):
     """
     A collection of errors that knows how to display itself in various formats.