Merge lp:~fgallina/rnr-server/paginated-handler into lp:rnr-server

[Fabián Ezequiel Gallina]

Added pagination support for piston handlers

Added pagination support for piston handlers

[lp:~fgallina/rnr-server/paginated-handler]

275. By Fabián Ezequiel Gallina on 2014-08-29

Promote PaginatedHandlerMixin.make_paginated_response to a function

276. By Fabián Ezequiel Gallina on 2014-08-29

Rename TestCase

[James Westby (james-w)]

Hi,

Thanks for making that change. I would move the functions to src/core/api/pagination.py and make them all public, but that's up to you whether you agree.

Thanks,

James

review: Approve

[lp:~fgallina/rnr-server/paginated-handler]

277. By Fabián Ezequiel Gallina on 2014-08-29

Move API pagination functions

=== added directory 'src/core/api'
=== added file 'src/core/api/__init__.py'
=== added file 'src/core/api/pagination.py'
--- src/core/api/pagination.py	1970-01-01 00:00:00 +0000
+++ src/core/api/pagination.py	2014-08-29 19:35:29 +0000
@@ -0,0 +1,77 @@
+import urllib
+import urlparse
+
+from django.core.paginator import (
+    EmptyPage,
+    InvalidPage,
+    PageNotAnInteger,
+    Paginator
+)
+
+
+def _get_page_url(request, page_number_fn):
+    absolute_uri = request.build_absolute_uri()
+    uri_split = urlparse.urlsplit(absolute_uri)
+    query_dict = urlparse.parse_qs(uri_split.query)
+
+    try:
+        page_number = page_number_fn()
+        query_dict['page'] = [page_number]
+        query = urllib.urlencode(query_dict, doseq=True)
+        page_url = urlparse.SplitResult(uri_split.scheme,
+                                        uri_split.netloc,
+                                        uri_split.path,
+                                        query,
+                                        uri_split.fragment).geturl()
+    except InvalidPage:
+        page_url = None
+
+    return page_url
+
+
+def _get_previous_page_url(request, page):
+    return _get_page_url(request, page.previous_page_number)
+
+
+def _get_next_page_url(request, page):
+    return _get_page_url(request, page.next_page_number)
+
+
+def make_paginated_response(
+        request, queryset, page_size=20, max_page_size=100):
+    """Return paginated results with pagination data.
+
+    This is the main entry point for the mixin and must be
+    explicitly called with the desired queryset/object list to be
+    paginated.
+
+    Args:
+        request: A request object.
+        queryset: A QuerySet or iterable to be paginated.
+        page_size: The number of results per page.
+        max_page_size: The max number of results per page.
+            Results are unlimited when None.
+
+    Returns:
+        A Dict including links to previous/next page, the object
+        list count for current page, the total number of results
+        and the results for the current page.
+    """
+    page_size = request.GET.get('page_size', page_size)
+    if max_page_size is not None:
+        page_size = min(page_size, max_page_size)
+
+    paginator = Paginator(queryset, page_size)
+    page = request.GET.get('page', 1)
+    try:
+        page = paginator.page(page)
+    except PageNotAnInteger:
+        page = paginator.page(1)
+    except EmptyPage:
+        page = paginator.page(paginator.num_pages)
+
+    # 'django-rest-framework'-like serialization
+    return {'previous': _get_previous_page_url(request, page),
+            'next': _get_next_page_url(request, page),
+            'count': len(page.object_list),
+            'results': page.object_list}

