Support for nesting resources etc...

--HG--
rename : djangorestframework/tests/resources.py => djangorestframework/tests/serializer.py

djangorestframework/mixins.py

@@ -582,7 +582,12 @@ class ListModelMixin(object):
 
     def get(self, request, *args, **kwargs):
         queryset = self.queryset if self.queryset else self.resource.model.objects.all()
-        ordering = getattr(self.resource, 'ordering', None)
+
+        if hasattr(self, 'resource'):
+            ordering = getattr(self.resource.Meta, 'ordering', None)
+        else:
+            ordering = None
+
         if ordering:
             args = as_tuple(ordering)
             queryset = queryset.order_by(*args)

djangorestframework/tests/resources.py

-"""Tests for the resource module"""
-from django.test import TestCase
-from djangorestframework.resources import _object_to_data
-
-from django.db import models
-
-import datetime
-import decimal
-
-class TestObjectToData(TestCase): 
-    """Tests for the _object_to_data function"""
-
-    def test_decimal(self):
-        """Decimals need to be converted to a string representation."""
-        self.assertEquals(_object_to_data(decimal.Decimal('1.5')), '1.5')
-
-    def test_function(self):
-        """Functions with no arguments should be called."""
-        def foo():
-            return 1
-        self.assertEquals(_object_to_data(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(_object_to_data(Foo().foo), 1)
-
-    def test_datetime(self):
-        """datetime objects are left as-is."""
-        now = datetime.datetime.now()
-        self.assertEquals(_object_to_data(now), now)
-    
-    def test_tuples(self):
-        """ Test tuple serialisation """
-        class M1(models.Model):
-            field1 = models.CharField()
-            field2 = models.CharField()
-        
-        class M2(models.Model):
-            field = models.OneToOneField(M1)
-        
-        class M3(models.Model):
-            field = models.ForeignKey(M1)
-        
-        m1 = M1(field1='foo', field2='bar')
-        m2 = M2(field=m1)
-        m3 = M3(field=m1)
-        
-        Resource = type('Resource', (object,), {'fields':(), 'include':(), 'exclude':()})
-        
-        r = Resource()
-        r.fields = (('field', ('field1')),)
-
-        self.assertEqual(_object_to_data(m2, r), dict(field=dict(field1=u'foo')))
-        
-        r.fields = (('field', ('field2')),)
-        self.assertEqual(_object_to_data(m3, r), dict(field=dict(field2=u'bar')))
-        

djangorestframework/tests/serializer.py

+"""Tests for the resource module"""
+from django.test import TestCase
+from djangorestframework.serializer import Serializer
+
+from django.db import models
+
+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')), '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)
+
+
+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()
+            field2 = models.CharField()
+
+        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):
+            class Meta:
+                fields = (('field', ('field1',)),)
+
+        class SerializerM3(Serializer):
+            class Meta:
+                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):
+            class Meta:
+                fields = ('field1', )
+
+        class NestedM3(Serializer):
+            class Meta:
+                fields = ('field2', )
+
+        class SerializerM2(Serializer):
+            class Meta:
+                fields = [('field', NestedM2)]
+
+        class SerializerM3(Serializer):
+            class Meta:
+                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):
+            class Meta:
+                fields = [('field', 'NestedM2')]
+
+        class SerializerM3(Serializer):
+            class Meta:
+                fields = [('field', 'NestedM3')]
+
+        class NestedM2(Serializer):
+            class Meta:
+                fields = ('field1', )
+
+        class NestedM3(Serializer):
+            class Meta:
+                fields = ('field2', )
+
+        self.assertEqual(SerializerM2().serialize(self.m2), {'field': {'field1': u'foo'}})
+        self.assertEqual(SerializerM3().serialize(self.m3), {'field': {'field2': u'bar'}})

djangorestframework/tests/validators.py

@@ -75,7 +75,8 @@ class TestNonFieldErrors(TestCase):
                 return self.cleaned_data  #pragma: no cover
         
         class MockResource(FormResource):
-            form = MockForm
+            class Meta:
+                form = MockForm
         
         class MockView(View):
             pass
@@ -99,10 +100,12 @@ class TestFormValidation(TestCase):
             qwerty = forms.CharField(required=True)
 
         class MockFormResource(FormResource):
-            form = MockForm
+            class Meta:
+                form = MockForm
         
         class MockModelResource(ModelResource):
-            form = MockForm
+            class Meta:
+                form = MockForm
  
         class MockFormView(View):
             resource = MockFormResource
@@ -275,7 +278,8 @@ class TestModelFormValidator(TestCase):
                 return 'read only'
         
         class MockResource(ModelResource):
-            model = MockModel
+            class Meta:
+                model = MockModel
  
         class MockView(View):
             resource = MockResource

djangorestframework/views.py

@@ -150,8 +150,8 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView):
         response.headers['Allow'] = ', '.join(self.allowed_methods)
         response.headers['Vary'] = 'Authenticate, Accept'
 
-        return self.render(response)    
-
+        return self.render(response)
+    
 
 class ModelView(View):
     """A RESTful view that maps to a model in the database."""

docs/index.rst

@@ -80,7 +80,8 @@ Using Django REST framework can be as simple as adding a few lines to your urlco
     from myapp.models import MyModel
     
     class MyResource(ModelResource):
-        model = MyModel
+        class Meta:
+            model = MyModel
 
     urlpatterns = patterns('',
         url(r'^$', ListOrCreateModelView.as_view(resource=MyResource)),
@@ -134,6 +135,7 @@ Library Reference
   library/renderers
   library/resource
   library/response
+  library/serializer
   library/status
   library/views
 

docs/library/serializer.rst

+:mod:`serializer` 
+=================
+
+.. module:: serializer
+
+.. autoclass:: serializer::Serializer.Meta
+   :members:
+
+.. autoclass:: serializer::Serializer
+   :members:

examples/blogpost/urls.py

@@ -11,9 +11,10 @@ class BlogPostResource(ModelResource):
     """
     A Blog Post has a *title* and *content*, and can be associated with zero or more comments.
     """
-    model = BlogPost
-    fields = ('created', 'title', 'slug', 'content', 'url', 'comments')
-    ordering = ('-created',)
+    class Meta:
+        model = BlogPost
+        fields = ('created', 'title', 'slug', 'content', 'url', 'comments')
+        ordering = ('-created',)
 
     def comments(self, instance):
         return reverse('comments', kwargs={'blogpost': instance.key}) 
@@ -23,9 +24,10 @@ class CommentResource(ModelResource):
     """
     A Comment is associated with a given Blog Post and has a *username* and *comment*, and optionally a *rating*. 
     """
-    model = Comment
-    fields = ('username', 'comment', 'created', 'rating', 'url', 'blogpost')
-    ordering = ('-created',)
+    class Meta:
+        model = Comment
+        fields = ('username', 'comment', 'created', 'rating', 'url', 'blogpost')
+        ordering = ('-created',)
 
 
 urlpatterns = patterns('',

examples/modelresourceexample/urls.py

@@ -4,9 +4,10 @@ from djangorestframework.resources import ModelResource
 from modelresourceexample.models import MyModel
 
 class MyModelResource(ModelResource):
-    model = MyModel
-    fields = ('foo', 'bar', 'baz', 'url')
-    ordering = ('created',)
+    class Meta:
+        model = MyModel
+        fields = ('foo', 'bar', 'baz', 'url')
+        ordering = ('created',)
 
 urlpatterns = patterns('',
     url(r'^$',          ListOrCreateModelView.as_view(resource=MyModelResource), name='model-resource-root'),