Add basic serializer tests

.travis.yml

@@ -12,7 +12,7 @@ env:
 install:
   - pip install $DJANGO 
   - pip install -e . --use-mirrors
-  - pip install -r requirements.txt
+  - pip install -r requirements.txt --use-mirrors
   - pip install coverage==3.5.1 --use-mirrors
 
 script:

djangorestframework/tests/renderers.py

@@ -54,7 +54,7 @@ class MockView(APIView):
     renderers = (RendererA, RendererB)
 
     def get(self, request, **kwargs):
-        response = Response(DUMMYSTATUS, DUMMYCONTENT)
+        response = Response(DUMMYCONTENT, status=DUMMYSTATUS)
         return self.render(response)
 
 

djangorestframework/tests/serializer.py

@@ -1,161 +1,117 @@
-# """Tests for the resource module"""
+import datetime
-# from django.db import models
+from django.test import TestCase
-# from django.test import TestCase
+from djangorestframework import serializers
-# from django.utils.translation import ugettext_lazy
-# from djangorestframework.serializer import Serializer
-
-# import datetime
-# import decimal
 
 
-# class TestObjectToData(TestCase):
+class Comment(object):
-#     """
+    def __init__(self, email, content, created):
-#     Tests for the Serializer class.
+        self.email = email
-#     """
+        self.content = content
+        self.created = created or datetime.datetime.now()
 
-#     def setUp(self):
+    def __eq__(self, other):
-#         self.serializer = Serializer()
+        return all([getattr(self, attr) == getattr(other, attr)
-#         self.serialize = self.serializer.serialize
+                    for attr in ('email', 'content', 'created')])
-
-#     def test_decimal(self):
-#         """Decimals need to be converted to a string representation."""
-#         self.assertEquals(self.serialize(decimal.Decimal('1.5')), decimal.Decimal('1.5'))
-
-#     def test_function(self):
-#         """Functions with no arguments should be called."""
-#         def foo():
-#             return 1
-#         self.assertEquals(self.serialize(foo), 1)
-
-#     def test_method(self):
-#         """Methods with only a ``self`` argument should be called."""
-#         class Foo(object):
-#             def foo(self):
-#                 return 1
-#         self.assertEquals(self.serialize(Foo().foo), 1)
-
-#     def test_datetime(self):
-#         """datetime objects are left as-is."""
-#         now = datetime.datetime.now()
-#         self.assertEquals(self.serialize(now), now)
-
-#     def test_dict_method_name_collision(self):
-#         """dict with key that collides with dict method name"""
-#         self.assertEquals(self.serialize({'items': 'foo'}), {'items': u'foo'})
-#         self.assertEquals(self.serialize({'keys': 'foo'}), {'keys': u'foo'})
-#         self.assertEquals(self.serialize({'values': 'foo'}), {'values': u'foo'})
-
-#     def test_ugettext_lazy(self):
-#         self.assertEquals(self.serialize(ugettext_lazy('foobar')), u'foobar')
 
 
-# class TestFieldNesting(TestCase):
+class CommentSerializer(serializers.Serializer):
-#     """
+    email = serializers.EmailField()
-#     Test nesting the fields in the Serializer class
+    content = serializers.CharField(max_length=1000)
-#     """
+    created = serializers.DateTimeField()
-#     def setUp(self):
-#         self.serializer = Serializer()
-#         self.serialize = self.serializer.serialize
 
-#         class M1(models.Model):
+    def restore_object(self, data, instance=None):
-#             field1 = models.CharField(max_length=256)
+        if instance is None:
-#             field2 = models.CharField(max_length=256)
+            return Comment(**data)
-
+        for key, val in data.items():
-#         class M2(models.Model):
+            setattr(instance, key, val)
-#             field = models.OneToOneField(M1)
+        return instance
-
-#         class M3(models.Model):
-#             field = models.ForeignKey(M1)
-
-#         self.m1 = M1(field1='foo', field2='bar')
-#         self.m2 = M2(field=self.m1)
-#         self.m3 = M3(field=self.m1)
 
 
-#     def test_tuple_nesting(self):
+class BasicTests(TestCase):
-#         """
+    def setUp(self):
-#         Test tuple nesting on `fields` attr
+        self.comment = Comment(
-#         """
+            'tom@example.com',
-#         class SerializerM2(Serializer):
+            'Happy new year!',
-#             fields = (('field', ('field1',)),)
+            datetime.datetime(2012, 1, 1)
+        )
+        self.data = {
+            'email': 'tom@example.com',
+            'content': 'Happy new year!',
+            'created': datetime.datetime(2012, 1, 1)
+        }
 
-#         class SerializerM3(Serializer):
+    def test_empty(self):
-#             fields = (('field', ('field2',)),)
+        serializer = CommentSerializer()
+        expected = {
+            'email': '',
+            'content': '',
+            'created': None
+        }
+        self.assertEquals(serializer.data, expected)
 