=== added directory 'src/core/tests'
=== added file 'src/core/tests/__init__.py'
=== added file 'src/core/tests/test_pagination.py'
--- src/core/tests/test_pagination.py	1970-01-01 00:00:00 +0000
+++ src/core/tests/test_pagination.py	2014-08-29 19:35:29 +0000
@@ -0,0 +1,145 @@
+import urlparse
+
+from django.test import TestCase
+from mock import Mock
+
+from core.api.pagination import make_paginated_response
+
+
+class MakePaginatedResponseTestCase(TestCase):
+
+    maxDiff = None
+
+    def setUp(self):
+        super(MakePaginatedResponseTestCase, self).setUp()
+        self.request = self.make_request()
+
+    def make_request(self, page_size=None, page=None, uri=None):
+        request = Mock()
+        request.GET = {}
+
+        if page_size is not None:
+            request.GET['page_size'] = page_size
+
+        if page is not None:
+            request.GET['page'] = page
+
+        if uri is None:
+            uri = 'http://someserver.org/api/objects/'
+
+        request.build_absolute_uri = lambda location=None: uri
+        return request
+
+    def test_first_page(self):
+        objects = range(100)
+        request = self.make_request(page=1)
+        response = make_paginated_response(request, objects)
+        self.assertEqual(response, {
+            'previous': None,
+            'next': self.request.build_absolute_uri() + '?page=2',
+            'count': 20,
+            'results': range(20)})
+
+    def test_no_page_gives_first_page(self):
+        objects = range(100)
+        response = make_paginated_response(self.request, objects)
+        self.assertEqual(response, {
+            'previous': None,
+            'next': self.request.build_absolute_uri() + '?page=2',
+            'count': 20,
+            'results': range(20)})
+
+    def test_next_page(self):
+        objects = range(100)
+        request = self.make_request(page=2)
+        response = make_paginated_response(request, objects)
+        self.assertEqual(response, {
+            'previous': self.request.build_absolute_uri() + '?page=1',
+            'next': self.request.build_absolute_uri() + '?page=3',
+            'count': 20,
+            'results': range(20, 40)})
+
+    def test_last_page(self):
+        objects = range(21)
+        request = self.make_request(page=2)
+        response = make_paginated_response(request, objects)
+        self.assertEqual(response, {
+            'previous': self.request.build_absolute_uri() + '?page=1',
+            'next': None,
+            'count': 1,
+            'results': [20]})
+
+    def test_unlimited_results(self):
+        objects = range(1000)
+        request = self.make_request(page_size=2000)
+        response = make_paginated_response(
+            request, objects, max_page_size=None)
+        self.assertEqual(response, {
+            'previous': None,
+            'next': None,
+            'count': 1000,
+            'results': objects})
+
+    def test_max_page_size(self):
+        objects = range(1000)
+        request = self.make_request(page_size=2000)
+        response = make_paginated_response(
+            request, objects, max_page_size=20)
+        self.assertEqual(response, {
+            'previous': None,
+            'next': request.build_absolute_uri() + '?page=2',
+            'count': 20,
+            'results': range(20)})
+
+    def test_default_page_size(self):
+        objects = range(100)
+        response = make_paginated_response(
+            self.request, objects, page_size=50)
+        self.assertEqual(response, {
+            'previous': None,
+            'next': self.request.build_absolute_uri() + '?page=2',
+            'count': 50,
+            'results': range(50)})
+
+    def test_invalid_page_uses_first(self):
+        objects = range(100)
+        request = self.make_request(page='invalid')
+        response = make_paginated_response(request, objects)
+        self.assertEqual(response, {
+            'previous': None,
+            'next': request.build_absolute_uri() + '?page=2',
+            'count': 20,
+            'results': range(20)})
+
+    def test_empty_page_uses_last_page(self):
+        objects = range(100)
+        # There are only 5 pages of 20 objects each, and user requests
+        # the 200th page, she should get the last page instead.
+        request = self.make_request(page=200)
+        response = make_paginated_response(request, objects)
+        self.assertEqual(response, {
+            'previous': request.build_absolute_uri() + '?page=4',
+            'next': None,
+            'count': 20,
+            'results': range(80, 100)})
+
+    def test_next_and_previous_links_respect_query_params(self):
+        objects = range(100)
+        uri = 'http://someserver.org/api/objects/?a=1&b=2&b=3&c=4'
+        request = self.make_request(page=2, uri=uri)
+        response = make_paginated_response(request, objects)
+
+        self.assertEqual(response['count'], 20)
+        self.assertEqual(response['results'], range(20, 40))
+
+        # existing query params must be in next and previous links
+        expected_previous_qs = urlparse.parse_qs(
+            urlparse.urlsplit(uri + '&page=1').query)
+        expected_next_qs = urlparse.parse_qs(
+            urlparse.urlsplit(uri + '&page=3').query)
+        previous_qs = urlparse.parse_qs(
+            urlparse.urlsplit(response['previous']).query)
+        next_qs = urlparse.parse_qs(
+            urlparse.urlsplit(response['next']).query)
+        self.assertEqual(previous_qs, expected_previous_qs)
+        self.assertEqual(next_qs, expected_next_qs)