From aed26b218ea39110489e85abc6f412399a1774a1 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 24 Aug 2012 22:11:00 +0100
Subject: Drop out resources & mixins

---
 djangorestframework/tests/serializer.py | 297 ++++++++++++++++----------------
 1 file changed, 149 insertions(+), 148 deletions(-)

(limited to 'djangorestframework/tests/serializer.py')

diff --git a/djangorestframework/tests/serializer.py b/djangorestframework/tests/serializer.py
index 834a60d0..7e9f4149 100644
--- a/djangorestframework/tests/serializer.py
+++ b/djangorestframework/tests/serializer.py
@@ -1,160 +1,161 @@
-"""Tests for the resource module"""
-from django.db import models
-from django.test import TestCase
-from django.utils.translation import ugettext_lazy
-from djangorestframework.serializer import Serializer
+# """Tests for the resource module"""
+# from django.db import models
+# from django.test import TestCase
+# from django.utils.translation import ugettext_lazy
+# from djangorestframework.serializer import Serializer
 
-import datetime
-import decimal
-
-class TestObjectToData(TestCase):
-    """
-    Tests for the Serializer class.
-    """
-
-    def setUp(self):
-        self.serializer = Serializer()
-        self.serialize = self.serializer.serialize
-
-    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'})
+# import datetime
+# import decimal
 
-    def test_ugettext_lazy(self):
-        self.assertEquals(self.serialize(ugettext_lazy('foobar')), u'foobar')
-
-
-class TestFieldNesting(TestCase):
-    """
-    Test nesting the fields in the Serializer class
-    """
-    def setUp(self):
-        self.serializer = Serializer()
-        self.serialize = self.serializer.serialize
-
-        class M1(models.Model):
-            field1 = models.CharField(max_length=256)
-            field2 = models.CharField(max_length=256)
-
-        class M2(models.Model):
-            field = models.OneToOneField(M1)
-
-        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):
-        """
-        Test tuple nesting on `fields` attr
-        """
-        class SerializerM2(Serializer):
-            fields = (('field', ('field1',)),)
-
-        class SerializerM3(Serializer):
-            fields = (('field', ('field2',)),)
-
-        self.assertEqual(SerializerM2().serialize(self.m2), {'field': {'field1': u'foo'}})
-        self.assertEqual(SerializerM3().serialize(self.m3), {'field': {'field2': u'bar'}})
-
-
-    def test_serializer_class_nesting(self):
-        """
-        Test related model serialization
-        """
-        class NestedM2(Serializer):
-            fields = ('field1', )
-
-        class NestedM3(Serializer):
-            fields = ('field2', )
-
-        class SerializerM2(Serializer):
-            fields = [('field', NestedM2)]
-
-        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_no_fields(self):
-        """
-        Test related serializer works when the fields attr isn't present. Fix for
-        #178.
-        """
-        class NestedM2(Serializer):
-            fields = ('field1', )
+# class TestObjectToData(TestCase):
+#     """
+#     Tests for the Serializer class.
+#     """
 
-        class NestedM3(Serializer):
-            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 setUp(self):
+#         self.serializer = Serializer()
+#         self.serialize = self.serializer.serialize
 
-    def test_serializer_classname_nesting(self):
-        """
-        Test related model serialization
-        """
-        class SerializerM2(Serializer):
-            fields = [('field', 'NestedM2')]
+#     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'))
 
-        class SerializerM3(Serializer):
-            fields = [('field', 'NestedM3')]
+#     def test_function(self):
+#         """Functions with no arguments should be called."""
+#         def foo():
+#             return 1
+#         self.assertEquals(self.serialize(foo), 1)
 
-        class NestedM2(Serializer):
-            fields = ('field1', )
+#     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)
 
-        class NestedM3(Serializer):
-            fields = ('field2', )
+#     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'})
 
-        self.assertEqual(SerializerM2().serialize(self.m2), {'field': {'field1': u'foo'}})
-        self.assertEqual(SerializerM3().serialize(self.m3), {'field': {'field2': u'bar'}})
+#     def test_ugettext_lazy(self):
+#         self.assertEquals(self.serialize(ugettext_lazy('foobar')), u'foobar')
 
-    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
+# class TestFieldNesting(TestCase):
+#     """
+#     Test nesting the fields in the Serializer class
+#     """
+#     def setUp(self):
+#         self.serializer = Serializer()
+#         self.serialize = self.serializer.serialize
 
-        self.m2.overridden = True
-        self.assertEqual(SerializerM2().serialize_model(self.m2),
-                         {'overridden': True})
+#         class M1(models.Model):
+#             field1 = models.CharField(max_length=256)
+#             field2 = models.CharField(max_length=256)
+
+#         class M2(models.Model):
+#             field = models.OneToOneField(M1)
+
+#         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):
+#         """
+#         Test tuple nesting on `fields` attr
+#         """
+#         class SerializerM2(Serializer):
+#             fields = (('field', ('field1',)),)
+
+#         class SerializerM3(Serializer):
+#             fields = (('field', ('field2',)),)
+
+#         self.assertEqual(SerializerM2().serialize(self.m2), {'field': {'field1': u'foo'}})
+#         self.assertEqual(SerializerM3().serialize(self.m3), {'field': {'field2': u'bar'}})
+
+
+#     def test_serializer_class_nesting(self):
+#         """
+#         Test related model serialization
+#         """
+#         class NestedM2(Serializer):
+#             fields = ('field1', )
+
+#         class NestedM3(Serializer):
+#             fields = ('field2', )
+
+#         class SerializerM2(Serializer):
+#             fields = [('field', NestedM2)]
+
+#         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_no_fields(self):
+#         """
+#         Test related serializer works when the fields attr isn't present. Fix for
+#         #178.
+#         """
+#         class NestedM2(Serializer):
+#             fields = ('field1', )
+
+#         class NestedM3(Serializer):
+#             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})
-- 
cgit v1.2.3


