  class MockView_PerViewThrottling(MockView):
      permission_classes = (PerViewThrottling,)
  
  
  class MockView_PerResourceThrottling(MockView):
      permission_classes = (PerResourceThrottling,)
      resource = FormResource
  
  
  class MockView_MinuteThrottling(MockView):
      throttle = '3/min'
  
  
  class ThrottlingTests(TestCase):
 
</s> remove from djangorestframework.permissions import PerUserThrottling, PerViewThrottling, PerResourceThrottling
from djangorestframework.resources import FormResource
 </s> add from djangorestframework.permissions import PerUserThrottling, PerViewThrottling </s> remove         class MockView(View):
            resource = MockResource
 </s> add #     def test_disabled_form_validator_returns_content_unchanged(self):
#         """If the view's form attribute is None then FormValidator(view).validate_request(content, None)
#         should just return the content unmodified."""
#         class DisabledFormResource(FormResource):
#             form = None

#         class MockView(View):
#             resource = DisabledFormResource </s> remove         # If this view has a resource that's been overridden, then use that resource for the name
        if getattr(self, 'resource', None) not in _resource_classes:
            name = self.resource.__name__
            name = _remove_trailing_string(name, 'Resource')
            name += getattr(self, '_suffix', '')

        # If it's a view class with no resource then grok the name from the class name
        else:
            name = self.__class__.__name__
            name = _remove_trailing_string(name, 'View')

 </s> add         name = self.__class__.__name__
        name = _remove_trailing_string(name, 'View') </s> remove class TestDisabledValidations(TestCase):
    """Tests on FormValidator with validation disabled by setting form to None"""

    def test_disabled_form_validator_returns_content_unchanged(self):
        """If the view's form attribute is None then FormValidator(view).validate_request(content, None)
        should just return the content unmodified."""
        class DisabledFormResource(FormResource):
            form = None

        class MockView(View):
            resource = DisabledFormResource

        view = MockView()
        content = {'qwerty': 'uiop'}
        self.assertEqual(FormResource(view).validate_request(content, None), content)

    def test_disabled_form_validator_get_bound_form_returns_none(self):
        """If the view's form attribute is None on then
        FormValidator(view).get_bound_form(content) should just return None."""
        class DisabledFormResource(FormResource):
            form = None

        class MockView(View):
            resource = DisabledFormResource

        view = MockView()
        content = {'qwerty': 'uiop'}
        self.assertEqual(FormResource(view).get_bound_form(content), None)

    def test_disabled_model_form_validator_returns_content_unchanged(self):
        """If the view's form is None and does not have a Resource with a model set then
        ModelFormValidator(view).validate_request(content, None) should just return the content unmodified."""

        class DisabledModelFormView(View):
            resource = ModelResource

        view = DisabledModelFormView()
        content = {'qwerty': 'uiop'}
        self.assertEqual(ModelResource(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 DisabledModelFormView(View):
            resource = ModelResource

        view = DisabledModelFormView()
        content = {'qwerty': 'uiop'}
        self.assertEqual(ModelResource(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)"""

    def test_validate_failed_due_to_non_field_error_returns_appropriate_message(self):
        """If validation fails with a non-field error, ensure the response a non-field error"""
        class MockForm(forms.Form):
            field1 = forms.CharField(required=False)
            field2 = forms.CharField(required=False)
            ERROR_TEXT = 'You may not supply both field1 and field2'

            def clean(self):
                if 'field1' in self.cleaned_data and 'field2' in self.cleaned_data:
                    raise forms.ValidationError(self.ERROR_TEXT)
                return self.cleaned_data

        class MockResource(FormResource):
            form = MockForm

        class MockView(View):
            pass

        view = MockView()
        content = {'field1': 'example1', 'field2': 'example2'}
        try:
            MockResource(view).validate_request(content, None)
        except ImmediateResponse, exc:
            response = exc.response
            self.assertEqual(response.raw_content, {'errors': [MockForm.ERROR_TEXT]})
        else:
            self.fail('ImmediateResponse was not raised')


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.
    (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 MockFormResource(FormResource):
            form = MockForm

        class MockModelResource(ModelResource):
            form = MockForm

        class MockFormView(View):
            resource = MockFormResource

        class MockModelFormView(View):
            resource = MockModelResource

        self.MockFormResource = MockFormResource
        self.MockModelResource = MockModelResource
        self.MockFormView = MockFormView
        self.MockModelFormView = MockModelFormView

    def validation_returns_content_unchanged_if_already_valid_and_clean(self, validator):
        """If the content is already valid and clean then validate(content) should just return the content unmodified."""
        content = {'qwerty': 'uiop'}
        self.assertEqual(validator.validate_request(content, None), content)

    def validation_failure_raises_response_exception(self, validator):
        """If form validation fails a ResourceException 400 (Bad Request) should be raised."""
        content = {}
        self.assertRaises(ImmediateResponse, validator.validate_request, content, None)

    def validation_does_not_allow_extra_fields_by_default(self, validator):
        """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': 'uiop', 'extra': 'extra'}
        self.assertRaises(ImmediateResponse, validator.validate_request, content, None)

    def validation_allows_extra_fields_if_explicitly_set(self, validator):
        """If we include an allowed_extra_fields paramater on _validate, then allow fields with those names."""
        content = {'qwerty': 'uiop', 'extra': 'extra'}
        validator._validate(content, None, allowed_extra_fields=('extra',))

    def validation_allows_unknown_fields_if_explicitly_allowed(self, validator):
        """If we set ``unknown_form_fields`` on the form resource, then don't
        raise errors on unexpected request data"""
        content = {'qwerty': 'uiop', 'extra': 'extra'}
        validator.allow_unknown_form_fields = True
        self.assertEqual({'qwerty': u'uiop'},
                         validator.validate_request(content, None),
                         "Resource didn't accept unknown fields.")
        validator.allow_unknown_form_fields = False

    def validation_does_not_require_extra_fields_if_explicitly_set(self, validator):
        """If we include an allowed_extra_fields paramater on _validate, then do not fail if we do not have fields with those names."""
        content = {'qwerty': 'uiop'}
        self.assertEqual(validator._validate(content, None, allowed_extra_fields=('extra',)), content)

    def validation_failed_due_to_no_content_returns_appropriate_message(self, validator):
        """If validation fails due to no content, ensure the response contains a single non-field error"""
        content = {}
        try:
            validator.validate_request(content, None)
        except ImmediateResponse, exc:
            response = exc.response
            self.assertEqual(response.raw_content, {'field_errors': {'qwerty': ['This field is required.']}})
        else:
            self.fail('ResourceException was not raised')

    def validation_failed_due_to_field_error_returns_appropriate_message(self, validator):
        """If validation fails due to a field error, ensure the response contains a single field error"""
        content = {'qwerty': ''}
        try:
            validator.validate_request(content, None)
        except ImmediateResponse, exc:
            response = exc.response
            self.assertEqual(response.raw_content, {'field_errors': {'qwerty': ['This field is required.']}})
        else:
            self.fail('ResourceException was not raised')

    def validation_failed_due_to_invalid_field_returns_appropriate_message(self, validator):
        """If validation fails due to an invalid field, ensure the response contains a single field error"""
        content = {'qwerty': 'uiop', 'extra': 'extra'}
        try:
            validator.validate_request(content, None)
        except ImmediateResponse, exc:
            response = exc.response
            self.assertEqual(response.raw_content, {'field_errors': {'extra': ['This field does not exist.']}})
        else:
            self.fail('ResourceException was not raised')

    def validation_failed_due_to_multiple_errors_returns_appropriate_message(self, validator):
        """If validation for multiple reasons, ensure the response contains each error"""
        content = {'qwerty': '', 'extra': 'extra'}
        try:
            validator.validate_request(content, None)
        except ImmediateResponse, exc:
            response = exc.response
            self.assertEqual(response.raw_content, {'field_errors': {'qwerty': ['This field is required.'],
                                                                         'extra': ['This field does not exist.']}})
        else:
            self.fail('ResourceException was not raised')

    # Tests on FormResource

    def test_form_validation_returns_content_unchanged_if_already_valid_and_clean(self):
        validator = self.MockFormResource(self.MockFormView())
        self.validation_returns_content_unchanged_if_already_valid_and_clean(validator)

    def test_form_validation_failure_raises_response_exception(self):
        validator = self.MockFormResource(self.MockFormView())
        self.validation_failure_raises_response_exception(validator)

    def test_validation_does_not_allow_extra_fields_by_default(self):
        validator = self.MockFormResource(self.MockFormView())
        self.validation_does_not_allow_extra_fields_by_default(validator)

    def test_validation_allows_extra_fields_if_explicitly_set(self):
        validator = self.MockFormResource(self.MockFormView())
        self.validation_allows_extra_fields_if_explicitly_set(validator)

    def test_validation_allows_unknown_fields_if_explicitly_allowed(self):
        validator = self.MockFormResource(self.MockFormView())
        self.validation_allows_unknown_fields_if_explicitly_allowed(validator)

    def test_validation_does_not_require_extra_fields_if_explicitly_set(self):
        validator = self.MockFormResource(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):
        validator = self.MockFormResource(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):
        validator = self.MockFormResource(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):
        validator = self.MockFormResource(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):
        validator = self.MockFormResource(self.MockFormView())
        self.validation_failed_due_to_multiple_errors_returns_appropriate_message(validator)

    # Same tests on ModelResource

    def test_modelform_validation_returns_content_unchanged_if_already_valid_and_clean(self):
        validator = self.MockModelResource(self.MockModelFormView())
        self.validation_returns_content_unchanged_if_already_valid_and_clean(validator)

    def test_modelform_validation_failure_raises_response_exception(self):
        validator = self.MockModelResource(self.MockModelFormView())
        self.validation_failure_raises_response_exception(validator)

    def test_modelform_validation_does_not_allow_extra_fields_by_default(self):
        validator = self.MockModelResource(self.MockModelFormView())
        self.validation_does_not_allow_extra_fields_by_default(validator)

    def test_modelform_validation_allows_extra_fields_if_explicitly_set(self):
        validator = self.MockModelResource(self.MockModelFormView())
        self.validation_allows_extra_fields_if_explicitly_set(validator)

    def test_modelform_validation_does_not_require_extra_fields_if_explicitly_set(self):
        validator = self.MockModelResource(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):
        validator = self.MockModelResource(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):
        validator = self.MockModelResource(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):
        validator = self.MockModelResource(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):
        validator = self.MockModelResource(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 MockResource(ModelResource):
            model = MockModel
 </s> add # class TestDisabledValidations(TestCase):
#     """Tests on FormValidator with validation disabled by setting form to None""" </s> remove class UserForm(ModelForm):
    class Meta:
        model = User
        exclude = ('last_login', 'date_joined')
 </s> add # class UserForm(ModelForm):
#     class Meta:
#         model = User
#         exclude = ('last_login', 'date_joined')
  class MockView_PerViewThrottling(MockView):
      permission_classes = (PerViewThrottling,)
  
  





  class MockView_MinuteThrottling(MockView):
      throttle = '3/min'
  
  
  class ThrottlingTests(TestCase):
keep keep keep keep replace replace replace replace replace keep keep keep keep keep
 Drop out resources & mixins 
djangorestframework/tests/throttling.py