Ticket #12521: only_validate_fields_on_modelform_not_entire_model.diff

django/core/exceptions.py

@@ -33 +33 @@
     pass
 
 NON_FIELD_ERRORS = '__all__'
-class BaseValidationError(Exception):
+class ValidationError(Exception):
     """An error while validating data."""
     def __init__(self, message, code=None, params=None):
         import operator
@@ -64 +64 @@
             return repr(self.message_dict)
         return repr(self.messages)
 
-class ValidationError(BaseValidationError):
-    pass
-
-class UnresolvableValidationError(BaseValidationError):
-    """Validation error that cannot be resolved by the user."""
-    pass
-

django/db/models/base.py

@@ -649 +649 @@
         not be associated with a particular field; it will have a special-case
         association with the field defined by NON_FIELD_ERRORS.
         """
-        self.validate_unique()
+        pass
 
-    def validate_unique(self):
-        unique_checks, date_checks = self._get_unique_checks()
+    def validate_unique(self, exclude=[]):
+        unique_checks, date_checks = self._get_unique_checks(exclude)
 
         errors = self._perform_unique_checks(unique_checks)
         date_errors = self._perform_date_checks(date_checks)
@@ -663 +663 @@
         if errors:
             raise ValidationError(errors)
 
-    def _get_unique_checks(self):
+    def _get_unique_checks(self, exclude=[]):
         from django.db.models.fields import FieldDoesNotExist, Field as ModelField
 
-        unique_checks = list(self._meta.unique_together)
+        unique_checks = []
+        # include all unique_together checks...
+        for check in self._meta.unique_together:
+            for name in check:
+                # ... except those that contain an excluded field
+                if name in exclude:
+                    break
+            else:
+                unique_checks.append(check)
+
         # these are checks for the unique_for_<date/year/month>
         date_checks = []
 
@@ -674 +683 @@
         # the list of checks. Again, skip empty fields and any that did not validate.
         for f in self._meta.fields:
             name = f.name
+            # do not process excluded fields
+            if name in exclude:
+                continue
             if f.unique:
                 unique_checks.append((name,))
             if f.unique_for_date:
@@ -795 +807 @@
             except ValidationError, e:
                 errors[f.name] = e.messages
 
-        # Form.clean() is run even if other validation fails, so do the
-        # same with Model.validate() for consistency.
         try:
-            self.validate()
+            self.validate_unique(exclude=exclude+errors.keys())
         except ValidationError, e:
             if hasattr(e, 'message_dict'):
                 if errors:
@@ -809 +819 @@
             else:
                 errors[NON_FIELD_ERRORS] = e.messages
 
+        # Form.clean() is run even if other validation fails, so do the
+        # same with Model.validate() for consistency.
+
+
+        # However, do not run Model.validate() on incomplete forms when creating new instance
+        if not (exclude and getattr(self, '_adding', True)):
+            try:
+                self.validate()
+            except ValidationError, e:
+                if hasattr(e, 'message_dict'):
+                    if errors:
+                        for k, v in e.message_dict.items():
+                            errors.set_default(k, []).extend(v)
+                    else:
+                        errors = e.message_dict
+                else:
+                    errors[NON_FIELD_ERRORS] = e.messages
+
         if errors:
             raise ValidationError(errors)
 

django/forms/models.py

@@ -9 +9 @@
 from django.utils.text import get_text_list, capfirst
 from django.utils.translation import ugettext_lazy as _, ugettext
 
-from django.core.exceptions import ValidationError, NON_FIELD_ERRORS, UnresolvableValidationError
+from django.core.exceptions import ValidationError, NON_FIELD_ERRORS
 from django.core.validators import EMPTY_VALUES
 from util import ErrorList
 from forms import BaseForm, get_declared_fields
@@ -249 +249 @@
         opts = self._meta
         self.instance = construct_instance(self, self.instance, opts.fields, opts.exclude)
         try:
-            self.instance.full_validate(exclude=self._errors.keys())
+            self.instance.full_validate(exclude=self._errors.keys() + list(opts.exclude or []))
         except ValidationError, e:
             for k, v in e.message_dict.items():
                 if k != NON_FIELD_ERRORS:
@@ -262 +262 @@
             if NON_FIELD_ERRORS in e.message_dict:
                 raise ValidationError(e.message_dict[NON_FIELD_ERRORS])
 
-            # If model validation threw errors for fields that aren't on the
-            # form, the the errors cannot be corrected by the user. Displaying
-            # those errors would be pointless, so raise another type of
-            # exception that *won't* be caught and displayed by the form.
-            if set(e.message_dict.keys()) - set(self.fields.keys() + [NON_FIELD_ERRORS]):
-                raise UnresolvableValidationError(e.message_dict)
-
-
         return self.cleaned_data
 
     def save(self, commit=True):

tests/modeltests/model_forms/models.py

@@ -1425 +1425 @@
 >>> form._errors
 {'__all__': [u'Price with this Price and Quantity already exists.']}
 
-# This form is never valid because quantity is blank=False.
 >>> class PriceForm(ModelForm):
 ...     class Meta:
 ...         model = Price
 ...         exclude = ('quantity',)
 >>> form = PriceForm({'price': '6.00'})
 >>> form.is_valid()
-Traceback (most recent call last):
-  ...
-UnresolvableValidationError: {'quantity': [u'This field cannot be null.']}
+True
 
 # Unique & unique together with null values
 >>> class BookForm(ModelForm):