Merge pull request #15 from erichonkanen/master

jerel · jerel · commit 576a9c6630f2 · 2014-12-10T10:27:27.000-06:00
Rest Framework &lt;-&gt; Ember Data key format conversion
diff --git a/README.rst b/README.rst
@@ -116,8 +116,6 @@ override ``settings.REST_FRAMEWORK``::
         ),
     }
 
-
-
 If ``PAGINATE_BY`` is set the renderer will return a ``meta`` object with
 record count and the next and previous links. Django Rest Framework looks
 for the ``page`` GET parameter by default allowing you to make requests for
@@ -141,6 +139,61 @@ the ``resource_name`` property is required on the class::
         permission_classes = (permissions.IsAuthenticated, )
 
 
+Ember Data <-> Rest Framework Format Conversion
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+*(camelization/underscore/pluralize)*
+
+This package includes the optional ability to automatically convert json requests
+and responses from the Ember Data camelCase to python/rest_framework's preferred 
+underscore. Additionally resource names can be pluralized if more than one object 
+is included in a serialized response as Ember Data expects. To hook this up, 
+include the following in your project settings::
+
+   REST_EMBER_FORMAT_KEYS = True
+   REST_EMBER_PLURALIZE_KEYS = True
+
+
+Example - Without format conversion::
+
+   {
+      "identity": [
+         {
+            "id": 1,
+            "username": "john",
+            "first_name": "John",
+            "last_name": "Coltrane"
+         },
+         {
+            "id": 2,
+            "username": "frodo",
+            "first_name": "Bilbo",
+            "last_name": "Baggins"
+         },
+      ],
+      ...
+   }
+
+Example - With format conversion::
+
+   {
+      "identities": [
+         {
+            "id": 1,
+            "username": "john",
+            "firstName": "John",
+            "lastName": "Coltrane"
+         },
+         {
+            "id": 2,
+            "username": "frodo",
+            "firstName": "Bilbo",
+            "lastName": "Baggins"
+         },
+      ],
+      ...
+   }
+
+
 Managing the trailing slash
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/example/tests/test_format_keys.py b/example/tests/test_format_keys.py
@@ -0,0 +1,76 @@
+import json
+
+from example.tests import TestBase
+
+from django.contrib.auth import get_user_model
+from django.core.urlresolvers import reverse, reverse_lazy
+from django.conf import settings
+
+
+class FormatKeysSetTests(TestBase):
+    """
+    Test that camelization and underscoring of key names works if they are activated.
+    """
+    list_url = reverse_lazy('user-list')
+
+    def setUp(self):
+        super(FormatKeysSetTests, self).setUp()
+        self.detail_url = reverse('user-detail', kwargs={'pk': self.miles.pk})
+
+        # Set the format keys settings.
+        setattr(settings, 'REST_EMBER_FORMAT_KEYS', True)
+        setattr(settings, 'REST_EMBER_PLURALIZE_KEYS', True)
+
+    def tearDown(self):
+        # Remove the format keys settings.
+        delattr(settings, 'REST_EMBER_FORMAT_KEYS')
+        delattr(settings, 'REST_EMBER_PLURALIZE_KEYS')
+
+
+    def test_camelization(self):
+        """
+        Test that camelization works.
+        """
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+        user = get_user_model().objects.all()[0]
+        expected = {
+            u'user': [{
+                u'id': user.pk,
+                u'firstName': user.first_name,
+                u'lastName': user.last_name,
+                u'email': user.email
+            }]
+        }
+
+        json_content = json.loads(response.content)
+        meta = json_content.get('meta')
+       
+        self.assertEquals(expected.get('user'), json_content.get('user'))
+        self.assertEqual('http://testserver/user-viewset/?page=2', meta.get('nextLink'))
+
+    def test_pluralization(self):
+        """
+        Test that the key name is pluralized.
+        """
+        response = self.client.get(self.list_url, {'page_size': 2})
+        self.assertEqual(response.status_code, 200)
+
+        users = get_user_model().objects.all()
+        expected = {
+            u'users': [{
+                u'id': users[0].pk,
+                u'firstName': users[0].first_name,
+                u'lastName': users[0].last_name,
+                u'email': users[0].email
+            },{
+                u'id': users[1].pk,
+                u'firstName': users[1].first_name,
+                u'lastName': users[1].last_name,
+                u'email': users[1].email
+            }]
+        }
+
+        json_content = json.loads(response.content)
+        self.assertEquals(expected.get('users'), json_content.get('users'))
diff --git a/example/tests/test_generic_viewset.py b/example/tests/test_generic_viewset.py
@@ -1,4 +1,3 @@
-
 import json
 from example.tests import TestBase
 from django.core.urlresolvers import reverse
