bugfix: camelcase, etc. sort parameters were being ignored.

Also added more test_cases and suppor for sorting via relationship paths.

Author: n2ygk

example/tests/test_filters.py

@@ -24,8 +24,7 @@ def test_sort(self):
                          msg=response.content.decode("utf-8"))
         dja_response = response.json()
         headlines = [c['attributes']['headline'] for c in dja_response['data']]
-        sorted_headlines = [c['attributes']['headline'] for c in dja_response['data']]
-        sorted_headlines.sort()
+        sorted_headlines = sorted(headlines)
         self.assertEqual(headlines, sorted_headlines)
 
     def test_sort_reverse(self):
@@ -37,8 +36,19 @@ def test_sort_reverse(self):
                          msg=response.content.decode("utf-8"))
         dja_response = response.json()
         headlines = [c['attributes']['headline'] for c in dja_response['data']]
-        sorted_headlines = [c['attributes']['headline'] for c in dja_response['data']]
-        sorted_headlines.sort()
+        sorted_headlines = sorted(headlines)
+        self.assertNotEqual(headlines, sorted_headlines)
+
+    def test_sort_double_negative(self):
+        """
+        what if they provide multiple `-`'s? It's OK.
+        """
+        response = self.client.get(self.url, data={'sort': '--headline'})
+        self.assertEqual(response.status_code, 200,
+                         msg=response.content.decode("utf-8"))
+        dja_response = response.json()
+        headlines = [c['attributes']['headline'] for c in dja_response['data']]
+        sorted_headlines = sorted(headlines)
         self.assertNotEqual(headlines, sorted_headlines)
 
     def test_sort_invalid(self):
@@ -52,3 +62,44 @@ def test_sort_invalid(self):
         dja_response = response.json()
         self.assertEqual(dja_response['errors'][0]['detail'],
                          "invalid sort parameters: nonesuch,-not_a_field")
+
+    def test_sort_camelcase(self):
+        """
+        test sort of camelcase field name
+        """
+        response = self.client.get(self.url, data={'sort': 'bodyText'})
+        self.assertEqual(response.status_code, 200,
+                         msg=response.content.decode("utf-8"))
+        dja_response = response.json()
+        blog_ids = [(c['attributes']['bodyText'] or '') for c in dja_response['data']]
+        sorted_blog_ids = sorted(blog_ids)
+        self.assertEqual(blog_ids, sorted_blog_ids)
+
+    def test_sort_underscore(self):
+        """
+        test sort of underscore field name
+        Do we allow this notation in a search even if camelcase is in effect?
+        "Be conservative in what you send, be liberal in what you accept"
+                   --  https://en.wikipedia.org/wiki/Robustness_principle
+        """
+        response = self.client.get(self.url, data={'sort': 'body_text'})
+        self.assertEqual(response.status_code, 200,
+                         msg=response.content.decode("utf-8"))
+        dja_response = response.json()
+        blog_ids = [(c['attributes']['bodyText'] or '') for c in dja_response['data']]
+        sorted_blog_ids = sorted(blog_ids)
+        self.assertEqual(blog_ids, sorted_blog_ids)
+
+    def test_sort_related(self):
+        """
+        test sort via related field using jsonapi path `.` and django orm `__` notation.
+        ORM relations must be predefined in the View's .ordering_fields attr
+        """
+        for datum in ('blog__id', 'blog.id'):
+            response = self.client.get(self.url, data={'sort': datum})
+            self.assertEqual(response.status_code, 200,
+                             msg=response.content.decode("utf-8"))
+            dja_response = response.json()
+            blog_ids = [c['relationships']['blog']['data']['id'] for c in dja_response['data']]
+            sorted_blog_ids = sorted(blog_ids)
+            self.assertEqual(blog_ids, sorted_blog_ids)

example/views.py

@@ -90,6 +90,7 @@ class NoPagination(PageNumberPagination):
 
 class NonPaginatedEntryViewSet(EntryViewSet):
     pagination_class = NoPagination
+    ordering_fields = ('headline', 'body_text', 'blog__name', 'blog__id')
 
 
 class AuthorViewSet(ModelViewSet):

rest_framework_json_api/filters.py

@@ -10,27 +10,35 @@ class JSONAPIOrderingFilter(OrderingFilter):
     if any sort field is invalid. If you prefer *not* to report 400 errors for
     invalid sort fields, just use OrderingFilter with `ordering_param='sort'`
 
-    TODO: Add sorting based upon relationships (sort=relname.fieldname)
+    Also applies DJA format_value() to convert (e.g. camelcase) to underscore.
+    (See JSON_API_FORMAT_FIELD_NAMES in docs/usage.md)
     """
     ordering_param = 'sort'
 
     def remove_invalid_fields(self, queryset, fields, view, request):
-        """
-        overrides remove_invalid_fields to raise a 400 exception instead of
-        silently removing them. set `ignore_bad_sort_fields = True` to not
-        do this validation.
-        """
         valid_fields = [
             item[0] for item in self.get_valid_fields(queryset, view,
                                                       {'request': request})
         ]
         bad_terms = [
             term for term in fields
-            if format_value(term.lstrip('-'), "underscore") not in valid_fields
+            if format_value(term.replace(".", "__").lstrip('-'), "underscore") not in valid_fields
         ]
         if bad_terms:
             raise ValidationError('invalid sort parameter{}: {}'.format(
                 ('s' if len(bad_terms) > 1 else ''), ','.join(bad_terms)))
+        # this looks like it duplicates code above, but we want the ValidationError to report
+        # the actual parameter supplied while we want the fields passed to the super() to
+        # be correctly rewritten.
+        # The leading `-` has to be stripped to prevent format_value from turning it into `_`.
+        underscore_fields = []
+        for item in fields:
+            item_rewritten = item.replace(".", "__")
+            if item_rewritten.startswith('-'):
+                underscore_fields.append(
+                    '-' + format_value(item_rewritten.lstrip('-'), "underscore"))
+            else:
+                underscore_fields.append(format_value(item_rewritten, "underscore"))
 
         return super(JSONAPIOrderingFilter, self).remove_invalid_fields(
-            queryset, fields, view, request)
+            queryset, underscore_fields, view, request)