ModelForm._post_clean() does not respect Model.clean() ValidationErrors that possess a message_dict, rather than a list of messages

[robboyle]

When a ModelForm runs it's model-level validation, it anticipates the Model's clean_fields() method raising a ValidationError with the message_dict property set. This let's the ModelForm associate the Model's Field validation errors with the ModelForm fields.

However, when the ModelForm then calls the Model's clean() method, it ignores the message_dict property if the ValidationError raised by clean() has it set. Instead, it always creates a new dictionary, associating all validation messages with the NON_FIELD_ERRORS key.

It would be nice if _post_clean() checked if Model.clean() was raising a ValidationError with a message_dict, and if so updated the errors with that dict, rather than blindly creating a new one. That way, the Model.clean() method could associate errors with a particular field, return a ValidationError with message_dict set, and this association would be perserved by the ModelForm.

Being able to have a form's clean method associate errors with a particular field is very handy. Being able to do this at the model level and then have model forms take advantage of it would bring model forms more on par with regular forms.

[robboyle]

My initial shot at a solution.

[Chris Wilson]

+1.

Model.full_clean does this, which is even simpler than the current patch:

        # Form.clean() is run even if other validation fails, so do the
        # same with Model.clean() for consistency.
        try:
            self.clean()
        except ValidationError, e:
            errors = e.update_error_dict(errors)

You could do exactly the same in BaseModelForm.post_clean for symmetry:

        # Call the model instance's clean method.
        try:
            self.instance.clean()
        except ValidationError, e:
            self._update_errors(e.update_error_dict({}))

BaseModelForm._post_clean does almost the same thing as Model.full_clean, and could perhaps be simplified to just call it. The main difference seems to be that validating uniqueness is optional:

        # Validate uniqueness if needed.
        if self._validate_unique:
            self.validate_unique()

and would fail if self.instance.validate_unique threw a ValidationError with a NON_FIELD_ERROR, because it assumes that the ValidationError contains a message_dict:

        try:
            self.instance.validate_unique(exclude=exclude)
        except ValidationError, e:
            self._update_errors(e.message_dict)

[Tim Graham]

I believe this was addressed by [f34cfec0].