diff --git a/tests/test_files.py b/tests/test_files.py deleted file mode 100644 index a5613fcbe..000000000 --- a/tests/test_files.py +++ /dev/null @@ -1,92 +0,0 @@ -# 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_hyperlinkedserializers.py b/tests/test_hyperlinkedserializers.py deleted file mode 100644 index ff3663dd3..000000000 --- a/tests/test_hyperlinkedserializers.py +++ /dev/null @@ -1,406 +0,0 @@ -# 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() - - -# 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 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) - - -# class AlbumSerializer(serializers.ModelSerializer): -# url = serializers.HyperlinkedIdentityField(view_name='album-detail', lookup_field='title') - -# class Meta: -# model = Album -# fields = ('title', 'url') - - -# class BasicSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = BasicModel - - -# class AnchorSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = Anchor - - -# class ManyToManySerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = ManyToManyModel - - -# class BlogPostSerializer(serializers.ModelSerializer): -# class Meta: -# model = BlogPost - - -# class OptionalRelationSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = OptionalRelationModel - - -# class BasicList(generics.ListCreateAPIView): -# queryset = BasicModel.objects.all() -# serializer_class = BasicSerializer - - -# class BasicDetail(generics.RetrieveUpdateDestroyAPIView): -# queryset = BasicModel.objects.all() -# serializer_class = BasicSerializer - - -# class AnchorDetail(generics.RetrieveAPIView): -# queryset = Anchor.objects.all() -# serializer_class = AnchorSerializer - - -# 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\d+)/$', BasicDetail.as_view(), name='basicmodel-detail'), -# url(r'^anchor/(?P\d+)/$', AnchorDetail.as_view(), name='anchor-detail'), -# url(r'^manytomany/$', ManyToManyList.as_view(), name='manytomanymodel-list'), -# url(r'^manytomany/(?P\d+)/$', ManyToManyDetail.as_view(), name='manytomanymodel-detail'), -# url(r'^posts/(?P\d+)/$', BlogPostDetail.as_view(), name='blogpost-detail'), -# url(r'^comments/$', BlogPostCommentListCreate.as_view(), name='blogpostcomment-list'), -# url(r'^comments/(?P\d+)/$', BlogPostCommentDetail.as_view(), name='blogpostcomment-detail'), -# url(r'^albums/(?P\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_nullable_fields.py b/tests/test_nullable_fields.py deleted file mode 100644 index 9843182ad..000000000 --- a/tests/test_nullable_fields.py +++ /dev/null @@ -1,39 +0,0 @@ -# from django.core.urlresolvers import reverse - -# from django.conf.urls import patterns, url -# from rest_framework import serializers, generics -# from rest_framework.test import APITestCase -# from tests.models import NullableForeignKeySource - - -# class NullableFKSourceSerializer(serializers.ModelSerializer): -# class Meta: -# model = NullableForeignKeySource - - -# class NullableFKSourceDetail(generics.RetrieveUpdateDestroyAPIView): -# queryset = NullableForeignKeySource.objects.all() -# serializer_class = NullableFKSourceSerializer - - -# urlpatterns = patterns( -# '', -# url(r'^objects/(?P<pk>\d+)/$', NullableFKSourceDetail.as_view(), name='object-detail'), -# ) - - -# 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_relations.py b/tests/test_relations.py index 16ead1f2f..62353dc25 100644 --- a/tests/test_relations.py +++ b/tests/test_relations.py @@ -134,155 +134,3 @@ class TestSlugRelatedField(APISimpleTestCase): 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_primitive, '') -# self.assertRaises(serializers.ValidationError, field.to_primitive, []) - -# def test_hyperlinked_related_field_with_empty_string(self): -# field = serializers.HyperlinkedRelatedField(queryset=NullModel.objects.all(), view_name='') -# self.assertRaises(serializers.ValidationError, field.to_primitive, '') -# self.assertRaises(serializers.ValidationError, field.to_primitive, []) - -# 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_primitive, '') -# self.assertRaises(serializers.ValidationError, field.to_primitive, []) - - -# 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 0337f3599..b938e3857 100644 --- a/tests/test_relations_hyperlink.py +++ b/tests/test_relations_hyperlink.py @@ -411,30 +411,6 @@ class HyperlinkedNullableForeignKeyTests(TestCase): ] 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) - # print serializer.is_valid() - # print serializer.errors - # print serializer - # self.assertTrue(serializer.is_valid()) - # serializer.save() - # self.assertEqual(serializer.data, data) - - # # 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' @@ -455,72 +431,3 @@ class HyperlinkedNullableOneToOneTests(TestCase): {'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 deleted file mode 100644 index 4a99fee99..000000000 --- a/tests/test_relations_nested.py +++ /dev/null @@ -1,326 +0,0 @@ -# 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 ba5f6c178..e95a877e1 100644 --- a/tests/test_relations_pk.py +++ b/tests/test_relations_pk.py @@ -398,27 +398,6 @@ class PKNullableForeignKeyTests(TestCase): ] 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): @@ -437,113 +416,3 @@ class PKNullableOneToOneTests(TestCase): {'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.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.is_valid()) -# 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_request.py b/tests/test_request.py index 8ddaf0a70..44afd2438 100644 --- a/tests/test_request.py +++ b/tests/test_request.py @@ -179,89 +179,6 @@ class TestContentParsing(TestCase): self.assertEqual(request._data, Empty) self.assertEqual(request._files, Empty) - # def test_accessing_post_after_data_form(self): - # """ - # Ensures request.POST can be accessed after request.DATA in - # form request. - # """ - # data = {'qwerty': 'uiop'} - # request = factory.post('/', data=data) - # self.assertEqual(request.DATA.items(), data.items()) - # self.assertEqual(request.POST.items(), data.items()) - - # def test_accessing_post_after_data_for_json(self): - # """ - # Ensures request.POST can be accessed after request.DATA in - # json request. - # """ - # data = {'qwerty': 'uiop'} - # content = json.dumps(data) - # content_type = 'application/json' - # parsers = (JSONParser, ) - - # request = factory.post('/', content, content_type=content_type, - # parsers=parsers) - # self.assertEqual(request.DATA.items(), data.items()) - # self.assertEqual(request.POST.items(), []) - - # def test_accessing_post_after_data_for_overloaded_json(self): - # """ - # Ensures request.POST can be accessed after request.DATA in overloaded - # json request. - # """ - # data = {'qwerty': 'uiop'} - # content = json.dumps(data) - # content_type = 'application/json' - # parsers = (JSONParser, ) - # form_data = {Request._CONTENT_PARAM: content, - # Request._CONTENTTYPE_PARAM: content_type} - - # request = factory.post('/', form_data, parsers=parsers) - # self.assertEqual(request.DATA.items(), data.items()) - # self.assertEqual(request.POST.items(), form_data.items()) - - # def test_accessing_data_after_post_form(self): - # """ - # Ensures request.DATA can be accessed after request.POST in - # form request. - # """ - # data = {'qwerty': 'uiop'} - # parsers = (FormParser, MultiPartParser) - # request = factory.post('/', data, parsers=parsers) - - # self.assertEqual(request.POST.items(), data.items()) - # self.assertEqual(request.DATA.items(), data.items()) - - # def test_accessing_data_after_post_for_json(self): - # """ - # Ensures request.DATA can be accessed after request.POST in - # json request. - # """ - # data = {'qwerty': 'uiop'} - # content = json.dumps(data) - # content_type = 'application/json' - # parsers = (JSONParser, ) - # request = factory.post('/', content, content_type=content_type, - # parsers=parsers) - # self.assertEqual(request.POST.items(), []) - # self.assertEqual(request.DATA.items(), data.items()) - - # def test_accessing_data_after_post_for_overloaded_json(self): - # """ - # Ensures request.DATA can be accessed after request.POST in overloaded - # json request - # """ - # data = {'qwerty': 'uiop'} - # content = json.dumps(data) - # content_type = 'application/json' - # parsers = (JSONParser, ) - # form_data = {Request._CONTENT_PARAM: content, - # Request._CONTENTTYPE_PARAM: content_type} - - # request = factory.post('/', form_data, parsers=parsers) - # self.assertEqual(request.POST.items(), form_data.items()) - # self.assertEqual(request.DATA.items(), data.items()) - class MockView(APIView): authentication_classes = (SessionAuthentication,) @@ -301,18 +218,6 @@ class TestContentParsingWithAuthentication(TestCase): response = self.csrf_client.post('/', content) self.assertEqual(status.HTTP_200_OK, response.status_code) - # def test_user_logged_in_authentication_has_post_when_logged_in(self): - # """Ensures request.POST exists after UserLoggedInAuthentication when user does log in""" - # self.client.login(username='john', password='password') - # self.csrf_client.login(username='john', password='password') - # content = {'example': 'example'} - - # response = self.client.post('/', content) - # self.assertEqual(status.OK, response.status_code, "POST data is malformed") - - # response = self.csrf_client.post('/', content) - # self.assertEqual(status.OK, response.status_code, "POST data is malformed") - class TestUserSetter(TestCase): diff --git a/tests/test_serializer.py b/tests/test_serializer.py index 77d5c3199..6dabaf42e 100644 --- a/tests/test_serializer.py +++ b/tests/test_serializer.py @@ -175,2007 +175,3 @@ class TestStarredSource: instance = {'a': 1, 'b': 2, 'c': 3, 'd': 4} serializer = self.Serializer(instance) assert serializer.data == self.data - -# # -*- 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 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 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') - -# 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 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 Meta: -# model = Book - - -# class ActionItemSerializer(serializers.ModelSerializer): - -# 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 Meta: -# model = ActionItem -# fields = ('title',) - - -# class ActionItemSerializerCustomRestore(serializers.ModelSerializer): - -# 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 - - -# class PersonSerializer(serializers.ModelSerializer): -# info = serializers.Field(source='info') - -# class Meta: -# model = Person -# fields = ('name', 'age', 'info') -# read_only_fields = ('age',) - - -# class NestedSerializer(serializers.Serializer): -# info = serializers.Field() - - -# class ModelSerializerWithNestedSerializer(serializers.ModelSerializer): -# nested = NestedSerializer(source='*') - -# class Meta: -# model = Person - - -# class NestedSerializerWithRenamedField(serializers.Serializer): -# renamed_info = serializers.Field(source='info') - - -# class ModelSerializerWithNestedSerializerWithRenamedField(serializers.ModelSerializer): -# nested = NestedSerializerWithRenamedField(source='*') - -# class Meta: -# model = Person - - -# 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 AlbumsSerializer(serializers.ModelSerializer): - -# class Meta: -# model = Album -# fields = ['title', 'ref'] # lists are also valid options - - -# class PositiveIntegerAsChoiceSerializer(serializers.ModelSerializer): -# class Meta: -# model = HasPositiveIntegerAsChoice -# fields = ['some_integer'] - - -# class ForeignKeySourceSerializer(serializers.ModelSerializer): -# 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 -# """ -# 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 BlogPostCommentSerializer(serializers.ModelSerializer): -# class Meta: -# model = BlogPostComment -# fields = ("text", "post_owner") - -# text = serializers.CharField() -# post_owner = PersonSerializer(source='blog_post.writer') - -# class BlogPostSerializer(serializers.Serializer): -# title = serializers.CharField() -# comments = BlogPostCommentSerializer(source='blogpostcomment_set') - -# 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) - -# 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 - -# 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) - - -# 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") - -# 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") - -# 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" - -# class AlbumCollection(object): -# albums = None - -# 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] - -# # 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): - -# 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_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) - - -# # Test for issue 747 - -# 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] -# ) - -# 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_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') - - -# 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() - -# 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 - -# 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 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. - -# 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 - -# 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 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') - -# 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]}) - -# 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 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_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 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 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 2259ee317..fb881a755 100644 --- a/tests/test_serializer_bulk_update.py +++ b/tests/test_serializer_bulk_update.py @@ -121,161 +121,3 @@ class BulkCreateSerializerTests(TestCase): expected_errors = {'non_field_errors': ['Expected a list of items but got type `dict`.']} 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 deleted file mode 100644 index 805ac7d46..000000000 --- a/tests/test_serializer_empty.py +++ /dev/null @@ -1,15 +0,0 @@ -# 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() - -# def get_bar(self, obj): -# return 'bar' - -# serializer = FooBarSerializer() -# self.assertEquals(serializer.data, {'foo': 0}) diff --git a/tests/test_serializer_nested.py b/tests/test_serializer_nested.py index 5e2074490..f5e4b26ad 100644 --- a/tests/test_serializer_nested.py +++ b/tests/test_serializer_nested.py @@ -38,353 +38,3 @@ class TestNestedSerializer: } serializer = self.Serializer() assert serializer.data == expected_data - -# """ -# 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_validation.py b/tests/test_validation.py index 3db825557..4234efd36 100644 --- a/tests/test_validation.py +++ b/tests/test_validation.py @@ -165,17 +165,6 @@ class TestChoiceFieldChoicesValidate(TestCase): except serializers.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)) - class RegexSerializer(serializers.Serializer): pin = serializers.CharField(