From 72bdd0fcec7faa32d7f24e0698736f9433b56f3f Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 7 Sep 2012 15:14:23 +0100
Subject: Add basic serializer tests

---
 djangorestframework/tests/serializer.py | 278 ++++++++++++++------------------
 1 file changed, 117 insertions(+), 161 deletions(-)

(limited to 'djangorestframework/tests/serializer.py')

diff --git a/djangorestframework/tests/serializer.py b/djangorestframework/tests/serializer.py
index 7e9f4149..93ae81ee 100644
--- a/djangorestframework/tests/serializer.py
+++ b/djangorestframework/tests/serializer.py
@@ -1,161 +1,117 @@
-# """Tests for the resource module"""
-# from django.db import models
-# from django.test import TestCase
-# from django.utils.translation import ugettext_lazy
-# from djangorestframework.serializer import Serializer
-
-# import datetime
-# import decimal
-
-
-# class TestObjectToData(TestCase):
-#     """
-#     Tests for the Serializer class.
-#     """
-
-#     def setUp(self):
-#         self.serializer = Serializer()
-#         self.serialize = self.serializer.serialize
-
-#     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):
-#     """
-#     Test nesting the fields in the Serializer class
-#     """
-#     def setUp(self):
-#         self.serializer = Serializer()
-#         self.serialize = self.serializer.serialize
-
-#         class M1(models.Model):
-#             field1 = models.CharField(max_length=256)
-#             field2 = models.CharField(max_length=256)
-
-#         class M2(models.Model):
-#             field = models.OneToOneField(M1)
-
-#         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):
-#         """
-#         Test tuple nesting on `fields` attr
-#         """
-#         class SerializerM2(Serializer):
-#             fields = (('field', ('field1',)),)
-
-#         class SerializerM3(Serializer):
-#             fields = (('field', ('field2',)),)
-
-#         self.assertEqual(SerializerM2().serialize(self.m2), {'field': {'field1': u'foo'}})
-#         self.assertEqual(SerializerM3().serialize(self.m3), {'field': {'field2': u'bar'}})
-
-
-#     def test_serializer_class_nesting(self):
-#         """
-#         Test related model serialization
-#         """
-#         class NestedM2(Serializer):
-#             fields = ('field1', )
-
-#         class NestedM3(Serializer):
-#             fields = ('field2', )
-
-#         class SerializerM2(Serializer):
-#             fields = [('field', NestedM2)]
-
-#         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_no_fields(self):
-#         """
-#         Test related serializer works when the fields attr isn't present. Fix for
-#         #178.
-#         """
-#         class NestedM2(Serializer):
-#             fields = ('field1', )
-
-#         class NestedM3(Serializer):
-#             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})
+import datetime
+from django.test import TestCase
+from djangorestframework import serializers
+
+
+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')])
+
+
+class CommentSerializer(serializers.Serializer):
+    email = serializers.EmailField()
+    content = serializers.CharField(max_length=1000)
+    created = serializers.DateTimeField()
+
+    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 BasicTests(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': 'Happy new year!',
+            'created': datetime.datetime(2012, 1, 1)
+        }
+
+    def test_empty(self):
+        serializer = CommentSerializer()
+        expected = {
+            'email': '',
+            'content': '',
+            'created': None
+        }
+        self.assertEquals(serializer.data, expected)
+
+    def test_serialization(self):
+        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)
+
+
+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)
+        }
+
+    def test_deserialization_for_create(self):
+        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).']})
+
+    def test_deserialization_for_update(self):
+        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 MetadataTests(TestCase):
+    # 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_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))
-- 
cgit v1.2.3


From 87dae4d8549c02fa9a57adb3bb876d249dae1f79 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 20 Sep 2012 13:19:43 +0100
Subject: Remove old 'djangorestframework directories

---
 djangorestframework/tests/serializer.py | 117 --------------------------------
 1 file changed, 117 deletions(-)
 delete mode 100644 djangorestframework/tests/serializer.py

(limited to 'djangorestframework/tests/serializer.py')

diff --git a/djangorestframework/tests/serializer.py b/djangorestframework/tests/serializer.py
deleted file mode 100644
index 93ae81ee..00000000
--- a/djangorestframework/tests/serializer.py
+++ /dev/null
@@ -1,117 +0,0 @@
-import datetime
-from django.test import TestCase
-from djangorestframework import serializers
-
-
-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')])
-
-
-class CommentSerializer(serializers.Serializer):
-    email = serializers.EmailField()
-    content = serializers.CharField(max_length=1000)
-    created = serializers.DateTimeField()
-
-    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 BasicTests(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': 'Happy new year!',
-            'created': datetime.datetime(2012, 1, 1)
-        }
-
-    def test_empty(self):
-        serializer = CommentSerializer()
-        expected = {
-            'email': '',
-            'content': '',
-            'created': None
-        }
-        self.assertEquals(serializer.data, expected)
-
-    def test_serialization(self):
-        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)
-
-
-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)
-        }
-
-    def test_deserialization_for_create(self):
-        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).']})
-
-    def test_deserialization_for_update(self):
-        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 MetadataTests(TestCase):
-    # 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_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))
-- 
cgit v1.2.3