@@ -49,3 +48,4 @@ def test_ember_expected_renderer(self):
             }
         )
 
+
diff --git a/example/tests/test_model_viewsets.py b/example/tests/test_model_viewsets.py
@@ -1,17 +1,19 @@
-
-
 import json
+
 from example.tests import TestBase
+
 from django.contrib.auth import get_user_model
 from django.core.urlresolvers import reverse, reverse_lazy
 from django.conf import settings
 
 
 class ModelViewSetTests(TestBase):
     """
-    Test usage with ModelViewSets
+    Test usage with ModelViewSets, also tests pluralization, camelization,
+    and underscore.
 
-    [<RegexURLPattern user-list ^user-viewsets/$>, <RegexURLPattern user-detail ^user-viewsets/(?P<pk>[^/]+)/$>]
+    [<RegexURLPattern user-list ^user-viewsets/$>,
+    <RegexURLPattern user-detail ^user-viewsets/(?P<pk>[^/]+)/$>]
     """
     list_url = reverse_lazy('user-list')
 
@@ -21,29 +23,31 @@ def setUp(self):
 
     def test_key_in_list_result(self):
         """
-        Ensure the result has a "user" key since that is the name of the model
+        Ensure the result has a 'user' key since that is the name of the model
         """
         response = self.client.get(self.list_url)
         self.assertEqual(response.status_code, 200)
 
         user = get_user_model().objects.all()[0]
-        expected = {"user": [{
-            'id': user.pk,
-            'first_name': user.first_name,
-            'last_name': user.last_name,
-            'email': user.email
-        }]}
+        expected = {
+            u'user': [{
+                u'id': user.pk,
+                u'first_name': user.first_name,
+                u'last_name': user.last_name,
+                u'email': user.email
+            }]
+        }
 
         json_content = json.loads(response.content)
-        meta = json_content.get("meta")
+        meta = json_content.get('meta')
 
         self.assertEquals(expected.get('user'), json_content.get('user'))
         self.assertEquals(meta.get('count', 0),
             get_user_model().objects.count())
-        self.assertEquals(meta.get("next"), 2)
+        self.assertEquals(meta.get('next'), 2)
         self.assertEqual('http://testserver/user-viewset/?page=2',
-            meta.get("next_link"))
-        self.assertEqual(meta.get("page"), 1)
+            meta.get('next_link'))
+        self.assertEqual(meta.get('page'), 1)
 
     def test_page_two_in_list_result(self):
         """
@@ -53,72 +57,75 @@ def test_page_two_in_list_result(self):
         self.assertEqual(response.status_code, 200)
 
         user = get_user_model().objects.all()[1]
-        expected = {"user": [{
-            'id': user.pk,
-            'first_name': user.first_name,
-            'last_name': user.last_name,
-            'email': user.email
-        }]}
+        expected = {
+            u'user': [{
+                u'id': user.pk,
+                u'first_name': user.first_name,
+                u'last_name': user.last_name,
+                u'email': user.email
+            }]
+        }
 
         json_content = json.loads(response.content)
-        meta = json_content.get("meta")
+        meta = json_content.get('meta')
 
         self.assertEquals(expected.get('user'), json_content.get('user'))
         self.assertEquals(meta.get('count', 0),
             get_user_model().objects.count())
-        self.assertIsNone(meta.get("next"))
-        self.assertIsNone(meta.get("next_link"))
-        self.assertEqual(meta.get("previous"), 1)
+        self.assertIsNone(meta.get('next'))
+        self.assertIsNone(meta.get('next_link'))
+        self.assertEqual(meta.get('previous'), 1)
         self.assertEqual('http://testserver/user-viewset/?page=1',
-            meta.get("previous_link"))
-        self.assertEqual(meta.get("page"), 2)
+            meta.get('previous_link'))
+        self.assertEqual(meta.get('page'), 2)
 
     def test_page_range_in_list_result(self):
         """
