diff options
Diffstat (limited to 'tests')
34 files changed, 7201 insertions, 6362 deletions
diff --git a/tests/models.py b/tests/models.py index fe064b46..06ec5a22 100644 --- a/tests/models.py +++ b/tests/models.py @@ -1,7 +1,6 @@ from __future__ import unicode_literals from django.db import models from django.utils.translation import ugettext_lazy as _ -from rest_framework import serializers def foobar(): @@ -178,9 +177,3 @@ class NullableOneToOneSource(RESTFrameworkModel): name = models.CharField(max_length=100) target = models.OneToOneField(OneToOneTarget, null=True, blank=True, related_name='nullable_source') - - -# Serializer used to test BasicModel -class BasicModelSerializer(serializers.ModelSerializer): - class Meta: - model = BasicModel diff --git a/tests/put_as_create_workspace.txt b/tests/put_as_create_workspace.txt new file mode 100644 index 00000000..6bc5218e --- /dev/null +++ b/tests/put_as_create_workspace.txt @@ -0,0 +1,33 @@ +# From test_validation... + +class TestPreSaveValidationExclusions(TestCase): + def test_pre_save_validation_exclusions(self): + """ + Somewhat weird test case to ensure that we don't perform model + validation on read only fields. + """ + obj = ValidationModel.objects.create(blank_validated_field='') + request = factory.put('/', {}, format='json') + view = UpdateValidationModel().as_view() + response = view(request, pk=obj.pk).render() + self.assertEqual(response.status_code, status.HTTP_200_OK) + + +# From test_permissions... + +class ModelPermissionsIntegrationTests(TestCase): + def setUp(...): + ... + + def test_has_put_as_create_permissions(self): + # User only has update permissions - should be able to update an entity. + request = factory.put('/1', {'text': 'foobar'}, format='json', + HTTP_AUTHORIZATION=self.updateonly_credentials) + response = instance_view(request, pk='1') + self.assertEqual(response.status_code, status.HTTP_200_OK) + + # But if PUTing to a new entity, permission should be denied. + request = factory.put('/2', {'text': 'foobar'}, format='json', + HTTP_AUTHORIZATION=self.updateonly_credentials) + response = instance_view(request, pk='2') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) diff --git a/tests/serializers.py b/tests/serializers.py deleted file mode 100644 index be7b3772..00000000 --- a/tests/serializers.py +++ /dev/null @@ -1,7 +0,0 @@ -from rest_framework import serializers -from tests.models import NullableForeignKeySource - - -class NullableFKSourceSerializer(serializers.ModelSerializer): - class Meta: - model = NullableForeignKeySource diff --git a/tests/test_description.py b/tests/test_description.py index 1e481f06..0675d209 100644 --- a/tests/test_description.py +++ b/tests/test_description.py @@ -98,6 +98,30 @@ class TestViewNamesAndDescriptions(TestCase): pass self.assertEqual(MockView().get_view_description(), '') + def test_view_description_can_be_promise(self): + """ + Ensure a view may have a docstring that is actually a lazily evaluated + class that can be converted to a string. + + See: https://github.com/tomchristie/django-rest-framework/issues/1708 + """ + # use a mock object instead of gettext_lazy to ensure that we can't end + # up with a test case string in our l10n catalog + class MockLazyStr(object): + def __init__(self, string): + self.s = string + + def __str__(self): + return self.s + + def __unicode__(self): + return self.s + + class MockView(APIView): + __doc__ = MockLazyStr("a gettext string") + + self.assertEqual(MockView().get_view_description(), 'a gettext string') + def test_markdown(self): """ Ensure markdown to HTML works as expected. diff --git a/tests/test_fields.py b/tests/test_fields.py index 0ddbe48b..a92fafbc 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -1,1034 +1,1042 @@ -""" -General serializer field tests. -""" -from __future__ import unicode_literals +# """ +# General serializer field tests. +# """ +# from __future__ import unicode_literals -import datetime -import re -from decimal import Decimal -from uuid import uuid4 -from django.core import validators -from django.db import models -from django.test import TestCase -from django.utils.datastructures import SortedDict -from rest_framework import serializers -from tests.models import RESTFrameworkModel +# import datetime +# import re +# from decimal import Decimal +# from uuid import uuid4 +# from django.core import validators +# from django.db import models +# from django.test import TestCase +# from django.utils.datastructures import SortedDict +# from rest_framework import serializers +# from tests.models import RESTFrameworkModel -class TimestampedModel(models.Model): - added = models.DateTimeField(auto_now_add=True) - updated = models.DateTimeField(auto_now=True) +# class TimestampedModel(models.Model): +# added = models.DateTimeField(auto_now_add=True) +# updated = models.DateTimeField(auto_now=True) -class CharPrimaryKeyModel(models.Model): - id = models.CharField(max_length=20, primary_key=True) +# class CharPrimaryKeyModel(models.Model): +# id = models.CharField(max_length=20, primary_key=True) -class TimestampedModelSerializer(serializers.ModelSerializer): - class Meta: - model = TimestampedModel +# class TimestampedModelSerializer(serializers.ModelSerializer): +# class Meta: +# model = TimestampedModel -class CharPrimaryKeyModelSerializer(serializers.ModelSerializer): - class Meta: - model = CharPrimaryKeyModel +# class CharPrimaryKeyModelSerializer(serializers.ModelSerializer): +# class Meta: +# model = CharPrimaryKeyModel -class TimeFieldModel(models.Model): - clock = models.TimeField() +# class TimeFieldModel(models.Model): +# clock = models.TimeField() -class TimeFieldModelSerializer(serializers.ModelSerializer): - class Meta: - model = TimeFieldModel +# class TimeFieldModelSerializer(serializers.ModelSerializer): +# class Meta: +# model = TimeFieldModel -SAMPLE_CHOICES = [ - ('red', 'Red'), - ('green', 'Green'), - ('blue', 'Blue'), -] +# SAMPLE_CHOICES = [ +# ('red', 'Red'), +# ('green', 'Green'), +# ('blue', 'Blue'), +# ] -class ChoiceFieldModel(models.Model): - choice = models.CharField(choices=SAMPLE_CHOICES, blank=True, max_length=255) +# class ChoiceFieldModel(models.Model): +# choice = models.CharField(choices=SAMPLE_CHOICES, blank=True, max_length=255) -class ChoiceFieldModelSerializer(serializers.ModelSerializer): - class Meta: - model = ChoiceFieldModel - - -class ChoiceFieldModelWithNull(models.Model): - choice = models.CharField(choices=SAMPLE_CHOICES, blank=True, null=True, max_length=255) - - -class ChoiceFieldModelWithNullSerializer(serializers.ModelSerializer): - class Meta: - model = ChoiceFieldModelWithNull - - -class BasicFieldTests(TestCase): - def test_auto_now_fields_read_only(self): - """ - auto_now and auto_now_add fields should be read_only by default. - """ - serializer = TimestampedModelSerializer() - self.assertEqual(serializer.fields['added'].read_only, True) - - def test_auto_pk_fields_read_only(self): - """ - AutoField fields should be read_only by default. - """ - serializer = TimestampedModelSerializer() - self.assertEqual(serializer.fields['id'].read_only, True) - - def test_non_auto_pk_fields_not_read_only(self): - """ - PK fields other than AutoField fields should not be read_only by default. - """ - serializer = CharPrimaryKeyModelSerializer() - self.assertEqual(serializer.fields['id'].read_only, False) - - def test_dict_field_ordering(self): - """ - Field should preserve dictionary ordering, if it exists. - See: https://github.com/tomchristie/django-rest-framework/issues/832 - """ - ret = SortedDict() - ret['c'] = 1 - ret['b'] = 1 - ret['a'] = 1 - ret['z'] = 1 - field = serializers.Field() - keys = list(field.to_native(ret).keys()) - self.assertEqual(keys, ['c', 'b', 'a', 'z']) - - def test_widget_html_attributes(self): - """ - Make sure widget_html() renders the correct attributes - """ - r = re.compile('(\S+)=["\']?((?:.(?!["\']?\s+(?:\S+)=|[>"\']))+.)["\']?') - form = TimeFieldModelSerializer().data - attributes = r.findall(form.fields['clock'].widget_html()) - self.assertIn(('name', 'clock'), attributes) - self.assertIn(('id', 'clock'), attributes) +# class ChoiceFieldModelSerializer(serializers.ModelSerializer): +# class Meta: +# model = ChoiceFieldModel + + +# class ChoiceFieldModelWithNull(models.Model): +# choice = models.CharField(choices=SAMPLE_CHOICES, blank=True, null=True, max_length=255) + + +# class ChoiceFieldModelWithNullSerializer(serializers.ModelSerializer): +# class Meta: +# model = ChoiceFieldModelWithNull + + +# class BasicFieldTests(TestCase): +# def test_auto_now_fields_read_only(self): +# """ +# auto_now and auto_now_add fields should be read_only by default. +# """ +# serializer = TimestampedModelSerializer() +# self.assertEqual(serializer.fields['added'].read_only, True) + +# def test_auto_pk_fields_read_only(self): +# """ +# AutoField fields should be read_only by default. +# """ +# serializer = TimestampedModelSerializer() +# self.assertEqual(serializer.fields['id'].read_only, True) + +# def test_non_auto_pk_fields_not_read_only(self): +# """ +# PK fields other than AutoField fields should not be read_only by default. +# """ +# serializer = CharPrimaryKeyModelSerializer() +# self.assertEqual(serializer.fields['id'].read_only, False) + +# def test_dict_field_ordering(self): +# """ +# Field should preserve dictionary ordering, if it exists. +# See: https://github.com/tomchristie/django-rest-framework/issues/832 +# """ +# ret = SortedDict() +# ret['c'] = 1 +# ret['b'] = 1 +# ret['a'] = 1 +# ret['z'] = 1 +# field = serializers.Field() +# keys = list(field.to_native(ret).keys()) +# self.assertEqual(keys, ['c', 'b', 'a', 'z']) + +# def test_widget_html_attributes(self): +# """ +# Make sure widget_html() renders the correct attributes +# """ +# r = re.compile('(\S+)=["\']?((?:.(?!["\']?\s+(?:\S+)=|[>"\']))+.)["\']?') +# form = TimeFieldModelSerializer().data +# attributes = r.findall(form.fields['clock'].widget_html()) +# self.assertIn(('name', 'clock'), attributes) +# self.assertIn(('id', 'clock'), attributes) -class DateFieldTest(TestCase): - """ - Tests for the DateFieldTest from_native() and to_native() behavior - """ - - def test_from_native_string(self): - """ - Make sure from_native() accepts default iso input formats. - """ - f = serializers.DateField() - result_1 = f.from_native('1984-07-31') - - self.assertEqual(datetime.date(1984, 7, 31), result_1) - - def test_from_native_datetime_date(self): - """ - Make sure from_native() accepts a datetime.date instance. - """ - f = serializers.DateField() - result_1 = f.from_native(datetime.date(1984, 7, 31)) - - self.assertEqual(result_1, datetime.date(1984, 7, 31)) - - def test_from_native_custom_format(self): - """ - Make sure from_native() accepts custom input formats. - """ - f = serializers.DateField(input_formats=['%Y -- %d']) - result = f.from_native('1984 -- 31') - - self.assertEqual(datetime.date(1984, 1, 31), result) - - def test_from_native_invalid_default_on_custom_format(self): - """ - Make sure from_native() don't accept default formats if custom format is preset - """ - f = serializers.DateField(input_formats=['%Y -- %d']) - - try: - f.from_native('1984-07-31') - except validators.ValidationError as e: - self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY -- DD"]) - else: - self.fail("ValidationError was not properly raised") - - def test_from_native_empty(self): - """ - Make sure from_native() returns None on empty param. - """ - f = serializers.DateField() - result = f.from_native('') - - self.assertEqual(result, None) - - def test_from_native_none(self): - """ - Make sure from_native() returns None on None param. - """ - f = serializers.DateField() - result = f.from_native(None) - - self.assertEqual(result, None) - - def test_from_native_invalid_date(self): - """ - Make sure from_native() raises a ValidationError on passing an invalid date. - """ - f = serializers.DateField() - - try: - f.from_native('1984-13-31') - except validators.ValidationError as e: - self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]"]) - else: - self.fail("ValidationError was not properly raised") - - def test_from_native_invalid_format(self): - """ - Make sure from_native() raises a ValidationError on passing an invalid format. - """ - f = serializers.DateField() - - try: - f.from_native('1984 -- 31') - except validators.ValidationError as e: - self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]"]) - else: - self.fail("ValidationError was not properly raised") - - def test_to_native(self): - """ - Make sure to_native() returns datetime as default. - """ - f = serializers.DateField() - - result_1 = f.to_native(datetime.date(1984, 7, 31)) - - self.assertEqual(datetime.date(1984, 7, 31), result_1) - - def test_to_native_iso(self): - """ - Make sure to_native() with 'iso-8601' returns iso formated date. - """ - f = serializers.DateField(format='iso-8601') - - result_1 = f.to_native(datetime.date(1984, 7, 31)) - - self.assertEqual('1984-07-31', result_1) - - def test_to_native_custom_format(self): - """ - Make sure to_native() returns correct custom format. - """ - f = serializers.DateField(format="%Y - %m.%d") - - result_1 = f.to_native(datetime.date(1984, 7, 31)) - - self.assertEqual('1984 - 07.31', result_1) - - def test_to_native_none(self): - """ - Make sure from_native() returns None on None param. - """ - f = serializers.DateField(required=False) - self.assertEqual(None, f.to_native(None)) - - -class DateTimeFieldTest(TestCase): - """ - Tests for the DateTimeField from_native() and to_native() behavior - """ - - def test_from_native_string(self): - """ - Make sure from_native() accepts default iso input formats. - """ - f = serializers.DateTimeField() - result_1 = f.from_native('1984-07-31 04:31') - result_2 = f.from_native('1984-07-31 04:31:59') - result_3 = f.from_native('1984-07-31 04:31:59.000200') - - self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31), result_1) - self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59), result_2) - self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59, 200), result_3) - - def test_from_native_datetime_datetime(self): - """ - Make sure from_native() accepts a datetime.datetime instance. - """ - f = serializers.DateTimeField() - result_1 = f.from_native(datetime.datetime(1984, 7, 31, 4, 31)) - result_2 = f.from_native(datetime.datetime(1984, 7, 31, 4, 31, 59)) - result_3 = f.from_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200)) - - self.assertEqual(result_1, datetime.datetime(1984, 7, 31, 4, 31)) - self.assertEqual(result_2, datetime.datetime(1984, 7, 31, 4, 31, 59)) - self.assertEqual(result_3, datetime.datetime(1984, 7, 31, 4, 31, 59, 200)) - - def test_from_native_custom_format(self): - """ - Make sure from_native() accepts custom input formats. - """ - f = serializers.DateTimeField(input_formats=['%Y -- %H:%M']) - result = f.from_native('1984 -- 04:59') - - self.assertEqual(datetime.datetime(1984, 1, 1, 4, 59), result) - - def test_from_native_invalid_default_on_custom_format(self): - """ - Make sure from_native() don't accept default formats if custom format is preset - """ - f = serializers.DateTimeField(input_formats=['%Y -- %H:%M']) - - try: - f.from_native('1984-07-31 04:31:59') - except validators.ValidationError as e: - self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: YYYY -- hh:mm"]) - else: - self.fail("ValidationError was not properly raised") - - def test_from_native_empty(self): - """ - Make sure from_native() returns None on empty param. - """ - f = serializers.DateTimeField() - result = f.from_native('') - - self.assertEqual(result, None) - - def test_from_native_none(self): - """ - Make sure from_native() returns None on None param. - """ - f = serializers.DateTimeField() - result = f.from_native(None) - - self.assertEqual(result, None) - - def test_from_native_invalid_datetime(self): - """ - Make sure from_native() raises a ValidationError on passing an invalid datetime. - """ - f = serializers.DateTimeField() - - try: - f.from_native('04:61:59') - except validators.ValidationError as e: - self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: " - "YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]"]) - else: - self.fail("ValidationError was not properly raised") - - def test_from_native_invalid_format(self): - """ - Make sure from_native() raises a ValidationError on passing an invalid format. - """ - f = serializers.DateTimeField() - - try: - f.from_native('04 -- 31') - except validators.ValidationError as e: - self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: " - "YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]"]) - else: - self.fail("ValidationError was not properly raised") - - def test_to_native(self): - """ - Make sure to_native() returns isoformat as default. - """ - f = serializers.DateTimeField() - - result_1 = f.to_native(datetime.datetime(1984, 7, 31)) - result_2 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31)) - result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59)) - result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200)) - - self.assertEqual(datetime.datetime(1984, 7, 31), result_1) - self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31), result_2) - self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59), result_3) - self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59, 200), result_4) - - def test_to_native_iso(self): - """ - Make sure to_native() with format=iso-8601 returns iso formatted datetime. - """ - f = serializers.DateTimeField(format='iso-8601') - - result_1 = f.to_native(datetime.datetime(1984, 7, 31)) - result_2 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31)) - result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59)) - result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200)) - - self.assertEqual('1984-07-31T00:00:00', result_1) - self.assertEqual('1984-07-31T04:31:00', result_2) - self.assertEqual('1984-07-31T04:31:59', result_3) - self.assertEqual('1984-07-31T04:31:59.000200', result_4) - - def test_to_native_custom_format(self): - """ - Make sure to_native() returns correct custom format. - """ - f = serializers.DateTimeField(format="%Y - %H:%M") - - result_1 = f.to_native(datetime.datetime(1984, 7, 31)) - result_2 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31)) - result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59)) - result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200)) - - self.assertEqual('1984 - 00:00', result_1) - self.assertEqual('1984 - 04:31', result_2) - self.assertEqual('1984 - 04:31', result_3) - self.assertEqual('1984 - 04:31', result_4) - - def test_to_native_none(self): - """ - Make sure from_native() returns None on None param. - """ - f = serializers.DateTimeField(required=False) - self.assertEqual(None, f.to_native(None)) - - -class TimeFieldTest(TestCase): - """ - Tests for the TimeField from_native() and to_native() behavior - """ - - def test_from_native_string(self): - """ - Make sure from_native() accepts default iso input formats. - """ - f = serializers.TimeField() - result_1 = f.from_native('04:31') - result_2 = f.from_native('04:31:59') - result_3 = f.from_native('04:31:59.000200') - - self.assertEqual(datetime.time(4, 31), result_1) - self.assertEqual(datetime.time(4, 31, 59), result_2) - self.assertEqual(datetime.time(4, 31, 59, 200), result_3) - - def test_from_native_datetime_time(self): - """ - Make sure from_native() accepts a datetime.time instance. - """ - f = serializers.TimeField() - result_1 = f.from_native(datetime.time(4, 31)) - result_2 = f.from_native(datetime.time(4, 31, 59)) - result_3 = f.from_native(datetime.time(4, 31, 59, 200)) - - self.assertEqual(result_1, datetime.time(4, 31)) - self.assertEqual(result_2, datetime.time(4, 31, 59)) - self.assertEqual(result_3, datetime.time(4, 31, 59, 200)) - - def test_from_native_custom_format(self): - """ - Make sure from_native() accepts custom input formats. - """ - f = serializers.TimeField(input_formats=['%H -- %M']) - result = f.from_native('04 -- 31') - - self.assertEqual(datetime.time(4, 31), result) - - def test_from_native_invalid_default_on_custom_format(self): - """ - Make sure from_native() don't accept default formats if custom format is preset - """ - f = serializers.TimeField(input_formats=['%H -- %M']) - - try: - f.from_native('04:31:59') - except validators.ValidationError as e: - self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: hh -- mm"]) - else: - self.fail("ValidationError was not properly raised") - - def test_from_native_empty(self): - """ - Make sure from_native() returns None on empty param. - """ - f = serializers.TimeField() - result = f.from_native('') - - self.assertEqual(result, None) - - def test_from_native_none(self): - """ - Make sure from_native() returns None on None param. - """ - f = serializers.TimeField() - result = f.from_native(None) - - self.assertEqual(result, None) - - def test_from_native_invalid_time(self): - """ - Make sure from_native() raises a ValidationError on passing an invalid time. - """ - f = serializers.TimeField() - - try: - f.from_native('04:61:59') - except validators.ValidationError as e: - self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: " - "hh:mm[:ss[.uuuuuu]]"]) - else: - self.fail("ValidationError was not properly raised") - - def test_from_native_invalid_format(self): - """ - Make sure from_native() raises a ValidationError on passing an invalid format. - """ - f = serializers.TimeField() - - try: - f.from_native('04 -- 31') - except validators.ValidationError as e: - self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: " - "hh:mm[:ss[.uuuuuu]]"]) - else: - self.fail("ValidationError was not properly raised") - - def test_to_native(self): - """ - Make sure to_native() returns time object as default. - """ - f = serializers.TimeField() - result_1 = f.to_native(datetime.time(4, 31)) - result_2 = f.to_native(datetime.time(4, 31, 59)) - result_3 = f.to_native(datetime.time(4, 31, 59, 200)) - - self.assertEqual(datetime.time(4, 31), result_1) - self.assertEqual(datetime.time(4, 31, 59), result_2) - self.assertEqual(datetime.time(4, 31, 59, 200), result_3) - - def test_to_native_iso(self): - """ - Make sure to_native() with format='iso-8601' returns iso formatted time. - """ - f = serializers.TimeField(format='iso-8601') - result_1 = f.to_native(datetime.time(4, 31)) - result_2 = f.to_native(datetime.time(4, 31, 59)) - result_3 = f.to_native(datetime.time(4, 31, 59, 200)) - - self.assertEqual('04:31:00', result_1) - self.assertEqual('04:31:59', result_2) - self.assertEqual('04:31:59.000200', result_3) - - def test_to_native_custom_format(self): - """ - Make sure to_native() returns correct custom format. - """ - f = serializers.TimeField(format="%H - %S [%f]") - result_1 = f.to_native(datetime.time(4, 31)) - result_2 = f.to_native(datetime.time(4, 31, 59)) - result_3 = f.to_native(datetime.time(4, 31, 59, 200)) - - self.assertEqual('04 - 00 [000000]', result_1) - self.assertEqual('04 - 59 [000000]', result_2) - self.assertEqual('04 - 59 [000200]', result_3) - - -class DecimalFieldTest(TestCase): - """ - Tests for the DecimalField from_native() and to_native() behavior - """ - - def test_from_native_string(self): - """ - Make sure from_native() accepts string values - """ - f = serializers.DecimalField() - result_1 = f.from_native('9000') - result_2 = f.from_native('1.00000001') - - self.assertEqual(Decimal('9000'), result_1) - self.assertEqual(Decimal('1.00000001'), result_2) - - def test_from_native_invalid_string(self): - """ - Make sure from_native() raises ValidationError on passing invalid string - """ - f = serializers.DecimalField() - - try: - f.from_native('123.45.6') - except validators.ValidationError as e: - self.assertEqual(e.messages, ["Enter a number."]) - else: - self.fail("ValidationError was not properly raised") - - def test_from_native_integer(self): - """ - Make sure from_native() accepts integer values - """ - f = serializers.DecimalField() - result = f.from_native(9000) - - self.assertEqual(Decimal('9000'), result) - - def test_from_native_float(self): - """ - Make sure from_native() accepts float values - """ - f = serializers.DecimalField() - result = f.from_native(1.00000001) - - self.assertEqual(Decimal('1.00000001'), result) - - def test_from_native_empty(self): - """ - Make sure from_native() returns None on empty param. - """ - f = serializers.DecimalField() - result = f.from_native('') - - self.assertEqual(result, None) - - def test_from_native_none(self): - """ - Make sure from_native() returns None on None param. - """ - f = serializers.DecimalField() - result = f.from_native(None) - - self.assertEqual(result, None) - - def test_to_native(self): - """ - Make sure to_native() returns Decimal as string. - """ - f = serializers.DecimalField() - - result_1 = f.to_native(Decimal('9000')) - result_2 = f.to_native(Decimal('1.00000001')) - - self.assertEqual(Decimal('9000'), result_1) - self.assertEqual(Decimal('1.00000001'), result_2) - - def test_to_native_none(self): - """ - Make sure from_native() returns None on None param. - """ - f = serializers.DecimalField(required=False) - self.assertEqual(None, f.to_native(None)) - - def test_valid_serialization(self): - """ - Make sure the serializer works correctly - """ - class DecimalSerializer(serializers.Serializer): - decimal_field = serializers.DecimalField(max_value=9010, - min_value=9000, - max_digits=6, - decimal_places=2) - - self.assertTrue(DecimalSerializer(data={'decimal_field': '9001'}).is_valid()) - self.assertTrue(DecimalSerializer(data={'decimal_field': '9001.2'}).is_valid()) - self.assertTrue(DecimalSerializer(data={'decimal_field': '9001.23'}).is_valid()) - - self.assertFalse(DecimalSerializer(data={'decimal_field': '8000'}).is_valid()) - self.assertFalse(DecimalSerializer(data={'decimal_field': '9900'}).is_valid()) - self.assertFalse(DecimalSerializer(data={'decimal_field': '9001.234'}).is_valid()) - - def test_raise_max_value(self): - """ - Make sure max_value violations raises ValidationError - """ - class DecimalSerializer(serializers.Serializer): - decimal_field = serializers.DecimalField(max_value=100) - - s = DecimalSerializer(data={'decimal_field': '123'}) - - self.assertFalse(s.is_valid()) - self.assertEqual(s.errors, {'decimal_field': ['Ensure this value is less than or equal to 100.']}) - - def test_raise_min_value(self): - """ - Make sure min_value violations raises ValidationError - """ - class DecimalSerializer(serializers.Serializer): - decimal_field = serializers.DecimalField(min_value=100) - - s = DecimalSerializer(data={'decimal_field': '99'}) - - self.assertFalse(s.is_valid()) - self.assertEqual(s.errors, {'decimal_field': ['Ensure this value is greater than or equal to 100.']}) - - def test_raise_max_digits(self): - """ - Make sure max_digits violations raises ValidationError - """ - class DecimalSerializer(serializers.Serializer): - decimal_field = serializers.DecimalField(max_digits=5) - - s = DecimalSerializer(data={'decimal_field': '123.456'}) - - self.assertFalse(s.is_valid()) - self.assertEqual(s.errors, {'decimal_field': ['Ensure that there are no more than 5 digits in total.']}) - - def test_raise_max_decimal_places(self): - """ - Make sure max_decimal_places violations raises ValidationError - """ - class DecimalSerializer(serializers.Serializer): - decimal_field = serializers.DecimalField(decimal_places=3) - - s = DecimalSerializer(data={'decimal_field': '123.4567'}) - - self.assertFalse(s.is_valid()) - self.assertEqual(s.errors, {'decimal_field': ['Ensure that there are no more than 3 decimal places.']}) - - def test_raise_max_whole_digits(self): - """ - Make sure max_whole_digits violations raises ValidationError - """ - class DecimalSerializer(serializers.Serializer): - decimal_field = serializers.DecimalField(max_digits=4, decimal_places=3) - - s = DecimalSerializer(data={'decimal_field': '12345.6'}) - - self.assertFalse(s.is_valid()) - self.assertEqual(s.errors, {'decimal_field': ['Ensure that there are no more than 4 digits in total.']}) - - -class ChoiceFieldTests(TestCase): - """ - Tests for the ChoiceField options generator - """ - def test_choices_required(self): - """ - Make sure proper choices are rendered if field is required - """ - f = serializers.ChoiceField(required=True, choices=SAMPLE_CHOICES) - self.assertEqual(f.choices, SAMPLE_CHOICES) - - def test_choices_not_required(self): - """ - Make sure proper choices (plus blank) are rendered if the field isn't required - """ - f = serializers.ChoiceField(required=False, choices=SAMPLE_CHOICES) - self.assertEqual(f.choices, models.fields.BLANK_CHOICE_DASH + SAMPLE_CHOICES) - - def test_blank_choice_display(self): - blank = 'No Preference' - f = serializers.ChoiceField( - required=False, - choices=SAMPLE_CHOICES, - blank_display_value=blank, - ) - self.assertEqual(f.choices, [('', blank)] + SAMPLE_CHOICES) - - def test_invalid_choice_model(self): - s = ChoiceFieldModelSerializer(data={'choice': 'wrong_value'}) - self.assertFalse(s.is_valid()) - self.assertEqual(s.errors, {'choice': ['Select a valid choice. wrong_value is not one of the available choices.']}) - self.assertEqual(s.data['choice'], '') - - def test_empty_choice_model(self): - """ - Test that the 'empty' value is correctly passed and used depending on - the 'null' property on the model field. - """ - s = ChoiceFieldModelSerializer(data={'choice': ''}) - self.assertTrue(s.is_valid()) - self.assertEqual(s.data['choice'], '') - - s = ChoiceFieldModelWithNullSerializer(data={'choice': ''}) - self.assertTrue(s.is_valid()) - self.assertEqual(s.data['choice'], None) - - def test_from_native_empty(self): - """ - Make sure from_native() returns an empty string on empty param by default. - """ - f = serializers.ChoiceField(choices=SAMPLE_CHOICES) - self.assertEqual(f.from_native(''), '') - self.assertEqual(f.from_native(None), '') - - def test_from_native_empty_override(self): - """ - Make sure you can override from_native() behavior regarding empty values. - """ - f = serializers.ChoiceField(choices=SAMPLE_CHOICES, empty=None) - self.assertEqual(f.from_native(''), None) - self.assertEqual(f.from_native(None), None) - - def test_metadata_choices(self): - """ - Make sure proper choices are included in the field's metadata. - """ - choices = [{'value': v, 'display_name': n} for v, n in SAMPLE_CHOICES] - f = serializers.ChoiceField(choices=SAMPLE_CHOICES) - self.assertEqual(f.metadata()['choices'], choices) - - def test_metadata_choices_not_required(self): - """ - Make sure proper choices are included in the field's metadata. - """ - choices = [{'value': v, 'display_name': n} - for v, n in models.fields.BLANK_CHOICE_DASH + SAMPLE_CHOICES] - f = serializers.ChoiceField(required=False, choices=SAMPLE_CHOICES) - self.assertEqual(f.metadata()['choices'], choices) - - -class EmailFieldTests(TestCase): - """ - Tests for EmailField attribute values - """ - - class EmailFieldModel(RESTFrameworkModel): - email_field = models.EmailField(blank=True) - - class EmailFieldWithGivenMaxLengthModel(RESTFrameworkModel): - email_field = models.EmailField(max_length=150, blank=True) - - def test_default_model_value(self): - class EmailFieldSerializer(serializers.ModelSerializer): - class Meta: - model = self.EmailFieldModel - - serializer = EmailFieldSerializer(data={}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(getattr(serializer.fields['email_field'], 'max_length'), 75) - - def test_given_model_value(self): - class EmailFieldSerializer(serializers.ModelSerializer): - class Meta: - model = self.EmailFieldWithGivenMaxLengthModel - - serializer = EmailFieldSerializer(data={}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(getattr(serializer.fields['email_field'], 'max_length'), 150) - - def test_given_serializer_value(self): - class EmailFieldSerializer(serializers.ModelSerializer): - email_field = serializers.EmailField(source='email_field', max_length=20, required=False) - - class Meta: - model = self.EmailFieldModel - - serializer = EmailFieldSerializer(data={}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(getattr(serializer.fields['email_field'], 'max_length'), 20) - - -class SlugFieldTests(TestCase): - """ - Tests for SlugField attribute values - """ - - class SlugFieldModel(RESTFrameworkModel): - slug_field = models.SlugField(blank=True) - - class SlugFieldWithGivenMaxLengthModel(RESTFrameworkModel): - slug_field = models.SlugField(max_length=84, blank=True) - - def test_default_model_value(self): - class SlugFieldSerializer(serializers.ModelSerializer): - class Meta: - model = self.SlugFieldModel - - serializer = SlugFieldSerializer(data={}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(getattr(serializer.fields['slug_field'], 'max_length'), 50) - - def test_given_model_value(self): - class SlugFieldSerializer(serializers.ModelSerializer): - class Meta: - model = self.SlugFieldWithGivenMaxLengthModel - - serializer = SlugFieldSerializer(data={}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(getattr(serializer.fields['slug_field'], 'max_length'), 84) - - def test_given_serializer_value(self): - class SlugFieldSerializer(serializers.ModelSerializer): - slug_field = serializers.SlugField(source='slug_field', - max_length=20, required=False) - - class Meta: - model = self.SlugFieldModel - - serializer = SlugFieldSerializer(data={}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(getattr(serializer.fields['slug_field'], - 'max_length'), 20) - - def test_invalid_slug(self): - """ - Make sure an invalid slug raises ValidationError - """ - class SlugFieldSerializer(serializers.ModelSerializer): - slug_field = serializers.SlugField(source='slug_field', max_length=20, required=True) +# class DateFieldTest(TestCase): +# """ +# Tests for the DateFieldTest from_native() and to_native() behavior +# """ + +# def test_from_native_string(self): +# """ +# Make sure from_native() accepts default iso input formats. +# """ +# f = serializers.DateField() +# result_1 = f.from_native('1984-07-31') + +# self.assertEqual(datetime.date(1984, 7, 31), result_1) + +# def test_from_native_datetime_date(self): +# """ +# Make sure from_native() accepts a datetime.date instance. +# """ +# f = serializers.DateField() +# result_1 = f.from_native(datetime.date(1984, 7, 31)) + +# self.assertEqual(result_1, datetime.date(1984, 7, 31)) + +# def test_from_native_custom_format(self): +# """ +# Make sure from_native() accepts custom input formats. +# """ +# f = serializers.DateField(input_formats=['%Y -- %d']) +# result = f.from_native('1984 -- 31') + +# self.assertEqual(datetime.date(1984, 1, 31), result) + +# def test_from_native_invalid_default_on_custom_format(self): +# """ +# Make sure from_native() don't accept default formats if custom format is preset +# """ +# f = serializers.DateField(input_formats=['%Y -- %d']) + +# try: +# f.from_native('1984-07-31') +# except validators.ValidationError as e: +# self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY -- DD"]) +# else: +# self.fail("ValidationError was not properly raised") + +# def test_from_native_empty(self): +# """ +# Make sure from_native() returns None on empty param. +# """ +# f = serializers.DateField() +# result = f.from_native('') + +# self.assertEqual(result, None) + +# def test_from_native_none(self): +# """ +# Make sure from_native() returns None on None param. +# """ +# f = serializers.DateField() +# result = f.from_native(None) + +# self.assertEqual(result, None) + +# def test_from_native_invalid_date(self): +# """ +# Make sure from_native() raises a ValidationError on passing an invalid date. +# """ +# f = serializers.DateField() + +# try: +# f.from_native('1984-13-31') +# except validators.ValidationError as e: +# self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]"]) +# else: +# self.fail("ValidationError was not properly raised") + +# def test_from_native_invalid_format(self): +# """ +# Make sure from_native() raises a ValidationError on passing an invalid format. +# """ +# f = serializers.DateField() + +# try: +# f.from_native('1984 -- 31') +# except validators.ValidationError as e: +# self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]"]) +# else: +# self.fail("ValidationError was not properly raised") + +# def test_to_native(self): +# """ +# Make sure to_native() returns datetime as default. +# """ +# f = serializers.DateField() + +# result_1 = f.to_native(datetime.date(1984, 7, 31)) + +# self.assertEqual(datetime.date(1984, 7, 31), result_1) + +# def test_to_native_iso(self): +# """ +# Make sure to_native() with 'iso-8601' returns iso formated date. +# """ +# f = serializers.DateField(format='iso-8601') + +# result_1 = f.to_native(datetime.date(1984, 7, 31)) + +# self.assertEqual('1984-07-31', result_1) + +# def test_to_native_custom_format(self): +# """ +# Make sure to_native() returns correct custom format. +# """ +# f = serializers.DateField(format="%Y - %m.%d") + +# result_1 = f.to_native(datetime.date(1984, 7, 31)) + +# self.assertEqual('1984 - 07.31', result_1) + +# def test_to_native_none(self): +# """ +# Make sure from_native() returns None on None param. +# """ +# f = serializers.DateField(required=False) +# self.assertEqual(None, f.to_native(None)) + + +# class DateTimeFieldTest(TestCase): +# """ +# Tests for the DateTimeField from_native() and to_native() behavior +# """ + +# def test_from_native_string(self): +# """ +# Make sure from_native() accepts default iso input formats. +# """ +# f = serializers.DateTimeField() +# result_1 = f.from_native('1984-07-31 04:31') +# result_2 = f.from_native('1984-07-31 04:31:59') +# result_3 = f.from_native('1984-07-31 04:31:59.000200') + +# self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31), result_1) +# self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59), result_2) +# self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59, 200), result_3) + +# def test_from_native_datetime_datetime(self): +# """ +# Make sure from_native() accepts a datetime.datetime instance. +# """ +# f = serializers.DateTimeField() +# result_1 = f.from_native(datetime.datetime(1984, 7, 31, 4, 31)) +# result_2 = f.from_native(datetime.datetime(1984, 7, 31, 4, 31, 59)) +# result_3 = f.from_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200)) + +# self.assertEqual(result_1, datetime.datetime(1984, 7, 31, 4, 31)) +# self.assertEqual(result_2, datetime.datetime(1984, 7, 31, 4, 31, 59)) +# self.assertEqual(result_3, datetime.datetime(1984, 7, 31, 4, 31, 59, 200)) + +# def test_from_native_custom_format(self): +# """ +# Make sure from_native() accepts custom input formats. +# """ +# f = serializers.DateTimeField(input_formats=['%Y -- %H:%M']) +# result = f.from_native('1984 -- 04:59') + +# self.assertEqual(datetime.datetime(1984, 1, 1, 4, 59), result) + +# def test_from_native_invalid_default_on_custom_format(self): +# """ +# Make sure from_native() don't accept default formats if custom format is preset +# """ +# f = serializers.DateTimeField(input_formats=['%Y -- %H:%M']) + +# try: +# f.from_native('1984-07-31 04:31:59') +# except validators.ValidationError as e: +# self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: YYYY -- hh:mm"]) +# else: +# self.fail("ValidationError was not properly raised") + +# def test_from_native_empty(self): +# """ +# Make sure from_native() returns None on empty param. +# """ +# f = serializers.DateTimeField() +# result = f.from_native('') + +# self.assertEqual(result, None) + +# def test_from_native_none(self): +# """ +# Make sure from_native() returns None on None param. +# """ +# f = serializers.DateTimeField() +# result = f.from_native(None) + +# self.assertEqual(result, None) + +# def test_from_native_invalid_datetime(self): +# """ +# Make sure from_native() raises a ValidationError on passing an invalid datetime. +# """ +# f = serializers.DateTimeField() + +# try: +# f.from_native('04:61:59') +# except validators.ValidationError as e: +# self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: " +# "YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]"]) +# else: +# self.fail("ValidationError was not properly raised") + +# def test_from_native_invalid_format(self): +# """ +# Make sure from_native() raises a ValidationError on passing an invalid format. +# """ +# f = serializers.DateTimeField() + +# try: +# f.from_native('04 -- 31') +# except validators.ValidationError as e: +# self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: " +# "YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]"]) +# else: +# self.fail("ValidationError was not properly raised") + +# def test_to_native(self): +# """ +# Make sure to_native() returns isoformat as default. +# """ +# f = serializers.DateTimeField() + +# result_1 = f.to_native(datetime.datetime(1984, 7, 31)) +# result_2 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31)) +# result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59)) +# result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200)) + +# self.assertEqual(datetime.datetime(1984, 7, 31), result_1) +# self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31), result_2) +# self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59), result_3) +# self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59, 200), result_4) + +# def test_to_native_iso(self): +# """ +# Make sure to_native() with format=iso-8601 returns iso formatted datetime. +# """ +# f = serializers.DateTimeField(format='iso-8601') + +# result_1 = f.to_native(datetime.datetime(1984, 7, 31)) +# result_2 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31)) +# result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59)) +# result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200)) + +# self.assertEqual('1984-07-31T00:00:00', result_1) +# self.assertEqual('1984-07-31T04:31:00', result_2) +# self.assertEqual('1984-07-31T04:31:59', result_3) +# self.assertEqual('1984-07-31T04:31:59.000200', result_4) + +# def test_to_native_custom_format(self): +# """ +# Make sure to_native() returns correct custom format. +# """ +# f = serializers.DateTimeField(format="%Y - %H:%M") + +# result_1 = f.to_native(datetime.datetime(1984, 7, 31)) +# result_2 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31)) +# result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59)) +# result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200)) + +# self.assertEqual('1984 - 00:00', result_1) +# self.assertEqual('1984 - 04:31', result_2) +# self.assertEqual('1984 - 04:31', result_3) +# self.assertEqual('1984 - 04:31', result_4) + +# def test_to_native_none(self): +# """ +# Make sure from_native() returns None on None param. +# """ +# f = serializers.DateTimeField(required=False) +# self.assertEqual(None, f.to_native(None)) + + +# class TimeFieldTest(TestCase): +# """ +# Tests for the TimeField from_native() and to_native() behavior +# """ + +# def test_from_native_string(self): +# """ +# Make sure from_native() accepts default iso input formats. +# """ +# f = serializers.TimeField() +# result_1 = f.from_native('04:31') +# result_2 = f.from_native('04:31:59') +# result_3 = f.from_native('04:31:59.000200') + +# self.assertEqual(datetime.time(4, 31), result_1) +# self.assertEqual(datetime.time(4, 31, 59), result_2) +# self.assertEqual(datetime.time(4, 31, 59, 200), result_3) + +# def test_from_native_datetime_time(self): +# """ +# Make sure from_native() accepts a datetime.time instance. +# """ +# f = serializers.TimeField() +# result_1 = f.from_native(datetime.time(4, 31)) +# result_2 = f.from_native(datetime.time(4, 31, 59)) +# result_3 = f.from_native(datetime.time(4, 31, 59, 200)) + +# self.assertEqual(result_1, datetime.time(4, 31)) +# self.assertEqual(result_2, datetime.time(4, 31, 59)) +# self.assertEqual(result_3, datetime.time(4, 31, 59, 200)) + +# def test_from_native_custom_format(self): +# """ +# Make sure from_native() accepts custom input formats. +# """ +# f = serializers.TimeField(input_formats=['%H -- %M']) +# result = f.from_native('04 -- 31') + +# self.assertEqual(datetime.time(4, 31), result) + +# def test_from_native_invalid_default_on_custom_format(self): +# """ +# Make sure from_native() don't accept default formats if custom format is preset +# """ +# f = serializers.TimeField(input_formats=['%H -- %M']) + +# try: +# f.from_native('04:31:59') +# except validators.ValidationError as e: +# self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: hh -- mm"]) +# else: +# self.fail("ValidationError was not properly raised") + +# def test_from_native_empty(self): +# """ +# Make sure from_native() returns None on empty param. +# """ +# f = serializers.TimeField() +# result = f.from_native('') + +# self.assertEqual(result, None) + +# def test_from_native_none(self): +# """ +# Make sure from_native() returns None on None param. +# """ +# f = serializers.TimeField() +# result = f.from_native(None) + +# self.assertEqual(result, None) + +# def test_from_native_invalid_time(self): +# """ +# Make sure from_native() raises a ValidationError on passing an invalid time. +# """ +# f = serializers.TimeField() + +# try: +# f.from_native('04:61:59') +# except validators.ValidationError as e: +# self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: " +# "hh:mm[:ss[.uuuuuu]]"]) +# else: +# self.fail("ValidationError was not properly raised") + +# def test_from_native_invalid_format(self): +# """ +# Make sure from_native() raises a ValidationError on passing an invalid format. +# """ +# f = serializers.TimeField() + +# try: +# f.from_native('04 -- 31') +# except validators.ValidationError as e: +# self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: " +# "hh:mm[:ss[.uuuuuu]]"]) +# else: +# self.fail("ValidationError was not properly raised") + +# def test_to_native(self): +# """ +# Make sure to_native() returns time object as default. +# """ +# f = serializers.TimeField() +# result_1 = f.to_native(datetime.time(4, 31)) +# result_2 = f.to_native(datetime.time(4, 31, 59)) +# result_3 = f.to_native(datetime.time(4, 31, 59, 200)) + +# self.assertEqual(datetime.time(4, 31), result_1) +# self.assertEqual(datetime.time(4, 31, 59), result_2) +# self.assertEqual(datetime.time(4, 31, 59, 200), result_3) + +# def test_to_native_iso(self): +# """ +# Make sure to_native() with format='iso-8601' returns iso formatted time. +# """ +# f = serializers.TimeField(format='iso-8601') +# result_1 = f.to_native(datetime.time(4, 31)) +# result_2 = f.to_native(datetime.time(4, 31, 59)) +# result_3 = f.to_native(datetime.time(4, 31, 59, 200)) + +# self.assertEqual('04:31:00', result_1) +# self.assertEqual('04:31:59', result_2) +# self.assertEqual('04:31:59.000200', result_3) + +# def test_to_native_custom_format(self): +# """ +# Make sure to_native() returns correct custom format. +# """ +# f = serializers.TimeField(format="%H - %S [%f]") +# result_1 = f.to_native(datetime.time(4, 31)) +# result_2 = f.to_native(datetime.time(4, 31, 59)) +# result_3 = f.to_native(datetime.time(4, 31, 59, 200)) + +# self.assertEqual('04 - 00 [000000]', result_1) +# self.assertEqual('04 - 59 [000000]', result_2) +# self.assertEqual('04 - 59 [000200]', result_3) + + +# class DecimalFieldTest(TestCase): +# """ +# Tests for the DecimalField from_native() and to_native() behavior +# """ + +# def test_from_native_string(self): +# """ +# Make sure from_native() accepts string values +# """ +# f = serializers.DecimalField() +# result_1 = f.from_native('9000') +# result_2 = f.from_native('1.00000001') + +# self.assertEqual(Decimal('9000'), result_1) +# self.assertEqual(Decimal('1.00000001'), result_2) + +# def test_from_native_invalid_string(self): +# """ +# Make sure from_native() raises ValidationError on passing invalid string +# """ +# f = serializers.DecimalField() + +# try: +# f.from_native('123.45.6') +# except validators.ValidationError as e: +# self.assertEqual(e.messages, ["Enter a number."]) +# else: +# self.fail("ValidationError was not properly raised") + +# def test_from_native_integer(self): +# """ +# Make sure from_native() accepts integer values +# """ +# f = serializers.DecimalField() +# result = f.from_native(9000) + +# self.assertEqual(Decimal('9000'), result) + +# def test_from_native_float(self): +# """ +# Make sure from_native() accepts float values +# """ +# f = serializers.DecimalField() +# result = f.from_native(1.00000001) + +# self.assertEqual(Decimal('1.00000001'), result) + +# def test_from_native_empty(self): +# """ +# Make sure from_native() returns None on empty param. +# """ +# f = serializers.DecimalField() +# result = f.from_native('') + +# self.assertEqual(result, None) + +# def test_from_native_none(self): +# """ +# Make sure from_native() returns None on None param. +# """ +# f = serializers.DecimalField() +# result = f.from_native(None) + +# self.assertEqual(result, None) + +# def test_to_native(self): +# """ +# Make sure to_native() returns Decimal as string. +# """ +# f = serializers.DecimalField() + +# result_1 = f.to_native(Decimal('9000')) +# result_2 = f.to_native(Decimal('1.00000001')) + +# self.assertEqual(Decimal('9000'), result_1) +# self.assertEqual(Decimal('1.00000001'), result_2) + +# def test_to_native_none(self): +# """ +# Make sure from_native() returns None on None param. +# """ +# f = serializers.DecimalField(required=False) +# self.assertEqual(None, f.to_native(None)) + +# def test_valid_serialization(self): +# """ +# Make sure the serializer works correctly +# """ +# class DecimalSerializer(serializers.Serializer): +# decimal_field = serializers.DecimalField(max_value=9010, +# min_value=9000, +# max_digits=6, +# decimal_places=2) + +# self.assertTrue(DecimalSerializer(data={'decimal_field': '9001'}).is_valid()) +# self.assertTrue(DecimalSerializer(data={'decimal_field': '9001.2'}).is_valid()) +# self.assertTrue(DecimalSerializer(data={'decimal_field': '9001.23'}).is_valid()) + +# self.assertFalse(DecimalSerializer(data={'decimal_field': '8000'}).is_valid()) +# self.assertFalse(DecimalSerializer(data={'decimal_field': '9900'}).is_valid()) +# self.assertFalse(DecimalSerializer(data={'decimal_field': '9001.234'}).is_valid()) + +# def test_raise_max_value(self): +# """ +# Make sure max_value violations raises ValidationError +# """ +# class DecimalSerializer(serializers.Serializer): +# decimal_field = serializers.DecimalField(max_value=100) + +# s = DecimalSerializer(data={'decimal_field': '123'}) + +# self.assertFalse(s.is_valid()) +# self.assertEqual(s.errors, {'decimal_field': ['Ensure this value is less than or equal to 100.']}) + +# def test_raise_min_value(self): +# """ +# Make sure min_value violations raises ValidationError +# """ +# class DecimalSerializer(serializers.Serializer): +# decimal_field = serializers.DecimalField(min_value=100) + +# s = DecimalSerializer(data={'decimal_field': '99'}) + +# self.assertFalse(s.is_valid()) +# self.assertEqual(s.errors, {'decimal_field': ['Ensure this value is greater than or equal to 100.']}) + +# def test_raise_max_digits(self): +# """ +# Make sure max_digits violations raises ValidationError +# """ +# class DecimalSerializer(serializers.Serializer): +# decimal_field = serializers.DecimalField(max_digits=5) + +# s = DecimalSerializer(data={'decimal_field': '123.456'}) + +# self.assertFalse(s.is_valid()) +# self.assertEqual(s.errors, {'decimal_field': ['Ensure that there are no more than 5 digits in total.']}) + +# def test_raise_max_decimal_places(self): +# """ +# Make sure max_decimal_places violations raises ValidationError +# """ +# class DecimalSerializer(serializers.Serializer): +# decimal_field = serializers.DecimalField(decimal_places=3) + +# s = DecimalSerializer(data={'decimal_field': '123.4567'}) + +# self.assertFalse(s.is_valid()) +# self.assertEqual(s.errors, {'decimal_field': ['Ensure that there are no more than 3 decimal places.']}) + +# def test_raise_max_whole_digits(self): +# """ +# Make sure max_whole_digits violations raises ValidationError +# """ +# class DecimalSerializer(serializers.Serializer): +# decimal_field = serializers.DecimalField(max_digits=4, decimal_places=3) + +# s = DecimalSerializer(data={'decimal_field': '12345.6'}) + +# self.assertFalse(s.is_valid()) +# self.assertEqual(s.errors, {'decimal_field': ['Ensure that there are no more than 4 digits in total.']}) + + +# class ChoiceFieldTests(TestCase): +# """ +# Tests for the ChoiceField options generator +# """ +# def test_choices_required(self): +# """ +# Make sure proper choices are rendered if field is required +# """ +# f = serializers.ChoiceField(required=True, choices=SAMPLE_CHOICES) +# self.assertEqual(f.choices, SAMPLE_CHOICES) + +# def test_choices_not_required(self): +# """ +# Make sure proper choices (plus blank) are rendered if the field isn't required +# """ +# f = serializers.ChoiceField(required=False, choices=SAMPLE_CHOICES) +# self.assertEqual(f.choices, models.fields.BLANK_CHOICE_DASH + SAMPLE_CHOICES) + +# def test_blank_choice_display(self): +# blank = 'No Preference' +# f = serializers.ChoiceField( +# required=False, +# choices=SAMPLE_CHOICES, +# blank_display_value=blank, +# ) +# self.assertEqual(f.choices, [('', blank)] + SAMPLE_CHOICES) + +# def test_invalid_choice_model(self): +# s = ChoiceFieldModelSerializer(data={'choice': 'wrong_value'}) +# self.assertFalse(s.is_valid()) +# self.assertEqual(s.errors, {'choice': ['Select a valid choice. wrong_value is not one of the available choices.']}) +# self.assertEqual(s.data['choice'], '') + +# def test_empty_choice_model(self): +# """ +# Test that the 'empty' value is correctly passed and used depending on +# the 'null' property on the model field. +# """ +# s = ChoiceFieldModelSerializer(data={'choice': ''}) +# self.assertTrue(s.is_valid()) +# self.assertEqual(s.data['choice'], '') + +# s = ChoiceFieldModelWithNullSerializer(data={'choice': ''}) +# self.assertTrue(s.is_valid()) +# self.assertEqual(s.data['choice'], None) + +# def test_from_native_empty(self): +# """ +# Make sure from_native() returns an empty string on empty param by default. +# """ +# f = serializers.ChoiceField(choices=SAMPLE_CHOICES) +# self.assertEqual(f.from_native(''), '') +# self.assertEqual(f.from_native(None), '') + +# def test_from_native_empty_override(self): +# """ +# Make sure you can override from_native() behavior regarding empty values. +# """ +# f = serializers.ChoiceField(choices=SAMPLE_CHOICES, empty=None) +# self.assertEqual(f.from_native(''), None) +# self.assertEqual(f.from_native(None), None) + +# def test_metadata_choices(self): +# """ +# Make sure proper choices are included in the field's metadata. +# """ +# choices = [{'value': v, 'display_name': n} for v, n in SAMPLE_CHOICES] +# f = serializers.ChoiceField(choices=SAMPLE_CHOICES) +# self.assertEqual(f.metadata()['choices'], choices) + +# def test_metadata_choices_not_required(self): +# """ +# Make sure proper choices are included in the field's metadata. +# """ +# choices = [{'value': v, 'display_name': n} +# for v, n in models.fields.BLANK_CHOICE_DASH + SAMPLE_CHOICES] +# f = serializers.ChoiceField(required=False, choices=SAMPLE_CHOICES) +# self.assertEqual(f.metadata()['choices'], choices) + + +# class EmailFieldTests(TestCase): +# """ +# Tests for EmailField attribute values +# """ + +# class EmailFieldModel(RESTFrameworkModel): +# email_field = models.EmailField(blank=True) + +# class EmailFieldWithGivenMaxLengthModel(RESTFrameworkModel): +# email_field = models.EmailField(max_length=150, blank=True) + +# def test_default_model_value(self): +# class EmailFieldSerializer(serializers.ModelSerializer): +# class Meta: +# model = self.EmailFieldModel + +# serializer = EmailFieldSerializer(data={}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(getattr(serializer.fields['email_field'], 'max_length'), 75) + +# def test_given_model_value(self): +# class EmailFieldSerializer(serializers.ModelSerializer): +# class Meta: +# model = self.EmailFieldWithGivenMaxLengthModel + +# serializer = EmailFieldSerializer(data={}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(getattr(serializer.fields['email_field'], 'max_length'), 150) + +# def test_given_serializer_value(self): +# class EmailFieldSerializer(serializers.ModelSerializer): +# email_field = serializers.EmailField(source='email_field', max_length=20, required=False) + +# class Meta: +# model = self.EmailFieldModel + +# serializer = EmailFieldSerializer(data={}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(getattr(serializer.fields['email_field'], 'max_length'), 20) + + +# class SlugFieldTests(TestCase): +# """ +# Tests for SlugField attribute values +# """ + +# class SlugFieldModel(RESTFrameworkModel): +# slug_field = models.SlugField(blank=True) + +# class SlugFieldWithGivenMaxLengthModel(RESTFrameworkModel): +# slug_field = models.SlugField(max_length=84, blank=True) + +# def test_default_model_value(self): +# class SlugFieldSerializer(serializers.ModelSerializer): +# class Meta: +# model = self.SlugFieldModel + +# serializer = SlugFieldSerializer(data={}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(getattr(serializer.fields['slug_field'], 'max_length'), 50) + +# def test_given_model_value(self): +# class SlugFieldSerializer(serializers.ModelSerializer): +# class Meta: +# model = self.SlugFieldWithGivenMaxLengthModel + +# serializer = SlugFieldSerializer(data={}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(getattr(serializer.fields['slug_field'], 'max_length'), 84) + +# def test_given_serializer_value(self): +# class SlugFieldSerializer(serializers.ModelSerializer): +# slug_field = serializers.SlugField(source='slug_field', +# max_length=20, required=False) + +# class Meta: +# model = self.SlugFieldModel + +# serializer = SlugFieldSerializer(data={}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(getattr(serializer.fields['slug_field'], +# 'max_length'), 20) + +# def test_invalid_slug(self): +# """ +# Make sure an invalid slug raises ValidationError +# """ +# class SlugFieldSerializer(serializers.ModelSerializer): +# slug_field = serializers.SlugField(source='slug_field', max_length=20, required=True) - class Meta: - model = self.SlugFieldModel +# class Meta: +# model = self.SlugFieldModel - s = SlugFieldSerializer(data={'slug_field': 'a b'}) +# s = SlugFieldSerializer(data={'slug_field': 'a b'}) - self.assertEqual(s.is_valid(), False) - self.assertEqual(s.errors, {'slug_field': ["Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens."]}) +# self.assertEqual(s.is_valid(), False) +# self.assertEqual(s.errors, {'slug_field': ["Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens."]}) -class URLFieldTests(TestCase): - """ - Tests for URLField attribute values. +# class URLFieldTests(TestCase): +# """ +# Tests for URLField attribute values. - (Includes test for #1210, checking that validators can be overridden.) - """ +# (Includes test for #1210, checking that validators can be overridden.) +# """ - class URLFieldModel(RESTFrameworkModel): - url_field = models.URLField(blank=True) +# class URLFieldModel(RESTFrameworkModel): +# url_field = models.URLField(blank=True) - class URLFieldWithGivenMaxLengthModel(RESTFrameworkModel): - url_field = models.URLField(max_length=128, blank=True) +# class URLFieldWithGivenMaxLengthModel(RESTFrameworkModel): +# url_field = models.URLField(max_length=128, blank=True) - def test_default_model_value(self): - class URLFieldSerializer(serializers.ModelSerializer): - class Meta: - model = self.URLFieldModel +# def test_default_model_value(self): +# class URLFieldSerializer(serializers.ModelSerializer): +# class Meta: +# model = self.URLFieldModel - serializer = URLFieldSerializer(data={}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(getattr(serializer.fields['url_field'], - 'max_length'), 200) +# serializer = URLFieldSerializer(data={}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(getattr(serializer.fields['url_field'], +# 'max_length'), 200) - def test_given_model_value(self): - class URLFieldSerializer(serializers.ModelSerializer): - class Meta: - model = self.URLFieldWithGivenMaxLengthModel +# def test_given_model_value(self): +# class URLFieldSerializer(serializers.ModelSerializer): +# class Meta: +# model = self.URLFieldWithGivenMaxLengthModel - serializer = URLFieldSerializer(data={}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(getattr(serializer.fields['url_field'], - 'max_length'), 128) +# serializer = URLFieldSerializer(data={}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(getattr(serializer.fields['url_field'], +# 'max_length'), 128) - def test_given_serializer_value(self): - class URLFieldSerializer(serializers.ModelSerializer): - url_field = serializers.URLField(source='url_field', - max_length=20, required=False) +# def test_given_serializer_value(self): +# class URLFieldSerializer(serializers.ModelSerializer): +# url_field = serializers.URLField(source='url_field', +# max_length=20, required=False) - class Meta: - model = self.URLFieldWithGivenMaxLengthModel +# class Meta: +# model = self.URLFieldWithGivenMaxLengthModel - serializer = URLFieldSerializer(data={}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(getattr(serializer.fields['url_field'], - 'max_length'), 20) +# serializer = URLFieldSerializer(data={}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(getattr(serializer.fields['url_field'], +# 'max_length'), 20) - def test_validators_can_be_overridden(self): - url_field = serializers.URLField(validators=[]) - validators = url_field.validators - self.assertEqual([], validators, 'Passing `validators` kwarg should have overridden default validators') +# def test_validators_can_be_overridden(self): +# url_field = serializers.URLField(validators=[]) +# validators = url_field.validators +# self.assertEqual([], validators, 'Passing `validators` kwarg should have overridden default validators') -class FieldMetadata(TestCase): - def setUp(self): - self.required_field = serializers.Field() - self.required_field.label = uuid4().hex - self.required_field.required = True +# class FieldMetadata(TestCase): +# def setUp(self): +# self.required_field = serializers.Field() +# self.required_field.label = uuid4().hex +# self.required_field.required = True - self.optional_field = serializers.Field() - self.optional_field.label = uuid4().hex - self.optional_field.required = False +# self.optional_field = serializers.Field() +# self.optional_field.label = uuid4().hex +# self.optional_field.required = False - def test_required(self): - self.assertEqual(self.required_field.metadata()['required'], True) +# def test_required(self): +# self.assertEqual(self.required_field.metadata()['required'], True) - def test_optional(self): - self.assertEqual(self.optional_field.metadata()['required'], False) +# def test_optional(self): +# self.assertEqual(self.optional_field.metadata()['required'], False) - def test_label(self): - for field in (self.required_field, self.optional_field): - self.assertEqual(field.metadata()['label'], field.label) +# def test_label(self): +# for field in (self.required_field, self.optional_field): +# self.assertEqual(field.metadata()['label'], field.label) -class FieldCallableDefault(TestCase): - def setUp(self): - self.simple_callable = lambda: 'foo bar' +# class FieldCallableDefault(TestCase): +# def setUp(self): +# self.simple_callable = lambda: 'foo bar' - def test_default_can_be_simple_callable(self): - """ - Ensure that the 'default' argument can also be a simple callable. - """ - field = serializers.WritableField(default=self.simple_callable) - into = {} - field.field_from_native({}, {}, 'field', into) - self.assertEqual(into, {'field': 'foo bar'}) +# def test_default_can_be_simple_callable(self): +# """ +# Ensure that the 'default' argument can also be a simple callable. +# """ +# field = serializers.WritableField(default=self.simple_callable) +# into = {} +# field.field_from_native({}, {}, 'field', into) +# self.assertEqual(into, {'field': 'foo bar'}) -class CustomIntegerField(TestCase): - """ - Test that custom fields apply min_value and max_value constraints - """ - def test_custom_fields_can_be_validated_for_value(self): +# class CustomIntegerField(TestCase): +# """ +# Test that custom fields apply min_value and max_value constraints +# """ +# def test_custom_fields_can_be_validated_for_value(self): - class MoneyField(models.PositiveIntegerField): - pass +# class MoneyField(models.PositiveIntegerField): +# pass - class EntryModel(models.Model): - bank = MoneyField(validators=[validators.MaxValueValidator(100)]) +# class EntryModel(models.Model): +# bank = MoneyField(validators=[validators.MaxValueValidator(100)]) - class EntrySerializer(serializers.ModelSerializer): - class Meta: - model = EntryModel +# class EntrySerializer(serializers.ModelSerializer): +# class Meta: +# model = EntryModel + +# entry = EntryModel(bank=1) + +# serializer = EntrySerializer(entry, data={"bank": 11}) +# self.assertTrue(serializer.is_valid()) + +# serializer = EntrySerializer(entry, data={"bank": -1}) +# self.assertFalse(serializer.is_valid()) + +# serializer = EntrySerializer(entry, data={"bank": 101}) +# self.assertFalse(serializer.is_valid()) + + +# class BooleanField(TestCase): +# """ +# Tests for BooleanField +# """ +# def test_boolean_required(self): +# class BooleanRequiredSerializer(serializers.Serializer): +# bool_field = serializers.BooleanField(required=True) + +# self.assertFalse(BooleanRequiredSerializer(data={}).is_valid()) + + +# class SerializerMethodFieldTest(TestCase): +# """ +# Tests for the SerializerMethodField field_to_native() behavior +# """ +# class SerializerTest(serializers.Serializer): +# def get_my_test(self, obj): +# return obj.my_test[0:5] + +# class ModelCharField(TestCase): +# """ +# Tests for CharField +# """ +# def test_none_serializing(self): +# class CharFieldSerializer(serializers.Serializer): +# char = serializers.CharField(allow_none=True, required=False) +# serializer = CharFieldSerializer(data={'char': None}) +# self.assertTrue(serializer.is_valid()) +# self.assertIsNone(serializer.object['char']) - entry = EntryModel(bank=1) - serializer = EntrySerializer(entry, data={"bank": 11}) - self.assertTrue(serializer.is_valid()) +# class SerializerMethodFieldTest(TestCase): +# """ +# Tests for the SerializerMethodField field_to_native() behavior +# """ +# class SerializerTest(serializers.Serializer): +# def get_my_test(self, obj): +# return obj.my_test[0:5] + +# class Example(): +# my_test = 'Hey, this is a test !' - serializer = EntrySerializer(entry, data={"bank": -1}) - self.assertFalse(serializer.is_valid()) - - serializer = EntrySerializer(entry, data={"bank": 101}) - self.assertFalse(serializer.is_valid()) - - -class BooleanField(TestCase): - """ - Tests for BooleanField - """ - def test_boolean_required(self): - class BooleanRequiredSerializer(serializers.Serializer): - bool_field = serializers.BooleanField(required=True) - - self.assertFalse(BooleanRequiredSerializer(data={}).is_valid()) - - -class ModelCharField(TestCase): - """ - Tests for CharField - """ - def test_none_serializing(self): - class CharFieldSerializer(serializers.Serializer): - char = serializers.CharField(allow_none=True, required=False) - serializer = CharFieldSerializer(data={'char': None}) - self.assertTrue(serializer.is_valid()) - self.assertIsNone(serializer.object['char']) - - -class SerializerMethodFieldTest(TestCase): - """ - Tests for the SerializerMethodField field_to_native() behavior - """ - class SerializerTest(serializers.Serializer): - def get_my_test(self, obj): - return obj.my_test[0:5] - - class Example(): - my_test = 'Hey, this is a test !' - - def test_field_to_native(self): - s = serializers.SerializerMethodField('get_my_test') - s.initialize(self.SerializerTest(), 'name') - result = s.field_to_native(self.Example(), None) - self.assertEqual(result, 'Hey, ') +# def test_field_to_native(self): +# s = serializers.SerializerMethodField('get_my_test') +# s.initialize(self.SerializerTest(), 'name') +# result = s.field_to_native(self.Example(), None) +# self.assertEqual(result, 'Hey, ') diff --git a/tests/test_files.py b/tests/test_files.py index de4f71d1..a5613fcb 100644 --- a/tests/test_files.py +++ b/tests/test_files.py @@ -1,92 +1,92 @@ -from __future__ import unicode_literals -from django.test import TestCase -from django.utils import six -from rest_framework import serializers -from rest_framework.compat import BytesIO -import datetime - - -class UploadedFile(object): - def __init__(self, file=None, created=None): - self.file = file - self.created = created or datetime.datetime.now() - - -class UploadedFileSerializer(serializers.Serializer): - file = serializers.FileField(required=False) - created = serializers.DateTimeField() - - def restore_object(self, attrs, instance=None): - if instance: - instance.file = attrs['file'] - instance.created = attrs['created'] - return instance - return UploadedFile(**attrs) - - -class FileSerializerTests(TestCase): - def test_create(self): - now = datetime.datetime.now() - file = BytesIO(six.b('stuff')) - file.name = 'stuff.txt' - file.size = len(file.getvalue()) - serializer = UploadedFileSerializer(data={'created': now}, files={'file': file}) - uploaded_file = UploadedFile(file=file, created=now) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.object.created, uploaded_file.created) - self.assertEqual(serializer.object.file, uploaded_file.file) - self.assertFalse(serializer.object is uploaded_file) - - def test_creation_failure(self): - """ - Passing files=None should result in an ValidationError - - Regression test for: - https://github.com/tomchristie/django-rest-framework/issues/542 - """ - now = datetime.datetime.now() - - serializer = UploadedFileSerializer(data={'created': now}) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.object.created, now) - self.assertIsNone(serializer.object.file) - - def test_remove_with_empty_string(self): - """ - Passing empty string as data should cause file to be removed - - Test for: - https://github.com/tomchristie/django-rest-framework/issues/937 - """ - now = datetime.datetime.now() - file = BytesIO(six.b('stuff')) - file.name = 'stuff.txt' - file.size = len(file.getvalue()) - - uploaded_file = UploadedFile(file=file, created=now) - - serializer = UploadedFileSerializer(instance=uploaded_file, data={'created': now, 'file': ''}) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.object.created, uploaded_file.created) - self.assertIsNone(serializer.object.file) - - def test_validation_error_with_non_file(self): - """ - Passing non-files should raise a validation error. - """ - now = datetime.datetime.now() - errmsg = 'No file was submitted. Check the encoding type on the form.' - - serializer = UploadedFileSerializer(data={'created': now, 'file': 'abc'}) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'file': [errmsg]}) - - def test_validation_with_no_data(self): - """ - Validation should still function when no data dictionary is provided. - """ - uploaded_file = BytesIO(six.b('stuff')) - uploaded_file.name = 'stuff.txt' - uploaded_file.size = len(uploaded_file.getvalue()) - serializer = UploadedFileSerializer(files={'file': uploaded_file}) - self.assertFalse(serializer.is_valid()) +# from __future__ import unicode_literals +# from django.test import TestCase +# from django.utils import six +# from rest_framework import serializers +# from rest_framework.compat import BytesIO +# import datetime + + +# class UploadedFile(object): +# def __init__(self, file=None, created=None): +# self.file = file +# self.created = created or datetime.datetime.now() + + +# class UploadedFileSerializer(serializers.Serializer): +# file = serializers.FileField(required=False) +# created = serializers.DateTimeField() + +# def restore_object(self, attrs, instance=None): +# if instance: +# instance.file = attrs['file'] +# instance.created = attrs['created'] +# return instance +# return UploadedFile(**attrs) + + +# class FileSerializerTests(TestCase): +# def test_create(self): +# now = datetime.datetime.now() +# file = BytesIO(six.b('stuff')) +# file.name = 'stuff.txt' +# file.size = len(file.getvalue()) +# serializer = UploadedFileSerializer(data={'created': now}, files={'file': file}) +# uploaded_file = UploadedFile(file=file, created=now) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.object.created, uploaded_file.created) +# self.assertEqual(serializer.object.file, uploaded_file.file) +# self.assertFalse(serializer.object is uploaded_file) + +# def test_creation_failure(self): +# """ +# Passing files=None should result in an ValidationError + +# Regression test for: +# https://github.com/tomchristie/django-rest-framework/issues/542 +# """ +# now = datetime.datetime.now() + +# serializer = UploadedFileSerializer(data={'created': now}) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.object.created, now) +# self.assertIsNone(serializer.object.file) + +# def test_remove_with_empty_string(self): +# """ +# Passing empty string as data should cause file to be removed + +# Test for: +# https://github.com/tomchristie/django-rest-framework/issues/937 +# """ +# now = datetime.datetime.now() +# file = BytesIO(six.b('stuff')) +# file.name = 'stuff.txt' +# file.size = len(file.getvalue()) + +# uploaded_file = UploadedFile(file=file, created=now) + +# serializer = UploadedFileSerializer(instance=uploaded_file, data={'created': now, 'file': ''}) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.object.created, uploaded_file.created) +# self.assertIsNone(serializer.object.file) + +# def test_validation_error_with_non_file(self): +# """ +# Passing non-files should raise a validation error. +# """ +# now = datetime.datetime.now() +# errmsg = 'No file was submitted. Check the encoding type on the form.' + +# serializer = UploadedFileSerializer(data={'created': now, 'file': 'abc'}) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'file': [errmsg]}) + +# def test_validation_with_no_data(self): +# """ +# Validation should still function when no data dictionary is provided. +# """ +# uploaded_file = BytesIO(six.b('stuff')) +# uploaded_file.name = 'stuff.txt' +# uploaded_file.size = len(uploaded_file.getvalue()) +# serializer = UploadedFileSerializer(files={'file': uploaded_file}) +# self.assertFalse(serializer.is_valid()) diff --git a/tests/test_filters.py b/tests/test_filters.py index 5722fd7c..dc84dcbd 100644 --- a/tests/test_filters.py +++ b/tests/test_filters.py @@ -2,10 +2,11 @@ from __future__ import unicode_literals import datetime from decimal import Decimal from django.db import models +from django.conf.urls import patterns, url from django.core.urlresolvers import reverse from django.test import TestCase from django.utils import unittest -from django.conf.urls import patterns, url +from django.utils.dateparse import parse_date from rest_framework import generics, serializers, status, filters from rest_framework.compat import django_filters from rest_framework.test import APIRequestFactory @@ -16,9 +17,14 @@ factory = APIRequestFactory() if django_filters: + class FilterableItemSerializer(serializers.ModelSerializer): + class Meta: + model = FilterableItem + # Basic filter on a list view. class FilterFieldsRootView(generics.ListCreateAPIView): - model = FilterableItem + queryset = FilterableItem.objects.all() + serializer_class = FilterableItemSerializer filter_fields = ['decimal', 'date'] filter_backends = (filters.DjangoFilterBackend,) @@ -33,7 +39,8 @@ if django_filters: fields = ['text', 'decimal', 'date'] class FilterClassRootView(generics.ListCreateAPIView): - model = FilterableItem + queryset = FilterableItem.objects.all() + serializer_class = FilterableItemSerializer filter_class = SeveralFieldsFilter filter_backends = (filters.DjangoFilterBackend,) @@ -46,12 +53,14 @@ if django_filters: fields = ['text'] class IncorrectlyConfiguredRootView(generics.ListCreateAPIView): - model = FilterableItem + queryset = FilterableItem.objects.all() + serializer_class = FilterableItemSerializer filter_class = MisconfiguredFilter filter_backends = (filters.DjangoFilterBackend,) class FilterClassDetailView(generics.RetrieveAPIView): - model = FilterableItem + queryset = FilterableItem.objects.all() + serializer_class = FilterableItemSerializer filter_class = SeveralFieldsFilter filter_backends = (filters.DjangoFilterBackend,) @@ -63,15 +72,12 @@ if django_filters: model = BaseFilterableItem class BaseFilterableItemFilterRootView(generics.ListCreateAPIView): - model = FilterableItem + queryset = FilterableItem.objects.all() + serializer_class = FilterableItemSerializer filter_class = BaseFilterableItemFilter filter_backends = (filters.DjangoFilterBackend,) # Regression test for #814 - class FilterableItemSerializer(serializers.ModelSerializer): - class Meta: - model = FilterableItem - class FilterFieldsQuerysetView(generics.ListCreateAPIView): queryset = FilterableItem.objects.all() serializer_class = FilterableItemSerializer @@ -97,7 +103,7 @@ if django_filters: class CommonFilteringTestCase(TestCase): def _serialize_object(self, obj): - return {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date} + return {'id': obj.id, 'text': obj.text, 'decimal': str(obj.decimal), 'date': obj.date.isoformat()} def setUp(self): """ @@ -140,7 +146,7 @@ class IntegrationTestFiltering(CommonFilteringTestCase): request = factory.get('/', {'decimal': '%s' % search_decimal}) response = view(request).render() self.assertEqual(response.status_code, status.HTTP_200_OK) - expected_data = [f for f in self.data if f['decimal'] == search_decimal] + expected_data = [f for f in self.data if Decimal(f['decimal']) == search_decimal] self.assertEqual(response.data, expected_data) # Tests that the date filter works. @@ -148,7 +154,7 @@ class IntegrationTestFiltering(CommonFilteringTestCase): request = factory.get('/', {'date': '%s' % search_date}) # search_date str: '2012-09-22' response = view(request).render() self.assertEqual(response.status_code, status.HTTP_200_OK) - expected_data = [f for f in self.data if f['date'] == search_date] + expected_data = [f for f in self.data if parse_date(f['date']) == search_date] self.assertEqual(response.data, expected_data) @unittest.skipUnless(django_filters, 'django-filter not installed') @@ -163,7 +169,7 @@ class IntegrationTestFiltering(CommonFilteringTestCase): request = factory.get('/', {'decimal': '%s' % search_decimal}) response = view(request).render() self.assertEqual(response.status_code, status.HTTP_200_OK) - expected_data = [f for f in self.data if f['decimal'] == search_decimal] + expected_data = [f for f in self.data if Decimal(f['decimal']) == search_decimal] self.assertEqual(response.data, expected_data) @unittest.skipUnless(django_filters, 'django-filter not installed') @@ -196,7 +202,7 @@ class IntegrationTestFiltering(CommonFilteringTestCase): request = factory.get('/', {'decimal': '%s' % search_decimal}) response = view(request).render() self.assertEqual(response.status_code, status.HTTP_200_OK) - expected_data = [f for f in self.data if f['decimal'] < search_decimal] + expected_data = [f for f in self.data if Decimal(f['decimal']) < search_decimal] self.assertEqual(response.data, expected_data) # Tests that the date filter set with 'gt' in the filter class works. @@ -204,7 +210,7 @@ class IntegrationTestFiltering(CommonFilteringTestCase): request = factory.get('/', {'date': '%s' % search_date}) # search_date str: '2012-10-02' response = view(request).render() self.assertEqual(response.status_code, status.HTTP_200_OK) - expected_data = [f for f in self.data if f['date'] > search_date] + expected_data = [f for f in self.data if parse_date(f['date']) > search_date] self.assertEqual(response.data, expected_data) # Tests that the text filter set with 'icontains' in the filter class works. @@ -224,8 +230,8 @@ class IntegrationTestFiltering(CommonFilteringTestCase): }) response = view(request).render() self.assertEqual(response.status_code, status.HTTP_200_OK) - expected_data = [f for f in self.data if f['date'] > search_date and - f['decimal'] < search_decimal] + expected_data = [f for f in self.data if parse_date(f['date']) > search_date and + Decimal(f['decimal']) < search_decimal] self.assertEqual(response.data, expected_data) @unittest.skipUnless(django_filters, 'django-filter not installed') @@ -323,6 +329,11 @@ class SearchFilterModel(models.Model): text = models.CharField(max_length=100) +class SearchFilterSerializer(serializers.ModelSerializer): + class Meta: + model = SearchFilterModel + + class SearchFilterTests(TestCase): def setUp(self): # Sequence of title/text is: @@ -342,7 +353,8 @@ class SearchFilterTests(TestCase): def test_search(self): class SearchListView(generics.ListAPIView): - model = SearchFilterModel + queryset = SearchFilterModel.objects.all() + serializer_class = SearchFilterSerializer filter_backends = (filters.SearchFilter,) search_fields = ('title', 'text') @@ -359,7 +371,8 @@ class SearchFilterTests(TestCase): def test_exact_search(self): class SearchListView(generics.ListAPIView): - model = SearchFilterModel + queryset = SearchFilterModel.objects.all() + serializer_class = SearchFilterSerializer filter_backends = (filters.SearchFilter,) search_fields = ('=title', 'text') @@ -375,7 +388,8 @@ class SearchFilterTests(TestCase): def test_startswith_search(self): class SearchListView(generics.ListAPIView): - model = SearchFilterModel + queryset = SearchFilterModel.objects.all() + serializer_class = SearchFilterSerializer filter_backends = (filters.SearchFilter,) search_fields = ('title', '^text') @@ -392,7 +406,8 @@ class SearchFilterTests(TestCase): def test_search_with_nonstandard_search_param(self): with temporary_setting('SEARCH_PARAM', 'query', module=filters): class SearchListView(generics.ListAPIView): - model = SearchFilterModel + queryset = SearchFilterModel.objects.all() + serializer_class = SearchFilterSerializer filter_backends = (filters.SearchFilter,) search_fields = ('title', 'text') @@ -418,6 +433,11 @@ class OrderingFilterRelatedModel(models.Model): related_name="relateds") +class OrderingFilterSerializer(serializers.ModelSerializer): + class Meta: + model = OrderingFilterModel + + class DjangoFilterOrderingModel(models.Model): date = models.DateField() text = models.CharField(max_length=10) @@ -426,6 +446,11 @@ class DjangoFilterOrderingModel(models.Model): ordering = ['-date'] +class DjangoFilterOrderingSerializer(serializers.ModelSerializer): + class Meta: + model = DjangoFilterOrderingModel + + class DjangoFilterOrderingTests(TestCase): def setUp(self): data = [{ @@ -444,7 +469,8 @@ class DjangoFilterOrderingTests(TestCase): def test_default_ordering(self): class DjangoFilterOrderingView(generics.ListAPIView): - model = DjangoFilterOrderingModel + serializer_class = DjangoFilterOrderingSerializer + queryset = DjangoFilterOrderingModel.objects.all() filter_backends = (filters.DjangoFilterBackend,) filter_fields = ['text'] ordering = ('-date',) @@ -456,9 +482,9 @@ class DjangoFilterOrderingTests(TestCase): self.assertEqual( response.data, [ - {'id': 3, 'date': datetime.date(2014, 10, 8), 'text': 'cde'}, - {'id': 2, 'date': datetime.date(2013, 10, 8), 'text': 'bcd'}, - {'id': 1, 'date': datetime.date(2012, 10, 8), 'text': 'abc'} + {'id': 3, 'date': '2014-10-08', 'text': 'cde'}, + {'id': 2, 'date': '2013-10-08', 'text': 'bcd'}, + {'id': 1, 'date': '2012-10-08', 'text': 'abc'} ] ) @@ -485,7 +511,8 @@ class OrderingFilterTests(TestCase): def test_ordering(self): class OrderingListView(generics.ListAPIView): - model = OrderingFilterModel + queryset = OrderingFilterModel.objects.all() + serializer_class = OrderingFilterSerializer filter_backends = (filters.OrderingFilter,) ordering = ('title',) ordering_fields = ('text',) @@ -504,7 +531,8 @@ class OrderingFilterTests(TestCase): def test_reverse_ordering(self): class OrderingListView(generics.ListAPIView): - model = OrderingFilterModel + queryset = OrderingFilterModel.objects.all() + serializer_class = OrderingFilterSerializer filter_backends = (filters.OrderingFilter,) ordering = ('title',) ordering_fields = ('text',) @@ -523,7 +551,8 @@ class OrderingFilterTests(TestCase): def test_incorrectfield_ordering(self): class OrderingListView(generics.ListAPIView): - model = OrderingFilterModel + queryset = OrderingFilterModel.objects.all() + serializer_class = OrderingFilterSerializer filter_backends = (filters.OrderingFilter,) ordering = ('title',) ordering_fields = ('text',) @@ -542,7 +571,8 @@ class OrderingFilterTests(TestCase): def test_default_ordering(self): class OrderingListView(generics.ListAPIView): - model = OrderingFilterModel + queryset = OrderingFilterModel.objects.all() + serializer_class = OrderingFilterSerializer filter_backends = (filters.OrderingFilter,) ordering = ('title',) oredering_fields = ('text',) @@ -561,7 +591,8 @@ class OrderingFilterTests(TestCase): def test_default_ordering_using_string(self): class OrderingListView(generics.ListAPIView): - model = OrderingFilterModel + queryset = OrderingFilterModel.objects.all() + serializer_class = OrderingFilterSerializer filter_backends = (filters.OrderingFilter,) ordering = 'title' ordering_fields = ('text',) @@ -590,7 +621,7 @@ class OrderingFilterTests(TestCase): new_related.save() class OrderingListView(generics.ListAPIView): - model = OrderingFilterModel + serializer_class = OrderingFilterSerializer filter_backends = (filters.OrderingFilter,) ordering = 'title' ordering_fields = '__all__' @@ -612,7 +643,8 @@ class OrderingFilterTests(TestCase): def test_ordering_with_nonstandard_ordering_param(self): with temporary_setting('ORDERING_PARAM', 'order', filters): class OrderingListView(generics.ListAPIView): - model = OrderingFilterModel + queryset = OrderingFilterModel.objects.all() + serializer_class = OrderingFilterSerializer filter_backends = (filters.OrderingFilter,) ordering = ('title',) ordering_fields = ('text',) diff --git a/tests/test_genericrelations.py b/tests/test_genericrelations.py index 95295eaa..a87ea3fd 100644 --- a/tests/test_genericrelations.py +++ b/tests/test_genericrelations.py @@ -1,151 +1,151 @@ -from __future__ import unicode_literals -from django.contrib.contenttypes.models import ContentType -from django.contrib.contenttypes.generic import GenericRelation, GenericForeignKey -from django.db import models -from django.test import TestCase -from rest_framework import serializers -from rest_framework.compat import python_2_unicode_compatible - - -@python_2_unicode_compatible -class Tag(models.Model): - """ - Tags have a descriptive slug, and are attached to an arbitrary object. - """ - tag = models.SlugField() - content_type = models.ForeignKey(ContentType) - object_id = models.PositiveIntegerField() - tagged_item = GenericForeignKey('content_type', 'object_id') - - def __str__(self): - return self.tag - - -@python_2_unicode_compatible -class Bookmark(models.Model): - """ - A URL bookmark that may have multiple tags attached. - """ - url = models.URLField() - tags = GenericRelation(Tag) - - def __str__(self): - return 'Bookmark: %s' % self.url - - -@python_2_unicode_compatible -class Note(models.Model): - """ - A textual note that may have multiple tags attached. - """ - text = models.TextField() - tags = GenericRelation(Tag) - - def __str__(self): - return 'Note: %s' % self.text - - -class TestGenericRelations(TestCase): - def setUp(self): - self.bookmark = Bookmark.objects.create(url='https://www.djangoproject.com/') - Tag.objects.create(tagged_item=self.bookmark, tag='django') - Tag.objects.create(tagged_item=self.bookmark, tag='python') - self.note = Note.objects.create(text='Remember the milk') - Tag.objects.create(tagged_item=self.note, tag='reminder') - - def test_generic_relation(self): - """ - Test a relationship that spans a GenericRelation field. - IE. A reverse generic relationship. - """ - - class BookmarkSerializer(serializers.ModelSerializer): - tags = serializers.RelatedField(many=True) - - class Meta: - model = Bookmark - exclude = ('id',) - - serializer = BookmarkSerializer(self.bookmark) - expected = { - 'tags': ['django', 'python'], - 'url': 'https://www.djangoproject.com/' - } - self.assertEqual(serializer.data, expected) - - def test_generic_nested_relation(self): - """ - Test saving a GenericRelation field via a nested serializer. - """ - - class TagSerializer(serializers.ModelSerializer): - class Meta: - model = Tag - exclude = ('content_type', 'object_id') - - class BookmarkSerializer(serializers.ModelSerializer): - tags = TagSerializer(many=True) - - class Meta: - model = Bookmark - exclude = ('id',) - - data = { - 'url': 'https://docs.djangoproject.com/', - 'tags': [ - {'tag': 'contenttypes'}, - {'tag': 'genericrelations'}, - ] - } - serializer = BookmarkSerializer(data=data) - self.assertTrue(serializer.is_valid()) - serializer.save() - self.assertEqual(serializer.object.tags.count(), 2) - - def test_generic_fk(self): - """ - Test a relationship that spans a GenericForeignKey field. - IE. A forward generic relationship. - """ - - class TagSerializer(serializers.ModelSerializer): - tagged_item = serializers.RelatedField() - - class Meta: - model = Tag - exclude = ('id', 'content_type', 'object_id') - - serializer = TagSerializer(Tag.objects.all(), many=True) - expected = [ - { - 'tag': 'django', - 'tagged_item': 'Bookmark: https://www.djangoproject.com/' - }, - { - 'tag': 'python', - 'tagged_item': 'Bookmark: https://www.djangoproject.com/' - }, - { - 'tag': 'reminder', - 'tagged_item': 'Note: Remember the milk' - } - ] - self.assertEqual(serializer.data, expected) - - def test_restore_object_generic_fk(self): - """ - Ensure an object with a generic foreign key can be restored. - """ - - class TagSerializer(serializers.ModelSerializer): - class Meta: - model = Tag - exclude = ('content_type', 'object_id') - - serializer = TagSerializer() - - bookmark = Bookmark(url='http://example.com') - attrs = {'tagged_item': bookmark, 'tag': 'example'} - - tag = serializer.restore_object(attrs) - self.assertEqual(tag.tagged_item, bookmark) +# from __future__ import unicode_literals +# from django.contrib.contenttypes.models import ContentType +# from django.contrib.contenttypes.generic import GenericRelation, GenericForeignKey +# from django.db import models +# from django.test import TestCase +# from rest_framework import serializers +# from rest_framework.compat import python_2_unicode_compatible + + +# @python_2_unicode_compatible +# class Tag(models.Model): +# """ +# Tags have a descriptive slug, and are attached to an arbitrary object. +# """ +# tag = models.SlugField() +# content_type = models.ForeignKey(ContentType) +# object_id = models.PositiveIntegerField() +# tagged_item = GenericForeignKey('content_type', 'object_id') + +# def __str__(self): +# return self.tag + + +# @python_2_unicode_compatible +# class Bookmark(models.Model): +# """ +# A URL bookmark that may have multiple tags attached. +# """ +# url = models.URLField() +# tags = GenericRelation(Tag) + +# def __str__(self): +# return 'Bookmark: %s' % self.url + + +# @python_2_unicode_compatible +# class Note(models.Model): +# """ +# A textual note that may have multiple tags attached. +# """ +# text = models.TextField() +# tags = GenericRelation(Tag) + +# def __str__(self): +# return 'Note: %s' % self.text + + +# class TestGenericRelations(TestCase): +# def setUp(self): +# self.bookmark = Bookmark.objects.create(url='https://www.djangoproject.com/') +# Tag.objects.create(tagged_item=self.bookmark, tag='django') +# Tag.objects.create(tagged_item=self.bookmark, tag='python') +# self.note = Note.objects.create(text='Remember the milk') +# Tag.objects.create(tagged_item=self.note, tag='reminder') + +# def test_generic_relation(self): +# """ +# Test a relationship that spans a GenericRelation field. +# IE. A reverse generic relationship. +# """ + +# class BookmarkSerializer(serializers.ModelSerializer): +# tags = serializers.RelatedField(many=True) + +# class Meta: +# model = Bookmark +# exclude = ('id',) + +# serializer = BookmarkSerializer(self.bookmark) +# expected = { +# 'tags': ['django', 'python'], +# 'url': 'https://www.djangoproject.com/' +# } +# self.assertEqual(serializer.data, expected) + +# def test_generic_nested_relation(self): +# """ +# Test saving a GenericRelation field via a nested serializer. +# """ + +# class TagSerializer(serializers.ModelSerializer): +# class Meta: +# model = Tag +# exclude = ('content_type', 'object_id') + +# class BookmarkSerializer(serializers.ModelSerializer): +# tags = TagSerializer(many=True) + +# class Meta: +# model = Bookmark +# exclude = ('id',) + +# data = { +# 'url': 'https://docs.djangoproject.com/', +# 'tags': [ +# {'tag': 'contenttypes'}, +# {'tag': 'genericrelations'}, +# ] +# } +# serializer = BookmarkSerializer(data=data) +# self.assertTrue(serializer.is_valid()) +# serializer.save() +# self.assertEqual(serializer.object.tags.count(), 2) + +# def test_generic_fk(self): +# """ +# Test a relationship that spans a GenericForeignKey field. +# IE. A forward generic relationship. +# """ + +# class TagSerializer(serializers.ModelSerializer): +# tagged_item = serializers.RelatedField() + +# class Meta: +# model = Tag +# exclude = ('id', 'content_type', 'object_id') + +# serializer = TagSerializer(Tag.objects.all(), many=True) +# expected = [ +# { +# 'tag': 'django', +# 'tagged_item': 'Bookmark: https://www.djangoproject.com/' +# }, +# { +# 'tag': 'python', +# 'tagged_item': 'Bookmark: https://www.djangoproject.com/' +# }, +# { +# 'tag': 'reminder', +# 'tagged_item': 'Note: Remember the milk' +# } +# ] +# self.assertEqual(serializer.data, expected) + +# def test_restore_object_generic_fk(self): +# """ +# Ensure an object with a generic foreign key can be restored. +# """ + +# class TagSerializer(serializers.ModelSerializer): +# class Meta: +# model = Tag +# exclude = ('content_type', 'object_id') + +# serializer = TagSerializer() + +# bookmark = Bookmark(url='http://example.com') +# attrs = {'tagged_item': bookmark, 'tag': 'example'} + +# tag = serializer.restore_object(attrs) +# self.assertEqual(tag.tagged_item, bookmark) diff --git a/tests/test_generics.py b/tests/test_generics.py index e9f5bebd..51004edf 100644 --- a/tests/test_generics.py +++ b/tests/test_generics.py @@ -1,4 +1,5 @@ from __future__ import unicode_literals +import django from django.db import models from django.shortcuts import get_object_or_404 from django.test import TestCase @@ -11,44 +12,53 @@ from tests.models import ForeignKeySource, ForeignKeyTarget factory = APIRequestFactory() +class BasicSerializer(serializers.ModelSerializer): + class Meta: + model = BasicModel + + +class ForeignKeySerializer(serializers.ModelSerializer): + class Meta: + model = ForeignKeySource + + class RootView(generics.ListCreateAPIView): """ Example description for OPTIONS. """ - model = BasicModel + queryset = BasicModel.objects.all() + serializer_class = BasicSerializer class InstanceView(generics.RetrieveUpdateDestroyAPIView): """ Example description for OPTIONS. """ - model = BasicModel - - def get_queryset(self): - queryset = super(InstanceView, self).get_queryset() - return queryset.exclude(text='filtered out') + queryset = BasicModel.objects.exclude(text='filtered out') + serializer_class = BasicSerializer class FKInstanceView(generics.RetrieveUpdateDestroyAPIView): """ FK: example description for OPTIONS. """ - model = ForeignKeySource + queryset = ForeignKeySource.objects.all() + serializer_class = ForeignKeySerializer class SlugSerializer(serializers.ModelSerializer): - slug = serializers.Field() # read only + slug = serializers.Field(read_only=True) class Meta: model = SlugBasedModel - exclude = ('id',) + fields = ('text', 'slug') class SlugBasedInstanceView(InstanceView): """ A model with a slug-field. """ - model = SlugBasedModel + queryset = SlugBasedModel.objects.all() serializer_class = SlugSerializer lookup_field = 'slug' @@ -112,46 +122,46 @@ class TestRootView(TestCase): self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED) self.assertEqual(response.data, {"detail": "Method 'DELETE' not allowed."}) - def test_options_root_view(self): - """ - OPTIONS requests to ListCreateAPIView should return metadata - """ - request = factory.options('/') - with self.assertNumQueries(0): - response = self.view(request).render() - expected = { - 'parses': [ - 'application/json', - 'application/x-www-form-urlencoded', - 'multipart/form-data' - ], - 'renders': [ - 'application/json', - 'text/html' - ], - 'name': 'Root', - 'description': 'Example description for OPTIONS.', - 'actions': { - 'POST': { - 'text': { - 'max_length': 100, - 'read_only': False, - 'required': True, - 'type': 'string', - "label": "Text comes here", - "help_text": "Text description." - }, - 'id': { - 'read_only': True, - 'required': False, - 'type': 'integer', - 'label': 'ID', - }, - } - } - } - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, expected) + # def test_options_root_view(self): + # """ + # OPTIONS requests to ListCreateAPIView should return metadata + # """ + # request = factory.options('/') + # with self.assertNumQueries(0): + # response = self.view(request).render() + # expected = { + # 'parses': [ + # 'application/json', + # 'application/x-www-form-urlencoded', + # 'multipart/form-data' + # ], + # 'renders': [ + # 'application/json', + # 'text/html' + # ], + # 'name': 'Root', + # 'description': 'Example description for OPTIONS.', + # 'actions': { + # 'POST': { + # 'text': { + # 'max_length': 100, + # 'read_only': False, + # 'required': True, + # 'type': 'string', + # "label": "Text comes here", + # "help_text": "Text description." + # }, + # 'id': { + # 'read_only': True, + # 'required': False, + # 'type': 'integer', + # 'label': 'ID', + # }, + # } + # } + # } + # self.assertEqual(response.status_code, status.HTTP_200_OK) + # self.assertEqual(response.data, expected) def test_post_cannot_set_id(self): """ @@ -167,6 +177,9 @@ class TestRootView(TestCase): self.assertEqual(created.text, 'foobar') +EXPECTED_QUERYS_FOR_PUT = 3 if django.VERSION < (1, 6) else 2 + + class TestInstanceView(TestCase): def setUp(self): """ @@ -210,10 +223,10 @@ class TestInstanceView(TestCase): """ data = {'text': 'foobar'} request = factory.put('/1', data, format='json') - with self.assertNumQueries(2): + with self.assertNumQueries(EXPECTED_QUERYS_FOR_PUT): response = self.view(request, pk='1').render() self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, {'id': 1, 'text': 'foobar'}) + self.assertEqual(dict(response.data), {'id': 1, 'text': 'foobar'}) updated = self.objects.get(id=1) self.assertEqual(updated.text, 'foobar') @@ -224,7 +237,7 @@ class TestInstanceView(TestCase): data = {'text': 'foobar'} request = factory.patch('/1', data, format='json') - with self.assertNumQueries(2): + with self.assertNumQueries(EXPECTED_QUERYS_FOR_PUT): response = self.view(request, pk=1).render() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data, {'id': 1, 'text': 'foobar'}) @@ -243,88 +256,88 @@ class TestInstanceView(TestCase): ids = [obj.id for obj in self.objects.all()] self.assertEqual(ids, [2, 3]) - def test_options_instance_view(self): - """ - OPTIONS requests to RetrieveUpdateDestroyAPIView should return metadata - """ - request = factory.options('/1') - with self.assertNumQueries(1): - response = self.view(request, pk=1).render() - expected = { - 'parses': [ - 'application/json', - 'application/x-www-form-urlencoded', - 'multipart/form-data' - ], - 'renders': [ - 'application/json', - 'text/html' - ], - 'name': 'Instance', - 'description': 'Example description for OPTIONS.', - 'actions': { - 'PUT': { - 'text': { - 'max_length': 100, - 'read_only': False, - 'required': True, - 'type': 'string', - 'label': 'Text comes here', - 'help_text': 'Text description.' - }, - 'id': { - 'read_only': True, - 'required': False, - 'type': 'integer', - 'label': 'ID', - }, - } - } - } - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, expected) - - def test_options_before_instance_create(self): - """ - OPTIONS requests to RetrieveUpdateDestroyAPIView should return metadata - before the instance has been created - """ - request = factory.options('/999') - with self.assertNumQueries(1): - response = self.view(request, pk=999).render() - expected = { - 'parses': [ - 'application/json', - 'application/x-www-form-urlencoded', - 'multipart/form-data' - ], - 'renders': [ - 'application/json', - 'text/html' - ], - 'name': 'Instance', - 'description': 'Example description for OPTIONS.', - 'actions': { - 'PUT': { - 'text': { - 'max_length': 100, - 'read_only': False, - 'required': True, - 'type': 'string', - 'label': 'Text comes here', - 'help_text': 'Text description.' - }, - 'id': { - 'read_only': True, - 'required': False, - 'type': 'integer', - 'label': 'ID', - }, - } - } - } - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, expected) + # def test_options_instance_view(self): + # """ + # OPTIONS requests to RetrieveUpdateDestroyAPIView should return metadata + # """ + # request = factory.options('/1') + # with self.assertNumQueries(1): + # response = self.view(request, pk=1).render() + # expected = { + # 'parses': [ + # 'application/json', + # 'application/x-www-form-urlencoded', + # 'multipart/form-data' + # ], + # 'renders': [ + # 'application/json', + # 'text/html' + # ], + # 'name': 'Instance', + # 'description': 'Example description for OPTIONS.', + # 'actions': { + # 'PUT': { + # 'text': { + # 'max_length': 100, + # 'read_only': False, + # 'required': True, + # 'type': 'string', + # 'label': 'Text comes here', + # 'help_text': 'Text description.' + # }, + # 'id': { + # 'read_only': True, + # 'required': False, + # 'type': 'integer', + # 'label': 'ID', + # }, + # } + # } + # } + # self.assertEqual(response.status_code, status.HTTP_200_OK) + # self.assertEqual(response.data, expected) + + # def test_options_before_instance_create(self): + # """ + # OPTIONS requests to RetrieveUpdateDestroyAPIView should return metadata + # before the instance has been created + # """ + # request = factory.options('/999') + # with self.assertNumQueries(1): + # response = self.view(request, pk=999).render() + # expected = { + # 'parses': [ + # 'application/json', + # 'application/x-www-form-urlencoded', + # 'multipart/form-data' + # ], + # 'renders': [ + # 'application/json', + # 'text/html' + # ], + # 'name': 'Instance', + # 'description': 'Example description for OPTIONS.', + # 'actions': { + # 'PUT': { + # 'text': { + # 'max_length': 100, + # 'read_only': False, + # 'required': True, + # 'type': 'string', + # 'label': 'Text comes here', + # 'help_text': 'Text description.' + # }, + # 'id': { + # 'read_only': True, + # 'required': False, + # 'type': 'integer', + # 'label': 'ID', + # }, + # } + # } + # } + # self.assertEqual(response.status_code, status.HTTP_200_OK) + # self.assertEqual(response.data, expected) def test_get_instance_view_incorrect_arg(self): """ @@ -342,7 +355,7 @@ class TestInstanceView(TestCase): """ data = {'id': 999, 'text': 'foobar'} request = factory.put('/1', data, format='json') - with self.assertNumQueries(2): + with self.assertNumQueries(EXPECTED_QUERYS_FOR_PUT): response = self.view(request, pk=1).render() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data, {'id': 1, 'text': 'foobar'}) @@ -351,18 +364,15 @@ class TestInstanceView(TestCase): def test_put_to_deleted_instance(self): """ - PUT requests to RetrieveUpdateDestroyAPIView should create an object - if it does not currently exist. + PUT requests to RetrieveUpdateDestroyAPIView should return 404 if + an object does not currently exist. """ self.objects.get(id=1).delete() data = {'text': 'foobar'} request = factory.put('/1', data, format='json') - with self.assertNumQueries(3): + with self.assertNumQueries(1): response = self.view(request, pk=1).render() - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - self.assertEqual(response.data, {'id': 1, 'text': 'foobar'}) - updated = self.objects.get(id=1) - self.assertEqual(updated.text, 'foobar') + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_put_to_filtered_out_instance(self): """ @@ -373,35 +383,7 @@ class TestInstanceView(TestCase): filtered_out_pk = BasicModel.objects.filter(text='filtered out')[0].pk request = factory.put('/{0}'.format(filtered_out_pk), data, format='json') response = self.view(request, pk=filtered_out_pk).render() - self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) - - def test_put_as_create_on_id_based_url(self): - """ - PUT requests to RetrieveUpdateDestroyAPIView should create an object - at the requested url if it doesn't exist. - """ - data = {'text': 'foobar'} - # pk fields can not be created on demand, only the database can set the pk for a new object - request = factory.put('/5', data, format='json') - with self.assertNumQueries(3): - response = self.view(request, pk=5).render() - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - new_obj = self.objects.get(pk=5) - self.assertEqual(new_obj.text, 'foobar') - - def test_put_as_create_on_slug_based_url(self): - """ - PUT requests to RetrieveUpdateDestroyAPIView should create an object - at the requested url if possible, else return HTTP_403_FORBIDDEN error-response. - """ - data = {'text': 'foobar'} - request = factory.put('/test_slug', data, format='json') - with self.assertNumQueries(2): - response = self.slug_based_view(request, slug='test_slug').render() - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - self.assertEqual(response.data, {'slug': 'test_slug', 'text': 'foobar'}) - new_obj = SlugBasedModel.objects.get(slug='test_slug') - self.assertEqual(new_obj.text, 'foobar') + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_patch_cannot_create_an_object(self): """ @@ -433,52 +415,52 @@ class TestFKInstanceView(TestCase): ] self.view = FKInstanceView.as_view() - def test_options_root_view(self): - """ - OPTIONS requests to ListCreateAPIView should return metadata - """ - request = factory.options('/999') - with self.assertNumQueries(1): - response = self.view(request, pk=999).render() - expected = { - 'name': 'Fk Instance', - 'description': 'FK: example description for OPTIONS.', - 'renders': [ - 'application/json', - 'text/html' - ], - 'parses': [ - 'application/json', - 'application/x-www-form-urlencoded', - 'multipart/form-data' - ], - 'actions': { - 'PUT': { - 'id': { - 'type': 'integer', - 'required': False, - 'read_only': True, - 'label': 'ID' - }, - 'name': { - 'type': 'string', - 'required': True, - 'read_only': False, - 'label': 'name', - 'max_length': 100 - }, - 'target': { - 'type': 'field', - 'required': True, - 'read_only': False, - 'label': 'Target', - 'help_text': 'Target' - } - } - } - } - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, expected) + # def test_options_root_view(self): + # """ + # OPTIONS requests to ListCreateAPIView should return metadata + # """ + # request = factory.options('/999') + # with self.assertNumQueries(1): + # response = self.view(request, pk=999).render() + # expected = { + # 'name': 'Fk Instance', + # 'description': 'FK: example description for OPTIONS.', + # 'renders': [ + # 'application/json', + # 'text/html' + # ], + # 'parses': [ + # 'application/json', + # 'application/x-www-form-urlencoded', + # 'multipart/form-data' + # ], + # 'actions': { + # 'PUT': { + # 'id': { + # 'type': 'integer', + # 'required': False, + # 'read_only': True, + # 'label': 'ID' + # }, + # 'name': { + # 'type': 'string', + # 'required': True, + # 'read_only': False, + # 'label': 'name', + # 'max_length': 100 + # }, + # 'target': { + # 'type': 'field', + # 'required': True, + # 'read_only': False, + # 'label': 'Target', + # 'help_text': 'Target' + # } + # } + # } + # } + # self.assertEqual(response.status_code, status.HTTP_200_OK) + # self.assertEqual(response.data, expected) class TestOverriddenGetObject(TestCase): @@ -503,7 +485,7 @@ class TestOverriddenGetObject(TestCase): """ Example detail view for override of get_object(). """ - model = BasicModel + serializer_class = BasicSerializer def get_object(self): pk = int(self.kwargs['pk']) @@ -565,7 +547,9 @@ class ClassA(models.Model): class ClassASerializer(serializers.ModelSerializer): - childs = serializers.PrimaryKeyRelatedField(many=True, source='childs') + childs = serializers.PrimaryKeyRelatedField( + many=True, queryset=ClassB.objects.all() + ) class Meta: model = ClassA @@ -573,7 +557,7 @@ class ClassASerializer(serializers.ModelSerializer): class ExampleView(generics.ListCreateAPIView): serializer_class = ClassASerializer - model = ClassA + queryset = ClassA.objects.all() class TestM2MBrowseableAPI(TestCase): @@ -603,7 +587,7 @@ class TwoFieldModel(models.Model): class DynamicSerializerView(generics.ListCreateAPIView): - model = TwoFieldModel + queryset = TwoFieldModel.objects.all() renderer_classes = (renderers.BrowsableAPIRenderer, renderers.JSONRenderer) def get_serializer_class(self): @@ -612,8 +596,11 @@ class DynamicSerializerView(generics.ListCreateAPIView): class Meta: model = TwoFieldModel fields = ('field_b',) - return DynamicSerializer - return super(DynamicSerializerView, self).get_serializer_class() + else: + class DynamicSerializer(serializers.ModelSerializer): + class Meta: + model = TwoFieldModel + return DynamicSerializer class TestFilterBackendAppliedToViews(TestCase): diff --git a/tests/test_hyperlinkedserializers.py b/tests/test_hyperlinkedserializers.py index d4548539..ff3663dd 100644 --- a/tests/test_hyperlinkedserializers.py +++ b/tests/test_hyperlinkedserializers.py @@ -1,380 +1,406 @@ -from __future__ import unicode_literals -import json -from django.test import TestCase -from rest_framework import generics, status, serializers -from django.conf.urls import patterns, url -from rest_framework.settings import api_settings -from rest_framework.test import APIRequestFactory -from tests.models import ( - Anchor, BasicModel, ManyToManyModel, BlogPost, BlogPostComment, - Album, Photo, OptionalRelationModel -) +# from __future__ import unicode_literals +# import json +# from django.test import TestCase +# from rest_framework import generics, status, serializers +# from django.conf.urls import patterns, url +# from rest_framework.settings import api_settings +# from rest_framework.test import APIRequestFactory +# from tests.models import ( +# Anchor, BasicModel, ManyToManyModel, BlogPost, BlogPostComment, +# Album, Photo, OptionalRelationModel +# ) -factory = APIRequestFactory() +# factory = APIRequestFactory() -class BlogPostCommentSerializer(serializers.ModelSerializer): - url = serializers.HyperlinkedIdentityField(view_name='blogpostcomment-detail') - text = serializers.CharField() - blog_post_url = serializers.HyperlinkedRelatedField(source='blog_post', view_name='blogpost-detail') +# class BlogPostCommentSerializer(serializers.ModelSerializer): +# url = serializers.HyperlinkedIdentityField(view_name='blogpostcomment-detail') +# text = serializers.CharField() +# blog_post_url = serializers.HyperlinkedRelatedField(source='blog_post', view_name='blogpost-detail') - class Meta: - model = BlogPostComment - fields = ('text', 'blog_post_url', 'url') +# class Meta: +# model = BlogPostComment +# fields = ('text', 'blog_post_url', 'url') -class PhotoSerializer(serializers.Serializer): - description = serializers.CharField() - album_url = serializers.HyperlinkedRelatedField(source='album', view_name='album-detail', queryset=Album.objects.all(), lookup_field='title') +# class PhotoSerializer(serializers.Serializer): +# description = serializers.CharField() +# album_url = serializers.HyperlinkedRelatedField(source='album', view_name='album-detail', queryset=Album.objects.all(), lookup_field='title') - def restore_object(self, attrs, instance=None): - return Photo(**attrs) +# def restore_object(self, attrs, instance=None): +# return Photo(**attrs) -class AlbumSerializer(serializers.ModelSerializer): - url = serializers.HyperlinkedIdentityField(view_name='album-detail', lookup_field='title') +# class AlbumSerializer(serializers.ModelSerializer): +# url = serializers.HyperlinkedIdentityField(view_name='album-detail', lookup_field='title') - class Meta: - model = Album - fields = ('title', 'url') +# class Meta: +# model = Album +# fields = ('title', 'url') -class BasicList(generics.ListCreateAPIView): - model = BasicModel - model_serializer_class = serializers.HyperlinkedModelSerializer +# class BasicSerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = BasicModel -class BasicDetail(generics.RetrieveUpdateDestroyAPIView): - model = BasicModel - model_serializer_class = serializers.HyperlinkedModelSerializer +# class AnchorSerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = Anchor -class AnchorDetail(generics.RetrieveAPIView): - model = Anchor - model_serializer_class = serializers.HyperlinkedModelSerializer +# class ManyToManySerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = ManyToManyModel -class ManyToManyList(generics.ListAPIView): - model = ManyToManyModel - model_serializer_class = serializers.HyperlinkedModelSerializer +# class BlogPostSerializer(serializers.ModelSerializer): +# class Meta: +# model = BlogPost -class ManyToManyDetail(generics.RetrieveAPIView): - model = ManyToManyModel - model_serializer_class = serializers.HyperlinkedModelSerializer +# class OptionalRelationSerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = OptionalRelationModel -class BlogPostCommentListCreate(generics.ListCreateAPIView): - model = BlogPostComment - serializer_class = BlogPostCommentSerializer +# class BasicList(generics.ListCreateAPIView): +# queryset = BasicModel.objects.all() +# serializer_class = BasicSerializer -class BlogPostCommentDetail(generics.RetrieveAPIView): - model = BlogPostComment - serializer_class = BlogPostCommentSerializer +# class BasicDetail(generics.RetrieveUpdateDestroyAPIView): +# queryset = BasicModel.objects.all() +# serializer_class = BasicSerializer -class BlogPostDetail(generics.RetrieveAPIView): - model = BlogPost +# class AnchorDetail(generics.RetrieveAPIView): +# queryset = Anchor.objects.all() +# serializer_class = AnchorSerializer -class PhotoListCreate(generics.ListCreateAPIView): - model = Photo - model_serializer_class = PhotoSerializer - - -class AlbumDetail(generics.RetrieveAPIView): - model = Album - serializer_class = AlbumSerializer - lookup_field = 'title' - - -class OptionalRelationDetail(generics.RetrieveUpdateDestroyAPIView): - model = OptionalRelationModel - model_serializer_class = serializers.HyperlinkedModelSerializer - - -urlpatterns = patterns( - '', - url(r'^basic/$', BasicList.as_view(), name='basicmodel-list'), - url(r'^basic/(?P<pk>\d+)/$', BasicDetail.as_view(), name='basicmodel-detail'), - url(r'^anchor/(?P<pk>\d+)/$', AnchorDetail.as_view(), name='anchor-detail'), - url(r'^manytomany/$', ManyToManyList.as_view(), name='manytomanymodel-list'), - url(r'^manytomany/(?P<pk>\d+)/$', ManyToManyDetail.as_view(), name='manytomanymodel-detail'), - url(r'^posts/(?P<pk>\d+)/$', BlogPostDetail.as_view(), name='blogpost-detail'), - url(r'^comments/$', BlogPostCommentListCreate.as_view(), name='blogpostcomment-list'), - url(r'^comments/(?P<pk>\d+)/$', BlogPostCommentDetail.as_view(), name='blogpostcomment-detail'), - url(r'^albums/(?P<title>\w[\w-]*)/$', AlbumDetail.as_view(), name='album-detail'), - url(r'^photos/$', PhotoListCreate.as_view(), name='photo-list'), - url(r'^optionalrelation/(?P<pk>\d+)/$', OptionalRelationDetail.as_view(), name='optionalrelationmodel-detail'), -) - - -class TestBasicHyperlinkedView(TestCase): - urls = 'tests.test_hyperlinkedserializers' - - def setUp(self): - """ - Create 3 BasicModel instances. - """ - items = ['foo', 'bar', 'baz'] - for item in items: - BasicModel(text=item).save() - self.objects = BasicModel.objects - self.data = [ - {'url': 'http://testserver/basic/%d/' % obj.id, 'text': obj.text} - for obj in self.objects.all() - ] - self.list_view = BasicList.as_view() - self.detail_view = BasicDetail.as_view() - - def test_get_list_view(self): - """ - GET requests to ListCreateAPIView should return list of objects. - """ - request = factory.get('/basic/') - response = self.list_view(request).render() - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, self.data) - - def test_get_detail_view(self): - """ - GET requests to ListCreateAPIView should return list of objects. - """ - request = factory.get('/basic/1') - response = self.detail_view(request, pk=1).render() - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, self.data[0]) - - -class TestManyToManyHyperlinkedView(TestCase): - urls = 'tests.test_hyperlinkedserializers' - - def setUp(self): - """ - Create 3 BasicModel instances. - """ - items = ['foo', 'bar', 'baz'] - anchors = [] - for item in items: - anchor = Anchor(text=item) - anchor.save() - anchors.append(anchor) - - manytomany = ManyToManyModel() - manytomany.save() - manytomany.rel.add(*anchors) - - self.data = [{ - 'url': 'http://testserver/manytomany/1/', - 'rel': [ - 'http://testserver/anchor/1/', - 'http://testserver/anchor/2/', - 'http://testserver/anchor/3/', - ] - }] - self.list_view = ManyToManyList.as_view() - self.detail_view = ManyToManyDetail.as_view() - - def test_get_list_view(self): - """ - GET requests to ListCreateAPIView should return list of objects. - """ - request = factory.get('/manytomany/') - response = self.list_view(request) - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, self.data) - - def test_get_detail_view(self): - """ - GET requests to ListCreateAPIView should return list of objects. - """ - request = factory.get('/manytomany/1/') - response = self.detail_view(request, pk=1) - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, self.data[0]) - - -class TestHyperlinkedIdentityFieldLookup(TestCase): - urls = 'tests.test_hyperlinkedserializers' - - def setUp(self): - """ - Create 3 Album instances. - """ - titles = ['foo', 'bar', 'baz'] - for title in titles: - album = Album(title=title) - album.save() - self.detail_view = AlbumDetail.as_view() - self.data = { - 'foo': {'title': 'foo', 'url': 'http://testserver/albums/foo/'}, - 'bar': {'title': 'bar', 'url': 'http://testserver/albums/bar/'}, - 'baz': {'title': 'baz', 'url': 'http://testserver/albums/baz/'} - } - - def test_lookup_field(self): - """ - GET requests to AlbumDetail view should return serialized Albums - with a url field keyed by `title`. - """ - for album in Album.objects.all(): - request = factory.get('/albums/{0}/'.format(album.title)) - response = self.detail_view(request, title=album.title) - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, self.data[album.title]) - - -class TestCreateWithForeignKeys(TestCase): - urls = 'tests.test_hyperlinkedserializers' - - def setUp(self): - """ - Create a blog post - """ - self.post = BlogPost.objects.create(title="Test post") - self.create_view = BlogPostCommentListCreate.as_view() - - def test_create_comment(self): - - data = { - 'text': 'A test comment', - 'blog_post_url': 'http://testserver/posts/1/' - } - - request = factory.post('/comments/', data=data) - response = self.create_view(request) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - self.assertEqual(response['Location'], 'http://testserver/comments/1/') - self.assertEqual(self.post.blogpostcomment_set.count(), 1) - self.assertEqual(self.post.blogpostcomment_set.all()[0].text, 'A test comment') - - -class TestCreateWithForeignKeysAndCustomSlug(TestCase): - urls = 'tests.test_hyperlinkedserializers' - - def setUp(self): - """ - Create an Album - """ - self.post = Album.objects.create(title='test-album') - self.list_create_view = PhotoListCreate.as_view() - - def test_create_photo(self): - - data = { - 'description': 'A test photo', - 'album_url': 'http://testserver/albums/test-album/' - } - - request = factory.post('/photos/', data=data) - response = self.list_create_view(request) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - self.assertNotIn('Location', response, msg='Location should only be included if there is a "url" field on the serializer') - self.assertEqual(self.post.photo_set.count(), 1) - self.assertEqual(self.post.photo_set.all()[0].description, 'A test photo') - - -class TestOptionalRelationHyperlinkedView(TestCase): - urls = 'tests.test_hyperlinkedserializers' - - def setUp(self): - """ - Create 1 OptionalRelationModel instances. - """ - OptionalRelationModel().save() - self.objects = OptionalRelationModel.objects - self.detail_view = OptionalRelationDetail.as_view() - self.data = {"url": "http://testserver/optionalrelation/1/", "other": None} - - def test_get_detail_view(self): - """ - GET requests to RetrieveAPIView with optional relations should return None - for non existing relations. - """ - request = factory.get('/optionalrelationmodel-detail/1') - response = self.detail_view(request, pk=1) - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data, self.data) - - def test_put_detail_view(self): - """ - PUT requests to RetrieveUpdateDestroyAPIView with optional relations - should accept None for non existing relations. - """ - response = self.client.put('/optionalrelation/1/', - data=json.dumps(self.data), - content_type='application/json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - - -class TestOverriddenURLField(TestCase): - def setUp(self): - class OverriddenURLSerializer(serializers.HyperlinkedModelSerializer): - url = serializers.SerializerMethodField('get_url') - - class Meta: - model = BlogPost - fields = ('title', 'url') - - def get_url(self, obj): - return 'foo bar' - - self.Serializer = OverriddenURLSerializer - self.obj = BlogPost.objects.create(title='New blog post') - - def test_overridden_url_field(self): - """ - The 'url' field should respect overriding. - Regression test for #936. - """ - serializer = self.Serializer(self.obj) - self.assertEqual( - serializer.data, - {'title': 'New blog post', 'url': 'foo bar'} - ) - - -class TestURLFieldNameBySettings(TestCase): - urls = 'tests.test_hyperlinkedserializers' - - def setUp(self): - self.saved_url_field_name = api_settings.URL_FIELD_NAME - api_settings.URL_FIELD_NAME = 'global_url_field' - - class Serializer(serializers.HyperlinkedModelSerializer): - - class Meta: - model = BlogPost - fields = ('title', api_settings.URL_FIELD_NAME) - - self.Serializer = Serializer - self.obj = BlogPost.objects.create(title="New blog post") - - def tearDown(self): - api_settings.URL_FIELD_NAME = self.saved_url_field_name - - def test_overridden_url_field_name(self): - request = factory.get('/posts/') - serializer = self.Serializer(self.obj, context={'request': request}) - self.assertIn(api_settings.URL_FIELD_NAME, serializer.data) - - -class TestURLFieldNameByOptions(TestCase): - urls = 'tests.test_hyperlinkedserializers' - - def setUp(self): - class Serializer(serializers.HyperlinkedModelSerializer): - - class Meta: - model = BlogPost - fields = ('title', 'serializer_url_field') - url_field_name = 'serializer_url_field' - - self.Serializer = Serializer - self.obj = BlogPost.objects.create(title="New blog post") - - def test_overridden_url_field_name(self): - request = factory.get('/posts/') - serializer = self.Serializer(self.obj, context={'request': request}) - self.assertIn(self.Serializer.Meta.url_field_name, serializer.data) +# class ManyToManyList(generics.ListAPIView): +# queryset = ManyToManyModel.objects.all() +# serializer_class = ManyToManySerializer + + +# class ManyToManyDetail(generics.RetrieveAPIView): +# queryset = ManyToManyModel.objects.all() +# serializer_class = ManyToManySerializer + + +# class BlogPostCommentListCreate(generics.ListCreateAPIView): +# queryset = BlogPostComment.objects.all() +# serializer_class = BlogPostCommentSerializer + + +# class BlogPostCommentDetail(generics.RetrieveAPIView): +# queryset = BlogPostComment.objects.all() +# serializer_class = BlogPostCommentSerializer + + +# class BlogPostDetail(generics.RetrieveAPIView): +# queryset = BlogPost.objects.all() +# serializer_class = BlogPostSerializer + + +# class PhotoListCreate(generics.ListCreateAPIView): +# queryset = Photo.objects.all() +# serializer_class = PhotoSerializer + + +# class AlbumDetail(generics.RetrieveAPIView): +# queryset = Album.objects.all() +# serializer_class = AlbumSerializer +# lookup_field = 'title' + + +# class OptionalRelationDetail(generics.RetrieveUpdateDestroyAPIView): +# queryset = OptionalRelationModel.objects.all() +# serializer_class = OptionalRelationSerializer + + +# urlpatterns = patterns( +# '', +# url(r'^basic/$', BasicList.as_view(), name='basicmodel-list'), +# url(r'^basic/(?P<pk>\d+)/$', BasicDetail.as_view(), name='basicmodel-detail'), +# url(r'^anchor/(?P<pk>\d+)/$', AnchorDetail.as_view(), name='anchor-detail'), +# url(r'^manytomany/$', ManyToManyList.as_view(), name='manytomanymodel-list'), +# url(r'^manytomany/(?P<pk>\d+)/$', ManyToManyDetail.as_view(), name='manytomanymodel-detail'), +# url(r'^posts/(?P<pk>\d+)/$', BlogPostDetail.as_view(), name='blogpost-detail'), +# url(r'^comments/$', BlogPostCommentListCreate.as_view(), name='blogpostcomment-list'), +# url(r'^comments/(?P<pk>\d+)/$', BlogPostCommentDetail.as_view(), name='blogpostcomment-detail'), +# url(r'^albums/(?P<title>\w[\w-]*)/$', AlbumDetail.as_view(), name='album-detail'), +# url(r'^photos/$', PhotoListCreate.as_view(), name='photo-list'), +# url(r'^optionalrelation/(?P<pk>\d+)/$', OptionalRelationDetail.as_view(), name='optionalrelationmodel-detail'), +# ) + + +# class TestBasicHyperlinkedView(TestCase): +# urls = 'tests.test_hyperlinkedserializers' + +# def setUp(self): +# """ +# Create 3 BasicModel instances. +# """ +# items = ['foo', 'bar', 'baz'] +# for item in items: +# BasicModel(text=item).save() +# self.objects = BasicModel.objects +# self.data = [ +# {'url': 'http://testserver/basic/%d/' % obj.id, 'text': obj.text} +# for obj in self.objects.all() +# ] +# self.list_view = BasicList.as_view() +# self.detail_view = BasicDetail.as_view() + +# def test_get_list_view(self): +# """ +# GET requests to ListCreateAPIView should return list of objects. +# """ +# request = factory.get('/basic/') +# response = self.list_view(request).render() +# self.assertEqual(response.status_code, status.HTTP_200_OK) +# self.assertEqual(response.data, self.data) + +# def test_get_detail_view(self): +# """ +# GET requests to ListCreateAPIView should return list of objects. +# """ +# request = factory.get('/basic/1') +# response = self.detail_view(request, pk=1).render() +# self.assertEqual(response.status_code, status.HTTP_200_OK) +# self.assertEqual(response.data, self.data[0]) + + +# class TestManyToManyHyperlinkedView(TestCase): +# urls = 'tests.test_hyperlinkedserializers' + +# def setUp(self): +# """ +# Create 3 BasicModel instances. +# """ +# items = ['foo', 'bar', 'baz'] +# anchors = [] +# for item in items: +# anchor = Anchor(text=item) +# anchor.save() +# anchors.append(anchor) + +# manytomany = ManyToManyModel() +# manytomany.save() +# manytomany.rel.add(*anchors) + +# self.data = [{ +# 'url': 'http://testserver/manytomany/1/', +# 'rel': [ +# 'http://testserver/anchor/1/', +# 'http://testserver/anchor/2/', +# 'http://testserver/anchor/3/', +# ] +# }] +# self.list_view = ManyToManyList.as_view() +# self.detail_view = ManyToManyDetail.as_view() + +# def test_get_list_view(self): +# """ +# GET requests to ListCreateAPIView should return list of objects. +# """ +# request = factory.get('/manytomany/') +# response = self.list_view(request) +# self.assertEqual(response.status_code, status.HTTP_200_OK) +# self.assertEqual(response.data, self.data) + +# def test_get_detail_view(self): +# """ +# GET requests to ListCreateAPIView should return list of objects. +# """ +# request = factory.get('/manytomany/1/') +# response = self.detail_view(request, pk=1) +# self.assertEqual(response.status_code, status.HTTP_200_OK) +# self.assertEqual(response.data, self.data[0]) + + +# class TestHyperlinkedIdentityFieldLookup(TestCase): +# urls = 'tests.test_hyperlinkedserializers' + +# def setUp(self): +# """ +# Create 3 Album instances. +# """ +# titles = ['foo', 'bar', 'baz'] +# for title in titles: +# album = Album(title=title) +# album.save() +# self.detail_view = AlbumDetail.as_view() +# self.data = { +# 'foo': {'title': 'foo', 'url': 'http://testserver/albums/foo/'}, +# 'bar': {'title': 'bar', 'url': 'http://testserver/albums/bar/'}, +# 'baz': {'title': 'baz', 'url': 'http://testserver/albums/baz/'} +# } + +# def test_lookup_field(self): +# """ +# GET requests to AlbumDetail view should return serialized Albums +# with a url field keyed by `title`. +# """ +# for album in Album.objects.all(): +# request = factory.get('/albums/{0}/'.format(album.title)) +# response = self.detail_view(request, title=album.title) +# self.assertEqual(response.status_code, status.HTTP_200_OK) +# self.assertEqual(response.data, self.data[album.title]) + + +# class TestCreateWithForeignKeys(TestCase): +# urls = 'tests.test_hyperlinkedserializers' + +# def setUp(self): +# """ +# Create a blog post +# """ +# self.post = BlogPost.objects.create(title="Test post") +# self.create_view = BlogPostCommentListCreate.as_view() + +# def test_create_comment(self): + +# data = { +# 'text': 'A test comment', +# 'blog_post_url': 'http://testserver/posts/1/' +# } + +# request = factory.post('/comments/', data=data) +# response = self.create_view(request) +# self.assertEqual(response.status_code, status.HTTP_201_CREATED) +# self.assertEqual(response['Location'], 'http://testserver/comments/1/') +# self.assertEqual(self.post.blogpostcomment_set.count(), 1) +# self.assertEqual(self.post.blogpostcomment_set.all()[0].text, 'A test comment') + + +# class TestCreateWithForeignKeysAndCustomSlug(TestCase): +# urls = 'tests.test_hyperlinkedserializers' + +# def setUp(self): +# """ +# Create an Album +# """ +# self.post = Album.objects.create(title='test-album') +# self.list_create_view = PhotoListCreate.as_view() + +# def test_create_photo(self): + +# data = { +# 'description': 'A test photo', +# 'album_url': 'http://testserver/albums/test-album/' +# } + +# request = factory.post('/photos/', data=data) +# response = self.list_create_view(request) +# self.assertEqual(response.status_code, status.HTTP_201_CREATED) +# self.assertNotIn('Location', response, msg='Location should only be included if there is a "url" field on the serializer') +# self.assertEqual(self.post.photo_set.count(), 1) +# self.assertEqual(self.post.photo_set.all()[0].description, 'A test photo') + + +# class TestOptionalRelationHyperlinkedView(TestCase): +# urls = 'tests.test_hyperlinkedserializers' + +# def setUp(self): +# """ +# Create 1 OptionalRelationModel instances. +# """ +# OptionalRelationModel().save() +# self.objects = OptionalRelationModel.objects +# self.detail_view = OptionalRelationDetail.as_view() +# self.data = {"url": "http://testserver/optionalrelation/1/", "other": None} + +# def test_get_detail_view(self): +# """ +# GET requests to RetrieveAPIView with optional relations should return None +# for non existing relations. +# """ +# request = factory.get('/optionalrelationmodel-detail/1') +# response = self.detail_view(request, pk=1) +# self.assertEqual(response.status_code, status.HTTP_200_OK) +# self.assertEqual(response.data, self.data) + +# def test_put_detail_view(self): +# """ +# PUT requests to RetrieveUpdateDestroyAPIView with optional relations +# should accept None for non existing relations. +# """ +# response = self.client.put('/optionalrelation/1/', +# data=json.dumps(self.data), +# content_type='application/json') +# self.assertEqual(response.status_code, status.HTTP_200_OK) + + +# class TestOverriddenURLField(TestCase): +# def setUp(self): +# class OverriddenURLSerializer(serializers.HyperlinkedModelSerializer): +# url = serializers.SerializerMethodField('get_url') + +# class Meta: +# model = BlogPost +# fields = ('title', 'url') + +# def get_url(self, obj): +# return 'foo bar' + +# self.Serializer = OverriddenURLSerializer +# self.obj = BlogPost.objects.create(title='New blog post') + +# def test_overridden_url_field(self): +# """ +# The 'url' field should respect overriding. +# Regression test for #936. +# """ +# serializer = self.Serializer(self.obj) +# self.assertEqual( +# serializer.data, +# {'title': 'New blog post', 'url': 'foo bar'} +# ) + + +# class TestURLFieldNameBySettings(TestCase): +# urls = 'tests.test_hyperlinkedserializers' + +# def setUp(self): +# self.saved_url_field_name = api_settings.URL_FIELD_NAME +# api_settings.URL_FIELD_NAME = 'global_url_field' + +# class Serializer(serializers.HyperlinkedModelSerializer): + +# class Meta: +# model = BlogPost +# fields = ('title', api_settings.URL_FIELD_NAME) + +# self.Serializer = Serializer +# self.obj = BlogPost.objects.create(title="New blog post") + +# def tearDown(self): +# api_settings.URL_FIELD_NAME = self.saved_url_field_name + +# def test_overridden_url_field_name(self): +# request = factory.get('/posts/') +# serializer = self.Serializer(self.obj, context={'request': request}) +# self.assertIn(api_settings.URL_FIELD_NAME, serializer.data) + + +# class TestURLFieldNameByOptions(TestCase): +# urls = 'tests.test_hyperlinkedserializers' + +# def setUp(self): +# class Serializer(serializers.HyperlinkedModelSerializer): + +# class Meta: +# model = BlogPost +# fields = ('title', 'serializer_url_field') +# url_field_name = 'serializer_url_field' + +# self.Serializer = Serializer +# self.obj = BlogPost.objects.create(title="New blog post") + +# def test_overridden_url_field_name(self): +# request = factory.get('/posts/') +# serializer = self.Serializer(self.obj, context={'request': request}) +# self.assertIn(self.Serializer.Meta.url_field_name, serializer.data) diff --git a/tests/test_model_serializer.py b/tests/test_model_serializer.py new file mode 100644 index 00000000..ec922b6d --- /dev/null +++ b/tests/test_model_serializer.py @@ -0,0 +1,470 @@ +""" +The `ModelSerializer` and `HyperlinkedModelSerializer` classes are essentially +shortcuts for automatically creating serializers based on a given model class. + +These tests deal with ensuring that we correctly map the model fields onto +an appropriate set of serializer fields for each case. +""" +from django.core.exceptions import ImproperlyConfigured +from django.db import models +from django.test import TestCase +from rest_framework import serializers + + +def dedent(blocktext): + return '\n'.join([line[12:] for line in blocktext.splitlines()[1:-1]]) + + +# Testing regular field mappings + +class CustomField(models.Field): + """ + A custom model field simply for testing purposes. + """ + pass + + +class RegularFieldsModel(models.Model): + """ + A model class for testing regular flat fields. + """ + auto_field = models.AutoField(primary_key=True) + big_integer_field = models.BigIntegerField() + boolean_field = models.BooleanField(default=False) + char_field = models.CharField(max_length=100) + comma_seperated_integer_field = models.CommaSeparatedIntegerField(max_length=100) + date_field = models.DateField() + datetime_field = models.DateTimeField() + decimal_field = models.DecimalField(max_digits=3, decimal_places=1) + email_field = models.EmailField(max_length=100) + float_field = models.FloatField() + integer_field = models.IntegerField() + null_boolean_field = models.NullBooleanField() + positive_integer_field = models.PositiveIntegerField() + positive_small_integer_field = models.PositiveSmallIntegerField() + slug_field = models.SlugField(max_length=100) + small_integer_field = models.SmallIntegerField() + text_field = models.TextField() + time_field = models.TimeField() + url_field = models.URLField(max_length=100) + custom_field = CustomField() + + def method(self): + return 'method' + + +class TestRegularFieldMappings(TestCase): + def test_regular_fields(self): + """ + Model fields should map to their equivelent serializer fields. + """ + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = RegularFieldsModel + + expected = dedent(""" + TestSerializer(): + auto_field = IntegerField(read_only=True) + big_integer_field = IntegerField() + boolean_field = BooleanField(default=False) + char_field = CharField(max_length=100) + comma_seperated_integer_field = CharField(max_length=100, validators=[<django.core.validators.RegexValidator object>]) + date_field = DateField() + datetime_field = DateTimeField() + decimal_field = DecimalField(decimal_places=1, max_digits=3) + email_field = EmailField(max_length=100) + float_field = FloatField() + integer_field = IntegerField() + null_boolean_field = BooleanField(required=False) + positive_integer_field = IntegerField() + positive_small_integer_field = IntegerField() + slug_field = SlugField(max_length=100) + small_integer_field = IntegerField() + text_field = CharField() + time_field = TimeField() + url_field = URLField(max_length=100) + custom_field = ModelField(model_field=<tests.test_model_serializer.CustomField: custom_field>) + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_method_field(self): + """ + Properties and methods on the model should be allowed as `Meta.fields` + values, and should map to `ReadOnlyField`. + """ + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = RegularFieldsModel + fields = ('auto_field', 'method') + + expected = dedent(""" + TestSerializer(): + auto_field = IntegerField(read_only=True) + method = ReadOnlyField() + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_pk_fields(self): + """ + Both `pk` and the actual primary key name are valid in `Meta.fields`. + """ + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = RegularFieldsModel + fields = ('pk', 'auto_field') + + expected = dedent(""" + TestSerializer(): + pk = IntegerField(label='Auto field', read_only=True) + auto_field = IntegerField(read_only=True) + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_extra_field_kwargs(self): + """ + Ensure `extra_kwargs` are passed to generated fields. + """ + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = RegularFieldsModel + fields = ('auto_field', 'char_field') + extra_kwargs = {'char_field': {'default': 'extra'}} + + expected = dedent(""" + TestSerializer(): + auto_field = IntegerField(read_only=True) + char_field = CharField(default='extra', max_length=100) + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_invalid_field(self): + """ + Field names that do not map to a model field or relationship should + raise a configuration errror. + """ + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = RegularFieldsModel + fields = ('auto_field', 'invalid') + + with self.assertRaises(ImproperlyConfigured) as excinfo: + TestSerializer() + expected = 'Field name `invalid` is not valid for model `ModelBase`.' + assert str(excinfo.exception) == expected + + def test_missing_field(self): + """ + Fields that have been declared on the serializer class must be included + in the `Meta.fields` if it exists. + """ + class TestSerializer(serializers.ModelSerializer): + missing = serializers.ReadOnlyField() + + class Meta: + model = RegularFieldsModel + fields = ('auto_field',) + + with self.assertRaises(ImproperlyConfigured) as excinfo: + TestSerializer() + expected = ( + 'Field `missing` has been declared on serializer ' + '`TestSerializer`, but is missing from `Meta.fields`.' + ) + assert str(excinfo.exception) == expected + + +# Testing relational field mappings + +class ForeignKeyTargetModel(models.Model): + name = models.CharField(max_length=100) + + +class ManyToManyTargetModel(models.Model): + name = models.CharField(max_length=100) + + +class OneToOneTargetModel(models.Model): + name = models.CharField(max_length=100) + + +class ThroughTargetModel(models.Model): + name = models.CharField(max_length=100) + + +class Supplementary(models.Model): + extra = models.IntegerField() + forwards = models.ForeignKey('ThroughTargetModel') + backwards = models.ForeignKey('RelationalModel') + + +class RelationalModel(models.Model): + foreign_key = models.ForeignKey(ForeignKeyTargetModel, related_name='reverse_foreign_key') + many_to_many = models.ManyToManyField(ManyToManyTargetModel, related_name='reverse_many_to_many') + one_to_one = models.OneToOneField(OneToOneTargetModel, related_name='reverse_one_to_one') + through = models.ManyToManyField(ThroughTargetModel, through=Supplementary, related_name='reverse_through') + + +class TestRelationalFieldMappings(TestCase): + def test_pk_relations(self): + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = RelationalModel + + expected = dedent(""" + TestSerializer(): + id = IntegerField(label='ID', read_only=True) + foreign_key = PrimaryKeyRelatedField(queryset=ForeignKeyTargetModel.objects.all()) + one_to_one = PrimaryKeyRelatedField(queryset=OneToOneTargetModel.objects.all()) + many_to_many = PrimaryKeyRelatedField(many=True, queryset=ManyToManyTargetModel.objects.all()) + through = PrimaryKeyRelatedField(many=True, read_only=True) + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_nested_relations(self): + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = RelationalModel + depth = 1 + + expected = dedent(""" + TestSerializer(): + id = IntegerField(label='ID', read_only=True) + foreign_key = NestedSerializer(read_only=True): + id = IntegerField(label='ID', read_only=True) + name = CharField(max_length=100) + one_to_one = NestedSerializer(read_only=True): + id = IntegerField(label='ID', read_only=True) + name = CharField(max_length=100) + many_to_many = NestedSerializer(many=True, read_only=True): + id = IntegerField(label='ID', read_only=True) + name = CharField(max_length=100) + through = NestedSerializer(many=True, read_only=True): + id = IntegerField(label='ID', read_only=True) + name = CharField(max_length=100) + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_hyperlinked_relations(self): + class TestSerializer(serializers.HyperlinkedModelSerializer): + class Meta: + model = RelationalModel + + expected = dedent(""" + TestSerializer(): + url = HyperlinkedIdentityField(view_name='relationalmodel-detail') + foreign_key = HyperlinkedRelatedField(queryset=ForeignKeyTargetModel.objects.all(), view_name='foreignkeytargetmodel-detail') + one_to_one = HyperlinkedRelatedField(queryset=OneToOneTargetModel.objects.all(), view_name='onetoonetargetmodel-detail') + many_to_many = HyperlinkedRelatedField(many=True, queryset=ManyToManyTargetModel.objects.all(), view_name='manytomanytargetmodel-detail') + through = HyperlinkedRelatedField(many=True, read_only=True, view_name='throughtargetmodel-detail') + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_nested_hyperlinked_relations(self): + class TestSerializer(serializers.HyperlinkedModelSerializer): + class Meta: + model = RelationalModel + depth = 1 + + expected = dedent(""" + TestSerializer(): + url = HyperlinkedIdentityField(view_name='relationalmodel-detail') + foreign_key = NestedSerializer(read_only=True): + url = HyperlinkedIdentityField(view_name='foreignkeytargetmodel-detail') + name = CharField(max_length=100) + one_to_one = NestedSerializer(read_only=True): + url = HyperlinkedIdentityField(view_name='onetoonetargetmodel-detail') + name = CharField(max_length=100) + many_to_many = NestedSerializer(many=True, read_only=True): + url = HyperlinkedIdentityField(view_name='manytomanytargetmodel-detail') + name = CharField(max_length=100) + through = NestedSerializer(many=True, read_only=True): + url = HyperlinkedIdentityField(view_name='throughtargetmodel-detail') + name = CharField(max_length=100) + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_pk_reverse_foreign_key(self): + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = ForeignKeyTargetModel + fields = ('id', 'name', 'reverse_foreign_key') + + expected = dedent(""" + TestSerializer(): + id = IntegerField(label='ID', read_only=True) + name = CharField(max_length=100) + reverse_foreign_key = PrimaryKeyRelatedField(many=True, queryset=RelationalModel.objects.all()) + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_pk_reverse_one_to_one(self): + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = OneToOneTargetModel + fields = ('id', 'name', 'reverse_one_to_one') + + expected = dedent(""" + TestSerializer(): + id = IntegerField(label='ID', read_only=True) + name = CharField(max_length=100) + reverse_one_to_one = PrimaryKeyRelatedField(queryset=RelationalModel.objects.all()) + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_pk_reverse_many_to_many(self): + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = ManyToManyTargetModel + fields = ('id', 'name', 'reverse_many_to_many') + + expected = dedent(""" + TestSerializer(): + id = IntegerField(label='ID', read_only=True) + name = CharField(max_length=100) + reverse_many_to_many = PrimaryKeyRelatedField(many=True, queryset=RelationalModel.objects.all()) + """) + self.assertEqual(repr(TestSerializer()), expected) + + def test_pk_reverse_through(self): + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = ThroughTargetModel + fields = ('id', 'name', 'reverse_through') + + expected = dedent(""" + TestSerializer(): + id = IntegerField(label='ID', read_only=True) + name = CharField(max_length=100) + reverse_through = PrimaryKeyRelatedField(many=True, read_only=True) + """) + self.assertEqual(repr(TestSerializer()), expected) + + +class TestIntegration(TestCase): + def setUp(self): + self.foreign_key_target = ForeignKeyTargetModel.objects.create( + name='foreign_key' + ) + self.one_to_one_target = OneToOneTargetModel.objects.create( + name='one_to_one' + ) + self.many_to_many_targets = [ + ManyToManyTargetModel.objects.create( + name='many_to_many (%d)' % idx + ) for idx in range(3) + ] + self.instance = RelationalModel.objects.create( + foreign_key=self.foreign_key_target, + one_to_one=self.one_to_one_target, + ) + self.instance.many_to_many = self.many_to_many_targets + self.instance.save() + + def test_pk_retrival(self): + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = RelationalModel + + serializer = TestSerializer(self.instance) + expected = { + 'id': self.instance.pk, + 'foreign_key': self.foreign_key_target.pk, + 'one_to_one': self.one_to_one_target.pk, + 'many_to_many': [item.pk for item in self.many_to_many_targets], + 'through': [] + } + self.assertEqual(serializer.data, expected) + + def test_pk_create(self): + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = RelationalModel + + new_foreign_key = ForeignKeyTargetModel.objects.create( + name='foreign_key' + ) + new_one_to_one = OneToOneTargetModel.objects.create( + name='one_to_one' + ) + new_many_to_many = [ + ManyToManyTargetModel.objects.create( + name='new many_to_many (%d)' % idx + ) for idx in range(3) + ] + data = { + 'foreign_key': new_foreign_key.pk, + 'one_to_one': new_one_to_one.pk, + 'many_to_many': [item.pk for item in new_many_to_many], + } + + # Serializer should validate okay. + serializer = TestSerializer(data=data) + assert serializer.is_valid() + + # Creating the instance, relationship attributes should be set. + instance = serializer.save() + assert instance.foreign_key.pk == new_foreign_key.pk + assert instance.one_to_one.pk == new_one_to_one.pk + assert [ + item.pk for item in instance.many_to_many.all() + ] == [ + item.pk for item in new_many_to_many + ] + assert list(instance.through.all()) == [] + + # Representation should be correct. + expected = { + 'id': instance.pk, + 'foreign_key': new_foreign_key.pk, + 'one_to_one': new_one_to_one.pk, + 'many_to_many': [item.pk for item in new_many_to_many], + 'through': [] + } + self.assertEqual(serializer.data, expected) + + def test_pk_update(self): + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = RelationalModel + + new_foreign_key = ForeignKeyTargetModel.objects.create( + name='foreign_key' + ) + new_one_to_one = OneToOneTargetModel.objects.create( + name='one_to_one' + ) + new_many_to_many = [ + ManyToManyTargetModel.objects.create( + name='new many_to_many (%d)' % idx + ) for idx in range(3) + ] + data = { + 'foreign_key': new_foreign_key.pk, + 'one_to_one': new_one_to_one.pk, + 'many_to_many': [item.pk for item in new_many_to_many], + } + + # Serializer should validate okay. + serializer = TestSerializer(self.instance, data=data) + assert serializer.is_valid() + + # Creating the instance, relationship attributes should be set. + instance = serializer.save() + assert instance.foreign_key.pk == new_foreign_key.pk + assert instance.one_to_one.pk == new_one_to_one.pk + assert [ + item.pk for item in instance.many_to_many.all() + ] == [ + item.pk for item in new_many_to_many + ] + assert list(instance.through.all()) == [] + + # Representation should be correct. + expected = { + 'id': self.instance.pk, + 'foreign_key': new_foreign_key.pk, + 'one_to_one': new_one_to_one.pk, + 'many_to_many': [item.pk for item in new_many_to_many], + 'through': [] + } + self.assertEqual(serializer.data, expected) diff --git a/tests/test_serializers.py b/tests/test_modelinfo.py index 31c41730..04b67f04 100644 --- a/tests/test_serializers.py +++ b/tests/test_modelinfo.py @@ -1,6 +1,6 @@ from django.test import TestCase from django.utils import six -from rest_framework.serializers import _resolve_model +from rest_framework.utils.model_meta import _resolve_model from tests.models import BasicModel diff --git a/tests/test_nullable_fields.py b/tests/test_nullable_fields.py index 0c133fc2..9843182a 100644 --- a/tests/test_nullable_fields.py +++ b/tests/test_nullable_fields.py @@ -1,30 +1,39 @@ -from django.core.urlresolvers import reverse +# from django.core.urlresolvers import reverse -from django.conf.urls import patterns, url -from rest_framework.test import APITestCase -from tests.models import NullableForeignKeySource -from tests.serializers import NullableFKSourceSerializer -from tests.views import NullableFKSourceDetail +# from django.conf.urls import patterns, url +# from rest_framework import serializers, generics +# from rest_framework.test import APITestCase +# from tests.models import NullableForeignKeySource -urlpatterns = patterns( - '', - url(r'^objects/(?P<pk>\d+)/$', NullableFKSourceDetail.as_view(), name='object-detail'), -) +# class NullableFKSourceSerializer(serializers.ModelSerializer): +# class Meta: +# model = NullableForeignKeySource -class NullableForeignKeyTests(APITestCase): - """ - DRF should be able to handle nullable foreign keys when a test - Client POST/PUT request is made with its own serialized object. - """ - urls = 'tests.test_nullable_fields' +# class NullableFKSourceDetail(generics.RetrieveUpdateDestroyAPIView): +# queryset = NullableForeignKeySource.objects.all() +# serializer_class = NullableFKSourceSerializer - def test_updating_object_with_null_fk(self): - obj = NullableForeignKeySource(name='example', target=None) - obj.save() - serialized_data = NullableFKSourceSerializer(obj).data - response = self.client.put(reverse('object-detail', args=[obj.pk]), serialized_data) +# urlpatterns = patterns( +# '', +# url(r'^objects/(?P<pk>\d+)/$', NullableFKSourceDetail.as_view(), name='object-detail'), +# ) - self.assertEqual(response.data, serialized_data) + +# class NullableForeignKeyTests(APITestCase): +# """ +# DRF should be able to handle nullable foreign keys when a test +# Client POST/PUT request is made with its own serialized object. +# """ +# urls = 'tests.test_nullable_fields' + +# def test_updating_object_with_null_fk(self): +# obj = NullableForeignKeySource(name='example', target=None) +# obj.save() +# serialized_data = NullableFKSourceSerializer(obj).data + +# response = self.client.put(reverse('object-detail', args=[obj.pk]), serialized_data) + +# self.assertEqual(response.data, serialized_data) diff --git a/tests/test_pagination.py b/tests/test_pagination.py index e1c2528b..1fd9cf9c 100644 --- a/tests/test_pagination.py +++ b/tests/test_pagination.py @@ -4,7 +4,7 @@ from decimal import Decimal from django.core.paginator import Paginator from django.test import TestCase from django.utils import unittest -from rest_framework import generics, status, pagination, filters, serializers +from rest_framework import generics, serializers, status, pagination, filters from rest_framework.compat import django_filters from rest_framework.test import APIRequestFactory from .models import BasicModel, FilterableItem @@ -22,11 +22,22 @@ def split_arguments_from_url(url): return path, args +class BasicSerializer(serializers.ModelSerializer): + class Meta: + model = BasicModel + + +class FilterableItemSerializer(serializers.ModelSerializer): + class Meta: + model = FilterableItem + + class RootView(generics.ListCreateAPIView): """ Example description for OPTIONS. """ - model = BasicModel + queryset = BasicModel.objects.all() + serializer_class = BasicSerializer paginate_by = 10 @@ -34,14 +45,16 @@ class DefaultPageSizeKwargView(generics.ListAPIView): """ View for testing default paginate_by_param usage """ - model = BasicModel + queryset = BasicModel.objects.all() + serializer_class = BasicSerializer class PaginateByParamView(generics.ListAPIView): """ View for testing custom paginate_by_param usage """ - model = BasicModel + queryset = BasicModel.objects.all() + serializer_class = BasicSerializer paginate_by_param = 'page_size' @@ -49,7 +62,8 @@ class MaxPaginateByView(generics.ListAPIView): """ View for testing custom max_paginate_by usage """ - model = BasicModel + queryset = BasicModel.objects.all() + serializer_class = BasicSerializer paginate_by = 3 max_paginate_by = 5 paginate_by_param = 'page_size' @@ -121,7 +135,7 @@ class IntegrationTestPaginationAndFiltering(TestCase): self.objects = FilterableItem.objects self.data = [ - {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date} + {'id': obj.id, 'text': obj.text, 'decimal': str(obj.decimal), 'date': obj.date.isoformat()} for obj in self.objects.all() ] @@ -140,7 +154,8 @@ class IntegrationTestPaginationAndFiltering(TestCase): fields = ['text', 'decimal', 'date'] class FilterFieldsRootView(generics.ListCreateAPIView): - model = FilterableItem + queryset = FilterableItem.objects.all() + serializer_class = FilterableItemSerializer paginate_by = 10 filter_class = DecimalFilter filter_backends = (filters.DjangoFilterBackend,) @@ -188,7 +203,8 @@ class IntegrationTestPaginationAndFiltering(TestCase): return queryset.filter(decimal__lt=Decimal(request.GET['decimal'])) class BasicFilterFieldsRootView(generics.ListCreateAPIView): - model = FilterableItem + queryset = FilterableItem.objects.all() + serializer_class = FilterableItemSerializer paginate_by = 10 filter_backends = (DecimalFilterBackend,) @@ -365,7 +381,7 @@ class TestMaxPaginateByParam(TestCase): # Tests for context in pagination serializers -class CustomField(serializers.Field): +class CustomField(serializers.ReadOnlyField): def to_native(self, value): if 'view' not in self.context: raise RuntimeError("context isn't getting passed into custom field") @@ -375,10 +391,10 @@ class CustomField(serializers.Field): class BasicModelSerializer(serializers.Serializer): text = CustomField() - def __init__(self, *args, **kwargs): - super(BasicModelSerializer, self).__init__(*args, **kwargs) + def to_native(self, value): if 'view' not in self.context: - raise RuntimeError("context isn't getting passed into serializer init") + raise RuntimeError("context isn't getting passed into serializer") + return super(BasicSerializer, self).to_native(value) class TestContextPassedToCustomField(TestCase): @@ -387,7 +403,7 @@ class TestContextPassedToCustomField(TestCase): def test_with_pagination(self): class ListView(generics.ListCreateAPIView): - model = BasicModel + queryset = BasicModel.objects.all() serializer_class = BasicModelSerializer paginate_by = 1 @@ -407,7 +423,7 @@ class LinksSerializer(serializers.Serializer): class CustomPaginationSerializer(pagination.BasePaginationSerializer): links = LinksSerializer(source='*') # Takes the page object as the source - total_results = serializers.Field(source='paginator.count') + total_results = serializers.ReadOnlyField(source='paginator.count') results_field = 'objects' diff --git a/tests/test_parsers.py b/tests/test_parsers.py index 8af90677..3f2672df 100644 --- a/tests/test_parsers.py +++ b/tests/test_parsers.py @@ -1,3 +1,5 @@ +# -*- coding: utf-8 -*- + from __future__ import unicode_literals from rest_framework.compat import StringIO from django import forms @@ -113,3 +115,25 @@ class TestFileUploadParser(TestCase): parser = FileUploadParser() filename = parser.get_filename(self.stream, None, self.parser_context) self.assertEqual(filename, 'file.txt') + + def test_get_encoded_filename(self): + parser = FileUploadParser() + + self.__replace_content_disposition('inline; filename*=utf-8\'\'ÀĥƦ.txt') + filename = parser.get_filename(self.stream, None, self.parser_context) + self.assertEqual(filename, 'ÀĥƦ.txt') + + self.__replace_content_disposition('inline; filename=fallback.txt; filename*=utf-8\'\'ÀĥƦ.txt') + filename = parser.get_filename(self.stream, None, self.parser_context) + self.assertEqual(filename, 'ÀĥƦ.txt') + + self.__replace_content_disposition('inline; filename=fallback.txt; filename*=utf-8\'en-us\'ÀĥƦ.txt') + filename = parser.get_filename(self.stream, None, self.parser_context) + self.assertEqual(filename, 'ÀĥƦ.txt') + + self.__replace_content_disposition('inline; filename=fallback.txt; filename*=utf-8--ÀĥƦ.txt') + filename = parser.get_filename(self.stream, None, self.parser_context) + self.assertEqual(filename, 'fallback.txt') + + def __replace_content_disposition(self, disposition): + self.parser_context['request'].META['HTTP_CONTENT_DISPOSITION'] = disposition diff --git a/tests/test_permissions.py b/tests/test_permissions.py index 93f8020f..ac398f80 100644 --- a/tests/test_permissions.py +++ b/tests/test_permissions.py @@ -3,7 +3,7 @@ from django.contrib.auth.models import User, Permission, Group from django.db import models from django.test import TestCase from django.utils import unittest -from rest_framework import generics, status, permissions, authentication, HTTP_HEADER_ENCODING +from rest_framework import generics, serializers, status, permissions, authentication, HTTP_HEADER_ENCODING from rest_framework.compat import guardian, get_model_name from rest_framework.filters import DjangoObjectPermissionsFilter from rest_framework.test import APIRequestFactory @@ -13,14 +13,21 @@ import base64 factory = APIRequestFactory() +class BasicSerializer(serializers.ModelSerializer): + class Meta: + model = BasicModel + + class RootView(generics.ListCreateAPIView): - model = BasicModel + queryset = BasicModel.objects.all() + serializer_class = BasicSerializer authentication_classes = [authentication.BasicAuthentication] permission_classes = [permissions.DjangoModelPermissions] class InstanceView(generics.RetrieveUpdateDestroyAPIView): - model = BasicModel + queryset = BasicModel.objects.all() + serializer_class = BasicSerializer authentication_classes = [authentication.BasicAuthentication] permission_classes = [permissions.DjangoModelPermissions] @@ -88,72 +95,59 @@ class ModelPermissionsIntegrationTests(TestCase): response = instance_view(request, pk=1) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - def test_has_put_as_create_permissions(self): - # User only has update permissions - should be able to update an entity. - request = factory.put('/1', {'text': 'foobar'}, format='json', - HTTP_AUTHORIZATION=self.updateonly_credentials) - response = instance_view(request, pk='1') - self.assertEqual(response.status_code, status.HTTP_200_OK) - - # But if PUTing to a new entity, permission should be denied. - request = factory.put('/2', {'text': 'foobar'}, format='json', - HTTP_AUTHORIZATION=self.updateonly_credentials) - response = instance_view(request, pk='2') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_options_permitted(self): - request = factory.options( - '/', - HTTP_AUTHORIZATION=self.permitted_credentials - ) - response = root_view(request, pk='1') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertIn('actions', response.data) - self.assertEqual(list(response.data['actions'].keys()), ['POST']) - - request = factory.options( - '/1', - HTTP_AUTHORIZATION=self.permitted_credentials - ) - response = instance_view(request, pk='1') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertIn('actions', response.data) - self.assertEqual(list(response.data['actions'].keys()), ['PUT']) - - def test_options_disallowed(self): - request = factory.options( - '/', - HTTP_AUTHORIZATION=self.disallowed_credentials - ) - response = root_view(request, pk='1') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertNotIn('actions', response.data) - - request = factory.options( - '/1', - HTTP_AUTHORIZATION=self.disallowed_credentials - ) - response = instance_view(request, pk='1') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertNotIn('actions', response.data) - - def test_options_updateonly(self): - request = factory.options( - '/', - HTTP_AUTHORIZATION=self.updateonly_credentials - ) - response = root_view(request, pk='1') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertNotIn('actions', response.data) - - request = factory.options( - '/1', - HTTP_AUTHORIZATION=self.updateonly_credentials - ) - response = instance_view(request, pk='1') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertIn('actions', response.data) - self.assertEqual(list(response.data['actions'].keys()), ['PUT']) + # def test_options_permitted(self): + # request = factory.options( + # '/', + # HTTP_AUTHORIZATION=self.permitted_credentials + # ) + # response = root_view(request, pk='1') + # self.assertEqual(response.status_code, status.HTTP_200_OK) + # self.assertIn('actions', response.data) + # self.assertEqual(list(response.data['actions'].keys()), ['POST']) + + # request = factory.options( + # '/1', + # HTTP_AUTHORIZATION=self.permitted_credentials + # ) + # response = instance_view(request, pk='1') + # self.assertEqual(response.status_code, status.HTTP_200_OK) + # self.assertIn('actions', response.data) + # self.assertEqual(list(response.data['actions'].keys()), ['PUT']) + + # def test_options_disallowed(self): + # request = factory.options( + # '/', + # HTTP_AUTHORIZATION=self.disallowed_credentials + # ) + # response = root_view(request, pk='1') + # self.assertEqual(response.status_code, status.HTTP_200_OK) + # self.assertNotIn('actions', response.data) + + # request = factory.options( + # '/1', + # HTTP_AUTHORIZATION=self.disallowed_credentials + # ) + # response = instance_view(request, pk='1') + # self.assertEqual(response.status_code, status.HTTP_200_OK) + # self.assertNotIn('actions', response.data) + + # def test_options_updateonly(self): + # request = factory.options( + # '/', + # HTTP_AUTHORIZATION=self.updateonly_credentials + # ) + # response = root_view(request, pk='1') + # self.assertEqual(response.status_code, status.HTTP_200_OK) + # self.assertNotIn('actions', response.data) + + # request = factory.options( + # '/1', + # HTTP_AUTHORIZATION=self.updateonly_credentials + # ) + # response = instance_view(request, pk='1') + # self.assertEqual(response.status_code, status.HTTP_200_OK) + # self.assertIn('actions', response.data) + # self.assertEqual(list(response.data['actions'].keys()), ['PUT']) class BasicPermModel(models.Model): @@ -167,6 +161,11 @@ class BasicPermModel(models.Model): ) +class BasicPermSerializer(serializers.ModelSerializer): + class Meta: + model = BasicPermModel + + # Custom object-level permission, that includes 'view' permissions class ViewObjectPermissions(permissions.DjangoObjectPermissions): perms_map = { @@ -181,7 +180,8 @@ class ViewObjectPermissions(permissions.DjangoObjectPermissions): class ObjectPermissionInstanceView(generics.RetrieveUpdateDestroyAPIView): - model = BasicPermModel + queryset = BasicPermModel.objects.all() + serializer_class = BasicPermSerializer authentication_classes = [authentication.BasicAuthentication] permission_classes = [ViewObjectPermissions] @@ -189,7 +189,8 @@ object_permissions_view = ObjectPermissionInstanceView.as_view() class ObjectPermissionListView(generics.ListAPIView): - model = BasicPermModel + queryset = BasicPermModel.objects.all() + serializer_class = BasicPermSerializer authentication_classes = [authentication.BasicAuthentication] permission_classes = [ViewObjectPermissions] diff --git a/tests/test_relations.py b/tests/test_relations.py index bc1db69f..c29618ce 100644 --- a/tests/test_relations.py +++ b/tests/test_relations.py @@ -1,149 +1,288 @@ -""" -General tests for relational fields. -""" -from __future__ import unicode_literals -from django import get_version -from django.db import models -from django.test import TestCase -from django.utils import unittest +from .utils import mock_reverse, fail_reverse, BadType, MockObject, MockQueryset +from django.core.exceptions import ImproperlyConfigured, ValidationError from rest_framework import serializers -from tests.models import BlogPost - - -class NullModel(models.Model): - pass - - -class FieldTests(TestCase): - def test_pk_related_field_with_empty_string(self): - """ - Regression test for #446 - - https://github.com/tomchristie/django-rest-framework/issues/446 - """ - field = serializers.PrimaryKeyRelatedField(queryset=NullModel.objects.all()) - self.assertRaises(serializers.ValidationError, field.from_native, '') - self.assertRaises(serializers.ValidationError, field.from_native, []) - - def test_hyperlinked_related_field_with_empty_string(self): - field = serializers.HyperlinkedRelatedField(queryset=NullModel.objects.all(), view_name='') - self.assertRaises(serializers.ValidationError, field.from_native, '') - self.assertRaises(serializers.ValidationError, field.from_native, []) - - def test_slug_related_field_with_empty_string(self): - field = serializers.SlugRelatedField(queryset=NullModel.objects.all(), slug_field='pk') - self.assertRaises(serializers.ValidationError, field.from_native, '') - self.assertRaises(serializers.ValidationError, field.from_native, []) - - -class TestManyRelatedMixin(TestCase): - def test_missing_many_to_many_related_field(self): - ''' - Regression test for #632 - - https://github.com/tomchristie/django-rest-framework/pull/632 - ''' - field = serializers.RelatedField(many=True, read_only=False) - - into = {} - field.field_from_native({}, None, 'field_name', into) - self.assertEqual(into['field_name'], []) - - -# Regression tests for #694 (`source` attribute on related fields) - -class RelatedFieldSourceTests(TestCase): - def test_related_manager_source(self): - """ - Relational fields should be able to use manager-returning methods as their source. - """ - BlogPost.objects.create(title='blah') - field = serializers.RelatedField(many=True, source='get_blogposts_manager') - - class ClassWithManagerMethod(object): - def get_blogposts_manager(self): - return BlogPost.objects - - obj = ClassWithManagerMethod() - value = field.field_to_native(obj, 'field_name') - self.assertEqual(value, ['BlogPost object']) - - def test_related_queryset_source(self): - """ - Relational fields should be able to use queryset-returning methods as their source. - """ - BlogPost.objects.create(title='blah') - field = serializers.RelatedField(many=True, source='get_blogposts_queryset') - - class ClassWithQuerysetMethod(object): - def get_blogposts_queryset(self): - return BlogPost.objects.all() - - obj = ClassWithQuerysetMethod() - value = field.field_to_native(obj, 'field_name') - self.assertEqual(value, ['BlogPost object']) - - def test_dotted_source(self): - """ - Source argument should support dotted.source notation. +from rest_framework.test import APISimpleTestCase +import pytest + + +class TestStringRelatedField(APISimpleTestCase): + def setUp(self): + self.instance = MockObject(pk=1, name='foo') + self.field = serializers.StringRelatedField() + + def test_string_related_representation(self): + representation = self.field.to_representation(self.instance) + assert representation == '<MockObject name=foo, pk=1>' + + +class TestPrimaryKeyRelatedField(APISimpleTestCase): + def setUp(self): + self.queryset = MockQueryset([ + MockObject(pk=1, name='foo'), + MockObject(pk=2, name='bar'), + MockObject(pk=3, name='baz') + ]) + self.instance = self.queryset.items[2] + self.field = serializers.PrimaryKeyRelatedField(queryset=self.queryset) + + def test_pk_related_lookup_exists(self): + instance = self.field.to_internal_value(self.instance.pk) + assert instance is self.instance + + def test_pk_related_lookup_does_not_exist(self): + with pytest.raises(ValidationError) as excinfo: + self.field.to_internal_value(4) + msg = excinfo.value.messages[0] + assert msg == "Invalid pk '4' - object does not exist." + + def test_pk_related_lookup_invalid_type(self): + with pytest.raises(ValidationError) as excinfo: + self.field.to_internal_value(BadType()) + msg = excinfo.value.messages[0] + assert msg == 'Incorrect type. Expected pk value, received BadType.' + + def test_pk_representation(self): + representation = self.field.to_representation(self.instance) + assert representation == self.instance.pk + + +class TestHyperlinkedIdentityField(APISimpleTestCase): + def setUp(self): + self.instance = MockObject(pk=1, name='foo') + self.field = serializers.HyperlinkedIdentityField(view_name='example') + self.field.reverse = mock_reverse + self.field.context = {'request': True} + + def test_representation(self): + representation = self.field.to_representation(self.instance) + assert representation == 'http://example.org/example/1/' + + def test_representation_unsaved_object(self): + representation = self.field.to_representation(MockObject(pk=None)) + assert representation is None + + def test_representation_with_format(self): + self.field.context['format'] = 'xml' + representation = self.field.to_representation(self.instance) + assert representation == 'http://example.org/example/1.xml/' + + def test_improperly_configured(self): """ - BlogPost.objects.create(title='blah') - field = serializers.RelatedField(many=True, source='a.b.c') - - class ClassWithQuerysetMethod(object): - a = { - 'b': { - 'c': BlogPost.objects.all() - } - } - - obj = ClassWithQuerysetMethod() - value = field.field_to_native(obj, 'field_name') - self.assertEqual(value, ['BlogPost object']) - - # Regression for #1129 - def test_exception_for_incorect_fk(self): + If a matching view cannot be reversed with the given instance, + the the user has misconfigured something, as the URL conf and the + hyperlinked field do not match. """ - Check that the exception message are correct if the source field - doesn't exist. - """ - from tests.models import ManyToManySource - - class Meta: - model = ManyToManySource + self.field.reverse = fail_reverse + with pytest.raises(ImproperlyConfigured): + self.field.to_representation(self.instance) - attrs = { - 'name': serializers.SlugRelatedField( - slug_field='name', source='banzai'), - 'Meta': Meta, - } - TestSerializer = type( - str('TestSerializer'), - (serializers.ModelSerializer,), - attrs - ) - with self.assertRaises(AttributeError): - TestSerializer(data={'name': 'foo'}) - - -@unittest.skipIf(get_version() < '1.6.0', 'Upstream behaviour changed in v1.6') -class RelatedFieldChoicesTests(TestCase): +class TestHyperlinkedIdentityFieldWithFormat(APISimpleTestCase): """ - Tests for #1408 "Web browseable API doesn't have blank option on drop down list box" - https://github.com/tomchristie/django-rest-framework/issues/1408 - """ - def test_blank_option_is_added_to_choice_if_required_equals_false(self): - """ + Tests for a hyperlinked identity field that has a `format` set, + which enforces that alternate formats are never linked too. - """ - post = BlogPost(title="Checking blank option is added") - post.save() - - queryset = BlogPost.objects.all() - field = serializers.RelatedField(required=False, queryset=queryset) + Eg. If your API includes some endpoints that accept both `.xml` and `.json`, + but other endpoints that only accept `.json`, we allow for hyperlinked + relationships that enforce only a single suffix type. + """ - choice_count = BlogPost.objects.count() - widget_count = len(field.widget.choices) + def setUp(self): + self.instance = MockObject(pk=1, name='foo') + self.field = serializers.HyperlinkedIdentityField(view_name='example', format='json') + self.field.reverse = mock_reverse + self.field.context = {'request': True} + + def test_representation(self): + representation = self.field.to_representation(self.instance) + assert representation == 'http://example.org/example/1/' + + def test_representation_with_format(self): + self.field.context['format'] = 'xml' + representation = self.field.to_representation(self.instance) + assert representation == 'http://example.org/example/1.json/' + + +class TestSlugRelatedField(APISimpleTestCase): + def setUp(self): + self.queryset = MockQueryset([ + MockObject(pk=1, name='foo'), + MockObject(pk=2, name='bar'), + MockObject(pk=3, name='baz') + ]) + self.instance = self.queryset.items[2] + self.field = serializers.SlugRelatedField( + slug_field='name', queryset=self.queryset + ) - self.assertEqual(widget_count, choice_count + 1, 'BLANK_CHOICE_DASH option should have been added') + def test_slug_related_lookup_exists(self): + instance = self.field.to_internal_value(self.instance.name) + assert instance is self.instance + + def test_slug_related_lookup_does_not_exist(self): + with pytest.raises(ValidationError) as excinfo: + self.field.to_internal_value('doesnotexist') + msg = excinfo.value.messages[0] + assert msg == 'Object with name=doesnotexist does not exist.' + + def test_slug_related_lookup_invalid_type(self): + with pytest.raises(ValidationError) as excinfo: + self.field.to_internal_value(BadType()) + msg = excinfo.value.messages[0] + assert msg == 'Invalid value.' + + def test_representation(self): + representation = self.field.to_representation(self.instance) + assert representation == self.instance.name + +# Older tests, for review... + +# """ +# General tests for relational fields. +# """ +# from __future__ import unicode_literals +# from django import get_version +# from django.db import models +# from django.test import TestCase +# from django.utils import unittest +# from rest_framework import serializers +# from tests.models import BlogPost + + +# class NullModel(models.Model): +# pass + + +# class FieldTests(TestCase): +# def test_pk_related_field_with_empty_string(self): +# """ +# Regression test for #446 + +# https://github.com/tomchristie/django-rest-framework/issues/446 +# """ +# field = serializers.PrimaryKeyRelatedField(queryset=NullModel.objects.all()) +# self.assertRaises(serializers.ValidationError, field.to_primative, '') +# self.assertRaises(serializers.ValidationError, field.to_primative, []) + +# def test_hyperlinked_related_field_with_empty_string(self): +# field = serializers.HyperlinkedRelatedField(queryset=NullModel.objects.all(), view_name='') +# self.assertRaises(serializers.ValidationError, field.to_primative, '') +# self.assertRaises(serializers.ValidationError, field.to_primative, []) + +# def test_slug_related_field_with_empty_string(self): +# field = serializers.SlugRelatedField(queryset=NullModel.objects.all(), slug_field='pk') +# self.assertRaises(serializers.ValidationError, field.to_primative, '') +# self.assertRaises(serializers.ValidationError, field.to_primative, []) + + +# class TestManyRelatedMixin(TestCase): +# def test_missing_many_to_many_related_field(self): +# ''' +# Regression test for #632 + +# https://github.com/tomchristie/django-rest-framework/pull/632 +# ''' +# field = serializers.RelatedField(many=True, read_only=False) + +# into = {} +# field.field_from_native({}, None, 'field_name', into) +# self.assertEqual(into['field_name'], []) + + +# # Regression tests for #694 (`source` attribute on related fields) + +# class RelatedFieldSourceTests(TestCase): +# def test_related_manager_source(self): +# """ +# Relational fields should be able to use manager-returning methods as their source. +# """ +# BlogPost.objects.create(title='blah') +# field = serializers.RelatedField(many=True, source='get_blogposts_manager') + +# class ClassWithManagerMethod(object): +# def get_blogposts_manager(self): +# return BlogPost.objects + +# obj = ClassWithManagerMethod() +# value = field.field_to_native(obj, 'field_name') +# self.assertEqual(value, ['BlogPost object']) + +# def test_related_queryset_source(self): +# """ +# Relational fields should be able to use queryset-returning methods as their source. +# """ +# BlogPost.objects.create(title='blah') +# field = serializers.RelatedField(many=True, source='get_blogposts_queryset') + +# class ClassWithQuerysetMethod(object): +# def get_blogposts_queryset(self): +# return BlogPost.objects.all() + +# obj = ClassWithQuerysetMethod() +# value = field.field_to_native(obj, 'field_name') +# self.assertEqual(value, ['BlogPost object']) + +# def test_dotted_source(self): +# """ +# Source argument should support dotted.source notation. +# """ +# BlogPost.objects.create(title='blah') +# field = serializers.RelatedField(many=True, source='a.b.c') + +# class ClassWithQuerysetMethod(object): +# a = { +# 'b': { +# 'c': BlogPost.objects.all() +# } +# } + +# obj = ClassWithQuerysetMethod() +# value = field.field_to_native(obj, 'field_name') +# self.assertEqual(value, ['BlogPost object']) + +# # Regression for #1129 +# def test_exception_for_incorect_fk(self): +# """ +# Check that the exception message are correct if the source field +# doesn't exist. +# """ +# from tests.models import ManyToManySource + +# class Meta: +# model = ManyToManySource + +# attrs = { +# 'name': serializers.SlugRelatedField( +# slug_field='name', source='banzai'), +# 'Meta': Meta, +# } + +# TestSerializer = type( +# str('TestSerializer'), +# (serializers.ModelSerializer,), +# attrs +# ) +# with self.assertRaises(AttributeError): +# TestSerializer(data={'name': 'foo'}) + + +# @unittest.skipIf(get_version() < '1.6.0', 'Upstream behaviour changed in v1.6') +# class RelatedFieldChoicesTests(TestCase): +# """ +# Tests for #1408 "Web browseable API doesn't have blank option on drop down list box" +# https://github.com/tomchristie/django-rest-framework/issues/1408 +# """ +# def test_blank_option_is_added_to_choice_if_required_equals_false(self): +# """ + +# """ +# post = BlogPost(title="Checking blank option is added") +# post.save() + +# queryset = BlogPost.objects.all() +# field = serializers.RelatedField(required=False, queryset=queryset) + +# choice_count = BlogPost.objects.count() +# widget_count = len(field.widget.choices) + +# self.assertEqual(widget_count, choice_count + 1, 'BLANK_CHOICE_DASH option should have been added') diff --git a/tests/test_relations_hyperlink.py b/tests/test_relations_hyperlink.py index 0c8eb254..315d1abf 100644 --- a/tests/test_relations_hyperlink.py +++ b/tests/test_relations_hyperlink.py @@ -1,525 +1,525 @@ -from __future__ import unicode_literals -from django.conf.urls import patterns, url -from django.test import TestCase -from rest_framework import serializers -from rest_framework.test import APIRequestFactory -from tests.models import ( - BlogPost, - ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, - NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource -) - -factory = APIRequestFactory() -request = factory.get('/') # Just to ensure we have a request in the serializer context - - -def dummy_view(request, pk): - pass - -urlpatterns = patterns( - '', - url(r'^dummyurl/(?P<pk>[0-9]+)/$', dummy_view, name='dummy-url'), - url(r'^manytomanysource/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanysource-detail'), - url(r'^manytomanytarget/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanytarget-detail'), - url(r'^foreignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeysource-detail'), - url(r'^foreignkeytarget/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeytarget-detail'), - url(r'^nullableforeignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='nullableforeignkeysource-detail'), - url(r'^onetoonetarget/(?P<pk>[0-9]+)/$', dummy_view, name='onetoonetarget-detail'), - url(r'^nullableonetoonesource/(?P<pk>[0-9]+)/$', dummy_view, name='nullableonetoonesource-detail'), -) - - -# ManyToMany -class ManyToManyTargetSerializer(serializers.HyperlinkedModelSerializer): - class Meta: - model = ManyToManyTarget - fields = ('url', 'name', 'sources') - - -class ManyToManySourceSerializer(serializers.HyperlinkedModelSerializer): - class Meta: - model = ManyToManySource - fields = ('url', 'name', 'targets') - - -# ForeignKey -class ForeignKeyTargetSerializer(serializers.HyperlinkedModelSerializer): - class Meta: - model = ForeignKeyTarget - fields = ('url', 'name', 'sources') - - -class ForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): - class Meta: - model = ForeignKeySource - fields = ('url', 'name', 'target') - - -# Nullable ForeignKey -class NullableForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): - class Meta: - model = NullableForeignKeySource - fields = ('url', 'name', 'target') - - -# Nullable OneToOne -class NullableOneToOneTargetSerializer(serializers.HyperlinkedModelSerializer): - class Meta: - model = OneToOneTarget - fields = ('url', 'name', 'nullable_source') - - -# TODO: Add test that .data cannot be accessed prior to .is_valid - -class HyperlinkedManyToManyTests(TestCase): - urls = 'tests.test_relations_hyperlink' - - def setUp(self): - for idx in range(1, 4): - target = ManyToManyTarget(name='target-%d' % idx) - target.save() - source = ManyToManySource(name='source-%d' % idx) - source.save() - for target in ManyToManyTarget.objects.all(): - source.targets.add(target) - - def test_many_to_many_retrieve(self): - queryset = ManyToManySource.objects.all() - serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']}, - {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, - {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_many_to_many_retrieve(self): - queryset = ManyToManyTarget.objects.all() - serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, - {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, - {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} - ] - self.assertEqual(serializer.data, expected) - - def test_many_to_many_update(self): - data = {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} - instance = ManyToManySource.objects.get(pk=1) - serializer = ManyToManySourceSerializer(instance, data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - serializer.save() - self.assertEqual(serializer.data, data) - - # Ensure source 1 is updated, and everything else is as expected - queryset = ManyToManySource.objects.all() - serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, - {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, - {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_many_to_many_update(self): - data = {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']} - instance = ManyToManyTarget.objects.get(pk=1) - serializer = ManyToManyTargetSerializer(instance, data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - serializer.save() - self.assertEqual(serializer.data, data) - - # Ensure target 1 is updated, and everything else is as expected - queryset = ManyToManyTarget.objects.all() - serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']}, - {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, - {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} - - ] - self.assertEqual(serializer.data, expected) - - def test_many_to_many_create(self): - data = {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} - serializer = ManyToManySourceSerializer(data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 4 is added, and everything else is as expected - queryset = ManyToManySource.objects.all() - serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']}, - {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, - {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, - {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_many_to_many_create(self): - data = {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} - serializer = ManyToManyTargetSerializer(data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'target-4') - - # Ensure target 4 is added, and everything else is as expected - queryset = ManyToManyTarget.objects.all() - serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, - {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, - {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']}, - {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} - ] - self.assertEqual(serializer.data, expected) - - -class HyperlinkedForeignKeyTests(TestCase): - urls = 'tests.test_relations_hyperlink' - - def setUp(self): - target = ForeignKeyTarget(name='target-1') - target.save() - new_target = ForeignKeyTarget(name='target-2') - new_target.save() - for idx in range(1, 4): - source = ForeignKeySource(name='source-%d' % idx, target=target) - source.save() - - def test_foreign_key_retrieve(self): - queryset = ForeignKeySource.objects.all() - serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_foreign_key_retrieve(self): - queryset = ForeignKeyTarget.objects.all() - serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, - {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update(self): - data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'} - instance = ForeignKeySource.objects.get(pk=1) - serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, data) - serializer.save() - - # Ensure source 1 is updated, and everything else is as expected - queryset = ForeignKeySource.objects.all() - serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'}, - {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_incorrect_type(self): - data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 2} - instance = ForeignKeySource.objects.get(pk=1) - serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected url string, received int.']}) - - def test_reverse_foreign_key_update(self): - data = {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} - instance = ForeignKeyTarget.objects.get(pk=2) - serializer = ForeignKeyTargetSerializer(instance, data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - # We shouldn't have saved anything to the db yet since save - # hasn't been called. - queryset = ForeignKeyTarget.objects.all() - new_serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, - {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, - ] - self.assertEqual(new_serializer.data, expected) - - serializer.save() - self.assertEqual(serializer.data, data) - - # Ensure target 2 is update, and everything else is as expected - queryset = ForeignKeyTarget.objects.all() - serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, - {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_create(self): - data = {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'} - serializer = ForeignKeySourceSerializer(data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 1 is updated, and everything else is as expected - queryset = ForeignKeySource.objects.all() - serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'}, - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_foreign_key_create(self): - data = {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} - serializer = ForeignKeyTargetSerializer(data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'target-3') - - # Ensure target 4 is added, and everything else is as expected - queryset = ForeignKeyTarget.objects.all() - serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, - {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, - {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_with_invalid_null(self): - data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': None} - instance = ForeignKeySource.objects.get(pk=1) - serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'target': ['This field is required.']}) - - -class HyperlinkedNullableForeignKeyTests(TestCase): - urls = 'tests.test_relations_hyperlink' - - def setUp(self): - target = ForeignKeyTarget(name='target-1') - target.save() - for idx in range(1, 4): - if idx == 3: - target = None - source = NullableForeignKeySource(name='source-%d' % idx, target=target) - source.save() - - def test_foreign_key_retrieve_with_null(self): - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_create_with_valid_null(self): - data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} - serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 4 is created, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, - {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_create_with_valid_emptystring(self): - """ - The emptystring should be interpreted as null in the context - of relationships. - """ - data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': ''} - expected_data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} - serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, expected_data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 4 is created, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, - {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_with_valid_null(self): - data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} - instance = NullableForeignKeySource.objects.get(pk=1) - serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, data) - serializer.save() - - # Ensure source 1 is updated, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}, - {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_with_valid_emptystring(self): - """ - The emptystring should be interpreted as null in the context - of relationships. - """ - data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': ''} - expected_data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} - instance = NullableForeignKeySource.objects.get(pk=1) - serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, expected_data) - serializer.save() - - # Ensure source 1 is updated, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}, - {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, - {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, - ] - self.assertEqual(serializer.data, expected) - - # reverse foreign keys MUST be read_only - # In the general case they do not provide .remove() or .clear() - # and cannot be arbitrarily set. - - # def test_reverse_foreign_key_update(self): - # data = {'id': 1, 'name': 'target-1', 'sources': [1]} - # instance = ForeignKeyTarget.objects.get(pk=1) - # serializer = ForeignKeyTargetSerializer(instance, data=data) - # self.assertTrue(serializer.is_valid()) - # self.assertEqual(serializer.data, data) - # serializer.save() - - # # Ensure target 1 is updated, and everything else is as expected - # queryset = ForeignKeyTarget.objects.all() - # serializer = ForeignKeyTargetSerializer(queryset, many=True) - # expected = [ - # {'id': 1, 'name': 'target-1', 'sources': [1]}, - # {'id': 2, 'name': 'target-2', 'sources': []}, - # ] - # self.assertEqual(serializer.data, expected) - - -class HyperlinkedNullableOneToOneTests(TestCase): - urls = 'tests.test_relations_hyperlink' - - def setUp(self): - target = OneToOneTarget(name='target-1') - target.save() - new_target = OneToOneTarget(name='target-2') - new_target.save() - source = NullableOneToOneSource(name='source-1', target=target) - source.save() - - def test_reverse_foreign_key_retrieve_with_null(self): - queryset = OneToOneTarget.objects.all() - serializer = NullableOneToOneTargetSerializer(queryset, many=True, context={'request': request}) - expected = [ - {'url': 'http://testserver/onetoonetarget/1/', 'name': 'target-1', 'nullable_source': 'http://testserver/nullableonetoonesource/1/'}, - {'url': 'http://testserver/onetoonetarget/2/', 'name': 'target-2', 'nullable_source': None}, - ] - self.assertEqual(serializer.data, expected) - - -# Regression tests for #694 (`source` attribute on related fields) - -class HyperlinkedRelatedFieldSourceTests(TestCase): - urls = 'tests.test_relations_hyperlink' - - def test_related_manager_source(self): - """ - Relational fields should be able to use manager-returning methods as their source. - """ - BlogPost.objects.create(title='blah') - field = serializers.HyperlinkedRelatedField( - many=True, - source='get_blogposts_manager', - view_name='dummy-url', - ) - field.context = {'request': request} - - class ClassWithManagerMethod(object): - def get_blogposts_manager(self): - return BlogPost.objects - - obj = ClassWithManagerMethod() - value = field.field_to_native(obj, 'field_name') - self.assertEqual(value, ['http://testserver/dummyurl/1/']) - - def test_related_queryset_source(self): - """ - Relational fields should be able to use queryset-returning methods as their source. - """ - BlogPost.objects.create(title='blah') - field = serializers.HyperlinkedRelatedField( - many=True, - source='get_blogposts_queryset', - view_name='dummy-url', - ) - field.context = {'request': request} - - class ClassWithQuerysetMethod(object): - def get_blogposts_queryset(self): - return BlogPost.objects.all() - - obj = ClassWithQuerysetMethod() - value = field.field_to_native(obj, 'field_name') - self.assertEqual(value, ['http://testserver/dummyurl/1/']) - - def test_dotted_source(self): - """ - Source argument should support dotted.source notation. - """ - BlogPost.objects.create(title='blah') - field = serializers.HyperlinkedRelatedField( - many=True, - source='a.b.c', - view_name='dummy-url', - ) - field.context = {'request': request} - - class ClassWithQuerysetMethod(object): - a = { - 'b': { - 'c': BlogPost.objects.all() - } - } - - obj = ClassWithQuerysetMethod() - value = field.field_to_native(obj, 'field_name') - self.assertEqual(value, ['http://testserver/dummyurl/1/']) +# from __future__ import unicode_literals +# from django.conf.urls import patterns, url +# from django.test import TestCase +# from rest_framework import serializers +# from rest_framework.test import APIRequestFactory +# from tests.models import ( +# BlogPost, +# ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, +# NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource +# ) + +# factory = APIRequestFactory() +# request = factory.get('/') # Just to ensure we have a request in the serializer context + + +# def dummy_view(request, pk): +# pass + +# urlpatterns = patterns( +# '', +# url(r'^dummyurl/(?P<pk>[0-9]+)/$', dummy_view, name='dummy-url'), +# url(r'^manytomanysource/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanysource-detail'), +# url(r'^manytomanytarget/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanytarget-detail'), +# url(r'^foreignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeysource-detail'), +# url(r'^foreignkeytarget/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeytarget-detail'), +# url(r'^nullableforeignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='nullableforeignkeysource-detail'), +# url(r'^onetoonetarget/(?P<pk>[0-9]+)/$', dummy_view, name='onetoonetarget-detail'), +# url(r'^nullableonetoonesource/(?P<pk>[0-9]+)/$', dummy_view, name='nullableonetoonesource-detail'), +# ) + + +# # ManyToMany +# class ManyToManyTargetSerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = ManyToManyTarget +# fields = ('url', 'name', 'sources') + + +# class ManyToManySourceSerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = ManyToManySource +# fields = ('url', 'name', 'targets') + + +# # ForeignKey +# class ForeignKeyTargetSerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = ForeignKeyTarget +# fields = ('url', 'name', 'sources') + + +# class ForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = ForeignKeySource +# fields = ('url', 'name', 'target') + + +# # Nullable ForeignKey +# class NullableForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = NullableForeignKeySource +# fields = ('url', 'name', 'target') + + +# # Nullable OneToOne +# class NullableOneToOneTargetSerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = OneToOneTarget +# fields = ('url', 'name', 'nullable_source') + + +# # TODO: Add test that .data cannot be accessed prior to .is_valid + +# class HyperlinkedManyToManyTests(TestCase): +# urls = 'tests.test_relations_hyperlink' + +# def setUp(self): +# for idx in range(1, 4): +# target = ManyToManyTarget(name='target-%d' % idx) +# target.save() +# source = ManyToManySource(name='source-%d' % idx) +# source.save() +# for target in ManyToManyTarget.objects.all(): +# source.targets.add(target) + +# def test_many_to_many_retrieve(self): +# queryset = ManyToManySource.objects.all() +# serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']}, +# {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, +# {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_many_to_many_retrieve(self): +# queryset = ManyToManyTarget.objects.all() +# serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, +# {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, +# {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_many_to_many_update(self): +# data = {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} +# instance = ManyToManySource.objects.get(pk=1) +# serializer = ManyToManySourceSerializer(instance, data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# serializer.save() +# self.assertEqual(serializer.data, data) + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = ManyToManySource.objects.all() +# serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, +# {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, +# {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_many_to_many_update(self): +# data = {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']} +# instance = ManyToManyTarget.objects.get(pk=1) +# serializer = ManyToManyTargetSerializer(instance, data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# serializer.save() +# self.assertEqual(serializer.data, data) + +# # Ensure target 1 is updated, and everything else is as expected +# queryset = ManyToManyTarget.objects.all() +# serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']}, +# {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, +# {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} + +# ] +# self.assertEqual(serializer.data, expected) + +# def test_many_to_many_create(self): +# data = {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} +# serializer = ManyToManySourceSerializer(data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 4 is added, and everything else is as expected +# queryset = ManyToManySource.objects.all() +# serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']}, +# {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, +# {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, +# {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_many_to_many_create(self): +# data = {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} +# serializer = ManyToManyTargetSerializer(data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'target-4') + +# # Ensure target 4 is added, and everything else is as expected +# queryset = ManyToManyTarget.objects.all() +# serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, +# {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, +# {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']}, +# {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} +# ] +# self.assertEqual(serializer.data, expected) + + +# class HyperlinkedForeignKeyTests(TestCase): +# urls = 'tests.test_relations_hyperlink' + +# def setUp(self): +# target = ForeignKeyTarget(name='target-1') +# target.save() +# new_target = ForeignKeyTarget(name='target-2') +# new_target.save() +# for idx in range(1, 4): +# source = ForeignKeySource(name='source-%d' % idx, target=target) +# source.save() + +# def test_foreign_key_retrieve(self): +# queryset = ForeignKeySource.objects.all() +# serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_foreign_key_retrieve(self): +# queryset = ForeignKeyTarget.objects.all() +# serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, +# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update(self): +# data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'} +# instance = ForeignKeySource.objects.get(pk=1) +# serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, data) +# serializer.save() + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = ForeignKeySource.objects.all() +# serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'}, +# {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_incorrect_type(self): +# data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 2} +# instance = ForeignKeySource.objects.get(pk=1) +# serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected url string, received int.']}) + +# def test_reverse_foreign_key_update(self): +# data = {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} +# instance = ForeignKeyTarget.objects.get(pk=2) +# serializer = ForeignKeyTargetSerializer(instance, data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# # We shouldn't have saved anything to the db yet since save +# # hasn't been called. +# queryset = ForeignKeyTarget.objects.all() +# new_serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, +# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, +# ] +# self.assertEqual(new_serializer.data, expected) + +# serializer.save() +# self.assertEqual(serializer.data, data) + +# # Ensure target 2 is update, and everything else is as expected +# queryset = ForeignKeyTarget.objects.all() +# serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, +# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_create(self): +# data = {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'} +# serializer = ForeignKeySourceSerializer(data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = ForeignKeySource.objects.all() +# serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_foreign_key_create(self): +# data = {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} +# serializer = ForeignKeyTargetSerializer(data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'target-3') + +# # Ensure target 4 is added, and everything else is as expected +# queryset = ForeignKeyTarget.objects.all() +# serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, +# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, +# {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_with_invalid_null(self): +# data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': None} +# instance = ForeignKeySource.objects.get(pk=1) +# serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'target': ['This field is required.']}) + + +# class HyperlinkedNullableForeignKeyTests(TestCase): +# urls = 'tests.test_relations_hyperlink' + +# def setUp(self): +# target = ForeignKeyTarget(name='target-1') +# target.save() +# for idx in range(1, 4): +# if idx == 3: +# target = None +# source = NullableForeignKeySource(name='source-%d' % idx, target=target) +# source.save() + +# def test_foreign_key_retrieve_with_null(self): +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_create_with_valid_null(self): +# data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} +# serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 4 is created, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, +# {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_create_with_valid_emptystring(self): +# """ +# The emptystring should be interpreted as null in the context +# of relationships. +# """ +# data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': ''} +# expected_data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} +# serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, expected_data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 4 is created, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, +# {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_with_valid_null(self): +# data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} +# instance = NullableForeignKeySource.objects.get(pk=1) +# serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, data) +# serializer.save() + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}, +# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_with_valid_emptystring(self): +# """ +# The emptystring should be interpreted as null in the context +# of relationships. +# """ +# data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': ''} +# expected_data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} +# instance = NullableForeignKeySource.objects.get(pk=1) +# serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, expected_data) +# serializer.save() + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}, +# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, +# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, +# ] +# self.assertEqual(serializer.data, expected) + +# # reverse foreign keys MUST be read_only +# # In the general case they do not provide .remove() or .clear() +# # and cannot be arbitrarily set. + +# # def test_reverse_foreign_key_update(self): +# # data = {'id': 1, 'name': 'target-1', 'sources': [1]} +# # instance = ForeignKeyTarget.objects.get(pk=1) +# # serializer = ForeignKeyTargetSerializer(instance, data=data) +# # self.assertTrue(serializer.is_valid()) +# # self.assertEqual(serializer.data, data) +# # serializer.save() + +# # # Ensure target 1 is updated, and everything else is as expected +# # queryset = ForeignKeyTarget.objects.all() +# # serializer = ForeignKeyTargetSerializer(queryset, many=True) +# # expected = [ +# # {'id': 1, 'name': 'target-1', 'sources': [1]}, +# # {'id': 2, 'name': 'target-2', 'sources': []}, +# # ] +# # self.assertEqual(serializer.data, expected) + + +# class HyperlinkedNullableOneToOneTests(TestCase): +# urls = 'tests.test_relations_hyperlink' + +# def setUp(self): +# target = OneToOneTarget(name='target-1') +# target.save() +# new_target = OneToOneTarget(name='target-2') +# new_target.save() +# source = NullableOneToOneSource(name='source-1', target=target) +# source.save() + +# def test_reverse_foreign_key_retrieve_with_null(self): +# queryset = OneToOneTarget.objects.all() +# serializer = NullableOneToOneTargetSerializer(queryset, many=True, context={'request': request}) +# expected = [ +# {'url': 'http://testserver/onetoonetarget/1/', 'name': 'target-1', 'nullable_source': 'http://testserver/nullableonetoonesource/1/'}, +# {'url': 'http://testserver/onetoonetarget/2/', 'name': 'target-2', 'nullable_source': None}, +# ] +# self.assertEqual(serializer.data, expected) + + +# # Regression tests for #694 (`source` attribute on related fields) + +# class HyperlinkedRelatedFieldSourceTests(TestCase): +# urls = 'tests.test_relations_hyperlink' + +# def test_related_manager_source(self): +# """ +# Relational fields should be able to use manager-returning methods as their source. +# """ +# BlogPost.objects.create(title='blah') +# field = serializers.HyperlinkedRelatedField( +# many=True, +# source='get_blogposts_manager', +# view_name='dummy-url', +# ) +# field.context = {'request': request} + +# class ClassWithManagerMethod(object): +# def get_blogposts_manager(self): +# return BlogPost.objects + +# obj = ClassWithManagerMethod() +# value = field.field_to_native(obj, 'field_name') +# self.assertEqual(value, ['http://testserver/dummyurl/1/']) + +# def test_related_queryset_source(self): +# """ +# Relational fields should be able to use queryset-returning methods as their source. +# """ +# BlogPost.objects.create(title='blah') +# field = serializers.HyperlinkedRelatedField( +# many=True, +# source='get_blogposts_queryset', +# view_name='dummy-url', +# ) +# field.context = {'request': request} + +# class ClassWithQuerysetMethod(object): +# def get_blogposts_queryset(self): +# return BlogPost.objects.all() + +# obj = ClassWithQuerysetMethod() +# value = field.field_to_native(obj, 'field_name') +# self.assertEqual(value, ['http://testserver/dummyurl/1/']) + +# def test_dotted_source(self): +# """ +# Source argument should support dotted.source notation. +# """ +# BlogPost.objects.create(title='blah') +# field = serializers.HyperlinkedRelatedField( +# many=True, +# source='a.b.c', +# view_name='dummy-url', +# ) +# field.context = {'request': request} + +# class ClassWithQuerysetMethod(object): +# a = { +# 'b': { +# 'c': BlogPost.objects.all() +# } +# } + +# obj = ClassWithQuerysetMethod() +# value = field.field_to_native(obj, 'field_name') +# self.assertEqual(value, ['http://testserver/dummyurl/1/']) diff --git a/tests/test_relations_nested.py b/tests/test_relations_nested.py index 4d9da489..4a99fee9 100644 --- a/tests/test_relations_nested.py +++ b/tests/test_relations_nested.py @@ -1,326 +1,326 @@ -from __future__ import unicode_literals -from django.db import models -from django.test import TestCase -from rest_framework import serializers - -from .models import OneToOneTarget - - -class OneToOneSource(models.Model): - name = models.CharField(max_length=100) - target = models.OneToOneField(OneToOneTarget, related_name='source', - null=True, blank=True) - - -class OneToManyTarget(models.Model): - name = models.CharField(max_length=100) - - -class OneToManySource(models.Model): - name = models.CharField(max_length=100) - target = models.ForeignKey(OneToManyTarget, related_name='sources') - - -class ReverseNestedOneToOneTests(TestCase): - def setUp(self): - class OneToOneSourceSerializer(serializers.ModelSerializer): - class Meta: - model = OneToOneSource - fields = ('id', 'name') - - class OneToOneTargetSerializer(serializers.ModelSerializer): - source = OneToOneSourceSerializer() - - class Meta: - model = OneToOneTarget - fields = ('id', 'name', 'source') - - self.Serializer = OneToOneTargetSerializer - - for idx in range(1, 4): - target = OneToOneTarget(name='target-%d' % idx) - target.save() - source = OneToOneSource(name='source-%d' % idx, target=target) - source.save() - - def test_one_to_one_retrieve(self): - queryset = OneToOneTarget.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, - {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, - {'id': 3, 'name': 'target-3', 'source': {'id': 3, 'name': 'source-3'}} - ] - self.assertEqual(serializer.data, expected) - - def test_one_to_one_create(self): - data = {'id': 4, 'name': 'target-4', 'source': {'id': 4, 'name': 'source-4'}} - serializer = self.Serializer(data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'target-4') - - # Ensure (target 4, target_source 4, source 4) are added, and - # everything else is as expected. - queryset = OneToOneTarget.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, - {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, - {'id': 3, 'name': 'target-3', 'source': {'id': 3, 'name': 'source-3'}}, - {'id': 4, 'name': 'target-4', 'source': {'id': 4, 'name': 'source-4'}} - ] - self.assertEqual(serializer.data, expected) - - def test_one_to_one_create_with_invalid_data(self): - data = {'id': 4, 'name': 'target-4', 'source': {'id': 4}} - serializer = self.Serializer(data=data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'source': [{'name': ['This field is required.']}]}) - - def test_one_to_one_update(self): - data = {'id': 3, 'name': 'target-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}} - instance = OneToOneTarget.objects.get(pk=3) - serializer = self.Serializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'target-3-updated') - - # Ensure (target 3, target_source 3, source 3) are updated, - # and everything else is as expected. - queryset = OneToOneTarget.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, - {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, - {'id': 3, 'name': 'target-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}} - ] - self.assertEqual(serializer.data, expected) - - -class ForwardNestedOneToOneTests(TestCase): - def setUp(self): - class OneToOneTargetSerializer(serializers.ModelSerializer): - class Meta: - model = OneToOneTarget - fields = ('id', 'name') - - class OneToOneSourceSerializer(serializers.ModelSerializer): - target = OneToOneTargetSerializer() - - class Meta: - model = OneToOneSource - fields = ('id', 'name', 'target') - - self.Serializer = OneToOneSourceSerializer - - for idx in range(1, 4): - target = OneToOneTarget(name='target-%d' % idx) - target.save() - source = OneToOneSource(name='source-%d' % idx, target=target) - source.save() - - def test_one_to_one_retrieve(self): - queryset = OneToOneSource.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, - {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, - {'id': 3, 'name': 'source-3', 'target': {'id': 3, 'name': 'target-3'}} - ] - self.assertEqual(serializer.data, expected) - - def test_one_to_one_create(self): - data = {'id': 4, 'name': 'source-4', 'target': {'id': 4, 'name': 'target-4'}} - serializer = self.Serializer(data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-4') - - # Ensure (target 4, target_source 4, source 4) are added, and - # everything else is as expected. - queryset = OneToOneSource.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, - {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, - {'id': 3, 'name': 'source-3', 'target': {'id': 3, 'name': 'target-3'}}, - {'id': 4, 'name': 'source-4', 'target': {'id': 4, 'name': 'target-4'}} - ] - self.assertEqual(serializer.data, expected) - - def test_one_to_one_create_with_invalid_data(self): - data = {'id': 4, 'name': 'source-4', 'target': {'id': 4}} - serializer = self.Serializer(data=data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'target': [{'name': ['This field is required.']}]}) - - def test_one_to_one_update(self): - data = {'id': 3, 'name': 'source-3-updated', 'target': {'id': 3, 'name': 'target-3-updated'}} - instance = OneToOneSource.objects.get(pk=3) - serializer = self.Serializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-3-updated') - - # Ensure (target 3, target_source 3, source 3) are updated, - # and everything else is as expected. - queryset = OneToOneSource.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, - {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, - {'id': 3, 'name': 'source-3-updated', 'target': {'id': 3, 'name': 'target-3-updated'}} - ] - self.assertEqual(serializer.data, expected) - - def test_one_to_one_update_to_null(self): - data = {'id': 3, 'name': 'source-3-updated', 'target': None} - instance = OneToOneSource.objects.get(pk=3) - serializer = self.Serializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-3-updated') - self.assertEqual(obj.target, None) - - queryset = OneToOneSource.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, - {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, - {'id': 3, 'name': 'source-3-updated', 'target': None} - ] - self.assertEqual(serializer.data, expected) - - # TODO: Nullable 1-1 tests - # def test_one_to_one_delete(self): - # data = {'id': 3, 'name': 'target-3', 'target_source': None} - # instance = OneToOneTarget.objects.get(pk=3) - # serializer = self.Serializer(instance, data=data) - # self.assertTrue(serializer.is_valid()) - # serializer.save() - - # # Ensure (target_source 3, source 3) are deleted, - # # and everything else is as expected. - # queryset = OneToOneTarget.objects.all() - # serializer = self.Serializer(queryset) - # expected = [ - # {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, - # {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, - # {'id': 3, 'name': 'target-3', 'source': None} - # ] - # self.assertEqual(serializer.data, expected) - - -class ReverseNestedOneToManyTests(TestCase): - def setUp(self): - class OneToManySourceSerializer(serializers.ModelSerializer): - class Meta: - model = OneToManySource - fields = ('id', 'name') - - class OneToManyTargetSerializer(serializers.ModelSerializer): - sources = OneToManySourceSerializer(many=True, allow_add_remove=True) - - class Meta: - model = OneToManyTarget - fields = ('id', 'name', 'sources') - - self.Serializer = OneToManyTargetSerializer - - target = OneToManyTarget(name='target-1') - target.save() - for idx in range(1, 4): - source = OneToManySource(name='source-%d' % idx, target=target) - source.save() - - def test_one_to_many_retrieve(self): - queryset = OneToManyTarget.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, - {'id': 2, 'name': 'source-2'}, - {'id': 3, 'name': 'source-3'}]}, - ] - self.assertEqual(serializer.data, expected) - - def test_one_to_many_create(self): - data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, - {'id': 2, 'name': 'source-2'}, - {'id': 3, 'name': 'source-3'}, - {'id': 4, 'name': 'source-4'}]} - instance = OneToManyTarget.objects.get(pk=1) - serializer = self.Serializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'target-1') - - # Ensure source 4 is added, and everything else is as - # expected. - queryset = OneToManyTarget.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, - {'id': 2, 'name': 'source-2'}, - {'id': 3, 'name': 'source-3'}, - {'id': 4, 'name': 'source-4'}]} - ] - self.assertEqual(serializer.data, expected) - - def test_one_to_many_create_with_invalid_data(self): - data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, - {'id': 2, 'name': 'source-2'}, - {'id': 3, 'name': 'source-3'}, - {'id': 4}]} - serializer = self.Serializer(data=data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'sources': [{}, {}, {}, {'name': ['This field is required.']}]}) - - def test_one_to_many_update(self): - data = {'id': 1, 'name': 'target-1-updated', 'sources': [{'id': 1, 'name': 'source-1-updated'}, - {'id': 2, 'name': 'source-2'}, - {'id': 3, 'name': 'source-3'}]} - instance = OneToManyTarget.objects.get(pk=1) - serializer = self.Serializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'target-1-updated') - - # Ensure (target 1, source 1) are updated, - # and everything else is as expected. - queryset = OneToManyTarget.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1-updated', 'sources': [{'id': 1, 'name': 'source-1-updated'}, - {'id': 2, 'name': 'source-2'}, - {'id': 3, 'name': 'source-3'}]} - - ] - self.assertEqual(serializer.data, expected) - - def test_one_to_many_delete(self): - data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, - {'id': 3, 'name': 'source-3'}]} - instance = OneToManyTarget.objects.get(pk=1) - serializer = self.Serializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - serializer.save() - - # Ensure source 2 is deleted, and everything else is as - # expected. - queryset = OneToManyTarget.objects.all() - serializer = self.Serializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, - {'id': 3, 'name': 'source-3'}]} - - ] - self.assertEqual(serializer.data, expected) +# from __future__ import unicode_literals +# from django.db import models +# from django.test import TestCase +# from rest_framework import serializers + +# from .models import OneToOneTarget + + +# class OneToOneSource(models.Model): +# name = models.CharField(max_length=100) +# target = models.OneToOneField(OneToOneTarget, related_name='source', +# null=True, blank=True) + + +# class OneToManyTarget(models.Model): +# name = models.CharField(max_length=100) + + +# class OneToManySource(models.Model): +# name = models.CharField(max_length=100) +# target = models.ForeignKey(OneToManyTarget, related_name='sources') + + +# class ReverseNestedOneToOneTests(TestCase): +# def setUp(self): +# class OneToOneSourceSerializer(serializers.ModelSerializer): +# class Meta: +# model = OneToOneSource +# fields = ('id', 'name') + +# class OneToOneTargetSerializer(serializers.ModelSerializer): +# source = OneToOneSourceSerializer() + +# class Meta: +# model = OneToOneTarget +# fields = ('id', 'name', 'source') + +# self.Serializer = OneToOneTargetSerializer + +# for idx in range(1, 4): +# target = OneToOneTarget(name='target-%d' % idx) +# target.save() +# source = OneToOneSource(name='source-%d' % idx, target=target) +# source.save() + +# def test_one_to_one_retrieve(self): +# queryset = OneToOneTarget.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, +# {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, +# {'id': 3, 'name': 'target-3', 'source': {'id': 3, 'name': 'source-3'}} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_one_to_one_create(self): +# data = {'id': 4, 'name': 'target-4', 'source': {'id': 4, 'name': 'source-4'}} +# serializer = self.Serializer(data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'target-4') + +# # Ensure (target 4, target_source 4, source 4) are added, and +# # everything else is as expected. +# queryset = OneToOneTarget.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, +# {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, +# {'id': 3, 'name': 'target-3', 'source': {'id': 3, 'name': 'source-3'}}, +# {'id': 4, 'name': 'target-4', 'source': {'id': 4, 'name': 'source-4'}} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_one_to_one_create_with_invalid_data(self): +# data = {'id': 4, 'name': 'target-4', 'source': {'id': 4}} +# serializer = self.Serializer(data=data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'source': [{'name': ['This field is required.']}]}) + +# def test_one_to_one_update(self): +# data = {'id': 3, 'name': 'target-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}} +# instance = OneToOneTarget.objects.get(pk=3) +# serializer = self.Serializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'target-3-updated') + +# # Ensure (target 3, target_source 3, source 3) are updated, +# # and everything else is as expected. +# queryset = OneToOneTarget.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, +# {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, +# {'id': 3, 'name': 'target-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}} +# ] +# self.assertEqual(serializer.data, expected) + + +# class ForwardNestedOneToOneTests(TestCase): +# def setUp(self): +# class OneToOneTargetSerializer(serializers.ModelSerializer): +# class Meta: +# model = OneToOneTarget +# fields = ('id', 'name') + +# class OneToOneSourceSerializer(serializers.ModelSerializer): +# target = OneToOneTargetSerializer() + +# class Meta: +# model = OneToOneSource +# fields = ('id', 'name', 'target') + +# self.Serializer = OneToOneSourceSerializer + +# for idx in range(1, 4): +# target = OneToOneTarget(name='target-%d' % idx) +# target.save() +# source = OneToOneSource(name='source-%d' % idx, target=target) +# source.save() + +# def test_one_to_one_retrieve(self): +# queryset = OneToOneSource.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, +# {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, +# {'id': 3, 'name': 'source-3', 'target': {'id': 3, 'name': 'target-3'}} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_one_to_one_create(self): +# data = {'id': 4, 'name': 'source-4', 'target': {'id': 4, 'name': 'target-4'}} +# serializer = self.Serializer(data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure (target 4, target_source 4, source 4) are added, and +# # everything else is as expected. +# queryset = OneToOneSource.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, +# {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, +# {'id': 3, 'name': 'source-3', 'target': {'id': 3, 'name': 'target-3'}}, +# {'id': 4, 'name': 'source-4', 'target': {'id': 4, 'name': 'target-4'}} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_one_to_one_create_with_invalid_data(self): +# data = {'id': 4, 'name': 'source-4', 'target': {'id': 4}} +# serializer = self.Serializer(data=data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'target': [{'name': ['This field is required.']}]}) + +# def test_one_to_one_update(self): +# data = {'id': 3, 'name': 'source-3-updated', 'target': {'id': 3, 'name': 'target-3-updated'}} +# instance = OneToOneSource.objects.get(pk=3) +# serializer = self.Serializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-3-updated') + +# # Ensure (target 3, target_source 3, source 3) are updated, +# # and everything else is as expected. +# queryset = OneToOneSource.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, +# {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, +# {'id': 3, 'name': 'source-3-updated', 'target': {'id': 3, 'name': 'target-3-updated'}} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_one_to_one_update_to_null(self): +# data = {'id': 3, 'name': 'source-3-updated', 'target': None} +# instance = OneToOneSource.objects.get(pk=3) +# serializer = self.Serializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() + +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-3-updated') +# self.assertEqual(obj.target, None) + +# queryset = OneToOneSource.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, +# {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, +# {'id': 3, 'name': 'source-3-updated', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) + +# # TODO: Nullable 1-1 tests +# # def test_one_to_one_delete(self): +# # data = {'id': 3, 'name': 'target-3', 'target_source': None} +# # instance = OneToOneTarget.objects.get(pk=3) +# # serializer = self.Serializer(instance, data=data) +# # self.assertTrue(serializer.is_valid()) +# # serializer.save() + +# # # Ensure (target_source 3, source 3) are deleted, +# # # and everything else is as expected. +# # queryset = OneToOneTarget.objects.all() +# # serializer = self.Serializer(queryset) +# # expected = [ +# # {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, +# # {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, +# # {'id': 3, 'name': 'target-3', 'source': None} +# # ] +# # self.assertEqual(serializer.data, expected) + + +# class ReverseNestedOneToManyTests(TestCase): +# def setUp(self): +# class OneToManySourceSerializer(serializers.ModelSerializer): +# class Meta: +# model = OneToManySource +# fields = ('id', 'name') + +# class OneToManyTargetSerializer(serializers.ModelSerializer): +# sources = OneToManySourceSerializer(many=True, allow_add_remove=True) + +# class Meta: +# model = OneToManyTarget +# fields = ('id', 'name', 'sources') + +# self.Serializer = OneToManyTargetSerializer + +# target = OneToManyTarget(name='target-1') +# target.save() +# for idx in range(1, 4): +# source = OneToManySource(name='source-%d' % idx, target=target) +# source.save() + +# def test_one_to_many_retrieve(self): +# queryset = OneToManyTarget.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, +# {'id': 2, 'name': 'source-2'}, +# {'id': 3, 'name': 'source-3'}]}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_one_to_many_create(self): +# data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, +# {'id': 2, 'name': 'source-2'}, +# {'id': 3, 'name': 'source-3'}, +# {'id': 4, 'name': 'source-4'}]} +# instance = OneToManyTarget.objects.get(pk=1) +# serializer = self.Serializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'target-1') + +# # Ensure source 4 is added, and everything else is as +# # expected. +# queryset = OneToManyTarget.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, +# {'id': 2, 'name': 'source-2'}, +# {'id': 3, 'name': 'source-3'}, +# {'id': 4, 'name': 'source-4'}]} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_one_to_many_create_with_invalid_data(self): +# data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, +# {'id': 2, 'name': 'source-2'}, +# {'id': 3, 'name': 'source-3'}, +# {'id': 4}]} +# serializer = self.Serializer(data=data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'sources': [{}, {}, {}, {'name': ['This field is required.']}]}) + +# def test_one_to_many_update(self): +# data = {'id': 1, 'name': 'target-1-updated', 'sources': [{'id': 1, 'name': 'source-1-updated'}, +# {'id': 2, 'name': 'source-2'}, +# {'id': 3, 'name': 'source-3'}]} +# instance = OneToManyTarget.objects.get(pk=1) +# serializer = self.Serializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'target-1-updated') + +# # Ensure (target 1, source 1) are updated, +# # and everything else is as expected. +# queryset = OneToManyTarget.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1-updated', 'sources': [{'id': 1, 'name': 'source-1-updated'}, +# {'id': 2, 'name': 'source-2'}, +# {'id': 3, 'name': 'source-3'}]} + +# ] +# self.assertEqual(serializer.data, expected) + +# def test_one_to_many_delete(self): +# data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, +# {'id': 3, 'name': 'source-3'}]} +# instance = OneToManyTarget.objects.get(pk=1) +# serializer = self.Serializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# serializer.save() + +# # Ensure source 2 is deleted, and everything else is as +# # expected. +# queryset = OneToManyTarget.objects.all() +# serializer = self.Serializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, +# {'id': 3, 'name': 'source-3'}]} + +# ] +# self.assertEqual(serializer.data, expected) diff --git a/tests/test_relations_pk.py b/tests/test_relations_pk.py index e3f836ed..031a79b3 100644 --- a/tests/test_relations_pk.py +++ b/tests/test_relations_pk.py @@ -1,551 +1,551 @@ -from __future__ import unicode_literals -from django.db import models -from django.test import TestCase -from django.utils import six -from rest_framework import serializers -from tests.models import ( - BlogPost, ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, - NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource, -) - - -# ManyToMany -class ManyToManyTargetSerializer(serializers.ModelSerializer): - class Meta: - model = ManyToManyTarget - fields = ('id', 'name', 'sources') - - -class ManyToManySourceSerializer(serializers.ModelSerializer): - class Meta: - model = ManyToManySource - fields = ('id', 'name', 'targets') - - -# ForeignKey -class ForeignKeyTargetSerializer(serializers.ModelSerializer): - class Meta: - model = ForeignKeyTarget - fields = ('id', 'name', 'sources') - - -class ForeignKeySourceSerializer(serializers.ModelSerializer): - class Meta: - model = ForeignKeySource - fields = ('id', 'name', 'target') - - -# Nullable ForeignKey -class NullableForeignKeySourceSerializer(serializers.ModelSerializer): - class Meta: - model = NullableForeignKeySource - fields = ('id', 'name', 'target') - - -# Nullable OneToOne -class NullableOneToOneTargetSerializer(serializers.ModelSerializer): - class Meta: - model = OneToOneTarget - fields = ('id', 'name', 'nullable_source') - - -# TODO: Add test that .data cannot be accessed prior to .is_valid - -class PKManyToManyTests(TestCase): - def setUp(self): - for idx in range(1, 4): - target = ManyToManyTarget(name='target-%d' % idx) - target.save() - source = ManyToManySource(name='source-%d' % idx) - source.save() - for target in ManyToManyTarget.objects.all(): - source.targets.add(target) - - def test_many_to_many_retrieve(self): - queryset = ManyToManySource.objects.all() - serializer = ManyToManySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'targets': [1]}, - {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, - {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_many_to_many_retrieve(self): - queryset = ManyToManyTarget.objects.all() - serializer = ManyToManyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, - {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, - {'id': 3, 'name': 'target-3', 'sources': [3]} - ] - self.assertEqual(serializer.data, expected) - - def test_many_to_many_update(self): - data = {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]} - instance = ManyToManySource.objects.get(pk=1) - serializer = ManyToManySourceSerializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - serializer.save() - self.assertEqual(serializer.data, data) - - # Ensure source 1 is updated, and everything else is as expected - queryset = ManyToManySource.objects.all() - serializer = ManyToManySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]}, - {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, - {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_many_to_many_update(self): - data = {'id': 1, 'name': 'target-1', 'sources': [1]} - instance = ManyToManyTarget.objects.get(pk=1) - serializer = ManyToManyTargetSerializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - serializer.save() - self.assertEqual(serializer.data, data) - - # Ensure target 1 is updated, and everything else is as expected - queryset = ManyToManyTarget.objects.all() - serializer = ManyToManyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': [1]}, - {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, - {'id': 3, 'name': 'target-3', 'sources': [3]} - ] - self.assertEqual(serializer.data, expected) - - def test_many_to_many_create(self): - data = {'id': 4, 'name': 'source-4', 'targets': [1, 3]} - serializer = ManyToManySourceSerializer(data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 4 is added, and everything else is as expected - queryset = ManyToManySource.objects.all() - serializer = ManyToManySourceSerializer(queryset, many=True) - self.assertFalse(serializer.fields['targets'].read_only) - expected = [ - {'id': 1, 'name': 'source-1', 'targets': [1]}, - {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, - {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]}, - {'id': 4, 'name': 'source-4', 'targets': [1, 3]}, - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_many_to_many_create(self): - data = {'id': 4, 'name': 'target-4', 'sources': [1, 3]} - serializer = ManyToManyTargetSerializer(data=data) - self.assertFalse(serializer.fields['sources'].read_only) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'target-4') - - # Ensure target 4 is added, and everything else is as expected - queryset = ManyToManyTarget.objects.all() - serializer = ManyToManyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, - {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, - {'id': 3, 'name': 'target-3', 'sources': [3]}, - {'id': 4, 'name': 'target-4', 'sources': [1, 3]} - ] - self.assertEqual(serializer.data, expected) - - -class PKForeignKeyTests(TestCase): - def setUp(self): - target = ForeignKeyTarget(name='target-1') - target.save() - new_target = ForeignKeyTarget(name='target-2') - new_target.save() - for idx in range(1, 4): - source = ForeignKeySource(name='source-%d' % idx, target=target) - source.save() - - def test_foreign_key_retrieve(self): - queryset = ForeignKeySource.objects.all() - serializer = ForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 1}, - {'id': 2, 'name': 'source-2', 'target': 1}, - {'id': 3, 'name': 'source-3', 'target': 1} - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_foreign_key_retrieve(self): - queryset = ForeignKeyTarget.objects.all() - serializer = ForeignKeyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, - {'id': 2, 'name': 'target-2', 'sources': []}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update(self): - data = {'id': 1, 'name': 'source-1', 'target': 2} - instance = ForeignKeySource.objects.get(pk=1) - serializer = ForeignKeySourceSerializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, data) - serializer.save() - - # Ensure source 1 is updated, and everything else is as expected - queryset = ForeignKeySource.objects.all() - serializer = ForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 2}, - {'id': 2, 'name': 'source-2', 'target': 1}, - {'id': 3, 'name': 'source-3', 'target': 1} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_incorrect_type(self): - data = {'id': 1, 'name': 'source-1', 'target': 'foo'} - instance = ForeignKeySource.objects.get(pk=1) - serializer = ForeignKeySourceSerializer(instance, data=data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected pk value, received %s.' % six.text_type.__name__]}) - - def test_reverse_foreign_key_update(self): - data = {'id': 2, 'name': 'target-2', 'sources': [1, 3]} - instance = ForeignKeyTarget.objects.get(pk=2) - serializer = ForeignKeyTargetSerializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - # We shouldn't have saved anything to the db yet since save - # hasn't been called. - queryset = ForeignKeyTarget.objects.all() - new_serializer = ForeignKeyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, - {'id': 2, 'name': 'target-2', 'sources': []}, - ] - self.assertEqual(new_serializer.data, expected) - - serializer.save() - self.assertEqual(serializer.data, data) - - # Ensure target 2 is update, and everything else is as expected - queryset = ForeignKeyTarget.objects.all() - serializer = ForeignKeyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': [2]}, - {'id': 2, 'name': 'target-2', 'sources': [1, 3]}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_create(self): - data = {'id': 4, 'name': 'source-4', 'target': 2} - serializer = ForeignKeySourceSerializer(data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 4 is added, and everything else is as expected - queryset = ForeignKeySource.objects.all() - serializer = ForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 1}, - {'id': 2, 'name': 'source-2', 'target': 1}, - {'id': 3, 'name': 'source-3', 'target': 1}, - {'id': 4, 'name': 'source-4', 'target': 2}, - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_foreign_key_create(self): - data = {'id': 3, 'name': 'target-3', 'sources': [1, 3]} - serializer = ForeignKeyTargetSerializer(data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'target-3') - - # Ensure target 3 is added, and everything else is as expected - queryset = ForeignKeyTarget.objects.all() - serializer = ForeignKeyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': [2]}, - {'id': 2, 'name': 'target-2', 'sources': []}, - {'id': 3, 'name': 'target-3', 'sources': [1, 3]}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_with_invalid_null(self): - data = {'id': 1, 'name': 'source-1', 'target': None} - instance = ForeignKeySource.objects.get(pk=1) - serializer = ForeignKeySourceSerializer(instance, data=data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'target': ['This field is required.']}) - - def test_foreign_key_with_empty(self): - """ - Regression test for #1072 - - https://github.com/tomchristie/django-rest-framework/issues/1072 - """ - serializer = NullableForeignKeySourceSerializer() - self.assertEqual(serializer.data['target'], None) - - -class PKNullableForeignKeyTests(TestCase): - def setUp(self): - target = ForeignKeyTarget(name='target-1') - target.save() - for idx in range(1, 4): - if idx == 3: - target = None - source = NullableForeignKeySource(name='source-%d' % idx, target=target) - source.save() - - def test_foreign_key_retrieve_with_null(self): - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 1}, - {'id': 2, 'name': 'source-2', 'target': 1}, - {'id': 3, 'name': 'source-3', 'target': None}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_create_with_valid_null(self): - data = {'id': 4, 'name': 'source-4', 'target': None} - serializer = NullableForeignKeySourceSerializer(data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 4 is created, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 1}, - {'id': 2, 'name': 'source-2', 'target': 1}, - {'id': 3, 'name': 'source-3', 'target': None}, - {'id': 4, 'name': 'source-4', 'target': None} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_create_with_valid_emptystring(self): - """ - The emptystring should be interpreted as null in the context - of relationships. - """ - data = {'id': 4, 'name': 'source-4', 'target': ''} - expected_data = {'id': 4, 'name': 'source-4', 'target': None} - serializer = NullableForeignKeySourceSerializer(data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, expected_data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 4 is created, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 1}, - {'id': 2, 'name': 'source-2', 'target': 1}, - {'id': 3, 'name': 'source-3', 'target': None}, - {'id': 4, 'name': 'source-4', 'target': None} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_with_valid_null(self): - data = {'id': 1, 'name': 'source-1', 'target': None} - instance = NullableForeignKeySource.objects.get(pk=1) - serializer = NullableForeignKeySourceSerializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, data) - serializer.save() - - # Ensure source 1 is updated, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': None}, - {'id': 2, 'name': 'source-2', 'target': 1}, - {'id': 3, 'name': 'source-3', 'target': None} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_with_valid_emptystring(self): - """ - The emptystring should be interpreted as null in the context - of relationships. - """ - data = {'id': 1, 'name': 'source-1', 'target': ''} - expected_data = {'id': 1, 'name': 'source-1', 'target': None} - instance = NullableForeignKeySource.objects.get(pk=1) - serializer = NullableForeignKeySourceSerializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, expected_data) - serializer.save() - - # Ensure source 1 is updated, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': None}, - {'id': 2, 'name': 'source-2', 'target': 1}, - {'id': 3, 'name': 'source-3', 'target': None} - ] - self.assertEqual(serializer.data, expected) - - # reverse foreign keys MUST be read_only - # In the general case they do not provide .remove() or .clear() - # and cannot be arbitrarily set. - - # def test_reverse_foreign_key_update(self): - # data = {'id': 1, 'name': 'target-1', 'sources': [1]} - # instance = ForeignKeyTarget.objects.get(pk=1) - # serializer = ForeignKeyTargetSerializer(instance, data=data) - # self.assertTrue(serializer.is_valid()) - # self.assertEqual(serializer.data, data) - # serializer.save() - - # # Ensure target 1 is updated, and everything else is as expected - # queryset = ForeignKeyTarget.objects.all() - # serializer = ForeignKeyTargetSerializer(queryset, many=True) - # expected = [ - # {'id': 1, 'name': 'target-1', 'sources': [1]}, - # {'id': 2, 'name': 'target-2', 'sources': []}, - # ] - # self.assertEqual(serializer.data, expected) - - -class PKNullableOneToOneTests(TestCase): - def setUp(self): - target = OneToOneTarget(name='target-1') - target.save() - new_target = OneToOneTarget(name='target-2') - new_target.save() - source = NullableOneToOneSource(name='source-1', target=new_target) - source.save() - - def test_reverse_foreign_key_retrieve_with_null(self): - queryset = OneToOneTarget.objects.all() - serializer = NullableOneToOneTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'nullable_source': None}, - {'id': 2, 'name': 'target-2', 'nullable_source': 1}, - ] - self.assertEqual(serializer.data, expected) - - -# The below models and tests ensure that serializer fields corresponding -# to a ManyToManyField field with a user-specified ``through`` model are -# set to read only - - -class ManyToManyThroughTarget(models.Model): - name = models.CharField(max_length=100) - - -class ManyToManyThrough(models.Model): - source = models.ForeignKey('ManyToManyThroughSource') - target = models.ForeignKey(ManyToManyThroughTarget) - - -class ManyToManyThroughSource(models.Model): - name = models.CharField(max_length=100) - targets = models.ManyToManyField(ManyToManyThroughTarget, - related_name='sources', - through='ManyToManyThrough') - - -class ManyToManyThroughTargetSerializer(serializers.ModelSerializer): - class Meta: - model = ManyToManyThroughTarget - fields = ('id', 'name', 'sources') - - -class ManyToManyThroughSourceSerializer(serializers.ModelSerializer): - class Meta: - model = ManyToManyThroughSource - fields = ('id', 'name', 'targets') - - -class PKManyToManyThroughTests(TestCase): - def setUp(self): - self.source = ManyToManyThroughSource.objects.create( - name='through-source-1') - self.target = ManyToManyThroughTarget.objects.create( - name='through-target-1') - - def test_many_to_many_create(self): - data = {'id': 2, 'name': 'source-2', 'targets': [self.target.pk]} - serializer = ManyToManyThroughSourceSerializer(data=data) - self.assertTrue(serializer.fields['targets'].read_only) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(obj.name, 'source-2') - self.assertEqual(obj.targets.count(), 0) - - def test_many_to_many_reverse_create(self): - data = {'id': 2, 'name': 'target-2', 'sources': [self.source.pk]} - serializer = ManyToManyThroughTargetSerializer(data=data) - self.assertTrue(serializer.fields['sources'].read_only) - self.assertTrue(serializer.is_valid()) - serializer.save() - obj = serializer.save() - self.assertEqual(obj.name, 'target-2') - self.assertEqual(obj.sources.count(), 0) - - -# Regression tests for #694 (`source` attribute on related fields) - - -class PrimaryKeyRelatedFieldSourceTests(TestCase): - def test_related_manager_source(self): - """ - Relational fields should be able to use manager-returning methods as their source. - """ - BlogPost.objects.create(title='blah') - field = serializers.PrimaryKeyRelatedField(many=True, source='get_blogposts_manager') - - class ClassWithManagerMethod(object): - def get_blogposts_manager(self): - return BlogPost.objects - - obj = ClassWithManagerMethod() - value = field.field_to_native(obj, 'field_name') - self.assertEqual(value, [1]) - - def test_related_queryset_source(self): - """ - Relational fields should be able to use queryset-returning methods as their source. - """ - BlogPost.objects.create(title='blah') - field = serializers.PrimaryKeyRelatedField(many=True, source='get_blogposts_queryset') - - class ClassWithQuerysetMethod(object): - def get_blogposts_queryset(self): - return BlogPost.objects.all() - - obj = ClassWithQuerysetMethod() - value = field.field_to_native(obj, 'field_name') - self.assertEqual(value, [1]) - - def test_dotted_source(self): - """ - Source argument should support dotted.source notation. - """ - BlogPost.objects.create(title='blah') - field = serializers.PrimaryKeyRelatedField(many=True, source='a.b.c') - - class ClassWithQuerysetMethod(object): - a = { - 'b': { - 'c': BlogPost.objects.all() - } - } - - obj = ClassWithQuerysetMethod() - value = field.field_to_native(obj, 'field_name') - self.assertEqual(value, [1]) +# from __future__ import unicode_literals +# from django.db import models +# from django.test import TestCase +# from django.utils import six +# from rest_framework import serializers +# from tests.models import ( +# BlogPost, ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, +# NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource, +# ) + + +# # ManyToMany +# class ManyToManyTargetSerializer(serializers.ModelSerializer): +# class Meta: +# model = ManyToManyTarget +# fields = ('id', 'name', 'sources') + + +# class ManyToManySourceSerializer(serializers.ModelSerializer): +# class Meta: +# model = ManyToManySource +# fields = ('id', 'name', 'targets') + + +# # ForeignKey +# class ForeignKeyTargetSerializer(serializers.ModelSerializer): +# class Meta: +# model = ForeignKeyTarget +# fields = ('id', 'name', 'sources') + + +# class ForeignKeySourceSerializer(serializers.ModelSerializer): +# class Meta: +# model = ForeignKeySource +# fields = ('id', 'name', 'target') + + +# # Nullable ForeignKey +# class NullableForeignKeySourceSerializer(serializers.ModelSerializer): +# class Meta: +# model = NullableForeignKeySource +# fields = ('id', 'name', 'target') + + +# # Nullable OneToOne +# class NullableOneToOneTargetSerializer(serializers.ModelSerializer): +# class Meta: +# model = OneToOneTarget +# fields = ('id', 'name', 'nullable_source') + + +# # TODO: Add test that .data cannot be accessed prior to .is_valid + +# class PKManyToManyTests(TestCase): +# def setUp(self): +# for idx in range(1, 4): +# target = ManyToManyTarget(name='target-%d' % idx) +# target.save() +# source = ManyToManySource(name='source-%d' % idx) +# source.save() +# for target in ManyToManyTarget.objects.all(): +# source.targets.add(target) + +# def test_many_to_many_retrieve(self): +# queryset = ManyToManySource.objects.all() +# serializer = ManyToManySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'targets': [1]}, +# {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, +# {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_many_to_many_retrieve(self): +# queryset = ManyToManyTarget.objects.all() +# serializer = ManyToManyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, +# {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, +# {'id': 3, 'name': 'target-3', 'sources': [3]} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_many_to_many_update(self): +# data = {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]} +# instance = ManyToManySource.objects.get(pk=1) +# serializer = ManyToManySourceSerializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# serializer.save() +# self.assertEqual(serializer.data, data) + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = ManyToManySource.objects.all() +# serializer = ManyToManySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]}, +# {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, +# {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_many_to_many_update(self): +# data = {'id': 1, 'name': 'target-1', 'sources': [1]} +# instance = ManyToManyTarget.objects.get(pk=1) +# serializer = ManyToManyTargetSerializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# serializer.save() +# self.assertEqual(serializer.data, data) + +# # Ensure target 1 is updated, and everything else is as expected +# queryset = ManyToManyTarget.objects.all() +# serializer = ManyToManyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': [1]}, +# {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, +# {'id': 3, 'name': 'target-3', 'sources': [3]} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_many_to_many_create(self): +# data = {'id': 4, 'name': 'source-4', 'targets': [1, 3]} +# serializer = ManyToManySourceSerializer(data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 4 is added, and everything else is as expected +# queryset = ManyToManySource.objects.all() +# serializer = ManyToManySourceSerializer(queryset, many=True) +# self.assertFalse(serializer.fields['targets'].read_only) +# expected = [ +# {'id': 1, 'name': 'source-1', 'targets': [1]}, +# {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, +# {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]}, +# {'id': 4, 'name': 'source-4', 'targets': [1, 3]}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_many_to_many_create(self): +# data = {'id': 4, 'name': 'target-4', 'sources': [1, 3]} +# serializer = ManyToManyTargetSerializer(data=data) +# self.assertFalse(serializer.fields['sources'].read_only) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'target-4') + +# # Ensure target 4 is added, and everything else is as expected +# queryset = ManyToManyTarget.objects.all() +# serializer = ManyToManyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, +# {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, +# {'id': 3, 'name': 'target-3', 'sources': [3]}, +# {'id': 4, 'name': 'target-4', 'sources': [1, 3]} +# ] +# self.assertEqual(serializer.data, expected) + + +# class PKForeignKeyTests(TestCase): +# def setUp(self): +# target = ForeignKeyTarget(name='target-1') +# target.save() +# new_target = ForeignKeyTarget(name='target-2') +# new_target.save() +# for idx in range(1, 4): +# source = ForeignKeySource(name='source-%d' % idx, target=target) +# source.save() + +# def test_foreign_key_retrieve(self): +# queryset = ForeignKeySource.objects.all() +# serializer = ForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 1}, +# {'id': 2, 'name': 'source-2', 'target': 1}, +# {'id': 3, 'name': 'source-3', 'target': 1} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_foreign_key_retrieve(self): +# queryset = ForeignKeyTarget.objects.all() +# serializer = ForeignKeyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, +# {'id': 2, 'name': 'target-2', 'sources': []}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update(self): +# data = {'id': 1, 'name': 'source-1', 'target': 2} +# instance = ForeignKeySource.objects.get(pk=1) +# serializer = ForeignKeySourceSerializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, data) +# serializer.save() + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = ForeignKeySource.objects.all() +# serializer = ForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 2}, +# {'id': 2, 'name': 'source-2', 'target': 1}, +# {'id': 3, 'name': 'source-3', 'target': 1} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_incorrect_type(self): +# data = {'id': 1, 'name': 'source-1', 'target': 'foo'} +# instance = ForeignKeySource.objects.get(pk=1) +# serializer = ForeignKeySourceSerializer(instance, data=data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected pk value, received %s.' % six.text_type.__name__]}) + +# def test_reverse_foreign_key_update(self): +# data = {'id': 2, 'name': 'target-2', 'sources': [1, 3]} +# instance = ForeignKeyTarget.objects.get(pk=2) +# serializer = ForeignKeyTargetSerializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# # We shouldn't have saved anything to the db yet since save +# # hasn't been called. +# queryset = ForeignKeyTarget.objects.all() +# new_serializer = ForeignKeyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, +# {'id': 2, 'name': 'target-2', 'sources': []}, +# ] +# self.assertEqual(new_serializer.data, expected) + +# serializer.save() +# self.assertEqual(serializer.data, data) + +# # Ensure target 2 is update, and everything else is as expected +# queryset = ForeignKeyTarget.objects.all() +# serializer = ForeignKeyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': [2]}, +# {'id': 2, 'name': 'target-2', 'sources': [1, 3]}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_create(self): +# data = {'id': 4, 'name': 'source-4', 'target': 2} +# serializer = ForeignKeySourceSerializer(data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 4 is added, and everything else is as expected +# queryset = ForeignKeySource.objects.all() +# serializer = ForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 1}, +# {'id': 2, 'name': 'source-2', 'target': 1}, +# {'id': 3, 'name': 'source-3', 'target': 1}, +# {'id': 4, 'name': 'source-4', 'target': 2}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_foreign_key_create(self): +# data = {'id': 3, 'name': 'target-3', 'sources': [1, 3]} +# serializer = ForeignKeyTargetSerializer(data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'target-3') + +# # Ensure target 3 is added, and everything else is as expected +# queryset = ForeignKeyTarget.objects.all() +# serializer = ForeignKeyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': [2]}, +# {'id': 2, 'name': 'target-2', 'sources': []}, +# {'id': 3, 'name': 'target-3', 'sources': [1, 3]}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_with_invalid_null(self): +# data = {'id': 1, 'name': 'source-1', 'target': None} +# instance = ForeignKeySource.objects.get(pk=1) +# serializer = ForeignKeySourceSerializer(instance, data=data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'target': ['This field is required.']}) + +# def test_foreign_key_with_empty(self): +# """ +# Regression test for #1072 + +# https://github.com/tomchristie/django-rest-framework/issues/1072 +# """ +# serializer = NullableForeignKeySourceSerializer() +# self.assertEqual(serializer.data['target'], None) + + +# class PKNullableForeignKeyTests(TestCase): +# def setUp(self): +# target = ForeignKeyTarget(name='target-1') +# target.save() +# for idx in range(1, 4): +# if idx == 3: +# target = None +# source = NullableForeignKeySource(name='source-%d' % idx, target=target) +# source.save() + +# def test_foreign_key_retrieve_with_null(self): +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 1}, +# {'id': 2, 'name': 'source-2', 'target': 1}, +# {'id': 3, 'name': 'source-3', 'target': None}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_create_with_valid_null(self): +# data = {'id': 4, 'name': 'source-4', 'target': None} +# serializer = NullableForeignKeySourceSerializer(data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 4 is created, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 1}, +# {'id': 2, 'name': 'source-2', 'target': 1}, +# {'id': 3, 'name': 'source-3', 'target': None}, +# {'id': 4, 'name': 'source-4', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_create_with_valid_emptystring(self): +# """ +# The emptystring should be interpreted as null in the context +# of relationships. +# """ +# data = {'id': 4, 'name': 'source-4', 'target': ''} +# expected_data = {'id': 4, 'name': 'source-4', 'target': None} +# serializer = NullableForeignKeySourceSerializer(data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, expected_data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 4 is created, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 1}, +# {'id': 2, 'name': 'source-2', 'target': 1}, +# {'id': 3, 'name': 'source-3', 'target': None}, +# {'id': 4, 'name': 'source-4', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_with_valid_null(self): +# data = {'id': 1, 'name': 'source-1', 'target': None} +# instance = NullableForeignKeySource.objects.get(pk=1) +# serializer = NullableForeignKeySourceSerializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, data) +# serializer.save() + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': None}, +# {'id': 2, 'name': 'source-2', 'target': 1}, +# {'id': 3, 'name': 'source-3', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_with_valid_emptystring(self): +# """ +# The emptystring should be interpreted as null in the context +# of relationships. +# """ +# data = {'id': 1, 'name': 'source-1', 'target': ''} +# expected_data = {'id': 1, 'name': 'source-1', 'target': None} +# instance = NullableForeignKeySource.objects.get(pk=1) +# serializer = NullableForeignKeySourceSerializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, expected_data) +# serializer.save() + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': None}, +# {'id': 2, 'name': 'source-2', 'target': 1}, +# {'id': 3, 'name': 'source-3', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) + +# # reverse foreign keys MUST be read_only +# # In the general case they do not provide .remove() or .clear() +# # and cannot be arbitrarily set. + +# # def test_reverse_foreign_key_update(self): +# # data = {'id': 1, 'name': 'target-1', 'sources': [1]} +# # instance = ForeignKeyTarget.objects.get(pk=1) +# # serializer = ForeignKeyTargetSerializer(instance, data=data) +# # self.assertTrue(serializer.is_valid()) +# # self.assertEqual(serializer.data, data) +# # serializer.save() + +# # # Ensure target 1 is updated, and everything else is as expected +# # queryset = ForeignKeyTarget.objects.all() +# # serializer = ForeignKeyTargetSerializer(queryset, many=True) +# # expected = [ +# # {'id': 1, 'name': 'target-1', 'sources': [1]}, +# # {'id': 2, 'name': 'target-2', 'sources': []}, +# # ] +# # self.assertEqual(serializer.data, expected) + + +# class PKNullableOneToOneTests(TestCase): +# def setUp(self): +# target = OneToOneTarget(name='target-1') +# target.save() +# new_target = OneToOneTarget(name='target-2') +# new_target.save() +# source = NullableOneToOneSource(name='source-1', target=new_target) +# source.save() + +# def test_reverse_foreign_key_retrieve_with_null(self): +# queryset = OneToOneTarget.objects.all() +# serializer = NullableOneToOneTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'nullable_source': None}, +# {'id': 2, 'name': 'target-2', 'nullable_source': 1}, +# ] +# self.assertEqual(serializer.data, expected) + + +# # The below models and tests ensure that serializer fields corresponding +# # to a ManyToManyField field with a user-specified ``through`` model are +# # set to read only + + +# class ManyToManyThroughTarget(models.Model): +# name = models.CharField(max_length=100) + + +# class ManyToManyThrough(models.Model): +# source = models.ForeignKey('ManyToManyThroughSource') +# target = models.ForeignKey(ManyToManyThroughTarget) + + +# class ManyToManyThroughSource(models.Model): +# name = models.CharField(max_length=100) +# targets = models.ManyToManyField(ManyToManyThroughTarget, +# related_name='sources', +# through='ManyToManyThrough') + + +# class ManyToManyThroughTargetSerializer(serializers.ModelSerializer): +# class Meta: +# model = ManyToManyThroughTarget +# fields = ('id', 'name', 'sources') + + +# class ManyToManyThroughSourceSerializer(serializers.ModelSerializer): +# class Meta: +# model = ManyToManyThroughSource +# fields = ('id', 'name', 'targets') + + +# class PKManyToManyThroughTests(TestCase): +# def setUp(self): +# self.source = ManyToManyThroughSource.objects.create( +# name='through-source-1') +# self.target = ManyToManyThroughTarget.objects.create( +# name='through-target-1') + +# def test_many_to_many_create(self): +# data = {'id': 2, 'name': 'source-2', 'targets': [self.target.pk]} +# serializer = ManyToManyThroughSourceSerializer(data=data) +# self.assertTrue(serializer.fields['targets'].read_only) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(obj.name, 'source-2') +# self.assertEqual(obj.targets.count(), 0) + +# def test_many_to_many_reverse_create(self): +# data = {'id': 2, 'name': 'target-2', 'sources': [self.source.pk]} +# serializer = ManyToManyThroughTargetSerializer(data=data) +# self.assertTrue(serializer.fields['sources'].read_only) +# self.assertTrue(serializer.is_valid()) +# serializer.save() +# obj = serializer.save() +# self.assertEqual(obj.name, 'target-2') +# self.assertEqual(obj.sources.count(), 0) + + +# # Regression tests for #694 (`source` attribute on related fields) + + +# class PrimaryKeyRelatedFieldSourceTests(TestCase): +# def test_related_manager_source(self): +# """ +# Relational fields should be able to use manager-returning methods as their source. +# """ +# BlogPost.objects.create(title='blah') +# field = serializers.PrimaryKeyRelatedField(many=True, source='get_blogposts_manager') + +# class ClassWithManagerMethod(object): +# def get_blogposts_manager(self): +# return BlogPost.objects + +# obj = ClassWithManagerMethod() +# value = field.field_to_native(obj, 'field_name') +# self.assertEqual(value, [1]) + +# def test_related_queryset_source(self): +# """ +# Relational fields should be able to use queryset-returning methods as their source. +# """ +# BlogPost.objects.create(title='blah') +# field = serializers.PrimaryKeyRelatedField(many=True, source='get_blogposts_queryset') + +# class ClassWithQuerysetMethod(object): +# def get_blogposts_queryset(self): +# return BlogPost.objects.all() + +# obj = ClassWithQuerysetMethod() +# value = field.field_to_native(obj, 'field_name') +# self.assertEqual(value, [1]) + +# def test_dotted_source(self): +# """ +# Source argument should support dotted.source notation. +# """ +# BlogPost.objects.create(title='blah') +# field = serializers.PrimaryKeyRelatedField(many=True, source='a.b.c') + +# class ClassWithQuerysetMethod(object): +# a = { +# 'b': { +# 'c': BlogPost.objects.all() +# } +# } + +# obj = ClassWithQuerysetMethod() +# value = field.field_to_native(obj, 'field_name') +# self.assertEqual(value, [1]) diff --git a/tests/test_relations_slug.py b/tests/test_relations_slug.py index 97ebf23a..f7a59a95 100644 --- a/tests/test_relations_slug.py +++ b/tests/test_relations_slug.py @@ -1,257 +1,257 @@ -from django.test import TestCase -from rest_framework import serializers -from tests.models import NullableForeignKeySource, ForeignKeySource, ForeignKeyTarget - - -class ForeignKeyTargetSerializer(serializers.ModelSerializer): - sources = serializers.SlugRelatedField(many=True, slug_field='name') - - class Meta: - model = ForeignKeyTarget - - -class ForeignKeySourceSerializer(serializers.ModelSerializer): - target = serializers.SlugRelatedField(slug_field='name') - - class Meta: - model = ForeignKeySource - - -class NullableForeignKeySourceSerializer(serializers.ModelSerializer): - target = serializers.SlugRelatedField(slug_field='name', required=False) - - class Meta: - model = NullableForeignKeySource - - -# TODO: M2M Tests, FKTests (Non-nullable), One2One -class SlugForeignKeyTests(TestCase): - def setUp(self): - target = ForeignKeyTarget(name='target-1') - target.save() - new_target = ForeignKeyTarget(name='target-2') - new_target.save() - for idx in range(1, 4): - source = ForeignKeySource(name='source-%d' % idx, target=target) - source.save() - - def test_foreign_key_retrieve(self): - queryset = ForeignKeySource.objects.all() - serializer = ForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 'target-1'}, - {'id': 2, 'name': 'source-2', 'target': 'target-1'}, - {'id': 3, 'name': 'source-3', 'target': 'target-1'} - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_foreign_key_retrieve(self): - queryset = ForeignKeyTarget.objects.all() - serializer = ForeignKeyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, - {'id': 2, 'name': 'target-2', 'sources': []}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update(self): - data = {'id': 1, 'name': 'source-1', 'target': 'target-2'} - instance = ForeignKeySource.objects.get(pk=1) - serializer = ForeignKeySourceSerializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, data) - serializer.save() - - # Ensure source 1 is updated, and everything else is as expected - queryset = ForeignKeySource.objects.all() - serializer = ForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 'target-2'}, - {'id': 2, 'name': 'source-2', 'target': 'target-1'}, - {'id': 3, 'name': 'source-3', 'target': 'target-1'} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_incorrect_type(self): - data = {'id': 1, 'name': 'source-1', 'target': 123} - instance = ForeignKeySource.objects.get(pk=1) - serializer = ForeignKeySourceSerializer(instance, data=data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'target': ['Object with name=123 does not exist.']}) - - def test_reverse_foreign_key_update(self): - data = {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']} - instance = ForeignKeyTarget.objects.get(pk=2) - serializer = ForeignKeyTargetSerializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - # We shouldn't have saved anything to the db yet since save - # hasn't been called. - queryset = ForeignKeyTarget.objects.all() - new_serializer = ForeignKeyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, - {'id': 2, 'name': 'target-2', 'sources': []}, - ] - self.assertEqual(new_serializer.data, expected) - - serializer.save() - self.assertEqual(serializer.data, data) - - # Ensure target 2 is update, and everything else is as expected - queryset = ForeignKeyTarget.objects.all() - serializer = ForeignKeyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': ['source-2']}, - {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_create(self): - data = {'id': 4, 'name': 'source-4', 'target': 'target-2'} - serializer = ForeignKeySourceSerializer(data=data) - serializer.is_valid() - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 4 is added, and everything else is as expected - queryset = ForeignKeySource.objects.all() - serializer = ForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 'target-1'}, - {'id': 2, 'name': 'source-2', 'target': 'target-1'}, - {'id': 3, 'name': 'source-3', 'target': 'target-1'}, - {'id': 4, 'name': 'source-4', 'target': 'target-2'}, - ] - self.assertEqual(serializer.data, expected) - - def test_reverse_foreign_key_create(self): - data = {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']} - serializer = ForeignKeyTargetSerializer(data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'target-3') - - # Ensure target 3 is added, and everything else is as expected - queryset = ForeignKeyTarget.objects.all() - serializer = ForeignKeyTargetSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'target-1', 'sources': ['source-2']}, - {'id': 2, 'name': 'target-2', 'sources': []}, - {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_with_invalid_null(self): - data = {'id': 1, 'name': 'source-1', 'target': None} - instance = ForeignKeySource.objects.get(pk=1) - serializer = ForeignKeySourceSerializer(instance, data=data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'target': ['This field is required.']}) - - -class SlugNullableForeignKeyTests(TestCase): - def setUp(self): - target = ForeignKeyTarget(name='target-1') - target.save() - for idx in range(1, 4): - if idx == 3: - target = None - source = NullableForeignKeySource(name='source-%d' % idx, target=target) - source.save() - - def test_foreign_key_retrieve_with_null(self): - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 'target-1'}, - {'id': 2, 'name': 'source-2', 'target': 'target-1'}, - {'id': 3, 'name': 'source-3', 'target': None}, - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_create_with_valid_null(self): - data = {'id': 4, 'name': 'source-4', 'target': None} - serializer = NullableForeignKeySourceSerializer(data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 4 is created, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 'target-1'}, - {'id': 2, 'name': 'source-2', 'target': 'target-1'}, - {'id': 3, 'name': 'source-3', 'target': None}, - {'id': 4, 'name': 'source-4', 'target': None} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_create_with_valid_emptystring(self): - """ - The emptystring should be interpreted as null in the context - of relationships. - """ - data = {'id': 4, 'name': 'source-4', 'target': ''} - expected_data = {'id': 4, 'name': 'source-4', 'target': None} - serializer = NullableForeignKeySourceSerializer(data=data) - self.assertTrue(serializer.is_valid()) - obj = serializer.save() - self.assertEqual(serializer.data, expected_data) - self.assertEqual(obj.name, 'source-4') - - # Ensure source 4 is created, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': 'target-1'}, - {'id': 2, 'name': 'source-2', 'target': 'target-1'}, - {'id': 3, 'name': 'source-3', 'target': None}, - {'id': 4, 'name': 'source-4', 'target': None} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_with_valid_null(self): - data = {'id': 1, 'name': 'source-1', 'target': None} - instance = NullableForeignKeySource.objects.get(pk=1) - serializer = NullableForeignKeySourceSerializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, data) - serializer.save() - - # Ensure source 1 is updated, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': None}, - {'id': 2, 'name': 'source-2', 'target': 'target-1'}, - {'id': 3, 'name': 'source-3', 'target': None} - ] - self.assertEqual(serializer.data, expected) - - def test_foreign_key_update_with_valid_emptystring(self): - """ - The emptystring should be interpreted as null in the context - of relationships. - """ - data = {'id': 1, 'name': 'source-1', 'target': ''} - expected_data = {'id': 1, 'name': 'source-1', 'target': None} - instance = NullableForeignKeySource.objects.get(pk=1) - serializer = NullableForeignKeySourceSerializer(instance, data=data) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, expected_data) - serializer.save() - - # Ensure source 1 is updated, and everything else is as expected - queryset = NullableForeignKeySource.objects.all() - serializer = NullableForeignKeySourceSerializer(queryset, many=True) - expected = [ - {'id': 1, 'name': 'source-1', 'target': None}, - {'id': 2, 'name': 'source-2', 'target': 'target-1'}, - {'id': 3, 'name': 'source-3', 'target': None} - ] - self.assertEqual(serializer.data, expected) +# from django.test import TestCase +# from rest_framework import serializers +# from tests.models import NullableForeignKeySource, ForeignKeySource, ForeignKeyTarget + + +# class ForeignKeyTargetSerializer(serializers.ModelSerializer): +# sources = serializers.SlugRelatedField(many=True, slug_field='name') + +# class Meta: +# model = ForeignKeyTarget + + +# class ForeignKeySourceSerializer(serializers.ModelSerializer): +# target = serializers.SlugRelatedField(slug_field='name') + +# class Meta: +# model = ForeignKeySource + + +# class NullableForeignKeySourceSerializer(serializers.ModelSerializer): +# target = serializers.SlugRelatedField(slug_field='name', required=False) + +# class Meta: +# model = NullableForeignKeySource + + +# # TODO: M2M Tests, FKTests (Non-nullable), One2One +# class SlugForeignKeyTests(TestCase): +# def setUp(self): +# target = ForeignKeyTarget(name='target-1') +# target.save() +# new_target = ForeignKeyTarget(name='target-2') +# new_target.save() +# for idx in range(1, 4): +# source = ForeignKeySource(name='source-%d' % idx, target=target) +# source.save() + +# def test_foreign_key_retrieve(self): +# queryset = ForeignKeySource.objects.all() +# serializer = ForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, +# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, +# {'id': 3, 'name': 'source-3', 'target': 'target-1'} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_foreign_key_retrieve(self): +# queryset = ForeignKeyTarget.objects.all() +# serializer = ForeignKeyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, +# {'id': 2, 'name': 'target-2', 'sources': []}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update(self): +# data = {'id': 1, 'name': 'source-1', 'target': 'target-2'} +# instance = ForeignKeySource.objects.get(pk=1) +# serializer = ForeignKeySourceSerializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, data) +# serializer.save() + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = ForeignKeySource.objects.all() +# serializer = ForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 'target-2'}, +# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, +# {'id': 3, 'name': 'source-3', 'target': 'target-1'} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_incorrect_type(self): +# data = {'id': 1, 'name': 'source-1', 'target': 123} +# instance = ForeignKeySource.objects.get(pk=1) +# serializer = ForeignKeySourceSerializer(instance, data=data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'target': ['Object with name=123 does not exist.']}) + +# def test_reverse_foreign_key_update(self): +# data = {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']} +# instance = ForeignKeyTarget.objects.get(pk=2) +# serializer = ForeignKeyTargetSerializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# # We shouldn't have saved anything to the db yet since save +# # hasn't been called. +# queryset = ForeignKeyTarget.objects.all() +# new_serializer = ForeignKeyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, +# {'id': 2, 'name': 'target-2', 'sources': []}, +# ] +# self.assertEqual(new_serializer.data, expected) + +# serializer.save() +# self.assertEqual(serializer.data, data) + +# # Ensure target 2 is update, and everything else is as expected +# queryset = ForeignKeyTarget.objects.all() +# serializer = ForeignKeyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': ['source-2']}, +# {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_create(self): +# data = {'id': 4, 'name': 'source-4', 'target': 'target-2'} +# serializer = ForeignKeySourceSerializer(data=data) +# serializer.is_valid() +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 4 is added, and everything else is as expected +# queryset = ForeignKeySource.objects.all() +# serializer = ForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, +# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, +# {'id': 3, 'name': 'source-3', 'target': 'target-1'}, +# {'id': 4, 'name': 'source-4', 'target': 'target-2'}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_reverse_foreign_key_create(self): +# data = {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']} +# serializer = ForeignKeyTargetSerializer(data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'target-3') + +# # Ensure target 3 is added, and everything else is as expected +# queryset = ForeignKeyTarget.objects.all() +# serializer = ForeignKeyTargetSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'target-1', 'sources': ['source-2']}, +# {'id': 2, 'name': 'target-2', 'sources': []}, +# {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_with_invalid_null(self): +# data = {'id': 1, 'name': 'source-1', 'target': None} +# instance = ForeignKeySource.objects.get(pk=1) +# serializer = ForeignKeySourceSerializer(instance, data=data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'target': ['This field is required.']}) + + +# class SlugNullableForeignKeyTests(TestCase): +# def setUp(self): +# target = ForeignKeyTarget(name='target-1') +# target.save() +# for idx in range(1, 4): +# if idx == 3: +# target = None +# source = NullableForeignKeySource(name='source-%d' % idx, target=target) +# source.save() + +# def test_foreign_key_retrieve_with_null(self): +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, +# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, +# {'id': 3, 'name': 'source-3', 'target': None}, +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_create_with_valid_null(self): +# data = {'id': 4, 'name': 'source-4', 'target': None} +# serializer = NullableForeignKeySourceSerializer(data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 4 is created, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, +# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, +# {'id': 3, 'name': 'source-3', 'target': None}, +# {'id': 4, 'name': 'source-4', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_create_with_valid_emptystring(self): +# """ +# The emptystring should be interpreted as null in the context +# of relationships. +# """ +# data = {'id': 4, 'name': 'source-4', 'target': ''} +# expected_data = {'id': 4, 'name': 'source-4', 'target': None} +# serializer = NullableForeignKeySourceSerializer(data=data) +# self.assertTrue(serializer.is_valid()) +# obj = serializer.save() +# self.assertEqual(serializer.data, expected_data) +# self.assertEqual(obj.name, 'source-4') + +# # Ensure source 4 is created, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, +# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, +# {'id': 3, 'name': 'source-3', 'target': None}, +# {'id': 4, 'name': 'source-4', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_with_valid_null(self): +# data = {'id': 1, 'name': 'source-1', 'target': None} +# instance = NullableForeignKeySource.objects.get(pk=1) +# serializer = NullableForeignKeySourceSerializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, data) +# serializer.save() + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': None}, +# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, +# {'id': 3, 'name': 'source-3', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) + +# def test_foreign_key_update_with_valid_emptystring(self): +# """ +# The emptystring should be interpreted as null in the context +# of relationships. +# """ +# data = {'id': 1, 'name': 'source-1', 'target': ''} +# expected_data = {'id': 1, 'name': 'source-1', 'target': None} +# instance = NullableForeignKeySource.objects.get(pk=1) +# serializer = NullableForeignKeySourceSerializer(instance, data=data) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, expected_data) +# serializer.save() + +# # Ensure source 1 is updated, and everything else is as expected +# queryset = NullableForeignKeySource.objects.all() +# serializer = NullableForeignKeySourceSerializer(queryset, many=True) +# expected = [ +# {'id': 1, 'name': 'source-1', 'target': None}, +# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, +# {'id': 3, 'name': 'source-3', 'target': None} +# ] +# self.assertEqual(serializer.data, expected) diff --git a/tests/test_renderers.py b/tests/test_renderers.py index 91244e26..a8fd5f46 100644 --- a/tests/test_renderers.py +++ b/tests/test_renderers.py @@ -13,7 +13,7 @@ from rest_framework.compat import yaml, etree, StringIO from rest_framework.response import Response from rest_framework.views import APIView from rest_framework.renderers import BaseRenderer, JSONRenderer, YAMLRenderer, \ - XMLRenderer, JSONPRenderer, BrowsableAPIRenderer, UnicodeJSONRenderer, UnicodeYAMLRenderer + XMLRenderer, JSONPRenderer, BrowsableAPIRenderer from rest_framework.parsers import YAMLParser, XMLParser from rest_framework.settings import api_settings from rest_framework.test import APIRequestFactory @@ -32,7 +32,7 @@ RENDERER_B_SERIALIZER = lambda x: ('Renderer B: %s' % x).encode('ascii') expected_results = [ - ((elem for elem in [1, 2, 3]), JSONRenderer, b'[1, 2, 3]') # Generator + ((elem for elem in [1, 2, 3]), JSONRenderer, b'[1,2,3]') # Generator ] @@ -270,7 +270,7 @@ class RendererEndToEndTests(TestCase): self.assertNotContains(resp, '>text/html; charset=utf-8<') -_flat_repr = '{"foo": ["bar", "baz"]}' +_flat_repr = '{"foo":["bar","baz"]}' _indented_repr = '{\n "foo": [\n "bar",\n "baz"\n ]\n}' @@ -373,22 +373,29 @@ class JSONRendererTests(TestCase): content = renderer.render(obj, 'application/json; indent=2') self.assertEqual(strip_trailing_whitespace(content.decode('utf-8')), _indented_repr) - def test_check_ascii(self): + +class UnicodeJSONRendererTests(TestCase): + """ + Tests specific for the Unicode JSON Renderer + """ + def test_proper_encoding(self): obj = {'countries': ['United Kingdom', 'France', 'España']} renderer = JSONRenderer() content = renderer.render(obj, 'application/json') - self.assertEqual(content, '{"countries": ["United Kingdom", "France", "Espa\\u00f1a"]}'.encode('utf-8')) + self.assertEqual(content, '{"countries":["United Kingdom","France","España"]}'.encode('utf-8')) -class UnicodeJSONRendererTests(TestCase): +class AsciiJSONRendererTests(TestCase): """ Tests specific for the Unicode JSON Renderer """ def test_proper_encoding(self): + class AsciiJSONRenderer(JSONRenderer): + ensure_ascii = True obj = {'countries': ['United Kingdom', 'France', 'España']} - renderer = UnicodeJSONRenderer() + renderer = AsciiJSONRenderer() content = renderer.render(obj, 'application/json') - self.assertEqual(content, '{"countries": ["United Kingdom", "France", "España"]}'.encode('utf-8')) + self.assertEqual(content, '{"countries":["United Kingdom","France","Espa\\u00f1a"]}'.encode('utf-8')) class JSONPRendererTests(TestCase): @@ -487,13 +494,9 @@ if yaml: def assertYAMLContains(self, content, string): self.assertTrue(string in content, '%r not in %r' % (string, content)) - class UnicodeYAMLRendererTests(TestCase): - """ - Tests specific for the Unicode YAML Renderer - """ def test_proper_encoding(self): obj = {'countries': ['United Kingdom', 'France', 'España']} - renderer = UnicodeYAMLRenderer() + renderer = YAMLRenderer() content = renderer.render(obj, 'application/yaml') self.assertEqual(content.strip(), 'countries: [United Kingdom, France, España]'.encode('utf-8')) diff --git a/tests/test_response.py b/tests/test_response.py index 2eff83d3..84c39c1a 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -2,11 +2,12 @@ from __future__ import unicode_literals from django.conf.urls import patterns, url, include from django.test import TestCase from django.utils import six -from tests.models import BasicModel, BasicModelSerializer +from tests.models import BasicModel from rest_framework.response import Response from rest_framework.views import APIView from rest_framework import generics from rest_framework import routers +from rest_framework import serializers from rest_framework import status from rest_framework.renderers import ( BaseRenderer, @@ -17,6 +18,12 @@ from rest_framework import viewsets from rest_framework.settings import api_settings +# Serializer used to test BasicModel +class BasicModelSerializer(serializers.ModelSerializer): + class Meta: + model = BasicModel + + class MockPickleRenderer(BaseRenderer): media_type = 'application/pickle' @@ -86,14 +93,15 @@ class HTMLView1(APIView): class HTMLNewModelViewSet(viewsets.ModelViewSet): - model = BasicModel + serializer_class = BasicModelSerializer + queryset = BasicModel.objects.all() class HTMLNewModelView(generics.ListCreateAPIView): renderer_classes = (BrowsableAPIRenderer,) permission_classes = [] serializer_class = BasicModelSerializer - model = BasicModel + queryset = BasicModel.objects.all() new_model_viewset_router = routers.DefaultRouter() @@ -224,8 +232,8 @@ class Issue467Tests(TestCase): def test_form_has_label_and_help_text(self): resp = self.client.get('/html_new_model') self.assertEqual(resp['Content-Type'], 'text/html; charset=utf-8') - self.assertContains(resp, 'Text comes here') - self.assertContains(resp, 'Text description.') + # self.assertContains(resp, 'Text comes here') + # self.assertContains(resp, 'Text description.') class Issue807Tests(TestCase): @@ -269,11 +277,11 @@ class Issue807Tests(TestCase): ) resp = self.client.get('/html_new_model_viewset/' + param) self.assertEqual(resp['Content-Type'], 'text/html; charset=utf-8') - self.assertContains(resp, 'Text comes here') - self.assertContains(resp, 'Text description.') + # self.assertContains(resp, 'Text comes here') + # self.assertContains(resp, 'Text description.') def test_form_has_label_and_help_text(self): resp = self.client.get('/html_new_model') self.assertEqual(resp['Content-Type'], 'text/html; charset=utf-8') - self.assertContains(resp, 'Text comes here') - self.assertContains(resp, 'Text description.') + # self.assertContains(resp, 'Text comes here') + # self.assertContains(resp, 'Text description.') diff --git a/tests/test_routers.py b/tests/test_routers.py index b076f134..34306146 100644 --- a/tests/test_routers.py +++ b/tests/test_routers.py @@ -3,7 +3,7 @@ from django.conf.urls import patterns, url, include from django.db import models from django.test import TestCase from django.core.exceptions import ImproperlyConfigured -from rest_framework import serializers, viewsets, permissions +from rest_framework import serializers, viewsets, mixins, permissions from rest_framework.decorators import detail_route, list_route from rest_framework.response import Response from rest_framework.routers import SimpleRouter, DefaultRouter @@ -76,9 +76,10 @@ class TestCustomLookupFields(TestCase): def setUp(self): class NoteSerializer(serializers.HyperlinkedModelSerializer): + url = serializers.HyperlinkedIdentityField(view_name='routertestmodel-detail', lookup_field='uuid') + class Meta: model = RouterTestModel - lookup_field = 'uuid' fields = ('url', 'uuid', 'text') class NoteViewSet(viewsets.ModelViewSet): @@ -86,8 +87,6 @@ class TestCustomLookupFields(TestCase): serializer_class = NoteSerializer lookup_field = 'uuid' - RouterTestModel.objects.create(uuid='123', text='foo bar') - self.router = SimpleRouter() self.router.register(r'notes', NoteViewSet) @@ -98,6 +97,8 @@ class TestCustomLookupFields(TestCase): url(r'^', include(self.router.urls)), ) + RouterTestModel.objects.create(uuid='123', text='foo bar') + def test_custom_lookup_field_route(self): detail_route = self.router.urls[-1] detail_url_pattern = detail_route.regex.pattern @@ -284,3 +285,19 @@ class TestDynamicListAndDetailRouter(TestCase): else: method_map = 'get' self.assertEqual(route.mapping[method_map], endpoint) + + +class TestRootWithAListlessViewset(TestCase): + def setUp(self): + class NoteViewSet(mixins.RetrieveModelMixin, + viewsets.GenericViewSet): + model = RouterTestModel + + self.router = DefaultRouter() + self.router.register(r'notes', NoteViewSet) + self.view = self.router.urls[0].callback + + def test_api_root(self): + request = factory.get('/') + response = self.view(request) + self.assertEqual(response.data, {}) diff --git a/tests/test_serializer.py b/tests/test_serializer.py index 90f37cf2..b0eb4e27 100644 --- a/tests/test_serializer.py +++ b/tests/test_serializer.py @@ -1,2004 +1,2004 @@ -# -*- coding: utf-8 -*- -from __future__ import unicode_literals -from django.db import models -from django.db.models.fields import BLANK_CHOICE_DASH -from django.test import TestCase -from django.utils import unittest -from django.utils.datastructures import MultiValueDict -from django.utils.translation import ugettext_lazy as _ -from rest_framework import serializers, fields, relations -from tests.models import ( - HasPositiveIntegerAsChoice, Album, ActionItem, Anchor, BasicModel, - BlankFieldModel, BlogPost, BlogPostComment, Book, CallableDefaultValueModel, - DefaultValueModel, ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo, - RESTFrameworkModel, ForeignKeySource -) -from tests.models import BasicModelSerializer -import datetime -import pickle -try: - import PIL -except: - PIL = None - - -if PIL is not None: - class AMOAFModel(RESTFrameworkModel): - char_field = models.CharField(max_length=1024, blank=True) - comma_separated_integer_field = models.CommaSeparatedIntegerField(max_length=1024, blank=True) - decimal_field = models.DecimalField(max_digits=64, decimal_places=32, blank=True) - email_field = models.EmailField(max_length=1024, blank=True) - file_field = models.FileField(upload_to='test', max_length=1024, blank=True) - image_field = models.ImageField(upload_to='test', max_length=1024, blank=True) - slug_field = models.SlugField(max_length=1024, blank=True) - url_field = models.URLField(max_length=1024, blank=True) - nullable_char_field = models.CharField(max_length=1024, blank=True, null=True) - - class DVOAFModel(RESTFrameworkModel): - positive_integer_field = models.PositiveIntegerField(blank=True) - positive_small_integer_field = models.PositiveSmallIntegerField(blank=True) - email_field = models.EmailField(blank=True) - file_field = models.FileField(upload_to='test', blank=True) - image_field = models.ImageField(upload_to='test', blank=True) - slug_field = models.SlugField(blank=True) - url_field = models.URLField(blank=True) +# # -*- coding: utf-8 -*- +# from __future__ import unicode_literals +# from django.db import models +# from django.db.models.fields import BLANK_CHOICE_DASH +# from django.test import TestCase +# from django.utils import unittest +# from django.utils.datastructures import MultiValueDict +# from django.utils.translation import ugettext_lazy as _ +# from rest_framework import serializers, fields, relations +# from tests.models import ( +# HasPositiveIntegerAsChoice, Album, ActionItem, Anchor, BasicModel, +# BlankFieldModel, BlogPost, BlogPostComment, Book, CallableDefaultValueModel, +# DefaultValueModel, ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo, +# RESTFrameworkModel, ForeignKeySource +# ) +# from tests.models import BasicModelSerializer +# import datetime +# import pickle +# try: +# import PIL +# except: +# PIL = None + + +# if PIL is not None: +# class AMOAFModel(RESTFrameworkModel): +# char_field = models.CharField(max_length=1024, blank=True) +# comma_separated_integer_field = models.CommaSeparatedIntegerField(max_length=1024, blank=True) +# decimal_field = models.DecimalField(max_digits=64, decimal_places=32, blank=True) +# email_field = models.EmailField(max_length=1024, blank=True) +# file_field = models.FileField(upload_to='test', max_length=1024, blank=True) +# image_field = models.ImageField(upload_to='test', max_length=1024, blank=True) +# slug_field = models.SlugField(max_length=1024, blank=True) +# url_field = models.URLField(max_length=1024, blank=True) +# nullable_char_field = models.CharField(max_length=1024, blank=True, null=True) + +# class DVOAFModel(RESTFrameworkModel): +# positive_integer_field = models.PositiveIntegerField(blank=True) +# positive_small_integer_field = models.PositiveSmallIntegerField(blank=True) +# email_field = models.EmailField(blank=True) +# file_field = models.FileField(upload_to='test', blank=True) +# image_field = models.ImageField(upload_to='test', blank=True) +# slug_field = models.SlugField(blank=True) +# url_field = models.URLField(blank=True) -class SubComment(object): - def __init__(self, sub_comment): - self.sub_comment = sub_comment +# class SubComment(object): +# def __init__(self, sub_comment): +# self.sub_comment = sub_comment -class Comment(object): - def __init__(self, email, content, created): - self.email = email - self.content = content - self.created = created or datetime.datetime.now() +# class Comment(object): +# def __init__(self, email, content, created): +# self.email = email +# self.content = content +# self.created = created or datetime.datetime.now() - def __eq__(self, other): - return all([getattr(self, attr) == getattr(other, attr) - for attr in ('email', 'content', 'created')]) +# def __eq__(self, other): +# return all([getattr(self, attr) == getattr(other, attr) +# for attr in ('email', 'content', 'created')]) - def get_sub_comment(self): - sub_comment = SubComment('And Merry Christmas!') - return sub_comment +# def get_sub_comment(self): +# sub_comment = SubComment('And Merry Christmas!') +# return sub_comment -class CommentSerializer(serializers.Serializer): - email = serializers.EmailField() - content = serializers.CharField(max_length=1000) - created = serializers.DateTimeField() - sub_comment = serializers.Field(source='get_sub_comment.sub_comment') +# class CommentSerializer(serializers.Serializer): +# email = serializers.EmailField() +# content = serializers.CharField(max_length=1000) +# created = serializers.DateTimeField() +# sub_comment = serializers.Field(source='get_sub_comment.sub_comment') - def restore_object(self, data, instance=None): - if instance is None: - return Comment(**data) - for key, val in data.items(): - setattr(instance, key, val) - return instance +# def restore_object(self, data, instance=None): +# if instance is None: +# return Comment(**data) +# for key, val in data.items(): +# setattr(instance, key, val) +# return instance -class NamesSerializer(serializers.Serializer): - first = serializers.CharField() - last = serializers.CharField(required=False, default='') - initials = serializers.CharField(required=False, default='') +# class NamesSerializer(serializers.Serializer): +# first = serializers.CharField() +# last = serializers.CharField(required=False, default='') +# initials = serializers.CharField(required=False, default='') -class PersonIdentifierSerializer(serializers.Serializer): - ssn = serializers.CharField() - names = NamesSerializer(source='names', required=False) +# class PersonIdentifierSerializer(serializers.Serializer): +# ssn = serializers.CharField() +# names = NamesSerializer(source='names', required=False) -class BookSerializer(serializers.ModelSerializer): - isbn = serializers.RegexField(regex=r'^[0-9]{13}$', error_messages={'invalid': 'isbn has to be exact 13 numbers'}) +# class BookSerializer(serializers.ModelSerializer): +# isbn = serializers.RegexField(regex=r'^[0-9]{13}$', error_messages={'invalid': 'isbn has to be exact 13 numbers'}) - class Meta: - model = Book +# class Meta: +# model = Book -class ActionItemSerializer(serializers.ModelSerializer): +# class ActionItemSerializer(serializers.ModelSerializer): - class Meta: - model = ActionItem +# class Meta: +# model = ActionItem -class ActionItemSerializerOptionalFields(serializers.ModelSerializer): - """ - Intended to test that fields with `required=False` are excluded from validation. - """ - title = serializers.CharField(required=False) +# class ActionItemSerializerOptionalFields(serializers.ModelSerializer): +# """ +# Intended to test that fields with `required=False` are excluded from validation. +# """ +# title = serializers.CharField(required=False) - class Meta: - model = ActionItem - fields = ('title',) +# class Meta: +# model = ActionItem +# fields = ('title',) -class ActionItemSerializerCustomRestore(serializers.ModelSerializer): +# class ActionItemSerializerCustomRestore(serializers.ModelSerializer): - class Meta: - model = ActionItem +# class Meta: +# model = ActionItem - def restore_object(self, data, instance=None): - if instance is None: - return ActionItem(**data) - for key, val in data.items(): - setattr(instance, key, val) - return instance +# def restore_object(self, data, instance=None): +# if instance is None: +# return ActionItem(**data) +# for key, val in data.items(): +# setattr(instance, key, val) +# return instance -class PersonSerializer(serializers.ModelSerializer): - info = serializers.Field(source='info') +# class PersonSerializer(serializers.ModelSerializer): +# info = serializers.Field(source='info') - class Meta: - model = Person - fields = ('name', 'age', 'info') - read_only_fields = ('age',) +# class Meta: +# model = Person +# fields = ('name', 'age', 'info') +# read_only_fields = ('age',) -class NestedSerializer(serializers.Serializer): - info = serializers.Field() +# class NestedSerializer(serializers.Serializer): +# info = serializers.Field() -class ModelSerializerWithNestedSerializer(serializers.ModelSerializer): - nested = NestedSerializer(source='*') +# class ModelSerializerWithNestedSerializer(serializers.ModelSerializer): +# nested = NestedSerializer(source='*') - class Meta: - model = Person +# class Meta: +# model = Person -class NestedSerializerWithRenamedField(serializers.Serializer): - renamed_info = serializers.Field(source='info') +# class NestedSerializerWithRenamedField(serializers.Serializer): +# renamed_info = serializers.Field(source='info') -class ModelSerializerWithNestedSerializerWithRenamedField(serializers.ModelSerializer): - nested = NestedSerializerWithRenamedField(source='*') +# class ModelSerializerWithNestedSerializerWithRenamedField(serializers.ModelSerializer): +# nested = NestedSerializerWithRenamedField(source='*') - class Meta: - model = Person +# class Meta: +# model = Person -class PersonSerializerInvalidReadOnly(serializers.ModelSerializer): - """ - Testing for #652. - """ - info = serializers.Field(source='info') +# class PersonSerializerInvalidReadOnly(serializers.ModelSerializer): +# """ +# Testing for #652. +# """ +# info = serializers.Field(source='info') - class Meta: - model = Person - fields = ('name', 'age', 'info') - read_only_fields = ('age', 'info') +# class Meta: +# model = Person +# fields = ('name', 'age', 'info') +# read_only_fields = ('age', 'info') -class AlbumsSerializer(serializers.ModelSerializer): +# class AlbumsSerializer(serializers.ModelSerializer): - class Meta: - model = Album - fields = ['title', 'ref'] # lists are also valid options +# class Meta: +# model = Album +# fields = ['title', 'ref'] # lists are also valid options -class PositiveIntegerAsChoiceSerializer(serializers.ModelSerializer): - class Meta: - model = HasPositiveIntegerAsChoice - fields = ['some_integer'] +# class PositiveIntegerAsChoiceSerializer(serializers.ModelSerializer): +# class Meta: +# model = HasPositiveIntegerAsChoice +# fields = ['some_integer'] -class ForeignKeySourceSerializer(serializers.ModelSerializer): - class Meta: - model = ForeignKeySource +# class ForeignKeySourceSerializer(serializers.ModelSerializer): +# class Meta: +# model = ForeignKeySource -class HyperlinkedForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): - class Meta: - model = ForeignKeySource +# class HyperlinkedForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): +# class Meta: +# model = ForeignKeySource -class BasicTests(TestCase): - def setUp(self): - self.comment = Comment( - 'tom@example.com', - 'Happy new year!', - datetime.datetime(2012, 1, 1) - ) - self.actionitem = ActionItem(title='Some to do item',) - self.data = { - 'email': 'tom@example.com', - 'content': 'Happy new year!', - 'created': datetime.datetime(2012, 1, 1), - 'sub_comment': 'This wont change' - } - self.expected = { - 'email': 'tom@example.com', - 'content': 'Happy new year!', - 'created': datetime.datetime(2012, 1, 1), - 'sub_comment': 'And Merry Christmas!' - } - self.person_data = {'name': 'dwight', 'age': 35} - self.person = Person(**self.person_data) - self.person.save() - - def test_empty(self): - serializer = CommentSerializer() - expected = { - 'email': '', - 'content': '', - 'created': None - } - self.assertEqual(serializer.data, expected) - - def test_retrieve(self): - serializer = CommentSerializer(self.comment) - self.assertEqual(serializer.data, self.expected) - - def test_create(self): - serializer = CommentSerializer(data=self.data) - expected = self.comment - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, expected) - self.assertFalse(serializer.object is expected) - self.assertEqual(serializer.data['sub_comment'], 'And Merry Christmas!') - - def test_create_nested(self): - """Test a serializer with nested data.""" - names = {'first': 'John', 'last': 'Doe', 'initials': 'jd'} - data = {'ssn': '1234567890', 'names': names} - serializer = PersonIdentifierSerializer(data=data) - - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, data) - self.assertFalse(serializer.object is data) - self.assertEqual(serializer.data['names'], names) - - def test_create_partial_nested(self): - """Test a serializer with nested data which has missing fields.""" - names = {'first': 'John'} - data = {'ssn': '1234567890', 'names': names} - serializer = PersonIdentifierSerializer(data=data) - - expected_names = {'first': 'John', 'last': '', 'initials': ''} - data['names'] = expected_names - - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, data) - self.assertFalse(serializer.object is expected_names) - self.assertEqual(serializer.data['names'], expected_names) - - def test_null_nested(self): - """Test a serializer with a nonexistent nested field""" - data = {'ssn': '1234567890'} - serializer = PersonIdentifierSerializer(data=data) - - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, data) - self.assertFalse(serializer.object is data) - expected = {'ssn': '1234567890', 'names': None} - self.assertEqual(serializer.data, expected) - - def test_update(self): - serializer = CommentSerializer(self.comment, data=self.data) - expected = self.comment - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, expected) - self.assertTrue(serializer.object is expected) - self.assertEqual(serializer.data['sub_comment'], 'And Merry Christmas!') - - def test_partial_update(self): - msg = 'Merry New Year!' - partial_data = {'content': msg} - serializer = CommentSerializer(self.comment, data=partial_data) - self.assertEqual(serializer.is_valid(), False) - serializer = CommentSerializer(self.comment, data=partial_data, partial=True) - expected = self.comment - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, expected) - self.assertTrue(serializer.object is expected) - self.assertEqual(serializer.data['content'], msg) - - def test_model_fields_as_expected(self): - """ - Make sure that the fields returned are the same as defined - in the Meta data - """ - serializer = PersonSerializer(self.person) - self.assertEqual( - set(serializer.data.keys()), - set(['name', 'age', 'info']) - ) - - def test_field_with_dictionary(self): - """ - Make sure that dictionaries from fields are left intact - """ - serializer = PersonSerializer(self.person) - expected = self.person_data - self.assertEqual(serializer.data['info'], expected) - - def test_read_only_fields(self): - """ - Attempting to update fields set as read_only should have no effect. - """ - serializer = PersonSerializer(self.person, data={'name': 'dwight', 'age': 99}) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(serializer.errors, {}) - # Assert age is unchanged (35) - self.assertEqual(instance.age, self.person_data['age']) - - def test_invalid_read_only_fields(self): - """ - Regression test for #652. - """ - self.assertRaises(AssertionError, PersonSerializerInvalidReadOnly, []) - - def test_serializer_data_is_cleared_on_save(self): - """ - Check _data attribute is cleared on `save()` - - Regression test for #1116 - — id field is not populated if `data` is accessed prior to `save()` - """ - serializer = ActionItemSerializer(self.actionitem) - self.assertIsNone(serializer.data.get('id', None), 'New instance. `id` should not be set.') - serializer.save() - self.assertIsNotNone(serializer.data.get('id', None), 'Model is saved. `id` should be set.') - - def test_fields_marked_as_not_required_are_excluded_from_validation(self): - """ - Check that fields with `required=False` are included in list of exclusions. - """ - serializer = ActionItemSerializerOptionalFields(self.actionitem) - exclusions = serializer.get_validation_exclusions() - self.assertTrue('title' in exclusions, '`title` field was marked `required=False` and should be excluded') - - -class DictStyleSerializer(serializers.Serializer): - """ - Note that we don't have any `restore_object` method, so the default - case of simply returning a dict will apply. - """ - email = serializers.EmailField() - - -class DictStyleSerializerTests(TestCase): - def test_dict_style_deserialize(self): - """ - Ensure serializers can deserialize into a dict. - """ - data = {'email': 'foo@example.com'} - serializer = DictStyleSerializer(data=data) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, data) - - def test_dict_style_serialize(self): - """ - Ensure serializers can serialize dict objects. - """ - data = {'email': 'foo@example.com'} - serializer = DictStyleSerializer(data) - self.assertEqual(serializer.data, data) - - -class ValidationTests(TestCase): - def setUp(self): - self.comment = Comment( - 'tom@example.com', - 'Happy new year!', - datetime.datetime(2012, 1, 1) - ) - self.data = { - 'email': 'tom@example.com', - 'content': 'x' * 1001, - 'created': datetime.datetime(2012, 1, 1) - } - self.actionitem = ActionItem(title='Some to do item',) - - def test_create(self): - serializer = CommentSerializer(data=self.data) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']}) - - def test_update(self): - serializer = CommentSerializer(self.comment, data=self.data) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']}) - - def test_update_missing_field(self): - data = { - 'content': 'xxx', - 'created': datetime.datetime(2012, 1, 1) - } - serializer = CommentSerializer(self.comment, data=data) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, {'email': ['This field is required.']}) - - def test_missing_bool_with_default(self): - """Make sure that a boolean value with a 'False' value is not - mistaken for not having a default.""" - data = { - 'title': 'Some action item', - # No 'done' value. - } - serializer = ActionItemSerializer(self.actionitem, data=data) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.errors, {}) - - def test_cross_field_validation(self): - - class CommentSerializerWithCrossFieldValidator(CommentSerializer): - - def validate(self, attrs): - if attrs["email"] not in attrs["content"]: - raise serializers.ValidationError("Email address not in content") - return attrs - - data = { - 'email': 'tom@example.com', - 'content': 'A comment from tom@example.com', - 'created': datetime.datetime(2012, 1, 1) - } - - serializer = CommentSerializerWithCrossFieldValidator(data=data) - self.assertTrue(serializer.is_valid()) - - data['content'] = 'A comment from foo@bar.com' - - serializer = CommentSerializerWithCrossFieldValidator(data=data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'non_field_errors': ['Email address not in content']}) - - def test_null_is_true_fields(self): - """ - Omitting a value for null-field should validate. - """ - serializer = PersonSerializer(data={'name': 'marko'}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.errors, {}) - - def test_modelserializer_max_length_exceeded(self): - data = { - 'title': 'x' * 201, - } - serializer = ActionItemSerializer(data=data) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']}) - - def test_modelserializer_max_length_exceeded_with_custom_restore(self): - """ - When overriding ModelSerializer.restore_object, validation tests should still apply. - Regression test for #623. - - https://github.com/tomchristie/django-rest-framework/pull/623 - """ - data = { - 'title': 'x' * 201, - } - serializer = ActionItemSerializerCustomRestore(data=data) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']}) - - def test_default_modelfield_max_length_exceeded(self): - data = { - 'title': 'Testing "info" field...', - 'info': 'x' * 13, - } - serializer = ActionItemSerializer(data=data) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, {'info': ['Ensure this value has at most 12 characters (it has 13).']}) - - def test_datetime_validation_failure(self): - """ - Test DateTimeField validation errors on non-str values. - Regression test for #669. - - https://github.com/tomchristie/django-rest-framework/issues/669 - """ - data = self.data - data['created'] = 0 - - serializer = CommentSerializer(data=data) - self.assertEqual(serializer.is_valid(), False) - - self.assertIn('created', serializer.errors) - - def test_missing_model_field_exception_msg(self): - """ - Assert that a meaningful exception message is outputted when the model - field is missing (e.g. when mistyping ``model``). - """ - class BrokenModelSerializer(serializers.ModelSerializer): - class Meta: - fields = ['some_field'] - - try: - BrokenModelSerializer() - except AssertionError as e: - self.assertEqual(e.args[0], "Serializer class 'BrokenModelSerializer' is missing 'model' Meta option") - except: - self.fail('Wrong exception type thrown.') - - def test_writable_star_source_on_nested_serializer(self): - """ - Assert that a nested serializer instantiated with source='*' correctly - expands the data into the outer serializer. - """ - serializer = ModelSerializerWithNestedSerializer(data={ - 'name': 'marko', - 'nested': {'info': 'hi'}}, - ) - self.assertEqual(serializer.is_valid(), True) - - def test_writable_star_source_on_nested_serializer_with_parent_object(self): - class TitleSerializer(serializers.Serializer): - title = serializers.WritableField(source='title') - - class AlbumSerializer(serializers.ModelSerializer): - nested = TitleSerializer(source='*') - - class Meta: - model = Album - fields = ('nested',) - - class PhotoSerializer(serializers.ModelSerializer): - album = AlbumSerializer(source='album') - - class Meta: - model = Photo - fields = ('album', ) - - photo = Photo(album=Album()) - - data = {'album': {'nested': {'title': 'test'}}} - - serializer = PhotoSerializer(photo, data=data) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.data, data) - - def test_writable_star_source_with_inner_source_fields(self): - """ - Tests that a serializer with source="*" correctly expands the - it's fields into the outer serializer even if they have their - own 'source' parameters. - """ - - serializer = ModelSerializerWithNestedSerializerWithRenamedField(data={ - 'name': 'marko', - 'nested': {'renamed_info': 'hi'}}, - ) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.errors, {}) - - -class CustomValidationTests(TestCase): - class CommentSerializerWithFieldValidator(CommentSerializer): - - def validate_email(self, attrs, source): - attrs[source] - return attrs - - def validate_content(self, attrs, source): - value = attrs[source] - if "test" not in value: - raise serializers.ValidationError("Test not in value") - return attrs - - def test_field_validation(self): - data = { - 'email': 'tom@example.com', - 'content': 'A test comment', - 'created': datetime.datetime(2012, 1, 1) - } - - serializer = self.CommentSerializerWithFieldValidator(data=data) - self.assertTrue(serializer.is_valid()) - - data['content'] = 'This should not validate' - - serializer = self.CommentSerializerWithFieldValidator(data=data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'content': ['Test not in value']}) - - def test_missing_data(self): - """ - Make sure that validate_content isn't called if the field is missing - """ - incomplete_data = { - 'email': 'tom@example.com', - 'created': datetime.datetime(2012, 1, 1) - } - serializer = self.CommentSerializerWithFieldValidator(data=incomplete_data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'content': ['This field is required.']}) - - def test_wrong_data(self): - """ - Make sure that validate_content isn't called if the field input is wrong - """ - wrong_data = { - 'email': 'not an email', - 'content': 'A test comment', - 'created': datetime.datetime(2012, 1, 1) - } - serializer = self.CommentSerializerWithFieldValidator(data=wrong_data) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'email': ['Enter a valid email address.']}) - - def test_partial_update(self): - """ - Make sure that validate_email isn't called when partial=True and email - isn't found in data. - """ - initial_data = { - 'email': 'tom@example.com', - 'content': 'A test comment', - 'created': datetime.datetime(2012, 1, 1) - } - - serializer = self.CommentSerializerWithFieldValidator(data=initial_data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.object - - new_content = 'An *updated* test comment' - partial_data = { - 'content': new_content - } - - serializer = self.CommentSerializerWithFieldValidator(instance=instance, - data=partial_data, - partial=True) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.object - self.assertEqual(instance.content, new_content) - - -class PositiveIntegerAsChoiceTests(TestCase): - def test_positive_integer_in_json_is_correctly_parsed(self): - data = {'some_integer': 1} - serializer = PositiveIntegerAsChoiceSerializer(data=data) - self.assertEqual(serializer.is_valid(), True) - - -class ModelValidationTests(TestCase): - def test_validate_unique(self): - """ - Just check if serializers.ModelSerializer handles unique checks via .full_clean() - """ - serializer = AlbumsSerializer(data={'title': 'a', 'ref': '1'}) - serializer.is_valid() - serializer.save() - second_serializer = AlbumsSerializer(data={'title': 'a'}) - self.assertFalse(second_serializer.is_valid()) - self.assertEqual(second_serializer.errors, {'title': ['Album with this Title already exists.']}) - third_serializer = AlbumsSerializer(data=[{'title': 'b', 'ref': '1'}, {'title': 'c'}], many=True) - self.assertFalse(third_serializer.is_valid()) - self.assertEqual(third_serializer.errors, [{'ref': ['Album with this Ref already exists.']}, {}]) - - def test_foreign_key_is_null_with_partial(self): - """ - Test ModelSerializer validation with partial=True - - Specifically test that a null foreign key does not pass validation - """ - album = Album(title='test') - album.save() - - class PhotoSerializer(serializers.ModelSerializer): - class Meta: - model = Photo - - photo_serializer = PhotoSerializer(data={'description': 'test', 'album': album.pk}) - self.assertTrue(photo_serializer.is_valid()) - photo = photo_serializer.save() - - # Updating only the album (foreign key) - photo_serializer = PhotoSerializer(instance=photo, data={'album': ''}, partial=True) - self.assertFalse(photo_serializer.is_valid()) - self.assertTrue('album' in photo_serializer.errors) - self.assertEqual(photo_serializer.errors['album'], [photo_serializer.error_messages['required']]) - - def test_foreign_key_with_partial(self): - """ - Test ModelSerializer validation with partial=True - - Specifically test foreign key validation. - """ - - album = Album(title='test') - album.save() - - class PhotoSerializer(serializers.ModelSerializer): - class Meta: - model = Photo - - photo_serializer = PhotoSerializer(data={'description': 'test', 'album': album.pk}) - self.assertTrue(photo_serializer.is_valid()) - photo = photo_serializer.save() - - # Updating only the album (foreign key) - photo_serializer = PhotoSerializer(instance=photo, data={'album': album.pk}, partial=True) - self.assertTrue(photo_serializer.is_valid()) - self.assertTrue(photo_serializer.save()) - - # Updating only the description - photo_serializer = PhotoSerializer(instance=photo, - data={'description': 'new'}, - partial=True) - - self.assertTrue(photo_serializer.is_valid()) - self.assertTrue(photo_serializer.save()) - - -class RegexValidationTest(TestCase): - def test_create_failed(self): - serializer = BookSerializer(data={'isbn': '1234567890'}) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']}) - - serializer = BookSerializer(data={'isbn': '12345678901234'}) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']}) - - serializer = BookSerializer(data={'isbn': 'abcdefghijklm'}) - self.assertFalse(serializer.is_valid()) - self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']}) - - def test_create_success(self): - serializer = BookSerializer(data={'isbn': '1234567890123'}) - self.assertTrue(serializer.is_valid()) - - -class MetadataTests(TestCase): - def test_empty(self): - serializer = CommentSerializer() - expected = { - 'email': serializers.CharField, - 'content': serializers.CharField, - 'created': serializers.DateTimeField - } - for field_name, field in expected.items(): - self.assertTrue(isinstance(serializer.data.fields[field_name], field)) - - -class ManyToManyTests(TestCase): - def setUp(self): - class ManyToManySerializer(serializers.ModelSerializer): - class Meta: - model = ManyToManyModel - - self.serializer_class = ManyToManySerializer - - # An anchor instance to use for the relationship - self.anchor = Anchor() - self.anchor.save() - - # A model instance with a many to many relationship to the anchor - self.instance = ManyToManyModel() - self.instance.save() - self.instance.rel.add(self.anchor) - - # A serialized representation of the model instance - self.data = {'id': 1, 'rel': [self.anchor.id]} - - def test_retrieve(self): - """ - Serialize an instance of a model with a ManyToMany relationship. - """ - serializer = self.serializer_class(instance=self.instance) - expected = self.data - self.assertEqual(serializer.data, expected) - - def test_create(self): - """ - Create an instance of a model with a ManyToMany relationship. - """ - data = {'rel': [self.anchor.id]} - serializer = self.serializer_class(data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(ManyToManyModel.objects.all()), 2) - self.assertEqual(instance.pk, 2) - self.assertEqual(list(instance.rel.all()), [self.anchor]) - - def test_update(self): - """ - Update an instance of a model with a ManyToMany relationship. - """ - new_anchor = Anchor() - new_anchor.save() - data = {'rel': [self.anchor.id, new_anchor.id]} - serializer = self.serializer_class(self.instance, data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(ManyToManyModel.objects.all()), 1) - self.assertEqual(instance.pk, 1) - self.assertEqual(list(instance.rel.all()), [self.anchor, new_anchor]) - - def test_create_empty_relationship(self): - """ - Create an instance of a model with a ManyToMany relationship, - containing no items. - """ - data = {'rel': []} - serializer = self.serializer_class(data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(ManyToManyModel.objects.all()), 2) - self.assertEqual(instance.pk, 2) - self.assertEqual(list(instance.rel.all()), []) - - def test_update_empty_relationship(self): - """ - Update an instance of a model with a ManyToMany relationship, - containing no items. - """ - new_anchor = Anchor() - new_anchor.save() - data = {'rel': []} - serializer = self.serializer_class(self.instance, data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(ManyToManyModel.objects.all()), 1) - self.assertEqual(instance.pk, 1) - self.assertEqual(list(instance.rel.all()), []) - - def test_create_empty_relationship_flat_data(self): - """ - Create an instance of a model with a ManyToMany relationship, - containing no items, using a representation that does not support - lists (eg form data). - """ - data = MultiValueDict() - data.setlist('rel', ['']) - serializer = self.serializer_class(data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(ManyToManyModel.objects.all()), 2) - self.assertEqual(instance.pk, 2) - self.assertEqual(list(instance.rel.all()), []) - - -class ReadOnlyManyToManyTests(TestCase): - def setUp(self): - class ReadOnlyManyToManySerializer(serializers.ModelSerializer): - rel = serializers.RelatedField(many=True, read_only=True) - - class Meta: - model = ReadOnlyManyToManyModel - - self.serializer_class = ReadOnlyManyToManySerializer - - # An anchor instance to use for the relationship - self.anchor = Anchor() - self.anchor.save() - - # A model instance with a many to many relationship to the anchor - self.instance = ReadOnlyManyToManyModel() - self.instance.save() - self.instance.rel.add(self.anchor) - - # A serialized representation of the model instance - self.data = {'rel': [self.anchor.id], 'id': 1, 'text': 'anchor'} - - def test_update(self): - """ - Attempt to update an instance of a model with a ManyToMany - relationship. Not updated due to read_only=True - """ - new_anchor = Anchor() - new_anchor.save() - data = {'rel': [self.anchor.id, new_anchor.id]} - serializer = self.serializer_class(self.instance, data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(ReadOnlyManyToManyModel.objects.all()), 1) - self.assertEqual(instance.pk, 1) - # rel is still as original (1 entry) - self.assertEqual(list(instance.rel.all()), [self.anchor]) - - def test_update_without_relationship(self): - """ - Attempt to update an instance of a model where many to ManyToMany - relationship is not supplied. Not updated due to read_only=True - """ - new_anchor = Anchor() - new_anchor.save() - data = {} - serializer = self.serializer_class(self.instance, data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(ReadOnlyManyToManyModel.objects.all()), 1) - self.assertEqual(instance.pk, 1) - # rel is still as original (1 entry) - self.assertEqual(list(instance.rel.all()), [self.anchor]) - - -class DefaultValueTests(TestCase): - def setUp(self): - class DefaultValueSerializer(serializers.ModelSerializer): - class Meta: - model = DefaultValueModel - - self.serializer_class = DefaultValueSerializer - self.objects = DefaultValueModel.objects - - def test_create_using_default(self): - data = {} - serializer = self.serializer_class(data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(self.objects.all()), 1) - self.assertEqual(instance.pk, 1) - self.assertEqual(instance.text, 'foobar') - - def test_create_overriding_default(self): - data = {'text': 'overridden'} - serializer = self.serializer_class(data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(self.objects.all()), 1) - self.assertEqual(instance.pk, 1) - self.assertEqual(instance.text, 'overridden') - - def test_partial_update_default(self): - """ Regression test for issue #532 """ - data = {'text': 'overridden'} - serializer = self.serializer_class(data=data, partial=True) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - - data = {'extra': 'extra_value'} - serializer = self.serializer_class(instance=instance, data=data, partial=True) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - - self.assertEqual(instance.extra, 'extra_value') - self.assertEqual(instance.text, 'overridden') - - -class WritableFieldDefaultValueTests(TestCase): - - def setUp(self): - self.expected = {'default': 'value'} - self.create_field = fields.WritableField - - def test_get_default_value_with_noncallable(self): - field = self.create_field(default=self.expected) - got = field.get_default_value() - self.assertEqual(got, self.expected) - - def test_get_default_value_with_callable(self): - field = self.create_field(default=lambda: self.expected) - got = field.get_default_value() - self.assertEqual(got, self.expected) - - def test_get_default_value_when_not_required(self): - field = self.create_field(default=self.expected, required=False) - got = field.get_default_value() - self.assertEqual(got, self.expected) - - def test_get_default_value_returns_None(self): - field = self.create_field() - got = field.get_default_value() - self.assertIsNone(got) - - def test_get_default_value_returns_non_True_values(self): - values = [None, '', False, 0, [], (), {}] # values that assumed as 'False' in the 'if' clause - for expected in values: - field = self.create_field(default=expected) - got = field.get_default_value() - self.assertEqual(got, expected) - - -class RelatedFieldDefaultValueTests(WritableFieldDefaultValueTests): - - def setUp(self): - self.expected = {'foo': 'bar'} - self.create_field = relations.RelatedField - - def test_get_default_value_returns_empty_list(self): - field = self.create_field(many=True) - got = field.get_default_value() - self.assertListEqual(got, []) - - def test_get_default_value_returns_expected(self): - expected = [1, 2, 3] - field = self.create_field(many=True, default=expected) - got = field.get_default_value() - self.assertListEqual(got, expected) - - -class CallableDefaultValueTests(TestCase): - def setUp(self): - class CallableDefaultValueSerializer(serializers.ModelSerializer): - class Meta: - model = CallableDefaultValueModel - - self.serializer_class = CallableDefaultValueSerializer - self.objects = CallableDefaultValueModel.objects - - def test_create_using_default(self): - data = {} - serializer = self.serializer_class(data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(self.objects.all()), 1) - self.assertEqual(instance.pk, 1) - self.assertEqual(instance.text, 'foobar') - - def test_create_overriding_default(self): - data = {'text': 'overridden'} - serializer = self.serializer_class(data=data) - self.assertEqual(serializer.is_valid(), True) - instance = serializer.save() - self.assertEqual(len(self.objects.all()), 1) - self.assertEqual(instance.pk, 1) - self.assertEqual(instance.text, 'overridden') - - -class ManyRelatedTests(TestCase): - def test_reverse_relations(self): - post = BlogPost.objects.create(title="Test blog post") - post.blogpostcomment_set.create(text="I hate this blog post") - post.blogpostcomment_set.create(text="I love this blog post") - - class BlogPostCommentSerializer(serializers.Serializer): - text = serializers.CharField() - - class BlogPostSerializer(serializers.Serializer): - title = serializers.CharField() - comments = BlogPostCommentSerializer(source='blogpostcomment_set') - - serializer = BlogPostSerializer(instance=post) - expected = { - 'title': 'Test blog post', - 'comments': [ - {'text': 'I hate this blog post'}, - {'text': 'I love this blog post'} - ] - } - - self.assertEqual(serializer.data, expected) - - def test_include_reverse_relations(self): - post = BlogPost.objects.create(title="Test blog post") - post.blogpostcomment_set.create(text="I hate this blog post") - post.blogpostcomment_set.create(text="I love this blog post") - - class BlogPostSerializer(serializers.ModelSerializer): - class Meta: - model = BlogPost - fields = ('id', 'title', 'blogpostcomment_set') - - serializer = BlogPostSerializer(instance=post) - expected = { - 'id': 1, 'title': 'Test blog post', 'blogpostcomment_set': [1, 2] - } - self.assertEqual(serializer.data, expected) - - def test_depth_include_reverse_relations(self): - post = BlogPost.objects.create(title="Test blog post") - post.blogpostcomment_set.create(text="I hate this blog post") - post.blogpostcomment_set.create(text="I love this blog post") - - class BlogPostSerializer(serializers.ModelSerializer): - class Meta: - model = BlogPost - fields = ('id', 'title', 'blogpostcomment_set') - depth = 1 - - serializer = BlogPostSerializer(instance=post) - expected = { - 'id': 1, 'title': 'Test blog post', - 'blogpostcomment_set': [ - {'id': 1, 'text': 'I hate this blog post', 'blog_post': 1}, - {'id': 2, 'text': 'I love this blog post', 'blog_post': 1} - ] - } - self.assertEqual(serializer.data, expected) - - def test_callable_source(self): - post = BlogPost.objects.create(title="Test blog post") - post.blogpostcomment_set.create(text="I love this blog post") - - class BlogPostCommentSerializer(serializers.Serializer): - text = serializers.CharField() - - class BlogPostSerializer(serializers.Serializer): - title = serializers.CharField() - first_comment = BlogPostCommentSerializer(source='get_first_comment') - - serializer = BlogPostSerializer(post) - - expected = { - 'title': 'Test blog post', - 'first_comment': {'text': 'I love this blog post'} - } - self.assertEqual(serializer.data, expected) - - -class RelatedTraversalTest(TestCase): - def test_nested_traversal(self): - """ - Source argument should support dotted.source notation. - """ - user = Person.objects.create(name="django") - post = BlogPost.objects.create(title="Test blog post", writer=user) - post.blogpostcomment_set.create(text="I love this blog post") +# class BasicTests(TestCase): +# def setUp(self): +# self.comment = Comment( +# 'tom@example.com', +# 'Happy new year!', +# datetime.datetime(2012, 1, 1) +# ) +# self.actionitem = ActionItem(title='Some to do item',) +# self.data = { +# 'email': 'tom@example.com', +# 'content': 'Happy new year!', +# 'created': datetime.datetime(2012, 1, 1), +# 'sub_comment': 'This wont change' +# } +# self.expected = { +# 'email': 'tom@example.com', +# 'content': 'Happy new year!', +# 'created': datetime.datetime(2012, 1, 1), +# 'sub_comment': 'And Merry Christmas!' +# } +# self.person_data = {'name': 'dwight', 'age': 35} +# self.person = Person(**self.person_data) +# self.person.save() + +# def test_empty(self): +# serializer = CommentSerializer() +# expected = { +# 'email': '', +# 'content': '', +# 'created': None +# } +# self.assertEqual(serializer.data, expected) + +# def test_retrieve(self): +# serializer = CommentSerializer(self.comment) +# self.assertEqual(serializer.data, self.expected) + +# def test_create(self): +# serializer = CommentSerializer(data=self.data) +# expected = self.comment +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, expected) +# self.assertFalse(serializer.object is expected) +# self.assertEqual(serializer.data['sub_comment'], 'And Merry Christmas!') + +# def test_create_nested(self): +# """Test a serializer with nested data.""" +# names = {'first': 'John', 'last': 'Doe', 'initials': 'jd'} +# data = {'ssn': '1234567890', 'names': names} +# serializer = PersonIdentifierSerializer(data=data) + +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, data) +# self.assertFalse(serializer.object is data) +# self.assertEqual(serializer.data['names'], names) + +# def test_create_partial_nested(self): +# """Test a serializer with nested data which has missing fields.""" +# names = {'first': 'John'} +# data = {'ssn': '1234567890', 'names': names} +# serializer = PersonIdentifierSerializer(data=data) + +# expected_names = {'first': 'John', 'last': '', 'initials': ''} +# data['names'] = expected_names + +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, data) +# self.assertFalse(serializer.object is expected_names) +# self.assertEqual(serializer.data['names'], expected_names) + +# def test_null_nested(self): +# """Test a serializer with a nonexistent nested field""" +# data = {'ssn': '1234567890'} +# serializer = PersonIdentifierSerializer(data=data) + +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, data) +# self.assertFalse(serializer.object is data) +# expected = {'ssn': '1234567890', 'names': None} +# self.assertEqual(serializer.data, expected) + +# def test_update(self): +# serializer = CommentSerializer(self.comment, data=self.data) +# expected = self.comment +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, expected) +# self.assertTrue(serializer.object is expected) +# self.assertEqual(serializer.data['sub_comment'], 'And Merry Christmas!') + +# def test_partial_update(self): +# msg = 'Merry New Year!' +# partial_data = {'content': msg} +# serializer = CommentSerializer(self.comment, data=partial_data) +# self.assertEqual(serializer.is_valid(), False) +# serializer = CommentSerializer(self.comment, data=partial_data, partial=True) +# expected = self.comment +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, expected) +# self.assertTrue(serializer.object is expected) +# self.assertEqual(serializer.data['content'], msg) + +# def test_model_fields_as_expected(self): +# """ +# Make sure that the fields returned are the same as defined +# in the Meta data +# """ +# serializer = PersonSerializer(self.person) +# self.assertEqual( +# set(serializer.data.keys()), +# set(['name', 'age', 'info']) +# ) + +# def test_field_with_dictionary(self): +# """ +# Make sure that dictionaries from fields are left intact +# """ +# serializer = PersonSerializer(self.person) +# expected = self.person_data +# self.assertEqual(serializer.data['info'], expected) + +# def test_read_only_fields(self): +# """ +# Attempting to update fields set as read_only should have no effect. +# """ +# serializer = PersonSerializer(self.person, data={'name': 'dwight', 'age': 99}) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(serializer.errors, {}) +# # Assert age is unchanged (35) +# self.assertEqual(instance.age, self.person_data['age']) + +# def test_invalid_read_only_fields(self): +# """ +# Regression test for #652. +# """ +# self.assertRaises(AssertionError, PersonSerializerInvalidReadOnly, []) + +# def test_serializer_data_is_cleared_on_save(self): +# """ +# Check _data attribute is cleared on `save()` + +# Regression test for #1116 +# — id field is not populated if `data` is accessed prior to `save()` +# """ +# serializer = ActionItemSerializer(self.actionitem) +# self.assertIsNone(serializer.data.get('id', None), 'New instance. `id` should not be set.') +# serializer.save() +# self.assertIsNotNone(serializer.data.get('id', None), 'Model is saved. `id` should be set.') + +# def test_fields_marked_as_not_required_are_excluded_from_validation(self): +# """ +# Check that fields with `required=False` are included in list of exclusions. +# """ +# serializer = ActionItemSerializerOptionalFields(self.actionitem) +# exclusions = serializer.get_validation_exclusions() +# self.assertTrue('title' in exclusions, '`title` field was marked `required=False` and should be excluded') + + +# class DictStyleSerializer(serializers.Serializer): +# """ +# Note that we don't have any `restore_object` method, so the default +# case of simply returning a dict will apply. +# """ +# email = serializers.EmailField() + + +# class DictStyleSerializerTests(TestCase): +# def test_dict_style_deserialize(self): +# """ +# Ensure serializers can deserialize into a dict. +# """ +# data = {'email': 'foo@example.com'} +# serializer = DictStyleSerializer(data=data) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, data) + +# def test_dict_style_serialize(self): +# """ +# Ensure serializers can serialize dict objects. +# """ +# data = {'email': 'foo@example.com'} +# serializer = DictStyleSerializer(data) +# self.assertEqual(serializer.data, data) + + +# class ValidationTests(TestCase): +# def setUp(self): +# self.comment = Comment( +# 'tom@example.com', +# 'Happy new year!', +# datetime.datetime(2012, 1, 1) +# ) +# self.data = { +# 'email': 'tom@example.com', +# 'content': 'x' * 1001, +# 'created': datetime.datetime(2012, 1, 1) +# } +# self.actionitem = ActionItem(title='Some to do item',) + +# def test_create(self): +# serializer = CommentSerializer(data=self.data) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']}) + +# def test_update(self): +# serializer = CommentSerializer(self.comment, data=self.data) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']}) + +# def test_update_missing_field(self): +# data = { +# 'content': 'xxx', +# 'created': datetime.datetime(2012, 1, 1) +# } +# serializer = CommentSerializer(self.comment, data=data) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, {'email': ['This field is required.']}) + +# def test_missing_bool_with_default(self): +# """Make sure that a boolean value with a 'False' value is not +# mistaken for not having a default.""" +# data = { +# 'title': 'Some action item', +# # No 'done' value. +# } +# serializer = ActionItemSerializer(self.actionitem, data=data) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.errors, {}) + +# def test_cross_field_validation(self): + +# class CommentSerializerWithCrossFieldValidator(CommentSerializer): + +# def validate(self, attrs): +# if attrs["email"] not in attrs["content"]: +# raise serializers.ValidationError("Email address not in content") +# return attrs + +# data = { +# 'email': 'tom@example.com', +# 'content': 'A comment from tom@example.com', +# 'created': datetime.datetime(2012, 1, 1) +# } + +# serializer = CommentSerializerWithCrossFieldValidator(data=data) +# self.assertTrue(serializer.is_valid()) + +# data['content'] = 'A comment from foo@bar.com' + +# serializer = CommentSerializerWithCrossFieldValidator(data=data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'non_field_errors': ['Email address not in content']}) + +# def test_null_is_true_fields(self): +# """ +# Omitting a value for null-field should validate. +# """ +# serializer = PersonSerializer(data={'name': 'marko'}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.errors, {}) + +# def test_modelserializer_max_length_exceeded(self): +# data = { +# 'title': 'x' * 201, +# } +# serializer = ActionItemSerializer(data=data) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']}) + +# def test_modelserializer_max_length_exceeded_with_custom_restore(self): +# """ +# When overriding ModelSerializer.restore_object, validation tests should still apply. +# Regression test for #623. + +# https://github.com/tomchristie/django-rest-framework/pull/623 +# """ +# data = { +# 'title': 'x' * 201, +# } +# serializer = ActionItemSerializerCustomRestore(data=data) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']}) + +# def test_default_modelfield_max_length_exceeded(self): +# data = { +# 'title': 'Testing "info" field...', +# 'info': 'x' * 13, +# } +# serializer = ActionItemSerializer(data=data) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, {'info': ['Ensure this value has at most 12 characters (it has 13).']}) + +# def test_datetime_validation_failure(self): +# """ +# Test DateTimeField validation errors on non-str values. +# Regression test for #669. + +# https://github.com/tomchristie/django-rest-framework/issues/669 +# """ +# data = self.data +# data['created'] = 0 + +# serializer = CommentSerializer(data=data) +# self.assertEqual(serializer.is_valid(), False) + +# self.assertIn('created', serializer.errors) + +# def test_missing_model_field_exception_msg(self): +# """ +# Assert that a meaningful exception message is outputted when the model +# field is missing (e.g. when mistyping ``model``). +# """ +# class BrokenModelSerializer(serializers.ModelSerializer): +# class Meta: +# fields = ['some_field'] + +# try: +# BrokenModelSerializer() +# except AssertionError as e: +# self.assertEqual(e.args[0], "Serializer class 'BrokenModelSerializer' is missing 'model' Meta option") +# except: +# self.fail('Wrong exception type thrown.') + +# def test_writable_star_source_on_nested_serializer(self): +# """ +# Assert that a nested serializer instantiated with source='*' correctly +# expands the data into the outer serializer. +# """ +# serializer = ModelSerializerWithNestedSerializer(data={ +# 'name': 'marko', +# 'nested': {'info': 'hi'}}, +# ) +# self.assertEqual(serializer.is_valid(), True) + +# def test_writable_star_source_on_nested_serializer_with_parent_object(self): +# class TitleSerializer(serializers.Serializer): +# title = serializers.WritableField(source='title') + +# class AlbumSerializer(serializers.ModelSerializer): +# nested = TitleSerializer(source='*') + +# class Meta: +# model = Album +# fields = ('nested',) + +# class PhotoSerializer(serializers.ModelSerializer): +# album = AlbumSerializer(source='album') + +# class Meta: +# model = Photo +# fields = ('album', ) + +# photo = Photo(album=Album()) + +# data = {'album': {'nested': {'title': 'test'}}} + +# serializer = PhotoSerializer(photo, data=data) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.data, data) + +# def test_writable_star_source_with_inner_source_fields(self): +# """ +# Tests that a serializer with source="*" correctly expands the +# it's fields into the outer serializer even if they have their +# own 'source' parameters. +# """ + +# serializer = ModelSerializerWithNestedSerializerWithRenamedField(data={ +# 'name': 'marko', +# 'nested': {'renamed_info': 'hi'}}, +# ) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.errors, {}) + + +# class CustomValidationTests(TestCase): +# class CommentSerializerWithFieldValidator(CommentSerializer): + +# def validate_email(self, attrs, source): +# attrs[source] +# return attrs + +# def validate_content(self, attrs, source): +# value = attrs[source] +# if "test" not in value: +# raise serializers.ValidationError("Test not in value") +# return attrs + +# def test_field_validation(self): +# data = { +# 'email': 'tom@example.com', +# 'content': 'A test comment', +# 'created': datetime.datetime(2012, 1, 1) +# } + +# serializer = self.CommentSerializerWithFieldValidator(data=data) +# self.assertTrue(serializer.is_valid()) + +# data['content'] = 'This should not validate' + +# serializer = self.CommentSerializerWithFieldValidator(data=data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'content': ['Test not in value']}) + +# def test_missing_data(self): +# """ +# Make sure that validate_content isn't called if the field is missing +# """ +# incomplete_data = { +# 'email': 'tom@example.com', +# 'created': datetime.datetime(2012, 1, 1) +# } +# serializer = self.CommentSerializerWithFieldValidator(data=incomplete_data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'content': ['This field is required.']}) + +# def test_wrong_data(self): +# """ +# Make sure that validate_content isn't called if the field input is wrong +# """ +# wrong_data = { +# 'email': 'not an email', +# 'content': 'A test comment', +# 'created': datetime.datetime(2012, 1, 1) +# } +# serializer = self.CommentSerializerWithFieldValidator(data=wrong_data) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'email': ['Enter a valid email address.']}) + +# def test_partial_update(self): +# """ +# Make sure that validate_email isn't called when partial=True and email +# isn't found in data. +# """ +# initial_data = { +# 'email': 'tom@example.com', +# 'content': 'A test comment', +# 'created': datetime.datetime(2012, 1, 1) +# } + +# serializer = self.CommentSerializerWithFieldValidator(data=initial_data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.object + +# new_content = 'An *updated* test comment' +# partial_data = { +# 'content': new_content +# } + +# serializer = self.CommentSerializerWithFieldValidator(instance=instance, +# data=partial_data, +# partial=True) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.object +# self.assertEqual(instance.content, new_content) + + +# class PositiveIntegerAsChoiceTests(TestCase): +# def test_positive_integer_in_json_is_correctly_parsed(self): +# data = {'some_integer': 1} +# serializer = PositiveIntegerAsChoiceSerializer(data=data) +# self.assertEqual(serializer.is_valid(), True) + + +# class ModelValidationTests(TestCase): +# def test_validate_unique(self): +# """ +# Just check if serializers.ModelSerializer handles unique checks via .full_clean() +# """ +# serializer = AlbumsSerializer(data={'title': 'a', 'ref': '1'}) +# serializer.is_valid() +# serializer.save() +# second_serializer = AlbumsSerializer(data={'title': 'a'}) +# self.assertFalse(second_serializer.is_valid()) +# self.assertEqual(second_serializer.errors, {'title': ['Album with this Title already exists.']}) +# third_serializer = AlbumsSerializer(data=[{'title': 'b', 'ref': '1'}, {'title': 'c'}], many=True) +# self.assertFalse(third_serializer.is_valid()) +# self.assertEqual(third_serializer.errors, [{'ref': ['Album with this Ref already exists.']}, {}]) + +# def test_foreign_key_is_null_with_partial(self): +# """ +# Test ModelSerializer validation with partial=True + +# Specifically test that a null foreign key does not pass validation +# """ +# album = Album(title='test') +# album.save() + +# class PhotoSerializer(serializers.ModelSerializer): +# class Meta: +# model = Photo + +# photo_serializer = PhotoSerializer(data={'description': 'test', 'album': album.pk}) +# self.assertTrue(photo_serializer.is_valid()) +# photo = photo_serializer.save() + +# # Updating only the album (foreign key) +# photo_serializer = PhotoSerializer(instance=photo, data={'album': ''}, partial=True) +# self.assertFalse(photo_serializer.is_valid()) +# self.assertTrue('album' in photo_serializer.errors) +# self.assertEqual(photo_serializer.errors['album'], [photo_serializer.error_messages['required']]) + +# def test_foreign_key_with_partial(self): +# """ +# Test ModelSerializer validation with partial=True + +# Specifically test foreign key validation. +# """ + +# album = Album(title='test') +# album.save() + +# class PhotoSerializer(serializers.ModelSerializer): +# class Meta: +# model = Photo + +# photo_serializer = PhotoSerializer(data={'description': 'test', 'album': album.pk}) +# self.assertTrue(photo_serializer.is_valid()) +# photo = photo_serializer.save() + +# # Updating only the album (foreign key) +# photo_serializer = PhotoSerializer(instance=photo, data={'album': album.pk}, partial=True) +# self.assertTrue(photo_serializer.is_valid()) +# self.assertTrue(photo_serializer.save()) + +# # Updating only the description +# photo_serializer = PhotoSerializer(instance=photo, +# data={'description': 'new'}, +# partial=True) + +# self.assertTrue(photo_serializer.is_valid()) +# self.assertTrue(photo_serializer.save()) + + +# class RegexValidationTest(TestCase): +# def test_create_failed(self): +# serializer = BookSerializer(data={'isbn': '1234567890'}) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']}) + +# serializer = BookSerializer(data={'isbn': '12345678901234'}) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']}) + +# serializer = BookSerializer(data={'isbn': 'abcdefghijklm'}) +# self.assertFalse(serializer.is_valid()) +# self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']}) + +# def test_create_success(self): +# serializer = BookSerializer(data={'isbn': '1234567890123'}) +# self.assertTrue(serializer.is_valid()) + + +# class MetadataTests(TestCase): +# def test_empty(self): +# serializer = CommentSerializer() +# expected = { +# 'email': serializers.CharField, +# 'content': serializers.CharField, +# 'created': serializers.DateTimeField +# } +# for field_name, field in expected.items(): +# self.assertTrue(isinstance(serializer.data.fields[field_name], field)) + + +# class ManyToManyTests(TestCase): +# def setUp(self): +# class ManyToManySerializer(serializers.ModelSerializer): +# class Meta: +# model = ManyToManyModel + +# self.serializer_class = ManyToManySerializer + +# # An anchor instance to use for the relationship +# self.anchor = Anchor() +# self.anchor.save() + +# # A model instance with a many to many relationship to the anchor +# self.instance = ManyToManyModel() +# self.instance.save() +# self.instance.rel.add(self.anchor) + +# # A serialized representation of the model instance +# self.data = {'id': 1, 'rel': [self.anchor.id]} + +# def test_retrieve(self): +# """ +# Serialize an instance of a model with a ManyToMany relationship. +# """ +# serializer = self.serializer_class(instance=self.instance) +# expected = self.data +# self.assertEqual(serializer.data, expected) + +# def test_create(self): +# """ +# Create an instance of a model with a ManyToMany relationship. +# """ +# data = {'rel': [self.anchor.id]} +# serializer = self.serializer_class(data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(ManyToManyModel.objects.all()), 2) +# self.assertEqual(instance.pk, 2) +# self.assertEqual(list(instance.rel.all()), [self.anchor]) + +# def test_update(self): +# """ +# Update an instance of a model with a ManyToMany relationship. +# """ +# new_anchor = Anchor() +# new_anchor.save() +# data = {'rel': [self.anchor.id, new_anchor.id]} +# serializer = self.serializer_class(self.instance, data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(ManyToManyModel.objects.all()), 1) +# self.assertEqual(instance.pk, 1) +# self.assertEqual(list(instance.rel.all()), [self.anchor, new_anchor]) + +# def test_create_empty_relationship(self): +# """ +# Create an instance of a model with a ManyToMany relationship, +# containing no items. +# """ +# data = {'rel': []} +# serializer = self.serializer_class(data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(ManyToManyModel.objects.all()), 2) +# self.assertEqual(instance.pk, 2) +# self.assertEqual(list(instance.rel.all()), []) + +# def test_update_empty_relationship(self): +# """ +# Update an instance of a model with a ManyToMany relationship, +# containing no items. +# """ +# new_anchor = Anchor() +# new_anchor.save() +# data = {'rel': []} +# serializer = self.serializer_class(self.instance, data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(ManyToManyModel.objects.all()), 1) +# self.assertEqual(instance.pk, 1) +# self.assertEqual(list(instance.rel.all()), []) + +# def test_create_empty_relationship_flat_data(self): +# """ +# Create an instance of a model with a ManyToMany relationship, +# containing no items, using a representation that does not support +# lists (eg form data). +# """ +# data = MultiValueDict() +# data.setlist('rel', ['']) +# serializer = self.serializer_class(data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(ManyToManyModel.objects.all()), 2) +# self.assertEqual(instance.pk, 2) +# self.assertEqual(list(instance.rel.all()), []) + + +# class ReadOnlyManyToManyTests(TestCase): +# def setUp(self): +# class ReadOnlyManyToManySerializer(serializers.ModelSerializer): +# rel = serializers.RelatedField(many=True, read_only=True) + +# class Meta: +# model = ReadOnlyManyToManyModel + +# self.serializer_class = ReadOnlyManyToManySerializer + +# # An anchor instance to use for the relationship +# self.anchor = Anchor() +# self.anchor.save() + +# # A model instance with a many to many relationship to the anchor +# self.instance = ReadOnlyManyToManyModel() +# self.instance.save() +# self.instance.rel.add(self.anchor) + +# # A serialized representation of the model instance +# self.data = {'rel': [self.anchor.id], 'id': 1, 'text': 'anchor'} + +# def test_update(self): +# """ +# Attempt to update an instance of a model with a ManyToMany +# relationship. Not updated due to read_only=True +# """ +# new_anchor = Anchor() +# new_anchor.save() +# data = {'rel': [self.anchor.id, new_anchor.id]} +# serializer = self.serializer_class(self.instance, data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(ReadOnlyManyToManyModel.objects.all()), 1) +# self.assertEqual(instance.pk, 1) +# # rel is still as original (1 entry) +# self.assertEqual(list(instance.rel.all()), [self.anchor]) + +# def test_update_without_relationship(self): +# """ +# Attempt to update an instance of a model where many to ManyToMany +# relationship is not supplied. Not updated due to read_only=True +# """ +# new_anchor = Anchor() +# new_anchor.save() +# data = {} +# serializer = self.serializer_class(self.instance, data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(ReadOnlyManyToManyModel.objects.all()), 1) +# self.assertEqual(instance.pk, 1) +# # rel is still as original (1 entry) +# self.assertEqual(list(instance.rel.all()), [self.anchor]) + + +# class DefaultValueTests(TestCase): +# def setUp(self): +# class DefaultValueSerializer(serializers.ModelSerializer): +# class Meta: +# model = DefaultValueModel + +# self.serializer_class = DefaultValueSerializer +# self.objects = DefaultValueModel.objects + +# def test_create_using_default(self): +# data = {} +# serializer = self.serializer_class(data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(self.objects.all()), 1) +# self.assertEqual(instance.pk, 1) +# self.assertEqual(instance.text, 'foobar') + +# def test_create_overriding_default(self): +# data = {'text': 'overridden'} +# serializer = self.serializer_class(data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(self.objects.all()), 1) +# self.assertEqual(instance.pk, 1) +# self.assertEqual(instance.text, 'overridden') + +# def test_partial_update_default(self): +# """ Regression test for issue #532 """ +# data = {'text': 'overridden'} +# serializer = self.serializer_class(data=data, partial=True) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() + +# data = {'extra': 'extra_value'} +# serializer = self.serializer_class(instance=instance, data=data, partial=True) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() + +# self.assertEqual(instance.extra, 'extra_value') +# self.assertEqual(instance.text, 'overridden') + + +# class WritableFieldDefaultValueTests(TestCase): + +# def setUp(self): +# self.expected = {'default': 'value'} +# self.create_field = fields.WritableField + +# def test_get_default_value_with_noncallable(self): +# field = self.create_field(default=self.expected) +# got = field.get_default_value() +# self.assertEqual(got, self.expected) + +# def test_get_default_value_with_callable(self): +# field = self.create_field(default=lambda: self.expected) +# got = field.get_default_value() +# self.assertEqual(got, self.expected) + +# def test_get_default_value_when_not_required(self): +# field = self.create_field(default=self.expected, required=False) +# got = field.get_default_value() +# self.assertEqual(got, self.expected) + +# def test_get_default_value_returns_None(self): +# field = self.create_field() +# got = field.get_default_value() +# self.assertIsNone(got) + +# def test_get_default_value_returns_non_True_values(self): +# values = [None, '', False, 0, [], (), {}] # values that assumed as 'False' in the 'if' clause +# for expected in values: +# field = self.create_field(default=expected) +# got = field.get_default_value() +# self.assertEqual(got, expected) + + +# class RelatedFieldDefaultValueTests(WritableFieldDefaultValueTests): + +# def setUp(self): +# self.expected = {'foo': 'bar'} +# self.create_field = relations.RelatedField + +# def test_get_default_value_returns_empty_list(self): +# field = self.create_field(many=True) +# got = field.get_default_value() +# self.assertListEqual(got, []) + +# def test_get_default_value_returns_expected(self): +# expected = [1, 2, 3] +# field = self.create_field(many=True, default=expected) +# got = field.get_default_value() +# self.assertListEqual(got, expected) + + +# class CallableDefaultValueTests(TestCase): +# def setUp(self): +# class CallableDefaultValueSerializer(serializers.ModelSerializer): +# class Meta: +# model = CallableDefaultValueModel + +# self.serializer_class = CallableDefaultValueSerializer +# self.objects = CallableDefaultValueModel.objects + +# def test_create_using_default(self): +# data = {} +# serializer = self.serializer_class(data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(self.objects.all()), 1) +# self.assertEqual(instance.pk, 1) +# self.assertEqual(instance.text, 'foobar') + +# def test_create_overriding_default(self): +# data = {'text': 'overridden'} +# serializer = self.serializer_class(data=data) +# self.assertEqual(serializer.is_valid(), True) +# instance = serializer.save() +# self.assertEqual(len(self.objects.all()), 1) +# self.assertEqual(instance.pk, 1) +# self.assertEqual(instance.text, 'overridden') + + +# class ManyRelatedTests(TestCase): +# def test_reverse_relations(self): +# post = BlogPost.objects.create(title="Test blog post") +# post.blogpostcomment_set.create(text="I hate this blog post") +# post.blogpostcomment_set.create(text="I love this blog post") + +# class BlogPostCommentSerializer(serializers.Serializer): +# text = serializers.CharField() + +# class BlogPostSerializer(serializers.Serializer): +# title = serializers.CharField() +# comments = BlogPostCommentSerializer(source='blogpostcomment_set') + +# serializer = BlogPostSerializer(instance=post) +# expected = { +# 'title': 'Test blog post', +# 'comments': [ +# {'text': 'I hate this blog post'}, +# {'text': 'I love this blog post'} +# ] +# } + +# self.assertEqual(serializer.data, expected) + +# def test_include_reverse_relations(self): +# post = BlogPost.objects.create(title="Test blog post") +# post.blogpostcomment_set.create(text="I hate this blog post") +# post.blogpostcomment_set.create(text="I love this blog post") + +# class BlogPostSerializer(serializers.ModelSerializer): +# class Meta: +# model = BlogPost +# fields = ('id', 'title', 'blogpostcomment_set') + +# serializer = BlogPostSerializer(instance=post) +# expected = { +# 'id': 1, 'title': 'Test blog post', 'blogpostcomment_set': [1, 2] +# } +# self.assertEqual(serializer.data, expected) + +# def test_depth_include_reverse_relations(self): +# post = BlogPost.objects.create(title="Test blog post") +# post.blogpostcomment_set.create(text="I hate this blog post") +# post.blogpostcomment_set.create(text="I love this blog post") + +# class BlogPostSerializer(serializers.ModelSerializer): +# class Meta: +# model = BlogPost +# fields = ('id', 'title', 'blogpostcomment_set') +# depth = 1 + +# serializer = BlogPostSerializer(instance=post) +# expected = { +# 'id': 1, 'title': 'Test blog post', +# 'blogpostcomment_set': [ +# {'id': 1, 'text': 'I hate this blog post', 'blog_post': 1}, +# {'id': 2, 'text': 'I love this blog post', 'blog_post': 1} +# ] +# } +# self.assertEqual(serializer.data, expected) + +# def test_callable_source(self): +# post = BlogPost.objects.create(title="Test blog post") +# post.blogpostcomment_set.create(text="I love this blog post") + +# class BlogPostCommentSerializer(serializers.Serializer): +# text = serializers.CharField() + +# class BlogPostSerializer(serializers.Serializer): +# title = serializers.CharField() +# first_comment = BlogPostCommentSerializer(source='get_first_comment') + +# serializer = BlogPostSerializer(post) + +# expected = { +# 'title': 'Test blog post', +# 'first_comment': {'text': 'I love this blog post'} +# } +# self.assertEqual(serializer.data, expected) + + +# class RelatedTraversalTest(TestCase): +# def test_nested_traversal(self): +# """ +# Source argument should support dotted.source notation. +# """ +# user = Person.objects.create(name="django") +# post = BlogPost.objects.create(title="Test blog post", writer=user) +# post.blogpostcomment_set.create(text="I love this blog post") - class PersonSerializer(serializers.ModelSerializer): - class Meta: - model = Person - fields = ("name", "age") +# class PersonSerializer(serializers.ModelSerializer): +# class Meta: +# model = Person +# fields = ("name", "age") - class BlogPostCommentSerializer(serializers.ModelSerializer): - class Meta: - model = BlogPostComment - fields = ("text", "post_owner") +# class BlogPostCommentSerializer(serializers.ModelSerializer): +# class Meta: +# model = BlogPostComment +# fields = ("text", "post_owner") - text = serializers.CharField() - post_owner = PersonSerializer(source='blog_post.writer') +# text = serializers.CharField() +# post_owner = PersonSerializer(source='blog_post.writer') - class BlogPostSerializer(serializers.Serializer): - title = serializers.CharField() - comments = BlogPostCommentSerializer(source='blogpostcomment_set') +# class BlogPostSerializer(serializers.Serializer): +# title = serializers.CharField() +# comments = BlogPostCommentSerializer(source='blogpostcomment_set') - serializer = BlogPostSerializer(instance=post) +# serializer = BlogPostSerializer(instance=post) - expected = { - 'title': 'Test blog post', - 'comments': [{ - 'text': 'I love this blog post', - 'post_owner': { - "name": "django", - "age": None - } - }] - } - - self.assertEqual(serializer.data, expected) +# expected = { +# 'title': 'Test blog post', +# 'comments': [{ +# 'text': 'I love this blog post', +# 'post_owner': { +# "name": "django", +# "age": None +# } +# }] +# } + +# self.assertEqual(serializer.data, expected) - def test_nested_traversal_with_none(self): - """ - If a component of the dotted.source is None, return None for the field. - """ - from tests.models import NullableForeignKeySource - instance = NullableForeignKeySource.objects.create(name='Source with null FK') - - class NullableSourceSerializer(serializers.Serializer): - target_name = serializers.Field(source='target.name') - - serializer = NullableSourceSerializer(instance=instance) - - expected = { - 'target_name': None, - } - - self.assertEqual(serializer.data, expected) - - -class SerializerMethodFieldTests(TestCase): - def setUp(self): - - class BoopSerializer(serializers.Serializer): - beep = serializers.SerializerMethodField('get_beep') - boop = serializers.Field() - boop_count = serializers.SerializerMethodField('get_boop_count') - - def get_beep(self, obj): - return 'hello!' - - def get_boop_count(self, obj): - return len(obj.boop) - - self.serializer_class = BoopSerializer - - def test_serializer_method_field(self): - - class MyModel(object): - boop = ['a', 'b', 'c'] - - source_data = MyModel() - - serializer = self.serializer_class(source_data) - - expected = { - 'beep': 'hello!', - 'boop': ['a', 'b', 'c'], - 'boop_count': 3, - } - - self.assertEqual(serializer.data, expected) - - -# Test for issue #324 -class BlankFieldTests(TestCase): - def setUp(self): - - class BlankFieldModelSerializer(serializers.ModelSerializer): - class Meta: - model = BlankFieldModel - - class BlankFieldSerializer(serializers.Serializer): - title = serializers.CharField(required=False) - - class NotBlankFieldModelSerializer(serializers.ModelSerializer): - class Meta: - model = BasicModel - - class NotBlankFieldSerializer(serializers.Serializer): - title = serializers.CharField() - - self.model_serializer_class = BlankFieldModelSerializer - self.serializer_class = BlankFieldSerializer - self.not_blank_model_serializer_class = NotBlankFieldModelSerializer - self.not_blank_serializer_class = NotBlankFieldSerializer - self.data = {'title': ''} - - def test_create_blank_field(self): - serializer = self.serializer_class(data=self.data) - self.assertEqual(serializer.is_valid(), True) - - def test_create_model_blank_field(self): - serializer = self.model_serializer_class(data=self.data) - self.assertEqual(serializer.is_valid(), True) - - def test_create_model_null_field(self): - serializer = self.model_serializer_class(data={'title': None}) - self.assertEqual(serializer.is_valid(), True) - serializer.save() - self.assertIsNot(serializer.object.pk, None) - self.assertEqual(serializer.object.title, '') - - def test_create_not_blank_field(self): - """ - Test to ensure blank data in a field not marked as blank=True - is considered invalid in a non-model serializer - """ - serializer = self.not_blank_serializer_class(data=self.data) - self.assertEqual(serializer.is_valid(), False) - - def test_create_model_not_blank_field(self): - """ - Test to ensure blank data in a field not marked as blank=True - is considered invalid in a model serializer - """ - serializer = self.not_blank_model_serializer_class(data=self.data) - self.assertEqual(serializer.is_valid(), False) - - def test_create_model_empty_field(self): - serializer = self.model_serializer_class(data={}) - self.assertEqual(serializer.is_valid(), True) - - def test_create_model_null_field_save(self): - """ - Regression test for #1330. - - https://github.com/tomchristie/django-rest-framework/pull/1330 - """ - serializer = self.model_serializer_class(data={'title': None}) - self.assertEqual(serializer.is_valid(), True) - - try: - serializer.save() - except Exception: - self.fail('Exception raised on save() after validation passes') - - -# Test for issue #460 -class SerializerPickleTests(TestCase): - """ - Test pickleability of the output of Serializers - """ - def test_pickle_simple_model_serializer_data(self): - """ - Test simple serializer - """ - pickle.dumps(PersonSerializer(Person(name="Methusela", age=969)).data) - - def test_pickle_inner_serializer(self): - """ - Test pickling a serializer whose resulting .data (a SortedDictWithMetadata) will - have unpickleable meta data--in order to make sure metadata doesn't get pulled into the pickle. - See DictWithMetadata.__getstate__ - """ - class InnerPersonSerializer(serializers.ModelSerializer): - class Meta: - model = Person - fields = ('name', 'age') - pickle.dumps(InnerPersonSerializer(Person(name="Noah", age=950)).data, 0) - - def test_getstate_method_should_not_return_none(self): - """ - Regression test for #645. - """ - data = serializers.DictWithMetadata({1: 1}) - self.assertEqual(data.__getstate__(), serializers.SortedDict({1: 1})) - - def test_serializer_data_is_pickleable(self): - """ - Another regression test for #645. - """ - data = serializers.SortedDictWithMetadata({1: 1}) - repr(pickle.loads(pickle.dumps(data, 0))) - - -# test for issue #725 -class SeveralChoicesModel(models.Model): - color = models.CharField( - max_length=10, - choices=[('red', 'Red'), ('green', 'Green'), ('blue', 'Blue')], - blank=False - ) - drink = models.CharField( - max_length=10, - choices=[('beer', 'Beer'), ('wine', 'Wine'), ('cider', 'Cider')], - blank=False, - default='beer' - ) - os = models.CharField( - max_length=10, - choices=[('linux', 'Linux'), ('osx', 'OSX'), ('windows', 'Windows')], - blank=True - ) - music_genre = models.CharField( - max_length=10, - choices=[('rock', 'Rock'), ('metal', 'Metal'), ('grunge', 'Grunge')], - blank=True, - default='metal' - ) - - -class SerializerChoiceFields(TestCase): - - def setUp(self): - super(SerializerChoiceFields, self).setUp() - - class SeveralChoicesSerializer(serializers.ModelSerializer): - class Meta: - model = SeveralChoicesModel - fields = ('color', 'drink', 'os', 'music_genre') - - self.several_choices_serializer = SeveralChoicesSerializer - - def test_choices_blank_false_not_default(self): - serializer = self.several_choices_serializer() - self.assertEqual( - serializer.fields['color'].choices, - [('red', 'Red'), ('green', 'Green'), ('blue', 'Blue')] - ) - - def test_choices_blank_false_with_default(self): - serializer = self.several_choices_serializer() - self.assertEqual( - serializer.fields['drink'].choices, - [('beer', 'Beer'), ('wine', 'Wine'), ('cider', 'Cider')] - ) - - def test_choices_blank_true_not_default(self): - serializer = self.several_choices_serializer() - self.assertEqual( - serializer.fields['os'].choices, - BLANK_CHOICE_DASH + [('linux', 'Linux'), ('osx', 'OSX'), ('windows', 'Windows')] - ) - - def test_choices_blank_true_with_default(self): - serializer = self.several_choices_serializer() - self.assertEqual( - serializer.fields['music_genre'].choices, - BLANK_CHOICE_DASH + [('rock', 'Rock'), ('metal', 'Metal'), ('grunge', 'Grunge')] - ) - - -# Regression tests for #675 -class Ticket(models.Model): - assigned = models.ForeignKey( - Person, related_name='assigned_tickets') - reviewer = models.ForeignKey( - Person, blank=True, null=True, related_name='reviewed_tickets') - - -class SerializerRelatedChoicesTest(TestCase): - - def setUp(self): - super(SerializerRelatedChoicesTest, self).setUp() - - class RelatedChoicesSerializer(serializers.ModelSerializer): - class Meta: - model = Ticket - fields = ('assigned', 'reviewer') - - self.related_fields_serializer = RelatedChoicesSerializer - - def test_empty_queryset_required(self): - serializer = self.related_fields_serializer() - self.assertEqual(serializer.fields['assigned'].queryset.count(), 0) - self.assertEqual( - [x for x in serializer.fields['assigned'].widget.choices], - [] - ) - - def test_empty_queryset_not_required(self): - serializer = self.related_fields_serializer() - self.assertEqual(serializer.fields['reviewer'].queryset.count(), 0) - self.assertEqual( - [x for x in serializer.fields['reviewer'].widget.choices], - [('', '---------')] - ) - - def test_with_some_persons_required(self): - Person.objects.create(name="Lionel Messi") - Person.objects.create(name="Xavi Hernandez") - serializer = self.related_fields_serializer() - self.assertEqual(serializer.fields['assigned'].queryset.count(), 2) - self.assertEqual( - [x for x in serializer.fields['assigned'].widget.choices], - [(1, 'Person object - 1'), (2, 'Person object - 2')] - ) - - def test_with_some_persons_not_required(self): - Person.objects.create(name="Lionel Messi") - Person.objects.create(name="Xavi Hernandez") - serializer = self.related_fields_serializer() - self.assertEqual(serializer.fields['reviewer'].queryset.count(), 2) - self.assertEqual( - [x for x in serializer.fields['reviewer'].widget.choices], - [('', '---------'), (1, 'Person object - 1'), (2, 'Person object - 2')] - ) +# def test_nested_traversal_with_none(self): +# """ +# If a component of the dotted.source is None, return None for the field. +# """ +# from tests.models import NullableForeignKeySource +# instance = NullableForeignKeySource.objects.create(name='Source with null FK') + +# class NullableSourceSerializer(serializers.Serializer): +# target_name = serializers.Field(source='target.name') + +# serializer = NullableSourceSerializer(instance=instance) + +# expected = { +# 'target_name': None, +# } + +# self.assertEqual(serializer.data, expected) + + +# class SerializerMethodFieldTests(TestCase): +# def setUp(self): + +# class BoopSerializer(serializers.Serializer): +# beep = serializers.SerializerMethodField('get_beep') +# boop = serializers.Field() +# boop_count = serializers.SerializerMethodField('get_boop_count') + +# def get_beep(self, obj): +# return 'hello!' + +# def get_boop_count(self, obj): +# return len(obj.boop) + +# self.serializer_class = BoopSerializer + +# def test_serializer_method_field(self): + +# class MyModel(object): +# boop = ['a', 'b', 'c'] + +# source_data = MyModel() + +# serializer = self.serializer_class(source_data) + +# expected = { +# 'beep': 'hello!', +# 'boop': ['a', 'b', 'c'], +# 'boop_count': 3, +# } + +# self.assertEqual(serializer.data, expected) + + +# # Test for issue #324 +# class BlankFieldTests(TestCase): +# def setUp(self): + +# class BlankFieldModelSerializer(serializers.ModelSerializer): +# class Meta: +# model = BlankFieldModel + +# class BlankFieldSerializer(serializers.Serializer): +# title = serializers.CharField(required=False) + +# class NotBlankFieldModelSerializer(serializers.ModelSerializer): +# class Meta: +# model = BasicModel + +# class NotBlankFieldSerializer(serializers.Serializer): +# title = serializers.CharField() + +# self.model_serializer_class = BlankFieldModelSerializer +# self.serializer_class = BlankFieldSerializer +# self.not_blank_model_serializer_class = NotBlankFieldModelSerializer +# self.not_blank_serializer_class = NotBlankFieldSerializer +# self.data = {'title': ''} + +# def test_create_blank_field(self): +# serializer = self.serializer_class(data=self.data) +# self.assertEqual(serializer.is_valid(), True) + +# def test_create_model_blank_field(self): +# serializer = self.model_serializer_class(data=self.data) +# self.assertEqual(serializer.is_valid(), True) + +# def test_create_model_null_field(self): +# serializer = self.model_serializer_class(data={'title': None}) +# self.assertEqual(serializer.is_valid(), True) +# serializer.save() +# self.assertIsNot(serializer.object.pk, None) +# self.assertEqual(serializer.object.title, '') + +# def test_create_not_blank_field(self): +# """ +# Test to ensure blank data in a field not marked as blank=True +# is considered invalid in a non-model serializer +# """ +# serializer = self.not_blank_serializer_class(data=self.data) +# self.assertEqual(serializer.is_valid(), False) + +# def test_create_model_not_blank_field(self): +# """ +# Test to ensure blank data in a field not marked as blank=True +# is considered invalid in a model serializer +# """ +# serializer = self.not_blank_model_serializer_class(data=self.data) +# self.assertEqual(serializer.is_valid(), False) + +# def test_create_model_empty_field(self): +# serializer = self.model_serializer_class(data={}) +# self.assertEqual(serializer.is_valid(), True) + +# def test_create_model_null_field_save(self): +# """ +# Regression test for #1330. + +# https://github.com/tomchristie/django-rest-framework/pull/1330 +# """ +# serializer = self.model_serializer_class(data={'title': None}) +# self.assertEqual(serializer.is_valid(), True) + +# try: +# serializer.save() +# except Exception: +# self.fail('Exception raised on save() after validation passes') + + +# # Test for issue #460 +# class SerializerPickleTests(TestCase): +# """ +# Test pickleability of the output of Serializers +# """ +# def test_pickle_simple_model_serializer_data(self): +# """ +# Test simple serializer +# """ +# pickle.dumps(PersonSerializer(Person(name="Methusela", age=969)).data) + +# def test_pickle_inner_serializer(self): +# """ +# Test pickling a serializer whose resulting .data (a SortedDictWithMetadata) will +# have unpickleable meta data--in order to make sure metadata doesn't get pulled into the pickle. +# See DictWithMetadata.__getstate__ +# """ +# class InnerPersonSerializer(serializers.ModelSerializer): +# class Meta: +# model = Person +# fields = ('name', 'age') +# pickle.dumps(InnerPersonSerializer(Person(name="Noah", age=950)).data, 0) + +# def test_getstate_method_should_not_return_none(self): +# """ +# Regression test for #645. +# """ +# data = serializers.DictWithMetadata({1: 1}) +# self.assertEqual(data.__getstate__(), serializers.SortedDict({1: 1})) + +# def test_serializer_data_is_pickleable(self): +# """ +# Another regression test for #645. +# """ +# data = serializers.SortedDictWithMetadata({1: 1}) +# repr(pickle.loads(pickle.dumps(data, 0))) + + +# # test for issue #725 +# class SeveralChoicesModel(models.Model): +# color = models.CharField( +# max_length=10, +# choices=[('red', 'Red'), ('green', 'Green'), ('blue', 'Blue')], +# blank=False +# ) +# drink = models.CharField( +# max_length=10, +# choices=[('beer', 'Beer'), ('wine', 'Wine'), ('cider', 'Cider')], +# blank=False, +# default='beer' +# ) +# os = models.CharField( +# max_length=10, +# choices=[('linux', 'Linux'), ('osx', 'OSX'), ('windows', 'Windows')], +# blank=True +# ) +# music_genre = models.CharField( +# max_length=10, +# choices=[('rock', 'Rock'), ('metal', 'Metal'), ('grunge', 'Grunge')], +# blank=True, +# default='metal' +# ) + + +# class SerializerChoiceFields(TestCase): + +# def setUp(self): +# super(SerializerChoiceFields, self).setUp() + +# class SeveralChoicesSerializer(serializers.ModelSerializer): +# class Meta: +# model = SeveralChoicesModel +# fields = ('color', 'drink', 'os', 'music_genre') + +# self.several_choices_serializer = SeveralChoicesSerializer + +# def test_choices_blank_false_not_default(self): +# serializer = self.several_choices_serializer() +# self.assertEqual( +# serializer.fields['color'].choices, +# [('red', 'Red'), ('green', 'Green'), ('blue', 'Blue')] +# ) + +# def test_choices_blank_false_with_default(self): +# serializer = self.several_choices_serializer() +# self.assertEqual( +# serializer.fields['drink'].choices, +# [('beer', 'Beer'), ('wine', 'Wine'), ('cider', 'Cider')] +# ) + +# def test_choices_blank_true_not_default(self): +# serializer = self.several_choices_serializer() +# self.assertEqual( +# serializer.fields['os'].choices, +# BLANK_CHOICE_DASH + [('linux', 'Linux'), ('osx', 'OSX'), ('windows', 'Windows')] +# ) + +# def test_choices_blank_true_with_default(self): +# serializer = self.several_choices_serializer() +# self.assertEqual( +# serializer.fields['music_genre'].choices, +# BLANK_CHOICE_DASH + [('rock', 'Rock'), ('metal', 'Metal'), ('grunge', 'Grunge')] +# ) + + +# # Regression tests for #675 +# class Ticket(models.Model): +# assigned = models.ForeignKey( +# Person, related_name='assigned_tickets') +# reviewer = models.ForeignKey( +# Person, blank=True, null=True, related_name='reviewed_tickets') + + +# class SerializerRelatedChoicesTest(TestCase): + +# def setUp(self): +# super(SerializerRelatedChoicesTest, self).setUp() + +# class RelatedChoicesSerializer(serializers.ModelSerializer): +# class Meta: +# model = Ticket +# fields = ('assigned', 'reviewer') + +# self.related_fields_serializer = RelatedChoicesSerializer + +# def test_empty_queryset_required(self): +# serializer = self.related_fields_serializer() +# self.assertEqual(serializer.fields['assigned'].queryset.count(), 0) +# self.assertEqual( +# [x for x in serializer.fields['assigned'].widget.choices], +# [] +# ) + +# def test_empty_queryset_not_required(self): +# serializer = self.related_fields_serializer() +# self.assertEqual(serializer.fields['reviewer'].queryset.count(), 0) +# self.assertEqual( +# [x for x in serializer.fields['reviewer'].widget.choices], +# [('', '---------')] +# ) + +# def test_with_some_persons_required(self): +# Person.objects.create(name="Lionel Messi") +# Person.objects.create(name="Xavi Hernandez") +# serializer = self.related_fields_serializer() +# self.assertEqual(serializer.fields['assigned'].queryset.count(), 2) +# self.assertEqual( +# [x for x in serializer.fields['assigned'].widget.choices], +# [(1, 'Person object - 1'), (2, 'Person object - 2')] +# ) + +# def test_with_some_persons_not_required(self): +# Person.objects.create(name="Lionel Messi") +# Person.objects.create(name="Xavi Hernandez") +# serializer = self.related_fields_serializer() +# self.assertEqual(serializer.fields['reviewer'].queryset.count(), 2) +# self.assertEqual( +# [x for x in serializer.fields['reviewer'].widget.choices], +# [('', '---------'), (1, 'Person object - 1'), (2, 'Person object - 2')] +# ) -class DepthTest(TestCase): - def test_implicit_nesting(self): - - writer = Person.objects.create(name="django", age=1) - post = BlogPost.objects.create(title="Test blog post", writer=writer) - comment = BlogPostComment.objects.create(text="Test blog post comment", blog_post=post) - - class BlogPostCommentSerializer(serializers.ModelSerializer): - class Meta: - model = BlogPostComment - depth = 2 - - serializer = BlogPostCommentSerializer(instance=comment) - expected = {'id': 1, 'text': 'Test blog post comment', 'blog_post': {'id': 1, 'title': 'Test blog post', - 'writer': {'id': 1, 'name': 'django', 'age': 1}}} - - self.assertEqual(serializer.data, expected) - - def test_explicit_nesting(self): - writer = Person.objects.create(name="django", age=1) - post = BlogPost.objects.create(title="Test blog post", writer=writer) - comment = BlogPostComment.objects.create(text="Test blog post comment", blog_post=post) - - class PersonSerializer(serializers.ModelSerializer): - class Meta: - model = Person - - class BlogPostSerializer(serializers.ModelSerializer): - writer = PersonSerializer() - - class Meta: - model = BlogPost - - class BlogPostCommentSerializer(serializers.ModelSerializer): - blog_post = BlogPostSerializer() - - class Meta: - model = BlogPostComment +# class DepthTest(TestCase): +# def test_implicit_nesting(self): + +# writer = Person.objects.create(name="django", age=1) +# post = BlogPost.objects.create(title="Test blog post", writer=writer) +# comment = BlogPostComment.objects.create(text="Test blog post comment", blog_post=post) + +# class BlogPostCommentSerializer(serializers.ModelSerializer): +# class Meta: +# model = BlogPostComment +# depth = 2 + +# serializer = BlogPostCommentSerializer(instance=comment) +# expected = {'id': 1, 'text': 'Test blog post comment', 'blog_post': {'id': 1, 'title': 'Test blog post', +# 'writer': {'id': 1, 'name': 'django', 'age': 1}}} + +# self.assertEqual(serializer.data, expected) + +# def test_explicit_nesting(self): +# writer = Person.objects.create(name="django", age=1) +# post = BlogPost.objects.create(title="Test blog post", writer=writer) +# comment = BlogPostComment.objects.create(text="Test blog post comment", blog_post=post) + +# class PersonSerializer(serializers.ModelSerializer): +# class Meta: +# model = Person + +# class BlogPostSerializer(serializers.ModelSerializer): +# writer = PersonSerializer() + +# class Meta: +# model = BlogPost + +# class BlogPostCommentSerializer(serializers.ModelSerializer): +# blog_post = BlogPostSerializer() + +# class Meta: +# model = BlogPostComment - serializer = BlogPostCommentSerializer(instance=comment) - expected = {'id': 1, 'text': 'Test blog post comment', 'blog_post': {'id': 1, 'title': 'Test blog post', - 'writer': {'id': 1, 'name': 'django', 'age': 1}}} +# serializer = BlogPostCommentSerializer(instance=comment) +# expected = {'id': 1, 'text': 'Test blog post comment', 'blog_post': {'id': 1, 'title': 'Test blog post', +# 'writer': {'id': 1, 'name': 'django', 'age': 1}}} - self.assertEqual(serializer.data, expected) +# self.assertEqual(serializer.data, expected) -class NestedSerializerContextTests(TestCase): +# class NestedSerializerContextTests(TestCase): - def test_nested_serializer_context(self): - """ - Regression for #497 - - https://github.com/tomchristie/django-rest-framework/issues/497 - """ - class PhotoSerializer(serializers.ModelSerializer): - class Meta: - model = Photo - fields = ("description", "callable") +# def test_nested_serializer_context(self): +# """ +# Regression for #497 + +# https://github.com/tomchristie/django-rest-framework/issues/497 +# """ +# class PhotoSerializer(serializers.ModelSerializer): +# class Meta: +# model = Photo +# fields = ("description", "callable") - callable = serializers.SerializerMethodField('_callable') +# callable = serializers.SerializerMethodField('_callable') - def _callable(self, instance): - if 'context_item' not in self.context: - raise RuntimeError("context isn't getting passed into 2nd level nested serializer") - return "success" - - class AlbumSerializer(serializers.ModelSerializer): - class Meta: - model = Album - fields = ("photo_set", "callable") +# def _callable(self, instance): +# if 'context_item' not in self.context: +# raise RuntimeError("context isn't getting passed into 2nd level nested serializer") +# return "success" + +# class AlbumSerializer(serializers.ModelSerializer): +# class Meta: +# model = Album +# fields = ("photo_set", "callable") - photo_set = PhotoSerializer(source="photo_set", many=True) - callable = serializers.SerializerMethodField("_callable") +# photo_set = PhotoSerializer(source="photo_set", many=True) +# callable = serializers.SerializerMethodField("_callable") - def _callable(self, instance): - if 'context_item' not in self.context: - raise RuntimeError("context isn't getting passed into 1st level nested serializer") - return "success" +# def _callable(self, instance): +# if 'context_item' not in self.context: +# raise RuntimeError("context isn't getting passed into 1st level nested serializer") +# return "success" - class AlbumCollection(object): - albums = None +# class AlbumCollection(object): +# albums = None - class AlbumCollectionSerializer(serializers.Serializer): - albums = AlbumSerializer(source="albums", many=True) +# class AlbumCollectionSerializer(serializers.Serializer): +# albums = AlbumSerializer(source="albums", many=True) - album1 = Album.objects.create(title="album 1") - album2 = Album.objects.create(title="album 2") - Photo.objects.create(description="Bigfoot", album=album1) - Photo.objects.create(description="Unicorn", album=album1) - Photo.objects.create(description="Yeti", album=album2) - Photo.objects.create(description="Sasquatch", album=album2) - album_collection = AlbumCollection() - album_collection.albums = [album1, album2] +# album1 = Album.objects.create(title="album 1") +# album2 = Album.objects.create(title="album 2") +# Photo.objects.create(description="Bigfoot", album=album1) +# Photo.objects.create(description="Unicorn", album=album1) +# Photo.objects.create(description="Yeti", album=album2) +# Photo.objects.create(description="Sasquatch", album=album2) +# album_collection = AlbumCollection() +# album_collection.albums = [album1, album2] - # This will raise RuntimeError if context doesn't get passed correctly to the nested Serializers - AlbumCollectionSerializer(album_collection, context={'context_item': 'album context'}).data +# # This will raise RuntimeError if context doesn't get passed correctly to the nested Serializers +# AlbumCollectionSerializer(album_collection, context={'context_item': 'album context'}).data -class DeserializeListTestCase(TestCase): +# class DeserializeListTestCase(TestCase): - def setUp(self): - self.data = { - 'email': 'nobody@nowhere.com', - 'content': 'This is some test content', - 'created': datetime.datetime(2013, 3, 7), - } +# def setUp(self): +# self.data = { +# 'email': 'nobody@nowhere.com', +# 'content': 'This is some test content', +# 'created': datetime.datetime(2013, 3, 7), +# } - def test_no_errors(self): - data = [self.data.copy() for x in range(0, 3)] - serializer = CommentSerializer(data=data, many=True) - self.assertTrue(serializer.is_valid()) - self.assertTrue(isinstance(serializer.object, list)) - self.assertTrue( - all((isinstance(item, Comment) for item in serializer.object)) - ) +# def test_no_errors(self): +# data = [self.data.copy() for x in range(0, 3)] +# serializer = CommentSerializer(data=data, many=True) +# self.assertTrue(serializer.is_valid()) +# self.assertTrue(isinstance(serializer.object, list)) +# self.assertTrue( +# all((isinstance(item, Comment) for item in serializer.object)) +# ) - def test_errors_return_as_list(self): - invalid_item = self.data.copy() - invalid_item['email'] = '' - data = [self.data.copy(), invalid_item, self.data.copy()] +# def test_errors_return_as_list(self): +# invalid_item = self.data.copy() +# invalid_item['email'] = '' +# data = [self.data.copy(), invalid_item, self.data.copy()] - serializer = CommentSerializer(data=data, many=True) - self.assertFalse(serializer.is_valid()) - expected = [{}, {'email': ['This field is required.']}, {}] - self.assertEqual(serializer.errors, expected) +# serializer = CommentSerializer(data=data, many=True) +# self.assertFalse(serializer.is_valid()) +# expected = [{}, {'email': ['This field is required.']}, {}] +# self.assertEqual(serializer.errors, expected) -# Test for issue 747 +# # Test for issue 747 -class LazyStringModel(object): - def __init__(self, lazystring): - self.lazystring = lazystring +# class LazyStringModel(object): +# def __init__(self, lazystring): +# self.lazystring = lazystring -class LazyStringSerializer(serializers.Serializer): - lazystring = serializers.Field() - - def restore_object(self, attrs, instance=None): - if instance is not None: - instance.lazystring = attrs.get('lazystring', instance.lazystring) - return instance - return LazyStringModel(**attrs) - - -class LazyStringsTestCase(TestCase): - def setUp(self): - self.model = LazyStringModel(lazystring=_('lazystring')) - - def test_lazy_strings_are_translated(self): - serializer = LazyStringSerializer(self.model) - self.assertEqual(type(serializer.data['lazystring']), - type('lazystring')) - - -# Test for issue #467 - -class FieldLabelTest(TestCase): - def setUp(self): - self.serializer_class = BasicModelSerializer - - def test_label_from_model(self): - """ - Validates that label and help_text are correctly copied from the model class. - """ - serializer = self.serializer_class() - text_field = serializer.fields['text'] - - self.assertEqual('Text comes here', text_field.label) - self.assertEqual('Text description.', text_field.help_text) - - def test_field_ctor(self): - """ - This is check that ctor supports both label and help_text. - """ - self.assertEqual('Label', fields.Field(label='Label', help_text='Help').label) - self.assertEqual('Help', fields.CharField(label='Label', help_text='Help').help_text) - self.assertEqual('Label', relations.HyperlinkedRelatedField(view_name='fake', label='Label', help_text='Help', many=True).label) - - -# Test for issue #961 - -class ManyFieldHelpTextTest(TestCase): - def test_help_text_no_hold_down_control_msg(self): - """ - Validate that help_text doesn't contain the 'Hold down "Control" ...' - message that Django appends to choice fields. - """ - rel_field = fields.Field(help_text=ManyToManyModel._meta.get_field('rel').help_text) - self.assertEqual('Some help text.', rel_field.help_text) - - -class AttributeMappingOnAutogeneratedRelatedFields(TestCase): - - def test_primary_key_related_field(self): - serializer = ForeignKeySourceSerializer() - self.assertEqual(serializer.fields['target'].help_text, 'Target') - self.assertEqual(serializer.fields['target'].label, 'Target') - - def test_hyperlinked_related_field(self): - serializer = HyperlinkedForeignKeySourceSerializer() - self.assertEqual(serializer.fields['target'].help_text, 'Target') - self.assertEqual(serializer.fields['target'].label, 'Target') - - -@unittest.skipUnless(PIL is not None, 'PIL is not installed') -class AttributeMappingOnAutogeneratedFieldsTests(TestCase): - - def setUp(self): - - class AMOAFSerializer(serializers.ModelSerializer): - class Meta: - model = AMOAFModel - - self.serializer_class = AMOAFSerializer - self.fields_attributes = { - 'char_field': [ - ('max_length', 1024), - ], - 'comma_separated_integer_field': [ - ('max_length', 1024), - ], - 'decimal_field': [ - ('max_digits', 64), - ('decimal_places', 32), - ], - 'email_field': [ - ('max_length', 1024), - ], - 'file_field': [ - ('max_length', 1024), - ], - 'image_field': [ - ('max_length', 1024), - ], - 'slug_field': [ - ('max_length', 1024), - ], - 'url_field': [ - ('max_length', 1024), - ], - 'nullable_char_field': [ - ('max_length', 1024), - ('allow_none', True), - ], - } - - def field_test(self, field): - serializer = self.serializer_class(data={}) - self.assertEqual(serializer.is_valid(), True) - - for attribute in self.fields_attributes[field]: - self.assertEqual( - getattr(serializer.fields[field], attribute[0]), - attribute[1] - ) - - def test_char_field(self): - self.field_test('char_field') - - def test_comma_separated_integer_field(self): - self.field_test('comma_separated_integer_field') - - def test_decimal_field(self): - self.field_test('decimal_field') - - def test_email_field(self): - self.field_test('email_field') - - def test_file_field(self): - self.field_test('file_field') - - def test_image_field(self): - self.field_test('image_field') - - def test_slug_field(self): - self.field_test('slug_field') - - def test_url_field(self): - self.field_test('url_field') - - def test_nullable_char_field(self): - self.field_test('nullable_char_field') - - -@unittest.skipUnless(PIL is not None, 'PIL is not installed') -class DefaultValuesOnAutogeneratedFieldsTests(TestCase): - - def setUp(self): - - class DVOAFSerializer(serializers.ModelSerializer): - class Meta: - model = DVOAFModel - - self.serializer_class = DVOAFSerializer - self.fields_attributes = { - 'positive_integer_field': [ - ('min_value', 0), - ], - 'positive_small_integer_field': [ - ('min_value', 0), - ], - 'email_field': [ - ('max_length', 75), - ], - 'file_field': [ - ('max_length', 100), - ], - 'image_field': [ - ('max_length', 100), - ], - 'slug_field': [ - ('max_length', 50), - ], - 'url_field': [ - ('max_length', 200), - ], - } - - def field_test(self, field): - serializer = self.serializer_class(data={}) - self.assertEqual(serializer.is_valid(), True) - - for attribute in self.fields_attributes[field]: - self.assertEqual( - getattr(serializer.fields[field], attribute[0]), - attribute[1] - ) +# class LazyStringSerializer(serializers.Serializer): +# lazystring = serializers.Field() + +# def restore_object(self, attrs, instance=None): +# if instance is not None: +# instance.lazystring = attrs.get('lazystring', instance.lazystring) +# return instance +# return LazyStringModel(**attrs) + + +# class LazyStringsTestCase(TestCase): +# def setUp(self): +# self.model = LazyStringModel(lazystring=_('lazystring')) + +# def test_lazy_strings_are_translated(self): +# serializer = LazyStringSerializer(self.model) +# self.assertEqual(type(serializer.data['lazystring']), +# type('lazystring')) + + +# # Test for issue #467 + +# class FieldLabelTest(TestCase): +# def setUp(self): +# self.serializer_class = BasicModelSerializer + +# def test_label_from_model(self): +# """ +# Validates that label and help_text are correctly copied from the model class. +# """ +# serializer = self.serializer_class() +# text_field = serializer.fields['text'] + +# self.assertEqual('Text comes here', text_field.label) +# self.assertEqual('Text description.', text_field.help_text) + +# def test_field_ctor(self): +# """ +# This is check that ctor supports both label and help_text. +# """ +# self.assertEqual('Label', fields.Field(label='Label', help_text='Help').label) +# self.assertEqual('Help', fields.CharField(label='Label', help_text='Help').help_text) +# self.assertEqual('Label', relations.HyperlinkedRelatedField(view_name='fake', label='Label', help_text='Help', many=True).label) + + +# # Test for issue #961 + +# class ManyFieldHelpTextTest(TestCase): +# def test_help_text_no_hold_down_control_msg(self): +# """ +# Validate that help_text doesn't contain the 'Hold down "Control" ...' +# message that Django appends to choice fields. +# """ +# rel_field = fields.Field(help_text=ManyToManyModel._meta.get_field('rel').help_text) +# self.assertEqual('Some help text.', rel_field.help_text) + + +# class AttributeMappingOnAutogeneratedRelatedFields(TestCase): + +# def test_primary_key_related_field(self): +# serializer = ForeignKeySourceSerializer() +# self.assertEqual(serializer.fields['target'].help_text, 'Target') +# self.assertEqual(serializer.fields['target'].label, 'Target') + +# def test_hyperlinked_related_field(self): +# serializer = HyperlinkedForeignKeySourceSerializer() +# self.assertEqual(serializer.fields['target'].help_text, 'Target') +# self.assertEqual(serializer.fields['target'].label, 'Target') + + +# @unittest.skipUnless(PIL is not None, 'PIL is not installed') +# class AttributeMappingOnAutogeneratedFieldsTests(TestCase): + +# def setUp(self): + +# class AMOAFSerializer(serializers.ModelSerializer): +# class Meta: +# model = AMOAFModel + +# self.serializer_class = AMOAFSerializer +# self.fields_attributes = { +# 'char_field': [ +# ('max_length', 1024), +# ], +# 'comma_separated_integer_field': [ +# ('max_length', 1024), +# ], +# 'decimal_field': [ +# ('max_digits', 64), +# ('decimal_places', 32), +# ], +# 'email_field': [ +# ('max_length', 1024), +# ], +# 'file_field': [ +# ('max_length', 1024), +# ], +# 'image_field': [ +# ('max_length', 1024), +# ], +# 'slug_field': [ +# ('max_length', 1024), +# ], +# 'url_field': [ +# ('max_length', 1024), +# ], +# 'nullable_char_field': [ +# ('max_length', 1024), +# ('allow_none', True), +# ], +# } + +# def field_test(self, field): +# serializer = self.serializer_class(data={}) +# self.assertEqual(serializer.is_valid(), True) + +# for attribute in self.fields_attributes[field]: +# self.assertEqual( +# getattr(serializer.fields[field], attribute[0]), +# attribute[1] +# ) + +# def test_char_field(self): +# self.field_test('char_field') + +# def test_comma_separated_integer_field(self): +# self.field_test('comma_separated_integer_field') + +# def test_decimal_field(self): +# self.field_test('decimal_field') + +# def test_email_field(self): +# self.field_test('email_field') + +# def test_file_field(self): +# self.field_test('file_field') + +# def test_image_field(self): +# self.field_test('image_field') + +# def test_slug_field(self): +# self.field_test('slug_field') + +# def test_url_field(self): +# self.field_test('url_field') + +# def test_nullable_char_field(self): +# self.field_test('nullable_char_field') + + +# @unittest.skipUnless(PIL is not None, 'PIL is not installed') +# class DefaultValuesOnAutogeneratedFieldsTests(TestCase): + +# def setUp(self): + +# class DVOAFSerializer(serializers.ModelSerializer): +# class Meta: +# model = DVOAFModel + +# self.serializer_class = DVOAFSerializer +# self.fields_attributes = { +# 'positive_integer_field': [ +# ('min_value', 0), +# ], +# 'positive_small_integer_field': [ +# ('min_value', 0), +# ], +# 'email_field': [ +# ('max_length', 75), +# ], +# 'file_field': [ +# ('max_length', 100), +# ], +# 'image_field': [ +# ('max_length', 100), +# ], +# 'slug_field': [ +# ('max_length', 50), +# ], +# 'url_field': [ +# ('max_length', 200), +# ], +# } + +# def field_test(self, field): +# serializer = self.serializer_class(data={}) +# self.assertEqual(serializer.is_valid(), True) + +# for attribute in self.fields_attributes[field]: +# self.assertEqual( +# getattr(serializer.fields[field], attribute[0]), +# attribute[1] +# ) - def test_positive_integer_field(self): - self.field_test('positive_integer_field') +# def test_positive_integer_field(self): +# self.field_test('positive_integer_field') - def test_positive_small_integer_field(self): - self.field_test('positive_small_integer_field') +# def test_positive_small_integer_field(self): +# self.field_test('positive_small_integer_field') - def test_email_field(self): - self.field_test('email_field') +# def test_email_field(self): +# self.field_test('email_field') - def test_file_field(self): - self.field_test('file_field') +# def test_file_field(self): +# self.field_test('file_field') - def test_image_field(self): - self.field_test('image_field') +# def test_image_field(self): +# self.field_test('image_field') - def test_slug_field(self): - self.field_test('slug_field') +# def test_slug_field(self): +# self.field_test('slug_field') - def test_url_field(self): - self.field_test('url_field') +# def test_url_field(self): +# self.field_test('url_field') -class MetadataSerializer(serializers.Serializer): - field1 = serializers.CharField(3, required=True) - field2 = serializers.CharField(10, required=False) +# class MetadataSerializer(serializers.Serializer): +# field1 = serializers.CharField(max_length=3, required=True) +# field2 = serializers.CharField(max_length=10, required=False) -class MetadataSerializerTestCase(TestCase): - def setUp(self): - self.serializer = MetadataSerializer() +# class MetadataSerializerTestCase(TestCase): +# def setUp(self): +# self.serializer = MetadataSerializer() - def test_serializer_metadata(self): - metadata = self.serializer.metadata() - expected = { - 'field1': { - 'required': True, - 'max_length': 3, - 'type': 'string', - 'read_only': False - }, - 'field2': { - 'required': False, - 'max_length': 10, - 'type': 'string', - 'read_only': False - } - } - self.assertEqual(expected, metadata) +# def test_serializer_metadata(self): +# metadata = self.serializer.metadata() +# expected = { +# 'field1': { +# 'required': True, +# 'max_length': 3, +# 'type': 'string', +# 'read_only': False +# }, +# 'field2': { +# 'required': False, +# 'max_length': 10, +# 'type': 'string', +# 'read_only': False +# } +# } +# self.assertEqual(expected, metadata) -# Regression test for #840 +# # Regression test for #840 -class SimpleModel(models.Model): - text = models.CharField(max_length=100) +# class SimpleModel(models.Model): +# text = models.CharField(max_length=100) - -class SimpleModelSerializer(serializers.ModelSerializer): - text = serializers.CharField() - other = serializers.CharField() - - class Meta: - model = SimpleModel - - def validate_other(self, attrs, source): - del attrs['other'] - return attrs + +# class SimpleModelSerializer(serializers.ModelSerializer): +# text = serializers.CharField() +# other = serializers.CharField() + +# class Meta: +# model = SimpleModel + +# def validate_other(self, attrs, source): +# del attrs['other'] +# return attrs -class FieldValidationRemovingAttr(TestCase): - def test_removing_non_model_field_in_validation(self): - """ - Removing an attr during field valiation should ensure that it is not - passed through when restoring the object. +# class FieldValidationRemovingAttr(TestCase): +# def test_removing_non_model_field_in_validation(self): +# """ +# Removing an attr during field valiation should ensure that it is not +# passed through when restoring the object. - This allows additional non-model fields to be supported. +# This allows additional non-model fields to be supported. - Regression test for #840. - """ - serializer = SimpleModelSerializer(data={'text': 'foo', 'other': 'bar'}) - self.assertTrue(serializer.is_valid()) - serializer.save() - self.assertEqual(serializer.object.text, 'foo') +# Regression test for #840. +# """ +# serializer = SimpleModelSerializer(data={'text': 'foo', 'other': 'bar'}) +# self.assertTrue(serializer.is_valid()) +# serializer.save() +# self.assertEqual(serializer.object.text, 'foo') -# Regression test for #878 +# # Regression test for #878 -class SimpleTargetModel(models.Model): - text = models.CharField(max_length=100) +# class SimpleTargetModel(models.Model): +# text = models.CharField(max_length=100) -class SimplePKSourceModelSerializer(serializers.Serializer): - targets = serializers.PrimaryKeyRelatedField(queryset=SimpleTargetModel.objects.all(), many=True) - text = serializers.CharField() +# class SimplePKSourceModelSerializer(serializers.Serializer): +# targets = serializers.PrimaryKeyRelatedField(queryset=SimpleTargetModel.objects.all(), many=True) +# text = serializers.CharField() -class SimpleSlugSourceModelSerializer(serializers.Serializer): - targets = serializers.SlugRelatedField(queryset=SimpleTargetModel.objects.all(), many=True, slug_field='pk') - text = serializers.CharField() +# class SimpleSlugSourceModelSerializer(serializers.Serializer): +# targets = serializers.SlugRelatedField(queryset=SimpleTargetModel.objects.all(), many=True, slug_field='pk') +# text = serializers.CharField() -class SerializerSupportsManyRelationships(TestCase): - def setUp(self): - SimpleTargetModel.objects.create(text='foo') - SimpleTargetModel.objects.create(text='bar') +# class SerializerSupportsManyRelationships(TestCase): +# def setUp(self): +# SimpleTargetModel.objects.create(text='foo') +# SimpleTargetModel.objects.create(text='bar') - def test_serializer_supports_pk_many_relationships(self): - """ - Regression test for #878. +# def test_serializer_supports_pk_many_relationships(self): +# """ +# Regression test for #878. - Note that pk behavior has a different code path to usual cases, - for performance reasons. - """ - serializer = SimplePKSourceModelSerializer(data={'text': 'foo', 'targets': [1, 2]}) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, {'text': 'foo', 'targets': [1, 2]}) +# Note that pk behavior has a different code path to usual cases, +# for performance reasons. +# """ +# serializer = SimplePKSourceModelSerializer(data={'text': 'foo', 'targets': [1, 2]}) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, {'text': 'foo', 'targets': [1, 2]}) - def test_serializer_supports_slug_many_relationships(self): - """ - Regression test for #878. - """ - serializer = SimpleSlugSourceModelSerializer(data={'text': 'foo', 'targets': [1, 2]}) - self.assertTrue(serializer.is_valid()) - self.assertEqual(serializer.data, {'text': 'foo', 'targets': [1, 2]}) +# def test_serializer_supports_slug_many_relationships(self): +# """ +# Regression test for #878. +# """ +# serializer = SimpleSlugSourceModelSerializer(data={'text': 'foo', 'targets': [1, 2]}) +# self.assertTrue(serializer.is_valid()) +# self.assertEqual(serializer.data, {'text': 'foo', 'targets': [1, 2]}) -class TransformMethodsSerializer(serializers.Serializer): - a = serializers.CharField() - b_renamed = serializers.CharField(source='b') - - def transform_a(self, obj, value): - return value.lower() - - def transform_b_renamed(self, obj, value): - if value is not None: - return 'and ' + value +# class TransformMethodsSerializer(serializers.Serializer): +# a = serializers.CharField() +# b_renamed = serializers.CharField(source='b') + +# def transform_a(self, obj, value): +# return value.lower() + +# def transform_b_renamed(self, obj, value): +# if value is not None: +# return 'and ' + value -class TestSerializerTransformMethods(TestCase): - def setUp(self): - self.s = TransformMethodsSerializer() +# class TestSerializerTransformMethods(TestCase): +# def setUp(self): +# self.s = TransformMethodsSerializer() - def test_transform_methods(self): - self.assertEqual( - self.s.to_native({'a': 'GREEN EGGS', 'b': 'HAM'}), - { - 'a': 'green eggs', - 'b_renamed': 'and HAM', - } - ) +# def test_transform_methods(self): +# self.assertEqual( +# self.s.to_native({'a': 'GREEN EGGS', 'b': 'HAM'}), +# { +# 'a': 'green eggs', +# 'b_renamed': 'and HAM', +# } +# ) - def test_missing_fields(self): - self.assertEqual( - self.s.to_native({'a': 'GREEN EGGS'}), - { - 'a': 'green eggs', - 'b_renamed': None, - } - ) +# def test_missing_fields(self): +# self.assertEqual( +# self.s.to_native({'a': 'GREEN EGGS'}), +# { +# 'a': 'green eggs', +# 'b_renamed': None, +# } +# ) -class DefaultTrueBooleanModel(models.Model): - cat = models.BooleanField(default=True) - dog = models.BooleanField(default=False) +# class DefaultTrueBooleanModel(models.Model): +# cat = models.BooleanField(default=True) +# dog = models.BooleanField(default=False) -class SerializerDefaultTrueBoolean(TestCase): +# class SerializerDefaultTrueBoolean(TestCase): - def setUp(self): - super(SerializerDefaultTrueBoolean, self).setUp() - - class DefaultTrueBooleanSerializer(serializers.ModelSerializer): - class Meta: - model = DefaultTrueBooleanModel - fields = ('cat', 'dog') - - self.default_true_boolean_serializer = DefaultTrueBooleanSerializer - - def test_enabled_as_false(self): - serializer = self.default_true_boolean_serializer(data={'cat': False, - 'dog': False}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.data['cat'], False) - self.assertEqual(serializer.data['dog'], False) +# def setUp(self): +# super(SerializerDefaultTrueBoolean, self).setUp() + +# class DefaultTrueBooleanSerializer(serializers.ModelSerializer): +# class Meta: +# model = DefaultTrueBooleanModel +# fields = ('cat', 'dog') + +# self.default_true_boolean_serializer = DefaultTrueBooleanSerializer + +# def test_enabled_as_false(self): +# serializer = self.default_true_boolean_serializer(data={'cat': False, +# 'dog': False}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.data['cat'], False) +# self.assertEqual(serializer.data['dog'], False) - def test_enabled_as_true(self): - serializer = self.default_true_boolean_serializer(data={'cat': True, - 'dog': True}) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.data['cat'], True) - self.assertEqual(serializer.data['dog'], True) - - def test_enabled_partial(self): - serializer = self.default_true_boolean_serializer(data={'cat': False}, - partial=True) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.data['cat'], False) - self.assertEqual(serializer.data['dog'], False) - - -class BoolenFieldTypeTest(TestCase): - ''' - Ensure the various Boolean based model fields are rendered as the proper - field type - - ''' - - def setUp(self): - ''' - Setup an ActionItemSerializer for BooleanTesting - ''' - data = { - 'title': 'b' * 201, - } - self.serializer = ActionItemSerializer(data=data) - - def test_booleanfield_type(self): - ''' - Test that BooleanField is infered from models.BooleanField - ''' - bfield = self.serializer.get_fields()['done'] - self.assertEqual(type(bfield), fields.BooleanField) - - def test_nullbooleanfield_type(self): - ''' - Test that BooleanField is infered from models.NullBooleanField - - https://groups.google.com/forum/#!topic/django-rest-framework/D9mXEftpuQ8 - ''' - bfield = self.serializer.get_fields()['started'] - self.assertEqual(type(bfield), fields.BooleanField) +# def test_enabled_as_true(self): +# serializer = self.default_true_boolean_serializer(data={'cat': True, +# 'dog': True}) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.data['cat'], True) +# self.assertEqual(serializer.data['dog'], True) + +# def test_enabled_partial(self): +# serializer = self.default_true_boolean_serializer(data={'cat': False}, +# partial=True) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.data['cat'], False) +# self.assertEqual(serializer.data['dog'], False) + + +# class BoolenFieldTypeTest(TestCase): +# ''' +# Ensure the various Boolean based model fields are rendered as the proper +# field type + +# ''' + +# def setUp(self): +# ''' +# Setup an ActionItemSerializer for BooleanTesting +# ''' +# data = { +# 'title': 'b' * 201, +# } +# self.serializer = ActionItemSerializer(data=data) + +# def test_booleanfield_type(self): +# ''' +# Test that BooleanField is infered from models.BooleanField +# ''' +# bfield = self.serializer.get_fields()['done'] +# self.assertEqual(type(bfield), fields.BooleanField) + +# def test_nullbooleanfield_type(self): +# ''' +# Test that BooleanField is infered from models.NullBooleanField + +# https://groups.google.com/forum/#!topic/django-rest-framework/D9mXEftpuQ8 +# ''' +# bfield = self.serializer.get_fields()['started'] +# self.assertEqual(type(bfield), fields.BooleanField) diff --git a/tests/test_serializer_bulk_update.py b/tests/test_serializer_bulk_update.py index 67a8ed0d..3341ce59 100644 --- a/tests/test_serializer_bulk_update.py +++ b/tests/test_serializer_bulk_update.py @@ -1,278 +1,278 @@ -""" -Tests to cover bulk create and update using serializers. -""" -from __future__ import unicode_literals -from django.test import TestCase -from rest_framework import serializers - - -class BulkCreateSerializerTests(TestCase): - """ - Creating multiple instances using serializers. - """ - - def setUp(self): - class BookSerializer(serializers.Serializer): - id = serializers.IntegerField() - title = serializers.CharField(max_length=100) - author = serializers.CharField(max_length=100) - - self.BookSerializer = BookSerializer - - def test_bulk_create_success(self): - """ - Correct bulk update serialization should return the input data. - """ - - data = [ - { - 'id': 0, - 'title': 'The electric kool-aid acid test', - 'author': 'Tom Wolfe' - }, { - 'id': 1, - 'title': 'If this is a man', - 'author': 'Primo Levi' - }, { - 'id': 2, - 'title': 'The wind-up bird chronicle', - 'author': 'Haruki Murakami' - } - ] - - serializer = self.BookSerializer(data=data, many=True) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, data) - - def test_bulk_create_errors(self): - """ - Correct bulk update serialization should return the input data. - """ - - data = [ - { - 'id': 0, - 'title': 'The electric kool-aid acid test', - 'author': 'Tom Wolfe' - }, { - 'id': 1, - 'title': 'If this is a man', - 'author': 'Primo Levi' - }, { - 'id': 'foo', - 'title': 'The wind-up bird chronicle', - 'author': 'Haruki Murakami' - } - ] - expected_errors = [ - {}, - {}, - {'id': ['Enter a whole number.']} - ] - - serializer = self.BookSerializer(data=data, many=True) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, expected_errors) - - def test_invalid_list_datatype(self): - """ - Data containing list of incorrect data type should return errors. - """ - data = ['foo', 'bar', 'baz'] - serializer = self.BookSerializer(data=data, many=True) - self.assertEqual(serializer.is_valid(), False) - - expected_errors = [ - {'non_field_errors': ['Invalid data']}, - {'non_field_errors': ['Invalid data']}, - {'non_field_errors': ['Invalid data']} - ] - - self.assertEqual(serializer.errors, expected_errors) - - def test_invalid_single_datatype(self): - """ - Data containing a single incorrect data type should return errors. - """ - data = 123 - serializer = self.BookSerializer(data=data, many=True) - self.assertEqual(serializer.is_valid(), False) - - expected_errors = {'non_field_errors': ['Expected a list of items.']} - - self.assertEqual(serializer.errors, expected_errors) - - def test_invalid_single_object(self): - """ - Data containing only a single object, instead of a list of objects - should return errors. - """ - data = { - 'id': 0, - 'title': 'The electric kool-aid acid test', - 'author': 'Tom Wolfe' - } - serializer = self.BookSerializer(data=data, many=True) - self.assertEqual(serializer.is_valid(), False) - - expected_errors = {'non_field_errors': ['Expected a list of items.']} - - self.assertEqual(serializer.errors, expected_errors) - - -class BulkUpdateSerializerTests(TestCase): - """ - Updating multiple instances using serializers. - """ - - def setUp(self): - class Book(object): - """ - A data type that can be persisted to a mock storage backend - with `.save()` and `.delete()`. - """ - object_map = {} - - def __init__(self, id, title, author): - self.id = id - self.title = title - self.author = author - - def save(self): - Book.object_map[self.id] = self - - def delete(self): - del Book.object_map[self.id] - - class BookSerializer(serializers.Serializer): - id = serializers.IntegerField() - title = serializers.CharField(max_length=100) - author = serializers.CharField(max_length=100) - - def restore_object(self, attrs, instance=None): - if instance: - instance.id = attrs['id'] - instance.title = attrs['title'] - instance.author = attrs['author'] - return instance - return Book(**attrs) - - self.Book = Book - self.BookSerializer = BookSerializer - - data = [ - { - 'id': 0, - 'title': 'The electric kool-aid acid test', - 'author': 'Tom Wolfe' - }, { - 'id': 1, - 'title': 'If this is a man', - 'author': 'Primo Levi' - }, { - 'id': 2, - 'title': 'The wind-up bird chronicle', - 'author': 'Haruki Murakami' - } - ] - - for item in data: - book = Book(item['id'], item['title'], item['author']) - book.save() - - def books(self): - """ - Return all the objects in the mock storage backend. - """ - return self.Book.object_map.values() - - def test_bulk_update_success(self): - """ - Correct bulk update serialization should return the input data. - """ - data = [ - { - 'id': 0, - 'title': 'The electric kool-aid acid test', - 'author': 'Tom Wolfe' - }, { - 'id': 2, - 'title': 'Kafka on the shore', - 'author': 'Haruki Murakami' - } - ] - serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.data, data) - serializer.save() - new_data = self.BookSerializer(self.books(), many=True).data - - self.assertEqual(data, new_data) - - def test_bulk_update_and_create(self): - """ - Bulk update serialization may also include created items. - """ - data = [ - { - 'id': 0, - 'title': 'The electric kool-aid acid test', - 'author': 'Tom Wolfe' - }, { - 'id': 3, - 'title': 'Kafka on the shore', - 'author': 'Haruki Murakami' - } - ] - serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.data, data) - serializer.save() - new_data = self.BookSerializer(self.books(), many=True).data - self.assertEqual(data, new_data) - - def test_bulk_update_invalid_create(self): - """ - Bulk update serialization without allow_add_remove may not create items. - """ - data = [ - { - 'id': 0, - 'title': 'The electric kool-aid acid test', - 'author': 'Tom Wolfe' - }, { - 'id': 3, - 'title': 'Kafka on the shore', - 'author': 'Haruki Murakami' - } - ] - expected_errors = [ - {}, - {'non_field_errors': ['Cannot create a new item, only existing items may be updated.']} - ] - serializer = self.BookSerializer(self.books(), data=data, many=True) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, expected_errors) - - def test_bulk_update_error(self): - """ - Incorrect bulk update serialization should return error data. - """ - data = [ - { - 'id': 0, - 'title': 'The electric kool-aid acid test', - 'author': 'Tom Wolfe' - }, { - 'id': 'foo', - 'title': 'Kafka on the shore', - 'author': 'Haruki Murakami' - } - ] - expected_errors = [ - {}, - {'id': ['Enter a whole number.']} - ] - serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, expected_errors) +# """ +# Tests to cover bulk create and update using serializers. +# """ +# from __future__ import unicode_literals +# from django.test import TestCase +# from rest_framework import serializers + + +# class BulkCreateSerializerTests(TestCase): +# """ +# Creating multiple instances using serializers. +# """ + +# def setUp(self): +# class BookSerializer(serializers.Serializer): +# id = serializers.IntegerField() +# title = serializers.CharField(max_length=100) +# author = serializers.CharField(max_length=100) + +# self.BookSerializer = BookSerializer + +# def test_bulk_create_success(self): +# """ +# Correct bulk update serialization should return the input data. +# """ + +# data = [ +# { +# 'id': 0, +# 'title': 'The electric kool-aid acid test', +# 'author': 'Tom Wolfe' +# }, { +# 'id': 1, +# 'title': 'If this is a man', +# 'author': 'Primo Levi' +# }, { +# 'id': 2, +# 'title': 'The wind-up bird chronicle', +# 'author': 'Haruki Murakami' +# } +# ] + +# serializer = self.BookSerializer(data=data, many=True) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, data) + +# def test_bulk_create_errors(self): +# """ +# Correct bulk update serialization should return the input data. +# """ + +# data = [ +# { +# 'id': 0, +# 'title': 'The electric kool-aid acid test', +# 'author': 'Tom Wolfe' +# }, { +# 'id': 1, +# 'title': 'If this is a man', +# 'author': 'Primo Levi' +# }, { +# 'id': 'foo', +# 'title': 'The wind-up bird chronicle', +# 'author': 'Haruki Murakami' +# } +# ] +# expected_errors = [ +# {}, +# {}, +# {'id': ['Enter a whole number.']} +# ] + +# serializer = self.BookSerializer(data=data, many=True) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, expected_errors) + +# def test_invalid_list_datatype(self): +# """ +# Data containing list of incorrect data type should return errors. +# """ +# data = ['foo', 'bar', 'baz'] +# serializer = self.BookSerializer(data=data, many=True) +# self.assertEqual(serializer.is_valid(), False) + +# expected_errors = [ +# {'non_field_errors': ['Invalid data']}, +# {'non_field_errors': ['Invalid data']}, +# {'non_field_errors': ['Invalid data']} +# ] + +# self.assertEqual(serializer.errors, expected_errors) + +# def test_invalid_single_datatype(self): +# """ +# Data containing a single incorrect data type should return errors. +# """ +# data = 123 +# serializer = self.BookSerializer(data=data, many=True) +# self.assertEqual(serializer.is_valid(), False) + +# expected_errors = {'non_field_errors': ['Expected a list of items.']} + +# self.assertEqual(serializer.errors, expected_errors) + +# def test_invalid_single_object(self): +# """ +# Data containing only a single object, instead of a list of objects +# should return errors. +# """ +# data = { +# 'id': 0, +# 'title': 'The electric kool-aid acid test', +# 'author': 'Tom Wolfe' +# } +# serializer = self.BookSerializer(data=data, many=True) +# self.assertEqual(serializer.is_valid(), False) + +# expected_errors = {'non_field_errors': ['Expected a list of items.']} + +# self.assertEqual(serializer.errors, expected_errors) + + +# class BulkUpdateSerializerTests(TestCase): +# """ +# Updating multiple instances using serializers. +# """ + +# def setUp(self): +# class Book(object): +# """ +# A data type that can be persisted to a mock storage backend +# with `.save()` and `.delete()`. +# """ +# object_map = {} + +# def __init__(self, id, title, author): +# self.id = id +# self.title = title +# self.author = author + +# def save(self): +# Book.object_map[self.id] = self + +# def delete(self): +# del Book.object_map[self.id] + +# class BookSerializer(serializers.Serializer): +# id = serializers.IntegerField() +# title = serializers.CharField(max_length=100) +# author = serializers.CharField(max_length=100) + +# def restore_object(self, attrs, instance=None): +# if instance: +# instance.id = attrs['id'] +# instance.title = attrs['title'] +# instance.author = attrs['author'] +# return instance +# return Book(**attrs) + +# self.Book = Book +# self.BookSerializer = BookSerializer + +# data = [ +# { +# 'id': 0, +# 'title': 'The electric kool-aid acid test', +# 'author': 'Tom Wolfe' +# }, { +# 'id': 1, +# 'title': 'If this is a man', +# 'author': 'Primo Levi' +# }, { +# 'id': 2, +# 'title': 'The wind-up bird chronicle', +# 'author': 'Haruki Murakami' +# } +# ] + +# for item in data: +# book = Book(item['id'], item['title'], item['author']) +# book.save() + +# def books(self): +# """ +# Return all the objects in the mock storage backend. +# """ +# return self.Book.object_map.values() + +# def test_bulk_update_success(self): +# """ +# Correct bulk update serialization should return the input data. +# """ +# data = [ +# { +# 'id': 0, +# 'title': 'The electric kool-aid acid test', +# 'author': 'Tom Wolfe' +# }, { +# 'id': 2, +# 'title': 'Kafka on the shore', +# 'author': 'Haruki Murakami' +# } +# ] +# serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.data, data) +# serializer.save() +# new_data = self.BookSerializer(self.books(), many=True).data + +# self.assertEqual(data, new_data) + +# def test_bulk_update_and_create(self): +# """ +# Bulk update serialization may also include created items. +# """ +# data = [ +# { +# 'id': 0, +# 'title': 'The electric kool-aid acid test', +# 'author': 'Tom Wolfe' +# }, { +# 'id': 3, +# 'title': 'Kafka on the shore', +# 'author': 'Haruki Murakami' +# } +# ] +# serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.data, data) +# serializer.save() +# new_data = self.BookSerializer(self.books(), many=True).data +# self.assertEqual(data, new_data) + +# def test_bulk_update_invalid_create(self): +# """ +# Bulk update serialization without allow_add_remove may not create items. +# """ +# data = [ +# { +# 'id': 0, +# 'title': 'The electric kool-aid acid test', +# 'author': 'Tom Wolfe' +# }, { +# 'id': 3, +# 'title': 'Kafka on the shore', +# 'author': 'Haruki Murakami' +# } +# ] +# expected_errors = [ +# {}, +# {'non_field_errors': ['Cannot create a new item, only existing items may be updated.']} +# ] +# serializer = self.BookSerializer(self.books(), data=data, many=True) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, expected_errors) + +# def test_bulk_update_error(self): +# """ +# Incorrect bulk update serialization should return error data. +# """ +# data = [ +# { +# 'id': 0, +# 'title': 'The electric kool-aid acid test', +# 'author': 'Tom Wolfe' +# }, { +# 'id': 'foo', +# 'title': 'Kafka on the shore', +# 'author': 'Haruki Murakami' +# } +# ] +# expected_errors = [ +# {}, +# {'id': ['Enter a whole number.']} +# ] +# serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, expected_errors) diff --git a/tests/test_serializer_empty.py b/tests/test_serializer_empty.py index 30cff361..805ac7d4 100644 --- a/tests/test_serializer_empty.py +++ b/tests/test_serializer_empty.py @@ -1,15 +1,15 @@ -from django.test import TestCase -from rest_framework import serializers +# from django.test import TestCase +# from rest_framework import serializers -class EmptySerializerTestCase(TestCase): - def test_empty_serializer(self): - class FooBarSerializer(serializers.Serializer): - foo = serializers.IntegerField() - bar = serializers.SerializerMethodField('get_bar') +# class EmptySerializerTestCase(TestCase): +# def test_empty_serializer(self): +# class FooBarSerializer(serializers.Serializer): +# foo = serializers.IntegerField() +# bar = serializers.SerializerMethodField() - def get_bar(self, obj): - return 'bar' +# def get_bar(self, obj): +# return 'bar' - serializer = FooBarSerializer() - self.assertEquals(serializer.data, {'foo': 0}) +# serializer = FooBarSerializer() +# self.assertEquals(serializer.data, {'foo': 0}) diff --git a/tests/test_serializer_import.py b/tests/test_serializer_import.py index 3b8ff4b3..d029c3c5 100644 --- a/tests/test_serializer_import.py +++ b/tests/test_serializer_import.py @@ -1,19 +1,19 @@ -from django.test import TestCase +# from django.test import TestCase -from rest_framework import serializers -from tests.accounts.serializers import AccountSerializer +# from rest_framework import serializers +# from tests.accounts.serializers import AccountSerializer -class ImportingModelSerializerTests(TestCase): - """ - In some situations like, GH #1225, it is possible, especially in - testing, to import a serializer who's related models have not yet - been resolved by Django. `AccountSerializer` is an example of such - a serializer (imported at the top of this file). - """ - def test_import_model_serializer(self): - """ - The serializer at the top of this file should have been - imported successfully, and we should be able to instantiate it. - """ - self.assertIsInstance(AccountSerializer(), serializers.ModelSerializer) +# class ImportingModelSerializerTests(TestCase): +# """ +# In some situations like, GH #1225, it is possible, especially in +# testing, to import a serializer who's related models have not yet +# been resolved by Django. `AccountSerializer` is an example of such +# a serializer (imported at the top of this file). +# """ +# def test_import_model_serializer(self): +# """ +# The serializer at the top of this file should have been +# imported successfully, and we should be able to instantiate it. +# """ +# self.assertIsInstance(AccountSerializer(), serializers.ModelSerializer) diff --git a/tests/test_serializer_nested.py b/tests/test_serializer_nested.py index c09c24db..b0f64ca7 100644 --- a/tests/test_serializer_nested.py +++ b/tests/test_serializer_nested.py @@ -1,349 +1,349 @@ -""" -Tests to cover nested serializers. - -Doesn't cover model serializers. -""" -from __future__ import unicode_literals -from django.test import TestCase -from rest_framework import serializers -from . import models - - -class WritableNestedSerializerBasicTests(TestCase): - """ - Tests for deserializing nested entities. - Basic tests that use serializers that simply restore to dicts. - """ - - def setUp(self): - class TrackSerializer(serializers.Serializer): - order = serializers.IntegerField() - title = serializers.CharField(max_length=100) - duration = serializers.IntegerField() - - class AlbumSerializer(serializers.Serializer): - album_name = serializers.CharField(max_length=100) - artist = serializers.CharField(max_length=100) - tracks = TrackSerializer(many=True) - - self.AlbumSerializer = AlbumSerializer - - def test_nested_validation_success(self): - """ - Correct nested serialization should return the input data. - """ - - data = { - 'album_name': 'Discovery', - 'artist': 'Daft Punk', - 'tracks': [ - {'order': 1, 'title': 'One More Time', 'duration': 235}, - {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, - {'order': 3, 'title': 'Digital Love', 'duration': 239} - ] - } - - serializer = self.AlbumSerializer(data=data) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, data) - - def test_nested_validation_error(self): - """ - Incorrect nested serialization should return appropriate error data. - """ - - data = { - 'album_name': 'Discovery', - 'artist': 'Daft Punk', - 'tracks': [ - {'order': 1, 'title': 'One More Time', 'duration': 235}, - {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, - {'order': 3, 'title': 'Digital Love', 'duration': 'foobar'} - ] - } - expected_errors = { - 'tracks': [ - {}, - {}, - {'duration': ['Enter a whole number.']} - ] - } - - serializer = self.AlbumSerializer(data=data) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, expected_errors) - - def test_many_nested_validation_error(self): - """ - Incorrect nested serialization should return appropriate error data - when multiple entities are being deserialized. - """ - - data = [ - { - 'album_name': 'Russian Red', - 'artist': 'I Love Your Glasses', - 'tracks': [ - {'order': 1, 'title': 'Cigarettes', 'duration': 121}, - {'order': 2, 'title': 'No Past Land', 'duration': 198}, - {'order': 3, 'title': 'They Don\'t Believe', 'duration': 191} - ] - }, - { - 'album_name': 'Discovery', - 'artist': 'Daft Punk', - 'tracks': [ - {'order': 1, 'title': 'One More Time', 'duration': 235}, - {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, - {'order': 3, 'title': 'Digital Love', 'duration': 'foobar'} - ] - } - ] - expected_errors = [ - {}, - { - 'tracks': [ - {}, - {}, - {'duration': ['Enter a whole number.']} - ] - } - ] - - serializer = self.AlbumSerializer(data=data, many=True) - self.assertEqual(serializer.is_valid(), False) - self.assertEqual(serializer.errors, expected_errors) - - -class WritableNestedSerializerObjectTests(TestCase): - """ - Tests for deserializing nested entities. - These tests use serializers that restore to concrete objects. - """ - - def setUp(self): - # Couple of concrete objects that we're going to deserialize into - class Track(object): - def __init__(self, order, title, duration): - self.order, self.title, self.duration = order, title, duration - - def __eq__(self, other): - return ( - self.order == other.order and - self.title == other.title and - self.duration == other.duration - ) - - class Album(object): - def __init__(self, album_name, artist, tracks): - self.album_name, self.artist, self.tracks = album_name, artist, tracks - - def __eq__(self, other): - return ( - self.album_name == other.album_name and - self.artist == other.artist and - self.tracks == other.tracks - ) - - # And their corresponding serializers - class TrackSerializer(serializers.Serializer): - order = serializers.IntegerField() - title = serializers.CharField(max_length=100) - duration = serializers.IntegerField() - - def restore_object(self, attrs, instance=None): - return Track(attrs['order'], attrs['title'], attrs['duration']) - - class AlbumSerializer(serializers.Serializer): - album_name = serializers.CharField(max_length=100) - artist = serializers.CharField(max_length=100) - tracks = TrackSerializer(many=True) - - def restore_object(self, attrs, instance=None): - return Album(attrs['album_name'], attrs['artist'], attrs['tracks']) - - self.Album, self.Track = Album, Track - self.AlbumSerializer = AlbumSerializer - - def test_nested_validation_success(self): - """ - Correct nested serialization should return a restored object - that corresponds to the input data. - """ - - data = { - 'album_name': 'Discovery', - 'artist': 'Daft Punk', - 'tracks': [ - {'order': 1, 'title': 'One More Time', 'duration': 235}, - {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, - {'order': 3, 'title': 'Digital Love', 'duration': 239} - ] - } - expected_object = self.Album( - album_name='Discovery', - artist='Daft Punk', - tracks=[ - self.Track(order=1, title='One More Time', duration=235), - self.Track(order=2, title='Aerodynamic', duration=184), - self.Track(order=3, title='Digital Love', duration=239), - ] - ) - - serializer = self.AlbumSerializer(data=data) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, expected_object) - - def test_many_nested_validation_success(self): - """ - Correct nested serialization should return multiple restored objects - that corresponds to the input data when multiple objects are - being deserialized. - """ - - data = [ - { - 'album_name': 'Russian Red', - 'artist': 'I Love Your Glasses', - 'tracks': [ - {'order': 1, 'title': 'Cigarettes', 'duration': 121}, - {'order': 2, 'title': 'No Past Land', 'duration': 198}, - {'order': 3, 'title': 'They Don\'t Believe', 'duration': 191} - ] - }, - { - 'album_name': 'Discovery', - 'artist': 'Daft Punk', - 'tracks': [ - {'order': 1, 'title': 'One More Time', 'duration': 235}, - {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, - {'order': 3, 'title': 'Digital Love', 'duration': 239} - ] - } - ] - expected_object = [ - self.Album( - album_name='Russian Red', - artist='I Love Your Glasses', - tracks=[ - self.Track(order=1, title='Cigarettes', duration=121), - self.Track(order=2, title='No Past Land', duration=198), - self.Track(order=3, title='They Don\'t Believe', duration=191), - ] - ), - self.Album( - album_name='Discovery', - artist='Daft Punk', - tracks=[ - self.Track(order=1, title='One More Time', duration=235), - self.Track(order=2, title='Aerodynamic', duration=184), - self.Track(order=3, title='Digital Love', duration=239), - ] - ) - ] - - serializer = self.AlbumSerializer(data=data, many=True) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, expected_object) - - -class ForeignKeyNestedSerializerUpdateTests(TestCase): - def setUp(self): - class Artist(object): - def __init__(self, name): - self.name = name - - def __eq__(self, other): - return self.name == other.name - - class Album(object): - def __init__(self, name, artist): - self.name, self.artist = name, artist - - def __eq__(self, other): - return self.name == other.name and self.artist == other.artist - - class ArtistSerializer(serializers.Serializer): - name = serializers.CharField() - - def restore_object(self, attrs, instance=None): - if instance: - instance.name = attrs['name'] - else: - instance = Artist(attrs['name']) - return instance - - class AlbumSerializer(serializers.Serializer): - name = serializers.CharField() - by = ArtistSerializer(source='artist') - - def restore_object(self, attrs, instance=None): - if instance: - instance.name = attrs['name'] - instance.artist = attrs['artist'] - else: - instance = Album(attrs['name'], attrs['artist']) - return instance - - self.Artist = Artist - self.Album = Album - self.AlbumSerializer = AlbumSerializer - - def test_create_via_foreign_key_with_source(self): - """ - Check that we can both *create* and *update* into objects across - ForeignKeys that have a `source` specified. - Regression test for #1170 - """ - data = { - 'name': 'Discovery', - 'by': {'name': 'Daft Punk'}, - } - - expected = self.Album(artist=self.Artist('Daft Punk'), name='Discovery') - - # create - serializer = self.AlbumSerializer(data=data) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, expected) - - # update - original = self.Album(artist=self.Artist('The Bats'), name='Free All the Monsters') - serializer = self.AlbumSerializer(instance=original, data=data) - self.assertEqual(serializer.is_valid(), True) - self.assertEqual(serializer.object, expected) - - -class NestedModelSerializerUpdateTests(TestCase): - def test_second_nested_level(self): - john = models.Person.objects.create(name="john") - - post = john.blogpost_set.create(title="Test blog post") - post.blogpostcomment_set.create(text="I hate this blog post") - post.blogpostcomment_set.create(text="I love this blog post") - - class BlogPostCommentSerializer(serializers.ModelSerializer): - class Meta: - model = models.BlogPostComment - - class BlogPostSerializer(serializers.ModelSerializer): - comments = BlogPostCommentSerializer(many=True, source='blogpostcomment_set') - - class Meta: - model = models.BlogPost - fields = ('id', 'title', 'comments') - - class PersonSerializer(serializers.ModelSerializer): - posts = BlogPostSerializer(many=True, source='blogpost_set') - - class Meta: - model = models.Person - fields = ('id', 'name', 'age', 'posts') - - serialize = PersonSerializer(instance=john) - deserialize = PersonSerializer(data=serialize.data, instance=john) - self.assertTrue(deserialize.is_valid()) - - result = deserialize.object - result.save() - self.assertEqual(result.id, john.id) +# """ +# Tests to cover nested serializers. + +# Doesn't cover model serializers. +# """ +# from __future__ import unicode_literals +# from django.test import TestCase +# from rest_framework import serializers +# from . import models + + +# class WritableNestedSerializerBasicTests(TestCase): +# """ +# Tests for deserializing nested entities. +# Basic tests that use serializers that simply restore to dicts. +# """ + +# def setUp(self): +# class TrackSerializer(serializers.Serializer): +# order = serializers.IntegerField() +# title = serializers.CharField(max_length=100) +# duration = serializers.IntegerField() + +# class AlbumSerializer(serializers.Serializer): +# album_name = serializers.CharField(max_length=100) +# artist = serializers.CharField(max_length=100) +# tracks = TrackSerializer(many=True) + +# self.AlbumSerializer = AlbumSerializer + +# def test_nested_validation_success(self): +# """ +# Correct nested serialization should return the input data. +# """ + +# data = { +# 'album_name': 'Discovery', +# 'artist': 'Daft Punk', +# 'tracks': [ +# {'order': 1, 'title': 'One More Time', 'duration': 235}, +# {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, +# {'order': 3, 'title': 'Digital Love', 'duration': 239} +# ] +# } + +# serializer = self.AlbumSerializer(data=data) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, data) + +# def test_nested_validation_error(self): +# """ +# Incorrect nested serialization should return appropriate error data. +# """ + +# data = { +# 'album_name': 'Discovery', +# 'artist': 'Daft Punk', +# 'tracks': [ +# {'order': 1, 'title': 'One More Time', 'duration': 235}, +# {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, +# {'order': 3, 'title': 'Digital Love', 'duration': 'foobar'} +# ] +# } +# expected_errors = { +# 'tracks': [ +# {}, +# {}, +# {'duration': ['Enter a whole number.']} +# ] +# } + +# serializer = self.AlbumSerializer(data=data) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, expected_errors) + +# def test_many_nested_validation_error(self): +# """ +# Incorrect nested serialization should return appropriate error data +# when multiple entities are being deserialized. +# """ + +# data = [ +# { +# 'album_name': 'Russian Red', +# 'artist': 'I Love Your Glasses', +# 'tracks': [ +# {'order': 1, 'title': 'Cigarettes', 'duration': 121}, +# {'order': 2, 'title': 'No Past Land', 'duration': 198}, +# {'order': 3, 'title': 'They Don\'t Believe', 'duration': 191} +# ] +# }, +# { +# 'album_name': 'Discovery', +# 'artist': 'Daft Punk', +# 'tracks': [ +# {'order': 1, 'title': 'One More Time', 'duration': 235}, +# {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, +# {'order': 3, 'title': 'Digital Love', 'duration': 'foobar'} +# ] +# } +# ] +# expected_errors = [ +# {}, +# { +# 'tracks': [ +# {}, +# {}, +# {'duration': ['Enter a whole number.']} +# ] +# } +# ] + +# serializer = self.AlbumSerializer(data=data, many=True) +# self.assertEqual(serializer.is_valid(), False) +# self.assertEqual(serializer.errors, expected_errors) + + +# class WritableNestedSerializerObjectTests(TestCase): +# """ +# Tests for deserializing nested entities. +# These tests use serializers that restore to concrete objects. +# """ + +# def setUp(self): +# # Couple of concrete objects that we're going to deserialize into +# class Track(object): +# def __init__(self, order, title, duration): +# self.order, self.title, self.duration = order, title, duration + +# def __eq__(self, other): +# return ( +# self.order == other.order and +# self.title == other.title and +# self.duration == other.duration +# ) + +# class Album(object): +# def __init__(self, album_name, artist, tracks): +# self.album_name, self.artist, self.tracks = album_name, artist, tracks + +# def __eq__(self, other): +# return ( +# self.album_name == other.album_name and +# self.artist == other.artist and +# self.tracks == other.tracks +# ) + +# # And their corresponding serializers +# class TrackSerializer(serializers.Serializer): +# order = serializers.IntegerField() +# title = serializers.CharField(max_length=100) +# duration = serializers.IntegerField() + +# def restore_object(self, attrs, instance=None): +# return Track(attrs['order'], attrs['title'], attrs['duration']) + +# class AlbumSerializer(serializers.Serializer): +# album_name = serializers.CharField(max_length=100) +# artist = serializers.CharField(max_length=100) +# tracks = TrackSerializer(many=True) + +# def restore_object(self, attrs, instance=None): +# return Album(attrs['album_name'], attrs['artist'], attrs['tracks']) + +# self.Album, self.Track = Album, Track +# self.AlbumSerializer = AlbumSerializer + +# def test_nested_validation_success(self): +# """ +# Correct nested serialization should return a restored object +# that corresponds to the input data. +# """ + +# data = { +# 'album_name': 'Discovery', +# 'artist': 'Daft Punk', +# 'tracks': [ +# {'order': 1, 'title': 'One More Time', 'duration': 235}, +# {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, +# {'order': 3, 'title': 'Digital Love', 'duration': 239} +# ] +# } +# expected_object = self.Album( +# album_name='Discovery', +# artist='Daft Punk', +# tracks=[ +# self.Track(order=1, title='One More Time', duration=235), +# self.Track(order=2, title='Aerodynamic', duration=184), +# self.Track(order=3, title='Digital Love', duration=239), +# ] +# ) + +# serializer = self.AlbumSerializer(data=data) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, expected_object) + +# def test_many_nested_validation_success(self): +# """ +# Correct nested serialization should return multiple restored objects +# that corresponds to the input data when multiple objects are +# being deserialized. +# """ + +# data = [ +# { +# 'album_name': 'Russian Red', +# 'artist': 'I Love Your Glasses', +# 'tracks': [ +# {'order': 1, 'title': 'Cigarettes', 'duration': 121}, +# {'order': 2, 'title': 'No Past Land', 'duration': 198}, +# {'order': 3, 'title': 'They Don\'t Believe', 'duration': 191} +# ] +# }, +# { +# 'album_name': 'Discovery', +# 'artist': 'Daft Punk', +# 'tracks': [ +# {'order': 1, 'title': 'One More Time', 'duration': 235}, +# {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, +# {'order': 3, 'title': 'Digital Love', 'duration': 239} +# ] +# } +# ] +# expected_object = [ +# self.Album( +# album_name='Russian Red', +# artist='I Love Your Glasses', +# tracks=[ +# self.Track(order=1, title='Cigarettes', duration=121), +# self.Track(order=2, title='No Past Land', duration=198), +# self.Track(order=3, title='They Don\'t Believe', duration=191), +# ] +# ), +# self.Album( +# album_name='Discovery', +# artist='Daft Punk', +# tracks=[ +# self.Track(order=1, title='One More Time', duration=235), +# self.Track(order=2, title='Aerodynamic', duration=184), +# self.Track(order=3, title='Digital Love', duration=239), +# ] +# ) +# ] + +# serializer = self.AlbumSerializer(data=data, many=True) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, expected_object) + + +# class ForeignKeyNestedSerializerUpdateTests(TestCase): +# def setUp(self): +# class Artist(object): +# def __init__(self, name): +# self.name = name + +# def __eq__(self, other): +# return self.name == other.name + +# class Album(object): +# def __init__(self, name, artist): +# self.name, self.artist = name, artist + +# def __eq__(self, other): +# return self.name == other.name and self.artist == other.artist + +# class ArtistSerializer(serializers.Serializer): +# name = serializers.CharField() + +# def restore_object(self, attrs, instance=None): +# if instance: +# instance.name = attrs['name'] +# else: +# instance = Artist(attrs['name']) +# return instance + +# class AlbumSerializer(serializers.Serializer): +# name = serializers.CharField() +# by = ArtistSerializer(source='artist') + +# def restore_object(self, attrs, instance=None): +# if instance: +# instance.name = attrs['name'] +# instance.artist = attrs['artist'] +# else: +# instance = Album(attrs['name'], attrs['artist']) +# return instance + +# self.Artist = Artist +# self.Album = Album +# self.AlbumSerializer = AlbumSerializer + +# def test_create_via_foreign_key_with_source(self): +# """ +# Check that we can both *create* and *update* into objects across +# ForeignKeys that have a `source` specified. +# Regression test for #1170 +# """ +# data = { +# 'name': 'Discovery', +# 'by': {'name': 'Daft Punk'}, +# } + +# expected = self.Album(artist=self.Artist('Daft Punk'), name='Discovery') + +# # create +# serializer = self.AlbumSerializer(data=data) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, expected) + +# # update +# original = self.Album(artist=self.Artist('The Bats'), name='Free All the Monsters') +# serializer = self.AlbumSerializer(instance=original, data=data) +# self.assertEqual(serializer.is_valid(), True) +# self.assertEqual(serializer.object, expected) + + +# class NestedModelSerializerUpdateTests(TestCase): +# def test_second_nested_level(self): +# john = models.Person.objects.create(name="john") + +# post = john.blogpost_set.create(title="Test blog post") +# post.blogpostcomment_set.create(text="I hate this blog post") +# post.blogpostcomment_set.create(text="I love this blog post") + +# class BlogPostCommentSerializer(serializers.ModelSerializer): +# class Meta: +# model = models.BlogPostComment + +# class BlogPostSerializer(serializers.ModelSerializer): +# comments = BlogPostCommentSerializer(many=True, source='blogpostcomment_set') + +# class Meta: +# model = models.BlogPost +# fields = ('id', 'title', 'comments') + +# class PersonSerializer(serializers.ModelSerializer): +# posts = BlogPostSerializer(many=True, source='blogpost_set') + +# class Meta: +# model = models.Person +# fields = ('id', 'name', 'age', 'posts') + +# serialize = PersonSerializer(instance=john) +# deserialize = PersonSerializer(data=serialize.data, instance=john) +# self.assertTrue(deserialize.is_valid()) + +# result = deserialize.object +# result.save() +# self.assertEqual(result.id, john.id) diff --git a/tests/test_throttling.py b/tests/test_throttling.py index 7b696f07..cc36a004 100644 --- a/tests/test_throttling.py +++ b/tests/test_throttling.py @@ -109,7 +109,7 @@ class ThrottlingTests(TestCase): def ensure_response_header_contains_proper_throttle_field(self, view, expected_headers): """ - Ensure the response returns an X-Throttle field with status and next attributes + Ensure the response returns an Retry-After field with status and next attributes set properly. """ request = self.factory.get('/') @@ -117,10 +117,8 @@ class ThrottlingTests(TestCase): self.set_throttle_timer(view, timer) response = view.as_view()(request) if expect is not None: - self.assertEqual(response['X-Throttle-Wait-Seconds'], expect) self.assertEqual(response['Retry-After'], expect) else: - self.assertFalse('X-Throttle-Wait-Seconds' in response) self.assertFalse('Retry-After' in response) def test_seconds_fields(self): @@ -173,13 +171,11 @@ class ThrottlingTests(TestCase): self.assertFalse(hasattr(MockView_NonTimeThrottling.throttle_classes[0], 'called')) response = MockView_NonTimeThrottling.as_view()(request) - self.assertFalse('X-Throttle-Wait-Seconds' in response) self.assertFalse('Retry-After' in response) self.assertTrue(MockView_NonTimeThrottling.throttle_classes[0].called) response = MockView_NonTimeThrottling.as_view()(request) - self.assertFalse('X-Throttle-Wait-Seconds' in response) self.assertFalse('Retry-After' in response) diff --git a/tests/test_validation.py b/tests/test_validation.py index e13e4078..ce39714d 100644 --- a/tests/test_validation.py +++ b/tests/test_validation.py @@ -1,5 +1,6 @@ from __future__ import unicode_literals from django.core.validators import MaxValueValidator +from django.core.exceptions import ValidationError from django.db import models from django.test import TestCase from rest_framework import generics, serializers, status @@ -22,23 +23,10 @@ class ValidationModelSerializer(serializers.ModelSerializer): class UpdateValidationModel(generics.RetrieveUpdateDestroyAPIView): - model = ValidationModel + queryset = ValidationModel.objects.all() serializer_class = ValidationModelSerializer -class TestPreSaveValidationExclusions(TestCase): - def test_pre_save_validation_exclusions(self): - """ - Somewhat weird test case to ensure that we don't perform model - validation on read only fields. - """ - obj = ValidationModel.objects.create(blank_validated_field='') - request = factory.put('/', {}, format='json') - view = UpdateValidationModel().as_view() - response = view(request, pk=obj.pk).render() - self.assertEqual(response.status_code, status.HTTP_200_OK) - - # Regression for #653 class ShouldValidateModel(models.Model): @@ -48,11 +36,10 @@ class ShouldValidateModel(models.Model): class ShouldValidateModelSerializer(serializers.ModelSerializer): renamed = serializers.CharField(source='should_validate_field', required=False) - def validate_renamed(self, attrs, source): - value = attrs[source] + def validate_renamed(self, value): if len(value) < 3: raise serializers.ValidationError('Minimum 3 characters.') - return attrs + return value class Meta: model = ShouldValidateModel @@ -117,7 +104,7 @@ class ValidationMaxValueValidatorModelSerializer(serializers.ModelSerializer): class UpdateMaxValueValidationModel(generics.RetrieveUpdateDestroyAPIView): - model = ValidationMaxValueValidatorModel + queryset = ValidationMaxValueValidatorModel.objects.all() serializer_class = ValidationMaxValueValidatorModelSerializer @@ -144,5 +131,44 @@ class TestMaxValueValidatorValidation(TestCase): 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.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 ValidationError: + 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)) diff --git a/tests/test_write_only_fields.py b/tests/test_write_only_fields.py index aabb18d6..dd3bbd6e 100644 --- a/tests/test_write_only_fields.py +++ b/tests/test_write_only_fields.py @@ -1,42 +1,31 @@ -from django.db import models from django.test import TestCase from rest_framework import serializers -class ExampleModel(models.Model): - email = models.EmailField(max_length=100) - password = models.CharField(max_length=100) - - class WriteOnlyFieldTests(TestCase): - def test_write_only_fields(self): + def setUp(self): class ExampleSerializer(serializers.Serializer): email = serializers.EmailField() password = serializers.CharField(write_only=True) + def create(self, attrs): + return attrs + + self.Serializer = ExampleSerializer + + def write_only_fields_are_present_on_input(self): data = { 'email': 'foo@example.com', 'password': '123' } - serializer = ExampleSerializer(data=data) + serializer = self.Serializer(data=data) self.assertTrue(serializer.is_valid()) - self.assertEquals(serializer.object, data) - self.assertEquals(serializer.data, {'email': 'foo@example.com'}) - - def test_write_only_fields_meta(self): - class ExampleSerializer(serializers.ModelSerializer): - class Meta: - model = ExampleModel - fields = ('email', 'password') - write_only_fields = ('password',) + self.assertEquals(serializer.validated_data, data) - data = { + def write_only_fields_are_not_present_on_output(self): + instance = { 'email': 'foo@example.com', 'password': '123' } - serializer = ExampleSerializer(data=data) - self.assertTrue(serializer.is_valid()) - self.assertTrue(isinstance(serializer.object, ExampleModel)) - self.assertEquals(serializer.object.email, data['email']) - self.assertEquals(serializer.object.password, data['password']) + serializer = self.Serializer(instance) self.assertEquals(serializer.data, {'email': 'foo@example.com'}) diff --git a/tests/utils.py b/tests/utils.py index 28be81bd..5e902ba9 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -1,4 +1,6 @@ from contextlib import contextmanager +from django.core.exceptions import ObjectDoesNotExist +from django.core.urlresolvers import NoReverseMatch from django.utils import six from rest_framework.settings import api_settings @@ -23,3 +25,54 @@ def temporary_setting(setting, value, module=None): if module is not None: six.moves.reload_module(module) + + +class MockObject(object): + def __init__(self, **kwargs): + self._kwargs = kwargs + for key, val in kwargs.items(): + setattr(self, key, val) + + def __str__(self): + kwargs_str = ', '.join([ + '%s=%s' % (key, value) + for key, value in sorted(self._kwargs.items()) + ]) + return '<MockObject %s>' % kwargs_str + + +class MockQueryset(object): + def __init__(self, iterable): + self.items = iterable + + def get(self, **lookup): + for item in self.items: + if all([ + getattr(item, key, None) == value + for key, value in lookup.items() + ]): + return item + raise ObjectDoesNotExist() + + +class BadType(object): + """ + When used as a lookup with a `MockQueryset`, these objects + will raise a `TypeError`, as occurs in Django when making + queryset lookups with an incorrect type for the lookup value. + """ + def __eq__(self): + raise TypeError() + + +def mock_reverse(view_name, args=None, kwargs=None, request=None, format=None): + args = args or [] + kwargs = kwargs or {} + value = (args + list(kwargs.values()) + ['-'])[0] + prefix = 'http://example.org' if request else '' + suffix = ('.' + format) if (format is not None) else '' + return '%s/%s/%s%s/' % (prefix, view_name, value, suffix) + + +def fail_reverse(view_name, args=None, kwargs=None, request=None, format=None): + raise NoReverseMatch() diff --git a/tests/views.py b/tests/views.py deleted file mode 100644 index 55935e92..00000000 --- a/tests/views.py +++ /dev/null @@ -1,8 +0,0 @@ -from rest_framework import generics -from .models import NullableForeignKeySource -from .serializers import NullableFKSourceSerializer - - -class NullableFKSourceDetail(generics.RetrieveUpdateDestroyAPIView): - model = NullableForeignKeySource - model_serializer_class = NullableFKSourceSerializer |