-#         self.assertEqual(SerializerM2().serialize(self.m2), {'field': {'field1': u'foo'}})
+    def test_serialization(self):
-#         self.assertEqual(SerializerM3().serialize(self.m3), {'field': {'field2': u'bar'}})
+        serializer = CommentSerializer(instance=self.comment)
+        expected = self.data
+        self.assertEquals(serializer.data, expected)
+
+    def test_deserialization_for_create(self):
+        serializer = CommentSerializer(self.data)
+        expected = self.comment
+        self.assertEquals(serializer.is_valid(), True)
+        self.assertEquals(serializer.object, expected)
+        self.assertFalse(serializer.object is expected)
+
+    def test_deserialization_for_update(self):
+        serializer = CommentSerializer(self.data, instance=self.comment)
+        expected = self.comment
+        self.assertEquals(serializer.is_valid(), True)
+        self.assertEquals(serializer.object, expected)
+        self.assertTrue(serializer.object is expected)
 
 
-#     def test_serializer_class_nesting(self):
+class ValidationTests(TestCase):
-#         """
+    def setUp(self):
-#         Test related model serialization
+        self.comment = Comment(
-#         """
+            'tom@example.com',
-#         class NestedM2(Serializer):
+            'Happy new year!',
-#             fields = ('field1', )
+            datetime.datetime(2012, 1, 1)
+        )
+        self.data = {
+            'email': 'tom@example.com',
+            'content': 'x' * 1001,
+            'created': datetime.datetime(2012, 1, 1)
+        }
 
-#         class NestedM3(Serializer):
+    def test_deserialization_for_create(self):
-#             fields = ('field2', )
+        serializer = CommentSerializer(self.data)
+        self.assertEquals(serializer.is_valid(), False)
+        self.assertEquals(serializer.errors, {'content': [u'Ensure this value has at most 1000 characters (it has 1001).']})
 
-#         class SerializerM2(Serializer):
+    def test_deserialization_for_update(self):
-#             fields = [('field', NestedM2)]
+        serializer = CommentSerializer(self.data, instance=self.comment)
+        self.assertEquals(serializer.is_valid(), False)
+        self.assertEquals(serializer.errors, {'content': [u'Ensure this value has at most 1000 characters (it has 1001).']})
 
-#         class SerializerM3(Serializer):
-#             fields = [('field', NestedM3)]
 
-#         self.assertEqual(SerializerM2().serialize(self.m2), {'field': {'field1': u'foo'}})
+class MetadataTests(TestCase):
-#         self.assertEqual(SerializerM3().serialize(self.m3), {'field': {'field2': u'bar'}})
+    # def setUp(self):
+    #     self.comment = Comment(
+    #         'tomchristie',
+    #         'Happy new year!',
+    #         datetime.datetime(2012, 1, 1)
+    #     )
+    #     self.data = {
+    #         'email': 'tomchristie',
+    #         'content': 'Happy new year!',
+    #         'created': datetime.datetime(2012, 1, 1)
+    #     }
 
-#     def test_serializer_no_fields(self):
+    def test_empty(self):
-#         """
+        serializer = CommentSerializer()
-#         Test related serializer works when the fields attr isn't present. Fix for
+        expected = {
-#         #178.
+            'email': serializers.CharField,
-#         """
+            'content': serializers.CharField,
-#         class NestedM2(Serializer):
+            'created': serializers.DateTimeField
-#             fields = ('field1', )
+        }
-
+        for field_name, field in expected.items():
-#         class NestedM3(Serializer):
+            self.assertTrue(isinstance(serializer.data.fields[field_name], field))
-#             fields = ('field2', )
-
-#         class SerializerM2(Serializer):
-#             include = [('field', NestedM2)]
-#             exclude = ('id', )
-
-#         class SerializerM3(Serializer):
-#             fields = [('field', NestedM3)]
-
-#         self.assertEqual(SerializerM2().serialize(self.m2), {'field': {'field1': u'foo'}})
-#         self.assertEqual(SerializerM3().serialize(self.m3), {'field': {'field2': u'bar'}})
-
-#     def test_serializer_classname_nesting(self):
-#         """
-#         Test related model serialization
-#         """
-#         class SerializerM2(Serializer):
-#             fields = [('field', 'NestedM2')]
-
-#         class SerializerM3(Serializer):
-#             fields = [('field', 'NestedM3')]
-
-#         class NestedM2(Serializer):
-#             fields = ('field1', )
-
-#         class NestedM3(Serializer):
-#             fields = ('field2', )
-
-#         self.assertEqual(SerializerM2().serialize(self.m2), {'field': {'field1': u'foo'}})
-#         self.assertEqual(SerializerM3().serialize(self.m3), {'field': {'field2': u'bar'}})
-
-#     def test_serializer_overridden_hook_method(self):
-#         """
-#         Test serializing a model instance which overrides a class method on the
-#         serializer.  Checks for correct behaviour in odd edge case.
-#         """
-#         class SerializerM2(Serializer):
-#             fields = ('overridden', )
-
-#             def overridden(self):
-#                 return False
-
-#         self.m2.overridden = True
-#         self.assertEqual(SerializerM2().serialize_model(self.m2),
-#                          {'overridden': True})

docs/requirements.txt

@@ -0,0 +1 @@
+markdown>=2.1.0