              if bound_form.non_field_errors():
                  detail[u'errors'] = bound_form.non_field_errors()
  
              # Add standard field errors
              field_errors = dict((key, map(unicode, val)) for (key, val) in bound_form.errors.iteritems() if not key.startswith('__'))
  
              # Add any unknown field errors
              for key in unknown_fields:
                  field_errors[key] = [u'This field does not exist.']
         
 
</s> remove         model_fields = set(field.name for field in self.model._meta.fields)
 </s> add         model = getattr(self.view, 'model', None)
        fields = getattr(self.view, 'fields', self.fields)
        exclude_fields = getattr(self.view, 'exclude_fields', self.exclude_fields)

        model_fields = set(field.name for field in model._meta.fields) </s> remove         if self.fields:
            return model_fields & set(as_tuple(self.fields))
 </s> add         if fields:
            return model_fields & set(as_tuple(fields)) </s> remove         property_fields = set(attr for attr in dir(self.model) if
                              isinstance(getattr(self.model, attr, None), property)
 </s> add         model = getattr(self.view, 'model', None)
        fields = getattr(self.view, 'fields', self.fields)
        exclude_fields = getattr(self.view, 'exclude_fields', self.exclude_fields)

        property_fields = set(attr for attr in dir(model) if
                              isinstance(getattr(model, attr, None), property) </s> remove         self.validation_failed_due_to_multiple_errors_returns_appropriate_message(self.MockModelFormValidator())


class TestModelFormValidator(TestCase):
    """Tests specific to ModelFormValidatorMixin"""
    
    def setUp(self):
        """Create a validator for a model with two fields and a property."""    
        class MockModel(models.Model):
            qwerty = models.CharField(max_length=256)
            uiop = models.CharField(max_length=256, blank=True)
            
            @property
            def readonly(self):
                return 'read only'
            
        class MockValidator(ModelFormValidatorMixin):
            model = MockModel
       
        self.MockValidator = MockValidator


    def test_property_fields_are_allowed_on_model_forms(self):
        """Validation on ModelForms may include property fields that exist on the Model to be included in the input."""
        content = {'qwerty':'example', 'uiop': 'example', 'readonly': 'read only'}
        self.assertEqual(self.MockValidator().validate(content), content)

    def test_property_fields_are_not_required_on_model_forms(self):
        """Validation on ModelForms does not require property fields that exist on the Model to be included in the input."""
        content = {'qwerty':'example', 'uiop': 'example'}
        self.assertEqual(self.MockValidator().validate(content), content)

    def test_extra_fields_not_allowed_on_model_forms(self):
        """If some (otherwise valid) content includes fields that are not in the form then validation should fail.
        It might be okay on normal form submission, but for Web APIs we oughta get strict, as it'll help show up
        broken clients more easily (eg submitting content with a misnamed field)"""
        content = {'qwerty': 'example', 'uiop':'example', 'readonly': 'read only', 'extra': 'extra'} 
        self.assertRaises(ResponseException, self.MockValidator().validate, content)
    
    def test_validate_requires_fields_on_model_forms(self):
        """If some (otherwise valid) content includes fields that are not in the form then validation should fail.
        It might be okay on normal form submission, but for Web APIs we oughta get strict, as it'll help show up
        broken clients more easily (eg submitting content with a misnamed field)"""
        content = {'readonly': 'read only'} 
        self.assertRaises(ResponseException, self.MockValidator().validate, content)
    
    def test_validate_does_not_require_blankable_fields_on_model_forms(self):
        """Test standard ModelForm validation behaviour - fields with blank=True are not required."""
        content = {'qwerty':'example', 'readonly': 'read only'}
        self.MockValidator().validate(content)
    
    def test_model_form_validator_uses_model_forms(self):
        self.assertTrue(isinstance(self.MockValidator().get_bound_form(), forms.ModelForm))
 </s> add         validator = ModelFormValidator(self.MockModelFormView())
        self.validation_failed_due_to_multiple_errors_returns_appropriate_message(validator)


# class TestModelFormValidator(TestCase):
#     """Tests specific to ModelFormValidatorMixin"""
#     
#     def setUp(self):
#         """Create a validator for a model with two fields and a property."""    
#         class MockModel(models.Model):
#             qwerty = models.CharField(max_length=256)
#             uiop = models.CharField(max_length=256, blank=True)
#             
#             @property
#             def readonly(self):
#                 return 'read only'
#             
#         class MockValidator(ModelFormValidatorMixin):
#             model = MockModel
#        
#         self.MockValidator = MockValidator
# 
# 
#     def test_property_fields_are_allowed_on_model_forms(self):
#         """Validation on ModelForms may include property fields that exist on the Model to be included in the input."""
#         content = {'qwerty':'example', 'uiop': 'example', 'readonly': 'read only'}
#         self.assertEqual(self.MockValidator().validate(content), content)
# 
#     def test_property_fields_are_not_required_on_model_forms(self):
#         """Validation on ModelForms does not require property fields that exist on the Model to be included in the input."""
#         content = {'qwerty':'example', 'uiop': 'example'}
#         self.assertEqual(self.MockValidator().validate(content), content)
# 
#     def test_extra_fields_not_allowed_on_model_forms(self):
#         """If some (otherwise valid) content includes fields that are not in the form then validation should fail.
#         It might be okay on normal form submission, but for Web APIs we oughta get strict, as it'll help show up
#         broken clients more easily (eg submitting content with a misnamed field)"""
#         content = {'qwerty': 'example', 'uiop':'example', 'readonly': 'read only', 'extra': 'extra'} 
#         self.assertRaises(ResponseException, self.MockValidator().validate, content)
#     
#     def test_validate_requires_fields_on_model_forms(self):
#         """If some (otherwise valid) content includes fields that are not in the form then validation should fail.
#         It might be okay on normal form submission, but for Web APIs we oughta get strict, as it'll help show up
#         broken clients more easily (eg submitting content with a misnamed field)"""
#         content = {'readonly': 'read only'} 
#         self.assertRaises(ResponseException, self.MockValidator().validate, content)
#     
#     def test_validate_does_not_require_blankable_fields_on_model_forms(self):
#         """Test standard ModelForm validation behaviour - fields with blank=True are not required."""
#         content = {'qwerty':'example', 'readonly': 'read only'}
#         self.MockValidator().validate(content)
#     
#     def test_model_form_validator_uses_model_forms(self):
#         self.assertTrue(isinstance(self.MockValidator().get_bound_form(), forms.ModelForm)) </s> remove         if self.fields:
            return property_fields & set(as_tuple(self.fields))
 </s> add         if fields:
            return property_fields & set(as_tuple(fields))
            field_errors = dict((key, map(unicode, val))
                for (key, val)
                in bound_form.errors.iteritems()
                if not key.startswith('__'))
              if bound_form.non_field_errors():
                  detail[u'errors'] = bound_form.non_field_errors()
  
              # Add standard field errors
            field_errors = dict((key, map(unicode, val))
                for (key, val)
                in bound_form.errors.iteritems()
                if not key.startswith('__'))
  
              # Add any unknown field errors
              for key in unknown_fields:
                  field_errors[key] = [u'This field does not exist.']
         
keep keep keep keep replace keep keep keep keep keep
 Lots of validator tests passing after refactor 
djangorestframework/validators.py