-        Ensure that the range of a page can be changed from the client.
+        Ensure that the range of a page can be changed from the client,
+        tests pluralization as two objects means it converts ``user`` to
+        ``users``.
         """
         response = self.client.get(self.list_url, {'page_size': 2})
         self.assertEqual(response.status_code, 200)
 
         users = get_user_model().objects.all()
-        expected = {"user": [
-        {
-            'id': users[0].pk,
-            'first_name': users[0].first_name,
-            'last_name': users[0].last_name,
-            'email': users[0].email
-        },
-        {
-            'id': users[1].pk,
-            'first_name': users[1].first_name,
-            'last_name': users[1].last_name,
-            'email': users[1].email
-        }]}
+        expected = {
+            u'users': [{
+                u'id': users[0].pk,
+                u'first_name': users[0].first_name,
+                u'last_name': users[0].last_name,
+                u'email': users[0].email
+            },{
+                u'id': users[1].pk,
+                u'first_name': users[1].first_name,
+                u'last_name': users[1].last_name,
+                u'email': users[1].email
+            }]
+        }
 
         json_content = json.loads(response.content)
-        meta = json_content.get("meta")
-        self.assertEquals(expected.get('user'), json_content.get('user'))
+        meta = json_content.get('meta')
+        self.assertEquals(expected.get('users'), json_content.get('user'))
         self.assertEquals(meta.get('count', 0),
             get_user_model().objects.count())
 
 
     def test_key_in_detail_result(self):
         """
-        Ensure the result has a "user" key.
+        Ensure the result has a 'user' key.
         """
         response = self.client.get(self.detail_url)
         self.assertEqual(response.status_code, 200)
 
         result = json.loads(response.content)
         expected = {
-            'user': {
-                'id': self.miles.pk,
-                'first_name': self.miles.first_name,
-                'last_name': self.miles.last_name,
-                'email': self.miles.email
+            u'user': {
+                u'id': self.miles.pk,
+                u'first_name': self.miles.first_name,
+                u'last_name': self.miles.last_name,
+                u'email': self.miles.email
             }
         }
-
         self.assertEqual(result, expected)
 
     def test_key_in_post(self):
@@ -127,11 +134,11 @@ def test_key_in_post(self):
         """
         self.client.login(username='miles', password='pw')
         data = {
-            'user': {
-                'id': self.miles.pk,
-                'first_name': self.miles.first_name,
-                'last_name': self.miles.last_name,
-                'email': 'miles@trumpet.org'
+            u'user': {
+                u'id': self.miles.pk,
+                u'first_name': self.miles.first_name,
+                u'last_name': self.miles.last_name,
+                u'email': 'miles@trumpet.org'
             }
         }
         response = self.client.put(self.detail_url, data=data, format='json')
@@ -145,4 +152,3 @@ def test_key_in_post(self):
         self.assertEqual(
             get_user_model().objects.get(pk=self.miles.pk).email,
             'miles@trumpet.org')
-
diff --git a/example/tests/test_multiple_id_mixin.py b/example/tests/test_multiple_id_mixin.py
@@ -1,5 +1,3 @@
-
-
 import json
 from example.tests import TestBase
 from django.contrib.auth import get_user_model
@@ -71,3 +69,4 @@ def test_multiple_ids_in_query_params(self):
             meta.get("next_link"))
         self.assertEqual(meta.get("page"), 1)
 
+
diff --git a/rest_framework_ember/parsers.py b/rest_framework_ember/parsers.py
@@ -2,9 +2,10 @@
 Parsers
 """
 from rest_framework.parsers import JSONParser
-
 from rest_framework_ember.utils import get_resource_name
 
+from .utils import format_keys
+
 
 class EmberJSONParser(JSONParser):
     """
@@ -21,14 +22,11 @@ class EmberJSONParser(JSONParser):
     So we can work with the grain on both Ember and RestFramework,
     Do some tweaks to the payload so DRF gets what it expects.
     """
-
     def parse(self, stream, media_type=None, parser_context=None):
         """
         Parses the incoming bytestream as JSON and returns the resulting data
         """
-        result = super(EmberJSONParser, self).parse(
-            stream, media_type=None, parser_context=None)
-
-        resource_name = get_resource_name(parser_context.get('view', None))
-        return result.get(resource_name)
-
+        result = super(EmberJSONParser, self).parse(stream, media_type=None,
+                                                    parser_context=None)
+        resource = result.get(get_resource_name(parser_context.get('view', None)))
+        return format_keys(resource, 'underscore')
diff --git a/rest_framework_ember/renderers.py b/rest_framework_ember/renderers.py
diff --git a/rest_framework_ember/utils.py b/rest_framework_ember/utils.py
diff --git a/setup.py b/setup.py

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-`
`2`	`1`	`import json`
`3`	`2`	`from example.tests import TestBase`
`4`	`3`	`from django.core.urlresolvers import reverse`
`@@ -49,3 +48,4 @@ def test_ember_expected_renderer(self):`
`49`	`48`	`}`
`50`	`49`	`)`
`51`	`50`
	`51`	`+`