mirror of
https://github.com/encode/django-rest-framework.git
synced 2025-11-04 09:57:55 +03:00
Lots of validator tests passing after refactor
This commit is contained in:
Tom Christie
parent
136c9b5271
commit
a9df917d10
|
|
@ -9,7 +9,6 @@ from django.template import RequestContext, loader
|
|||
from django import forms
|
||||
|
||||
from djangorestframework.response import NoContent, ResponseException
|
||||
from djangorestframework.validators import FormValidatorMixin
|
||||
from djangorestframework.utils import dict2xml, url_resolves
|
||||
from djangorestframework.markdownwrapper import apply_markdown
|
||||
from djangorestframework.breadcrumbs import get_breadcrumbs
|
||||
|
|
@ -217,15 +216,11 @@ class DocumentingTemplateEmitter(BaseEmitter):
|
|||
#form_instance = resource.form_instance
|
||||
# TODO! Reinstate this
|
||||
|
||||
form_instance = None
|
||||
|
||||
if isinstance(resource, FormValidatorMixin):
|
||||
# If we already have a bound form instance (IE provided by the input parser, then use that)
|
||||
if resource.bound_form_instance is not None:
|
||||
form_instance = resource.bound_form_instance
|
||||
form_instance = getattr(resource, 'bound_form_instance', None)
|
||||
|
||||
if not form_instance and hasattr(resource, 'get_bound_form'):
|
||||
# Otherwise if we have a response that is valid against the form then use that
|
||||
if not form_instance and resource.response.has_content_body:
|
||||
if resource.response.has_content_body:
|
||||
try:
|
||||
form_instance = resource.get_bound_form(resource.response.cleaned_content)
|
||||
if form_instance and not form_instance.is_valid():
|
||||
|
|
|
|||
|
|
@ -5,15 +5,14 @@ from django.db.models.fields.related import RelatedField
|
|||
|
||||
from djangorestframework.response import Response, ResponseException
|
||||
from djangorestframework.resource import Resource
|
||||
from djangorestframework.validators import ModelFormValidatorMixin
|
||||
from djangorestframework import status
|
||||
from djangorestframework import status, validators
|
||||
|
||||
import decimal
|
||||
import inspect
|
||||
import re
|
||||
|
||||
|
||||
class ModelResource(Resource, ModelFormValidatorMixin):
|
||||
class ModelResource(Resource):
|
||||
"""A specialized type of Resource, for resources that map directly to a Django Model.
|
||||
Useful things this provides:
|
||||
|
||||
|
|
@ -21,6 +20,9 @@ class ModelResource(Resource, ModelFormValidatorMixin):
|
|||
1. Nice serialization of returned Models and QuerySets.
|
||||
2. A default set of create/read/update/delete operations."""
|
||||
|
||||
# List of validators to validate, cleanup and type-ify the request content
|
||||
validators = (validators.ModelFormValidator,)
|
||||
|
||||
# The model attribute refers to the Django Model which this Resource maps to.
|
||||
# (The Model's class, rather than an instance of the Model)
|
||||
model = None
|
||||
|
|
|
|||
|
|
@ -196,6 +196,29 @@ class RequestMixin(object):
|
|||
|
||||
return parser.parse(stream)
|
||||
|
||||
|
||||
def validate(self, content):
|
||||
"""
|
||||
Validate, cleanup, and type-ify the request content.
|
||||
"""
|
||||
for validator_cls in self.validators:
|
||||
validator = validator_cls(self)
|
||||
content = validator.validate(content)
|
||||
return content
|
||||
|
||||
|
||||
def get_bound_form(self, content=None):
|
||||
"""
|
||||
Return a bound form instance for the given content,
|
||||
if there is an appropriate form validator attached to the view.
|
||||
"""
|
||||
for validator_cls in self.validators:
|
||||
if hasattr(validator_cls, 'get_bound_form'):
|
||||
validator = validator_cls(self)
|
||||
return validator.get_bound_form(content)
|
||||
return None
|
||||
|
||||
|
||||
@property
|
||||
def parsed_media_types(self):
|
||||
"""Return an list of all the media types that this view can parse."""
|
||||
|
|
|
|||
|
|
@ -3,10 +3,9 @@ from django.views.decorators.csrf import csrf_exempt
|
|||
|
||||
from djangorestframework.compat import View
|
||||
from djangorestframework.emitters import EmitterMixin
|
||||
from djangorestframework.validators import FormValidatorMixin
|
||||
from djangorestframework.response import Response, ResponseException
|
||||
from djangorestframework.request import RequestMixin, AuthMixin
|
||||
from djangorestframework import emitters, parsers, authenticators, status
|
||||
from djangorestframework import emitters, parsers, authenticators, validators, status
|
||||
|
||||
|
||||
# TODO: Figure how out references and named urls need to work nicely
|
||||
|
|
@ -17,7 +16,7 @@ from djangorestframework import emitters, parsers, authenticators, status
|
|||
__all__ = ['Resource']
|
||||
|
||||
|
||||
class Resource(EmitterMixin, AuthMixin, FormValidatorMixin, RequestMixin, View):
|
||||
class Resource(EmitterMixin, AuthMixin, RequestMixin, View):
|
||||
"""Handles incoming requests and maps them to REST operations,
|
||||
performing authentication, input deserialization, input validation, output serialization."""
|
||||
|
||||
|
|
@ -39,6 +38,9 @@ class Resource(EmitterMixin, AuthMixin, FormValidatorMixin, RequestMixin, View):
|
|||
parsers.FormParser,
|
||||
parsers.MultipartParser )
|
||||
|
||||
# List of validators to validate, cleanup and type-ify the request content
|
||||
validators = (validators.FormValidator,)
|
||||
|
||||
# List of all authenticating methods to attempt.
|
||||
authenticators = ( authenticators.UserLoggedInAuthenticator,
|
||||
authenticators.BasicAuthenticator )
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@ from django import forms
|
|||
from django.db import models
|
||||
from django.test import TestCase
|
||||
from djangorestframework.compat import RequestFactory
|
||||
from djangorestframework.validators import ValidatorMixin, FormValidatorMixin, ModelFormValidatorMixin
|
||||
from djangorestframework.validators import BaseValidator, FormValidator, ModelFormValidator
|
||||
from djangorestframework.response import ResponseException
|
||||
|
||||
|
||||
|
|
@ -11,59 +11,68 @@ class TestValidatorMixinInterfaces(TestCase):
|
|||
|
||||
def test_validator_mixin_interface(self):
|
||||
"""Ensure the ValidatorMixin base class interface is as expected."""
|
||||
self.assertRaises(NotImplementedError, ValidatorMixin().validate, None)
|
||||
self.assertRaises(NotImplementedError, BaseValidator(None).validate, None)
|
||||
|
||||
def test_form_validator_mixin_interface(self):
|
||||
"""Ensure the FormValidatorMixin interface is as expected."""
|
||||
self.assertTrue(issubclass(FormValidatorMixin, ValidatorMixin))
|
||||
getattr(FormValidatorMixin, 'form')
|
||||
getattr(FormValidatorMixin, 'validate')
|
||||
#def test_form_validator_mixin_interface(self):
|
||||
# """Ensure the FormValidatorMixin interface is as expected."""
|
||||
# self.assertTrue(issubclass(FormValidator, BaseValidator))
|
||||
# getattr(FormValidator, 'form')
|
||||
# getattr(FormValidator, 'validate')
|
||||
|
||||
def test_model_form_validator_mixin_interface(self):
|
||||
"""Ensure the ModelFormValidatorMixin interface is as expected."""
|
||||
self.assertTrue(issubclass(ModelFormValidatorMixin, FormValidatorMixin))
|
||||
getattr(ModelFormValidatorMixin, 'model')
|
||||
getattr(ModelFormValidatorMixin, 'form')
|
||||
getattr(ModelFormValidatorMixin, 'fields')
|
||||
getattr(ModelFormValidatorMixin, 'exclude_fields')
|
||||
getattr(ModelFormValidatorMixin, 'validate')
|
||||
#def test_model_form_validator_mixin_interface(self):
|
||||
# """Ensure the ModelFormValidatorMixin interface is as expected."""
|
||||
# self.assertTrue(issubclass(ModelFormValidator, FormValidator))
|
||||
# getattr(ModelFormValidator, 'model')
|
||||
# getattr(ModelFormValidator, 'form')
|
||||
# getattr(ModelFormValidator, 'fields')
|
||||
# getattr(ModelFormValidator, 'exclude_fields')
|
||||
# getattr(ModelFormValidator, 'validate')
|
||||
|
||||
|
||||
class TestDisabledValidations(TestCase):
|
||||
"""Tests on Validator Mixins with validation disabled by setting form to None"""
|
||||
"""Tests on FormValidator with validation disabled by setting form to None"""
|
||||
|
||||
def test_disabled_form_validator_returns_content_unchanged(self):
|
||||
"""If the form attribute is None on FormValidatorMixin then validate(content) should just return the content unmodified."""
|
||||
class DisabledFormValidator(FormValidatorMixin):
|
||||
"""If the view's form attribute is None then FormValidator(view).validate(content)
|
||||
should just return the content unmodified."""
|
||||
class DisabledFormView(object):
|
||||
form = None
|
||||
|
||||
view = DisabledFormView()
|
||||
content = {'qwerty':'uiop'}
|
||||
self.assertEqual(DisabledFormValidator().validate(content), content)
|
||||
self.assertEqual(FormValidator(view).validate(content), content)
|
||||
|
||||
def test_disabled_form_validator_get_bound_form_returns_none(self):
|
||||
"""If the form attribute is None on FormValidatorMixin then get_bound_form(content) should just return None."""
|
||||
class DisabledFormValidator(FormValidatorMixin):
|
||||
"""If the view's form attribute is None on then
|
||||
FormValidator(view).get_bound_form(content) should just return None."""
|
||||
class DisabledFormView(object):
|
||||
form = None
|
||||
|
||||
view = DisabledFormView()
|
||||
content = {'qwerty':'uiop'}
|
||||
self.assertEqual(DisabledFormValidator().get_bound_form(content), None)
|
||||
self.assertEqual(FormValidator(view).get_bound_form(content), None)
|
||||
|
||||
|
||||
def test_disabled_model_form_validator_returns_content_unchanged(self):
|
||||
"""If the form attribute is None on FormValidatorMixin then validate(content) should just return the content unmodified."""
|
||||
class DisabledModelFormValidator(ModelFormValidatorMixin):
|
||||
"""If the view's form and model attributes are None then
|
||||
ModelFormValidator(view).validate(content) should just return the content unmodified."""
|
||||
class DisabledModelFormView(object):
|
||||
form = None
|
||||
model = None
|
||||
|
||||
view = DisabledModelFormView()
|
||||
content = {'qwerty':'uiop'}
|
||||
self.assertEqual(DisabledModelFormValidator().validate(content), content)
|
||||
self.assertEqual(ModelFormValidator(view).get_bound_form(content), None)#
|
||||
|
||||
def test_disabled_model_form_validator_get_bound_form_returns_none(self):
|
||||
"""If the form attribute is None on FormValidatorMixin then get_bound_form(content) should just return None."""
|
||||
class DisabledModelFormValidator(ModelFormValidatorMixin):
|
||||
class DisabledModelFormView(object):
|
||||
form = None
|
||||
model = None
|
||||
|
||||
view = DisabledModelFormView()
|
||||
content = {'qwerty':'uiop'}
|
||||
self.assertEqual(DisabledModelFormValidator().get_bound_form(content), None)
|
||||
|
||||
self.assertEqual(ModelFormValidator(view).get_bound_form(content), None)#
|
||||
|
||||
class TestNonFieldErrors(TestCase):
|
||||
"""Tests against form validation errors caused by non-field errors. (eg as might be caused by some custom form validation)"""
|
||||
|
|
@ -80,12 +89,13 @@ class TestNonFieldErrors(TestCase):
|
|||
raise forms.ValidationError(self.ERROR_TEXT)
|
||||
return self.cleaned_data #pragma: no cover
|
||||
|
||||
class MockValidator(FormValidatorMixin):
|
||||
class MockView(object):
|
||||
form = MockForm
|
||||
|
||||
view = MockView()
|
||||
content = {'field1': 'example1', 'field2': 'example2'}
|
||||
try:
|
||||
MockValidator().validate(content)
|
||||
FormValidator(view).validate(content)
|
||||
except ResponseException, exc:
|
||||
self.assertEqual(exc.response.raw_content, {'errors': [MockForm.ERROR_TEXT]})
|
||||
else:
|
||||
|
|
@ -95,19 +105,21 @@ class TestNonFieldErrors(TestCase):
|
|||
class TestFormValidation(TestCase):
|
||||
"""Tests which check basic form validation.
|
||||
Also includes the same set of tests with a ModelFormValidator for which the form has been explicitly set.
|
||||
(ModelFormValidatorMixin should behave as FormValidatorMixin if form is set rather than relying on the default ModelForm)"""
|
||||
(ModelFormValidator should behave as FormValidator if a form is set rather than relying on the default ModelForm)"""
|
||||
def setUp(self):
|
||||
class MockForm(forms.Form):
|
||||
qwerty = forms.CharField(required=True)
|
||||
|
||||
class MockFormValidator(FormValidatorMixin):
|
||||
class MockFormView(object):
|
||||
form = MockForm
|
||||
validators = (FormValidator,)
|
||||
|
||||
class MockModelFormValidator(ModelFormValidatorMixin):
|
||||
class MockModelFormView(object):
|
||||
form = MockForm
|
||||
validators = (ModelFormValidator,)
|
||||
|
||||
self.MockFormValidator = MockFormValidator
|
||||
self.MockModelFormValidator = MockModelFormValidator
|
||||
self.MockFormView = MockFormView
|
||||
self.MockModelFormView = MockModelFormView
|
||||
|
||||
|
||||
def validation_returns_content_unchanged_if_already_valid_and_clean(self, validator):
|
||||
|
|
@ -181,111 +193,129 @@ class TestFormValidation(TestCase):
|
|||
# Tests on FormValidtionMixin
|
||||
|
||||
def test_form_validation_returns_content_unchanged_if_already_valid_and_clean(self):
|
||||
self.validation_returns_content_unchanged_if_already_valid_and_clean(self.MockFormValidator())
|
||||
validator = FormValidator(self.MockFormView())
|
||||
self.validation_returns_content_unchanged_if_already_valid_and_clean(validator)
|
||||
|
||||
def test_form_validation_failure_raises_response_exception(self):
|
||||
self.validation_failure_raises_response_exception(self.MockFormValidator())
|
||||
validator = FormValidator(self.MockFormView())
|
||||
self.validation_failure_raises_response_exception(validator)
|
||||
|
||||
def test_validation_does_not_allow_extra_fields_by_default(self):
|
||||
self.validation_does_not_allow_extra_fields_by_default(self.MockFormValidator())
|
||||
validator = FormValidator(self.MockFormView())
|
||||
self.validation_does_not_allow_extra_fields_by_default(validator)
|
||||
|
||||
def test_validation_allows_extra_fields_if_explicitly_set(self):
|
||||
self.validation_allows_extra_fields_if_explicitly_set(self.MockFormValidator())
|
||||
validator = FormValidator(self.MockFormView())
|
||||
self.validation_allows_extra_fields_if_explicitly_set(validator)
|
||||
|
||||
def test_validation_does_not_require_extra_fields_if_explicitly_set(self):
|
||||
self.validation_does_not_require_extra_fields_if_explicitly_set(self.MockFormValidator())
|
||||
validator = FormValidator(self.MockFormView())
|
||||
self.validation_does_not_require_extra_fields_if_explicitly_set(validator)
|
||||
|
||||
def test_validation_failed_due_to_no_content_returns_appropriate_message(self):
|
||||
self.validation_failed_due_to_no_content_returns_appropriate_message(self.MockFormValidator())
|
||||
validator = FormValidator(self.MockFormView())
|
||||
self.validation_failed_due_to_no_content_returns_appropriate_message(validator)
|
||||
|
||||
def test_validation_failed_due_to_field_error_returns_appropriate_message(self):
|
||||
self.validation_failed_due_to_field_error_returns_appropriate_message(self.MockFormValidator())
|
||||
validator = FormValidator(self.MockFormView())
|
||||
self.validation_failed_due_to_field_error_returns_appropriate_message(validator)
|
||||
|
||||
def test_validation_failed_due_to_invalid_field_returns_appropriate_message(self):
|
||||
self.validation_failed_due_to_invalid_field_returns_appropriate_message(self.MockFormValidator())
|
||||
validator = FormValidator(self.MockFormView())
|
||||
self.validation_failed_due_to_invalid_field_returns_appropriate_message(validator)
|
||||
|
||||
def test_validation_failed_due_to_multiple_errors_returns_appropriate_message(self):
|
||||
self.validation_failed_due_to_multiple_errors_returns_appropriate_message(self.MockFormValidator())
|
||||
validator = FormValidator(self.MockFormView())
|
||||
self.validation_failed_due_to_multiple_errors_returns_appropriate_message(validator)
|
||||
|
||||
# Same tests on ModelFormValidtionMixin
|
||||
|
||||
def test_modelform_validation_returns_content_unchanged_if_already_valid_and_clean(self):
|
||||
self.validation_returns_content_unchanged_if_already_valid_and_clean(self.MockModelFormValidator())
|
||||
validator = ModelFormValidator(self.MockModelFormView())
|
||||
self.validation_returns_content_unchanged_if_already_valid_and_clean(validator)
|
||||
|
||||
def test_modelform_validation_failure_raises_response_exception(self):
|
||||
self.validation_failure_raises_response_exception(self.MockModelFormValidator())
|
||||
validator = ModelFormValidator(self.MockModelFormView())
|
||||
self.validation_failure_raises_response_exception(validator)
|
||||
|
||||
def test_modelform_validation_does_not_allow_extra_fields_by_default(self):
|
||||
self.validation_does_not_allow_extra_fields_by_default(self.MockModelFormValidator())
|
||||
validator = ModelFormValidator(self.MockModelFormView())
|
||||
self.validation_does_not_allow_extra_fields_by_default(validator)
|
||||
|
||||
def test_modelform_validation_allows_extra_fields_if_explicitly_set(self):
|
||||
self.validation_allows_extra_fields_if_explicitly_set(self.MockModelFormValidator())
|
||||
validator = ModelFormValidator(self.MockModelFormView())
|
||||
self.validation_allows_extra_fields_if_explicitly_set(validator)
|
||||
|
||||
def test_modelform_validation_does_not_require_extra_fields_if_explicitly_set(self):
|
||||
self.validation_does_not_require_extra_fields_if_explicitly_set(self.MockModelFormValidator())
|
||||
validator = ModelFormValidator(self.MockModelFormView())
|
||||
self.validation_does_not_require_extra_fields_if_explicitly_set(validator)
|
||||
|
||||
def test_modelform_validation_failed_due_to_no_content_returns_appropriate_message(self):
|
||||
self.validation_failed_due_to_no_content_returns_appropriate_message(self.MockModelFormValidator())
|
||||
validator = ModelFormValidator(self.MockModelFormView())
|
||||
self.validation_failed_due_to_no_content_returns_appropriate_message(validator)
|
||||
|
||||
def test_modelform_validation_failed_due_to_field_error_returns_appropriate_message(self):
|
||||
self.validation_failed_due_to_field_error_returns_appropriate_message(self.MockModelFormValidator())
|
||||
validator = ModelFormValidator(self.MockModelFormView())
|
||||
self.validation_failed_due_to_field_error_returns_appropriate_message(validator)
|
||||
|
||||
def test_modelform_validation_failed_due_to_invalid_field_returns_appropriate_message(self):
|
||||
self.validation_failed_due_to_invalid_field_returns_appropriate_message(self.MockModelFormValidator())
|
||||
validator = ModelFormValidator(self.MockModelFormView())
|
||||
self.validation_failed_due_to_invalid_field_returns_appropriate_message(validator)
|
||||
|
||||
def test_modelform_validation_failed_due_to_multiple_errors_returns_appropriate_message(self):
|
||||
self.validation_failed_due_to_multiple_errors_returns_appropriate_message(self.MockModelFormValidator())
|
||||
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))
|
||||
# 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))
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -4,25 +4,31 @@ from django.db import models
|
|||
from djangorestframework.response import ResponseException
|
||||
from djangorestframework.utils import as_tuple
|
||||
|
||||
class ValidatorMixin(object):
|
||||
"""Base class for all ValidatorMixin classes, which simply defines the interface they provide."""
|
||||
|
||||
class BaseValidator(object):
|
||||
"""Base class for all Validator classes, which simply defines the interface they provide."""
|
||||
|
||||
def __init__(self, view):
|
||||
self.view = view
|
||||
|
||||
def validate(self, content):
|
||||
"""Given some content as input return some cleaned, validated content.
|
||||
Raises a ResponseException with status code 400 (Bad Request) on failure.
|
||||
Typically raises a ResponseException with status code 400 (Bad Request) on failure.
|
||||
|
||||
Must be overridden to be implemented."""
|
||||
raise NotImplementedError()
|
||||
|
||||
|
||||
class FormValidatorMixin(ValidatorMixin):
|
||||
"""Validator Mixin that uses forms for validation.
|
||||
Extends the ValidatorMixin interface to also provide a get_bound_form() method.
|
||||
(Which may be used by some emitters.)"""
|
||||
class FormValidator(BaseValidator):
|
||||
"""Validator class that uses forms for validation.
|
||||
Also provides a get_bound_form() method which may be used by some renderers.
|
||||
|
||||
The view class should provide `.form` attribute which specifies the form classmethod
|
||||
to be used for validation.
|
||||
|
||||
On calling validate() this validator may set a `.bound_form_instance` attribute on the
|
||||
view, which may be used by some renderers."""
|
||||
|
||||
"""The form class that should be used for validation, or None to turn off form validation."""
|
||||
form = None
|
||||
bound_form_instance = None
|
||||
|
||||
def validate(self, content):
|
||||
"""Given some content as input return some cleaned, validated content.
|
||||
|
|
@ -44,7 +50,7 @@ class FormValidatorMixin(ValidatorMixin):
|
|||
if bound_form is None:
|
||||
return content
|
||||
|
||||
self.bound_form_instance = bound_form
|
||||
self.view.bound_form_instance = bound_form
|
||||
|
||||
seen_fields_set = set(content.keys())
|
||||
form_fields_set = set(bound_form.fields.keys())
|
||||
|
|
@ -78,7 +84,10 @@ class FormValidatorMixin(ValidatorMixin):
|
|||
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('__'))
|
||||
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:
|
||||
|
|
@ -94,20 +103,21 @@ class FormValidatorMixin(ValidatorMixin):
|
|||
def get_bound_form(self, content=None):
|
||||
"""Given some content return a Django form bound to that content.
|
||||
If form validation is turned off (form class attribute is None) then returns None."""
|
||||
if not self.form:
|
||||
form_cls = getattr(self.view, 'form', None)
|
||||
|
||||
if not form_cls:
|
||||
return None
|
||||
|
||||
if not content is None:
|
||||
if content is not None:
|
||||
if hasattr(content, 'FILES'):
|
||||
return self.form(content, content.FILES)
|
||||
return self.form(content)
|
||||
return self.form()
|
||||
return form_cls(content, content.FILES)
|
||||
return form_cls(content)
|
||||
return form_cls()
|
||||
|
||||
|
||||
class ModelFormValidatorMixin(FormValidatorMixin):
|
||||
"""Validator Mixin that uses forms for validation and falls back to a model form if no form is set.
|
||||
Extends the ValidatorMixin interface to also provide a get_bound_form() method.
|
||||
(Which may be used by some emitters.)"""
|
||||
class ModelFormValidator(FormValidator):
|
||||
"""Validator class that uses forms for validation and otherwise falls back to a model form if no form is set.
|
||||
Also provides a get_bound_form() method which may be used by some renderers."""
|
||||
|
||||
"""The form class that should be used for validation, or None to use model form validation."""
|
||||
form = None
|
||||
|
|
@ -148,15 +158,18 @@ class ModelFormValidatorMixin(FormValidatorMixin):
|
|||
If the form class attribute has been explicitly set then use that class to create a Form,
|
||||
otherwise if model is set use that class to create a ModelForm, otherwise return None."""
|
||||
|
||||
if self.form:
|
||||
# Use explict Form
|
||||
return super(ModelFormValidatorMixin, self).get_bound_form(content)
|
||||
form_cls = getattr(self.view, 'form', None)
|
||||
model_cls = getattr(self.view, 'model', None)
|
||||
|
||||
elif self.model:
|
||||
if form_cls:
|
||||
# Use explict Form
|
||||
return super(ModelFormValidator, self).get_bound_form(content)
|
||||
|
||||
elif model_cls:
|
||||
# Fall back to ModelForm which we create on the fly
|
||||
class OnTheFlyModelForm(forms.ModelForm):
|
||||
class Meta:
|
||||
model = self.model
|
||||
model = model_cls
|
||||
#fields = tuple(self._model_fields_set)
|
||||
|
||||
# Instantiate the ModelForm as appropriate
|
||||
|
|
@ -176,24 +189,32 @@ class ModelFormValidatorMixin(FormValidatorMixin):
|
|||
@property
|
||||
def _model_fields_set(self):
|
||||
"""Return a set containing the names of validated fields on the model."""
|
||||
model_fields = set(field.name for field in self.model._meta.fields)
|
||||
model = getattr(self.view, 'model', None)
|
||||
fields = getattr(self.view, 'fields', self.fields)
|
||||
exclude_fields = getattr(self.view, 'exclude_fields', self.exclude_fields)
|
||||
|
||||
if self.fields:
|
||||
return model_fields & set(as_tuple(self.fields))
|
||||
model_fields = set(field.name for field in model._meta.fields)
|
||||
|
||||
return model_fields - set(as_tuple(self.exclude_fields))
|
||||
if fields:
|
||||
return model_fields & set(as_tuple(fields))
|
||||
|
||||
return model_fields - set(as_tuple(exclude_fields))
|
||||
|
||||
@property
|
||||
def _property_fields_set(self):
|
||||
"""Returns a set containing the names of validated properties on the model."""
|
||||
property_fields = set(attr for attr in dir(self.model) if
|
||||
isinstance(getattr(self.model, attr, None), property)
|
||||
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)
|
||||
and not attr.startswith('_'))
|
||||
|
||||
if self.fields:
|
||||
return property_fields & set(as_tuple(self.fields))
|
||||
if fields:
|
||||
return property_fields & set(as_tuple(fields))
|
||||
|
||||
return property_fields - set(as_tuple(self.exclude_fields))
|
||||
return property_fields - set(as_tuple(exclude_fields))
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user