def test_get_context_data(self):
request = HttpRequest()
request.GET = {'page': 2}
view = ReviewListView(request=request)
view.object_list = [ReviewFactory()]
with patch.object(Paginator, 'page') as mock_page:
view.get_context_data()
mock_page.assert_called_once_with(2)
with patch.object(
Paginator,
'page',
side_effect=PageNotAnInteger()
) as mock_page:
try:
view.get_context_data()
except PageNotAnInteger:
pass
mock_page.has_call(1)
with patch.object(Paginator, 'page', side_effect=EmptyPage()) as mock:
try:
view.get_context_data()
except EmptyPage:
pass
mock.has_call(1)
def validate_number(self, number):
"""
Validates the given 1-based page number.
We also check that the number isn't too large.
"""
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger("That page number is not an integer")
if number < 1:
raise EmptyPage("That page number is less than 1")
if number >= 1000:
# Anything >=1,000 will result in a hard error in
# Elasticsearch which would happen before we even get a chance
# to validate that the range is too big. The error you would
# get from Elasticsearch 6.x is something like this:
#
# Result window is too large, from + size must be less
# than or equal to: [10000] but was [11000].
#
# See https://github.com/mdn/kuma/issues/6092
raise InvalidPage("Page number too large")
return number
def test_get_context_data(self):
news = ArtsNewsFactory()
request = HttpRequest()
view = NewsListView(request=request)
view.object_list = [news]
request.GET = {'page': 2}
with patch.object(Paginator, 'page', return_value='page') as mock_page:
with patch.object(view, 'get_queryset', return_value=[news]):
context = view.get_context_data()
self.assertEqual(context['page'], 'page')
mock_page.assert_called_once_with(2)
with patch.object(
Paginator,
'page',
side_effect=PageNotAnInteger()
) as mock_page:
with patch.object(view, 'get_queryset', return_value=[news]):
try:
context = view.get_context_data()
except PageNotAnInteger:
pass
mock_page.has_call(1)
with patch.object(Paginator, 'page', side_effect=EmptyPage()) as mock:
with patch.object(view, 'get_queryset', return_value=[news]):
try:
context = view.get_context_data()
except EmptyPage:
pass
mock.has_call(1)
def page(self, number):
"""
Returns a Page object for the given 1-based page number.
This will attempt to pull the results out of the cache first, based on
the requested page number. If not found in the cache,
it will pull a fresh list and then cache that result + the total result count.
"""
if self.cache_key is None:
return super(CachedPaginator, self).page(number)
# In order to prevent counting the queryset
# we only validate that the provided number is integer
# The rest of the validation will happen when we fetch fresh data.
# so if the number is invalid, no cache will be setted
# number = self.validate_number(number)
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger('That page number is not an integer')
page_cache_key = "%s:%s:%s" % (self.cache_key, self.per_page, number)
page_data = cache.get(page_cache_key)
if page_data is None:
page = super(CachedPaginator, self).page(number)
#cache not only the objects, but the total count too.
page_data = (page.object_list, self.count)
cache.set(page_cache_key, page_data, self.cache_timeout)
else:
cached_object_list, cached_total_count = page_data
self.set_count(cached_total_count)
page = Page(cached_object_list, number, self)
return page
def test_get_context_data(self):
request = HttpRequest()
request.GET = {'page': 2}
view = PastAuditionListView(request=request)
view.object_list = [AuditionFactory()]
with patch.object(Paginator, 'page', return_value='page') as mock_page:
context = view.get_context_data()
mock_page.assert_called_once_with(2)
self.assertEqual(context['page'], 'page')
with patch.object(
Paginator,
'page',
side_effect=PageNotAnInteger()
) as mock_page:
try:
view.get_context_data()
except PageNotAnInteger:
pass
mock_page.has_call(1)
with patch.object(Paginator, 'page', side_effect=EmptyPage()) as mock:
try:
view.get_context_data()
except EmptyPage:
pass
mock.has_call(1)
def validate_number(self, number):
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger('That page number is not an integer')
if number not in self.object_list:
raise EmptyPage('That page contains no result')
return number
def validate_number(self, number):
try:
number = int(number)
except ValueError:
raise PageNotAnInteger('That page number is not an integer')
if number < 1:
raise EmptyPage('That page number is less than 1')
return number
def paginated_note_view(request):
try:
note_list = Note.objects.all()
paginator = Paginator(note_list, 3)
page = request.GET.get('page')
notes = paginator.get_page(page)
return render(request, 'notes_list.html', {'notes': notes})
except (TypeError, ValueError):
raise PageNotAnInteger('That page number is not an integer')
def validate_page_number(number):
"""Validate the given 1-based page number."""
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger('That page number is not an integer')
if number < 1:
raise EmptyPage('That page number is less than 1')
return number
def test_generic_pagination_return_except_pagenotinteger(
self, mock_paginator):
mock_paginator.side_effect = PageNotAnInteger()
items = [1, 2, 3, 4, 5, 6]
paginated_items = utils.generic_pagination(items, 1, 2)
self.assertEqual(paginated_items.number, 1)
def validate_number(self, number):
"""
Validates the given 1-based page number.
"""
try:
number = int(number)
except ValueError:
raise PageNotAnInteger("That page number is not an integer")
if number < 1:
raise EmptyPage("That page number is less than 1")
return number
def validate_number(self, number):
"""Validate the given 1-based page number."""
try:
if isinstance(number, float) and not number.is_integer():
raise ValueError
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger(_("That page number is not an integer"))
if number < 1:
raise EmptyPage(_("That page number is less than 1"))
return number
def validate_number(self, number):
"""
Validates the given 1-based page number.
This class overrides the default behavior and ignores the upper bound.
"""
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger('That page number is not an integer')
if number < 1:
raise EmptyPage('That page number is less than 1')
return number
def test_invalid_page_pagination_number(self):
data = ["s", "b", "c", "d", "e", "f", "g", "h"]
test_1 = paginate_page("...", data)
test_2 = paginate_page(-1, data)
with patch.object(Manager, 'get_or_create') as a:
a.side_effect = PageNotAnInteger("page number is not an integer")
res = paginate_page("...", data)
self.assertEqual(res['page_range'], test_1['page_range'])
with patch.object(Manager, 'get_or_create') as a:
a.side_effect = EmptyPage("page number is less than 1")
res = paginate_page(-1, data)
self.assertEqual(res['page_range'], test_2['page_range'])
def validate_number(self, number):
"""Validates the given 1-based page number.
Override to stop checking if we have gone to far since that requires
knowing the total number of pages.
"""
try:
number = int(number)
except ValueError:
raise PageNotAnInteger("That page number is not an integer")
if number < 1:
raise EmptyPage("That page number is less than 1")
return number
def validate_number(
self, number
): # overwrite validation so it allows empty pages all the time
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger('That page number is not an integer')
if number < 1:
raise EmptyPage('That page number is less than 1')
if not self.allow_empty_first_page:
if number > self.num_pages:
raise EmptyPage('That page contains no results')
return number
def validate_number(self, number):
"""
Validates the given 1-based page number.
:param number:
:return:
"""
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger(_('That page number is not an integer'))
if number < 1:
raise EmptyPage(_('That page number is less than 1'))
return number
def pre_validate_number(self, number):
"""
Validate the given 1-based page number, without checking if the number is greater than
the total number of pages.
"""
try:
if isinstance(number, float) and not number.is_integer():
raise ValueError
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger(_("That page number is not an integer"))
if number < 1:
raise EmptyPage(_("That page number is less than 1"))
return number
def validate_number(self, number):
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger("That page number is not an integer")
if number < 1:
raise EmptyPage("That page number is less than 1")
if number > self.num_pages:
if number == 1 and self.allow_empty_first_page:
pass
else:
raise EmptyPage('That page contains no results')
return number
def set_count(self, count):
"""
method used for seting and validating the count param
the count param changes PAGINATION_COUNT which control the
quantity of instances comming in one page
:param count: set count used for pagination
"""
try:
self.PAGINATION_COUNT = int(count)
except Exception:
raise PageNotAnInteger(self.PAGE_ERR_MSG_COUNT_ARG)
if self.PAGINATION_COUNT <= 0:
raise InvalidPage(self.PAGE_ERR_MSG_LOW_0)
def validate_number(self, number):
try:
if isinstance(number, float) and not number.is_integer():
raise ValueError
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger(_('That page number is not an integer'))
if number < 1:
raise EmptyPage(_('That page number is less than 1'))
if number > self.num_pages and not (number == 1
and self.allow_empty_first_page):
return 1
return number
def validate_number(self, number):
"""
Validates the given 1-based page number.
"""
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger('That page number is not an integer')
if number < 1:
raise EmptyPage('That page number is less than 1')
if number > self.num_pages:
if number == 1 and self.allow_empty_first_page:
pass
else:
number = self.num_pages
return number
def validate_number(self, number):
"""Validate the given 1-based page number."""
try:
if isinstance(number, float) and not number.is_integer():
raise ValueError
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger(_('That page number is not an integer'))
if number < 1:
raise EmptyPage(_('That page number is less than 1'))
if number > self.num_pages:
if number == 1:
pass
else:
raise EmptyPage(_('That page contains no results'))
return number
def validate_number(self, number):
"Validates the given 1-based page number."
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger('That page number is not an integer')
if number < 1:
return 1
if number > self.num_pages:
if number == 1 and self.allow_empty_first_page:
return 1
elif self.num_pages > 0:
return self.num_pages
else:
raise EmptyPage('That page contains no results')
return number
def validate_number(self, number):
"Validates the given 1-based page number."
try:
number = int(number)
except ValueError:
raise PageNotAnInteger('That page number is not an integer')
if number < 1:
if SHOW_FIRST_PAGE_WHEN_INVALID:
number = 1
else:
raise EmptyPage('That page number is less than 1')
if number > self.num_pages:
if number == 1 and self.allow_empty_first_page:
pass
else:
number = 1
return number
def page(self, number):
"Returns a Page object for the given 1-based page number."
try:
number = int(number)
except ValueError:
raise PageNotAnInteger('That page number is not an integer')
bottom = (number - 1) * self.per_page
top = bottom + self.per_page + 5
try:
_page = EndlessPage(list(self.object_list[bottom:top]), number, self)
except AssertionError:
top = top - 5
_page = EndlessPage(list(self.object_list[bottom:top]), number, self)
if not _page.object_list:
if number == 1 and self.allow_empty_first_page:
pass
else:
raise EmptyPage('That page contains no results')
return _page
def validate_number(self, number):
"Validates the given 1-based page number."
try:
number = int(number)
# catch any case that given number is None or a string which is not a number
except (ValueError, TypeError):
raise PageNotAnInteger('That page number is not an integer')
if number < 1:
raise EmptyPage('That page number is less than 1')
if number > self.num_pages:
if number == 1:
pass
elif self.limited_number_of_objects:
bottom = (number - 1) * self.per_page
top = bottom + self.per_page
if not self.object_list[bottom:top].count():
raise EmptyPage('That page contains no results')
else:
raise EmptyPage('That page contains no results')
return number
