aboutsummaryrefslogtreecommitdiffstats
path: root/docs/src/callback.js
blob: aaf69cde785752c2e3bace5b63433852e708b718 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
function noop(){}

function chain(delegateFn, explicitDone){
  var onDoneFn = noop;
  var onErrorFn = function(e){
    console.error(e.stack || e);
    process.exit(-1);
  };
  var waitForCount = 1;
  delegateFn = delegateFn || noop;
  var stackError = new Error('capture stack');

  function decrementWaitFor() {
    waitForCount--;
    if (waitForCount == 0)
      onDoneFn();
  }

  function self(){
    try {
      return delegateFn.apply(self, arguments);
    } catch (error) {
      self.error(error);
    } finally {
      if (!explicitDone)
        decrementWaitFor();
    }
  };
  self.onDone = function(callback){
    onDoneFn = callback;
    return self;
  };
  self.from __future__ import unicode_literals
from django.core.validators import MaxValueValidator
from django.db import models
from django.test import TestCase
from rest_framework import exceptions, generics, serializers, status
from rest_framework.test import APIRequestFactory

factory = APIRequestFactory()


# Regression for #666

class ValidationModel(models.Model):
    blank_validated_field = models.CharField(max_length=255)


class ValidationModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = ValidationModel
        fields = ('blank_validated_field',)
        read_only_fields = ('blank_validated_field',)


class UpdateValidationModel(generics.RetrieveUpdateDestroyAPIView):
    queryset = ValidationModel.objects.all()
    serializer_class = ValidationModelSerializer


# Regression for #653

class ShouldValidateModel(models.Model):
    should_validate_field = models.CharField(max_length=255)


class ShouldValidateModelSerializer(serializers.ModelSerializer):
    renamed = serializers.CharField(source='should_validate_field', required=False)

    def validate_renamed(self, value):
        if len(value) < 3:
            raise exceptions.ValidationFailed('Minimum 3 characters.')
        return value

    class Meta:
        model = ShouldValidateModel
        fields = ('renamed',)


class TestPreSaveValidationExclusionsSerializer(TestCase
with 'source' applied do get still get model validation. """ # We've set `required=False` on the serializer, but the model # does not have `blank=True`, so this serializer should not validate. serializer = ShouldValidateModelSerializer(data={'renamed': ''}) self.assertEqual(serializer.is_valid(), False) self.assertIn('renamed', serializer.errors) self.assertNotIn('should_validate_field', serializer.errors) class TestCustomValidationMethods(TestCase): def test_custom_validation_method_is_executed(self): serializer = ShouldValidateModelSerializer(data={'renamed': 'fo'}) self.assertFalse(serializer.is_valid()) self.assertIn('renamed', serializer.errors) def test_custom_validation_method_passing(self): serializer = ShouldValidateModelSerializer(data={'renamed': 'foo'}) self.assertTrue(serializer.is_valid()) class ValidationSerializer(serializers.Serializer): foo = serializers.CharField() def validate_foo(self, attrs, source): raise exceptions.ValidationFailed("foo invalid") def validate(self, attrs): raise exceptions.ValidationFailed("serializer invalid") class TestAvoidValidation(TestCase): """ If serializer was initialized with invalid data (None or non dict-like), it should avoid validation layer (validate_<field> and validate methods) """ def test_serializer_errors_has_only_invalid_data_error(self): serializer = ValidationSerializer(data='invalid data') self.assertFalse(serializer.is_valid()) self.assertDictEqual(serializer.errors, {'non_field_errors': ['Invalid data']}) # regression tests for issue: 1493 class ValidationMaxValueValidatorModel(models.Model): number_value = models.PositiveIntegerField(validators=[MaxValueValidator(100)]) class ValidationMaxValueValidatorModelSerializer(serializers.ModelSerializer): class Meta: model = ValidationMaxValueValidatorModel class UpdateMaxValueValidationModel(generics.RetrieveUpdateDestroyAPIView): queryset = ValidationMaxValueValidatorModel.objects.all() serializer_class = ValidationMaxValueValidatorModelSerializer class TestMaxValueValidatorValidation(TestCase): def test_max_value_validation_serializer_success(self): serializer = ValidationMaxValueValidatorModelSerializer(data={'number_value': 99}) self.assertTrue(serializer.is_valid()) def test_max_value_validation_serializer_fails(self): serializer = ValidationMaxValueValidatorModelSerializer(data={'number_value': 101}) self.assertFalse(serializer.is_valid()) self.assertDictEqual({'number_value': ['Ensure this value is less than or equal to 100.']}, serializer.errors) def test_max_value_validation_success(self): obj = ValidationMaxValueValidatorModel.objects.create(number_value=100) request = factory.patch('/{0}'.format(obj.pk), {'number_value': 98}, format='json') view = UpdateMaxValueValidationModel().as_view() response = view(request, pk=obj.pk).render() self.assertEqual(response.status_code, status.HTTP_200_OK) def test_max_value_validation_fail(self): obj = ValidationMaxValueValidatorModel.objects.create(number_value=100) request = factory.patch('/{0}'.format(obj.pk), {'number_value': 101}, format='json') view = UpdateMaxValueValidationModel().as_view() response = view(request, pk=obj.pk).render() self.assertEqual(response.content, b'{"number_value":["Ensure this value is less than or equal to 100."]}') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) class TestChoiceFieldChoicesValidate(TestCase): CHOICES = [ (0, 'Small'), (1, 'Medium'), (2, 'Large'), ] CHOICES_NESTED = [ ('Category', ( (1, 'First'), (2, 'Second'), (3, 'Third'), )), (4, 'Fourth'), ] def test_choices(self): """ Make sure a value for choices works as expected. """ f = serializers.ChoiceField(choices=self.CHOICES) value = self.CHOICES[0][0] try: f.to_internal_value(value) except exceptions.ValidationFailed: self.fail("Value %s does not validate" % str(value)) # def test_nested_choices(self): # """ # Make sure a nested value for choices works as expected. # """ # f = serializers.ChoiceField(choices=self.CHOICES_NESTED) # value = self.CHOICES_NESTED[0][1][0][0] # try: # f.to_native(value) # except ValidationError: # self.fail("Value %s does not validate" % str(value))