Debian Codegraph @

tests/pagination/tests.py

raw
1 import collections.abc
2 import unittest.mock
3 import warnings
4 from datetime import datetime
5
6 from django.core.paginator import (
7 EmptyPage,
8 InvalidPage,
9 PageNotAnInteger,
10 Paginator,
11 UnorderedObjectListWarning,
12 )
13 from django.test import SimpleTestCase, TestCase
14
15 from .custom import ValidAdjacentNumsPaginator
16 from .models import Article
17
18
19 class PaginationTests(SimpleTestCase):
20 """
21 Tests for the Paginator and Page classes.
22 """
23
24 def check_paginator(self, params, output):
25 """
26 Helper method that instantiates a Paginator object from the passed
27 params and then checks that its attributes match the passed output.
28 """
29 count, num_pages, page_range = output
30 paginator = Paginator(*params)
31 self.check_attribute("count", paginator, count, params)
32 self.check_attribute("num_pages", paginator, num_pages, params)
33 self.check_attribute("page_range", paginator, page_range, params, coerce=list)
34
35 def check_attribute(self, name, paginator, expected, params, coerce=None):
36 """
37 Helper method that checks a single attribute and gives a nice error
38 message upon test failure.
39 """
40 got = getattr(paginator, name)
41 if coerce is not None:
42 got = coerce(got)
43 self.assertEqual(
44 expected,
45 got,
46 "For '%s', expected %s but got %s. Paginator parameters were: %s"
47 % (name, expected, got, params),
48 )
49
50 def test_paginator(self):
51 """
52 Tests the paginator attributes using varying inputs.
53 """
54 nine = [1, 2, 3, 4, 5, 6, 7, 8, 9]
55 ten = nine + [10]
56 eleven = ten + [11]
57 tests = (
58 # Each item is 2-tuple:
59 # First tuple is Paginator parameters - object_list, per_page,
60 # orphans, and allow_empty_first_page.
61 # Second tuple is resulting Paginator attributes - count,
62 # num_pages, and page_range.
63 # Ten items, varying orphans, no empty first page.
64 ((ten, 4, 0, False), (10, 3, [1, 2, 3])),
65 ((ten, 4, 1, False), (10, 3, [1, 2, 3])),
66 ((ten, 4, 2, False), (10, 2, [1, 2])),
67 ((ten, 4, 5, False), (10, 2, [1, 2])),
68 ((ten, 4, 6, False), (10, 1, [1])),
69 # Ten items, varying orphans, allow empty first page.
70 ((ten, 4, 0, True), (10, 3, [1, 2, 3])),
71 ((ten, 4, 1, True), (10, 3, [1, 2, 3])),
72 ((ten, 4, 2, True), (10, 2, [1, 2])),
73 ((ten, 4, 5, True), (10, 2, [1, 2])),
74 ((ten, 4, 6, True), (10, 1, [1])),
75 # One item, varying orphans, no empty first page.
76 (([1], 4, 0, False), (1, 1, [1])),
77 (([1], 4, 1, False), (1, 1, [1])),
78 (([1], 4, 2, False), (1, 1, [1])),
79 # One item, varying orphans, allow empty first page.
80 (([1], 4, 0, True), (1, 1, [1])),
81 (([1], 4, 1, True), (1, 1, [1])),
82 (([1], 4, 2, True), (1, 1, [1])),
83 # Zero items, varying orphans, no empty first page.
84 (([], 4, 0, False), (0, 0, [])),
85 (([], 4, 1, False), (0, 0, [])),
86 (([], 4, 2, False), (0, 0, [])),
87 # Zero items, varying orphans, allow empty first page.
88 (([], 4, 0, True), (0, 1, [1])),
89 (([], 4, 1, True), (0, 1, [1])),
90 (([], 4, 2, True), (0, 1, [1])),
91 # Number if items one less than per_page.
92 (([], 1, 0, True), (0, 1, [1])),
93 (([], 1, 0, False), (0, 0, [])),
94 (([1], 2, 0, True), (1, 1, [1])),
95 ((nine, 10, 0, True), (9, 1, [1])),
96 # Number if items equal to per_page.
97 (([1], 1, 0, True), (1, 1, [1])),
98 (([1, 2], 2, 0, True), (2, 1, [1])),
99 ((ten, 10, 0, True), (10, 1, [1])),
100 # Number if items one more than per_page.
101 (([1, 2], 1, 0, True), (2, 2, [1, 2])),
102 (([1, 2, 3], 2, 0, True), (3, 2, [1, 2])),
103 ((eleven, 10, 0, True), (11, 2, [1, 2])),
104 # Number if items one more than per_page with one orphan.
105 (([1, 2], 1, 1, True), (2, 1, [1])),
106 (([1, 2, 3], 2, 1, True), (3, 1, [1])),
107 ((eleven, 10, 1, True), (11, 1, [1])),
108 # Non-integer inputs
109 ((ten, "4", 1, False), (10, 3, [1, 2, 3])),
110 ((ten, "4", 1, False), (10, 3, [1, 2, 3])),
111 ((ten, 4, "1", False), (10, 3, [1, 2, 3])),
112 ((ten, 4, "1", False), (10, 3, [1, 2, 3])),
113 )
114 for params, output in tests:
115 self.check_paginator(params, output)
116
117 def test_invalid_page_number(self):
118 """
119 Invalid page numbers result in the correct exception being raised.
120 """
121 paginator = Paginator([1, 2, 3], 2)
122 with self.assertRaises(InvalidPage):
123 paginator.page(3)
124 with self.assertRaises(PageNotAnInteger):
125 paginator.validate_number(None)
126 with self.assertRaises(PageNotAnInteger):
127 paginator.validate_number("x")
128 with self.assertRaises(PageNotAnInteger):
129 paginator.validate_number(1.2)
130
131 def test_error_messages(self):
132 error_messages = {
133 "invalid_page": "Wrong page number",
134 "min_page": "Too small",
135 "no_results": "There is nothing here",
136 }
137 paginator = Paginator([1, 2, 3], 2, error_messages=error_messages)
138 msg = "Wrong page number"
139 with self.assertRaisesMessage(PageNotAnInteger, msg):
140 paginator.validate_number(1.2)
141 msg = "Too small"
142 with self.assertRaisesMessage(EmptyPage, msg):
143 paginator.validate_number(-1)
144 msg = "There is nothing here"
145 with self.assertRaisesMessage(EmptyPage, msg):
146 paginator.validate_number(3)
147
148 error_messages = {"min_page": "Too small"}
149 paginator = Paginator([1, 2, 3], 2, error_messages=error_messages)
150 # Custom message.
151 msg = "Too small"
152 with self.assertRaisesMessage(EmptyPage, msg):
153 paginator.validate_number(-1)
154 # Default message.
155 msg = "That page contains no results"
156 with self.assertRaisesMessage(EmptyPage, msg):
157 paginator.validate_number(3)
158
159 def test_float_integer_page(self):
160 paginator = Paginator([1, 2, 3], 2)
161 self.assertEqual(paginator.validate_number(1.0), 1)
162
163 def test_no_content_allow_empty_first_page(self):
164 # With no content and allow_empty_first_page=True, 1 is a valid page number
165 paginator = Paginator([], 2)
166 self.assertEqual(paginator.validate_number(1), 1)
167
168 def test_paginate_misc_classes(self):
169 class CountContainer:
170 def count(self):
171 return 42
172
173 # Paginator can be passed other objects with a count() method.
174 paginator = Paginator(CountContainer(), 10)
175 self.assertEqual(42, paginator.count)
176 self.assertEqual(5, paginator.num_pages)
177 self.assertEqual([1, 2, 3, 4, 5], list(paginator.page_range))
178
179 # Paginator can be passed other objects that implement __len__.
180 class LenContainer:
181 def __len__(self):
182 return 42
183
184 paginator = Paginator(LenContainer(), 10)
185 self.assertEqual(42, paginator.count)
186 self.assertEqual(5, paginator.num_pages)
187 self.assertEqual([1, 2, 3, 4, 5], list(paginator.page_range))
188
189 def test_count_does_not_silence_attribute_error(self):
190 class AttributeErrorContainer:
191 def count(self):
192 raise AttributeError("abc")
193
194 with self.assertRaisesMessage(AttributeError, "abc"):
195 Paginator(AttributeErrorContainer(), 10).count
196
197 def test_count_does_not_silence_type_error(self):
198 class TypeErrorContainer:
199 def count(self):
200 raise TypeError("abc")
201
202 with self.assertRaisesMessage(TypeError, "abc"):
203 Paginator(TypeErrorContainer(), 10).count
204
205 def check_indexes(self, params, page_num, indexes):
206 """
207 Helper method that instantiates a Paginator object from the passed
208 params and then checks that the start and end indexes of the passed
209 page_num match those given as a 2-tuple in indexes.
210 """
211 paginator = Paginator(*params)
212 if page_num == "first":
213 page_num = 1
214 elif page_num == "last":
215 page_num = paginator.num_pages
216 page = paginator.page(page_num)
217 start, end = indexes
218 msg = "For %s of page %s, expected %s but got %s. Paginator parameters were: %s"
219 self.assertEqual(
220 start,
221 page.start_index(),
222 msg % ("start index", page_num, start, page.start_index(), params),
223 )
224 self.assertEqual(
225 end,
226 page.end_index(),
227 msg % ("end index", page_num, end, page.end_index(), params),
228 )
229
230 def test_page_indexes(self):
231 """
232 Paginator pages have the correct start and end indexes.
233 """
234 ten = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
235 tests = (
236 # Each item is 3-tuple:
237 # First tuple is Paginator parameters - object_list, per_page,
238 # orphans, and allow_empty_first_page.
239 # Second tuple is the start and end indexes of the first page.
240 # Third tuple is the start and end indexes of the last page.
241 # Ten items, varying per_page, no orphans.
242 ((ten, 1, 0, True), (1, 1), (10, 10)),
243 ((ten, 2, 0, True), (1, 2), (9, 10)),
244 ((ten, 3, 0, True), (1, 3), (10, 10)),
245 ((ten, 5, 0, True), (1, 5), (6, 10)),
246 # Ten items, varying per_page, with orphans.
247 ((ten, 1, 1, True), (1, 1), (9, 10)),
248 ((ten, 1, 2, True), (1, 1), (8, 10)),
249 ((ten, 3, 1, True), (1, 3), (7, 10)),
250 ((ten, 3, 2, True), (1, 3), (7, 10)),
251 ((ten, 3, 4, True), (1, 3), (4, 10)),
252 ((ten, 5, 1, True), (1, 5), (6, 10)),
253 ((ten, 5, 2, True), (1, 5), (6, 10)),
254 ((ten, 5, 5, True), (1, 10), (1, 10)),
255 # One item, varying orphans, no empty first page.
256 (([1], 4, 0, False), (1, 1), (1, 1)),
257 (([1], 4, 1, False), (1, 1), (1, 1)),
258 (([1], 4, 2, False), (1, 1), (1, 1)),
259 # One item, varying orphans, allow empty first page.
260 (([1], 4, 0, True), (1, 1), (1, 1)),
261 (([1], 4, 1, True), (1, 1), (1, 1)),
262 (([1], 4, 2, True), (1, 1), (1, 1)),
263 # Zero items, varying orphans, allow empty first page.
264 (([], 4, 0, True), (0, 0), (0, 0)),
265 (([], 4, 1, True), (0, 0), (0, 0)),
266 (([], 4, 2, True), (0, 0), (0, 0)),
267 )
268 for params, first, last in tests:
269 self.check_indexes(params, "first", first)
270 self.check_indexes(params, "last", last)
271
272 # When no items and no empty first page, we should get EmptyPage error.
273 with self.assertRaises(EmptyPage):
274 self.check_indexes(([], 4, 0, False), 1, None)
275 with self.assertRaises(EmptyPage):
276 self.check_indexes(([], 4, 1, False), 1, None)
277 with self.assertRaises(EmptyPage):
278 self.check_indexes(([], 4, 2, False), 1, None)
279
280 def test_page_sequence(self):
281 """
282 A paginator page acts like a standard sequence.
283 """
284 eleven = "abcdefghijk"
285 page2 = Paginator(eleven, per_page=5, orphans=1).page(2)
286 self.assertEqual(len(page2), 6)
287 self.assertIn("k", page2)
288 self.assertNotIn("a", page2)
289 self.assertEqual("".join(page2), "fghijk")
290 self.assertEqual("".join(reversed(page2)), "kjihgf")
291
292 def test_get_page_hook(self):
293 """
294 A Paginator subclass can use the ``_get_page`` hook to
295 return an alternative to the standard Page class.
296 """
297 eleven = "abcdefghijk"
298 paginator = ValidAdjacentNumsPaginator(eleven, per_page=6)
299 page1 = paginator.page(1)
300 page2 = paginator.page(2)
301 self.assertIsNone(page1.previous_page_number())
302 self.assertEqual(page1.next_page_number(), 2)
303 self.assertEqual(page2.previous_page_number(), 1)
304 self.assertIsNone(page2.next_page_number())
305
306 def test_page_range_iterator(self):
307 """
308 Paginator.page_range should be an iterator.
309 """
310 self.assertIsInstance(Paginator([1, 2, 3], 2).page_range, type(range(0)))
311
312 def test_get_page(self):
313 """
314 Paginator.get_page() returns a valid page even with invalid page
315 arguments.
316 """
317 paginator = Paginator([1, 2, 3], 2)
318 page = paginator.get_page(1)
319 self.assertEqual(page.number, 1)
320 self.assertEqual(page.object_list, [1, 2])
321 # An empty page returns the last page.
322 self.assertEqual(paginator.get_page(3).number, 2)
323 # Non-integer page returns the first page.
324 self.assertEqual(paginator.get_page(None).number, 1)
325
326 def test_get_page_empty_object_list(self):
327 """Paginator.get_page() with an empty object_list."""
328 paginator = Paginator([], 2)
329 # An empty page returns the last page.
330 self.assertEqual(paginator.get_page(1).number, 1)
331 self.assertEqual(paginator.get_page(2).number, 1)
332 # Non-integer page returns the first page.
333 self.assertEqual(paginator.get_page(None).number, 1)
334
335 def test_get_page_empty_object_list_and_allow_empty_first_page_false(self):
336 """
337 Paginator.get_page() raises EmptyPage if allow_empty_first_page=False
338 and object_list is empty.
339 """
340 paginator = Paginator([], 2, allow_empty_first_page=False)
341 with self.assertRaises(EmptyPage):
342 paginator.get_page(1)
343
344 def test_paginator_iteration(self):
345 paginator = Paginator([1, 2, 3], 2)
346 page_iterator = iter(paginator)
347 for page, expected in enumerate(([1, 2], [3]), start=1):
348 with self.subTest(page=page):
349 self.assertEqual(expected, list(next(page_iterator)))
350
351 self.assertEqual(
352 [str(page) for page in iter(paginator)],
353 ["<Page 1 of 2>", "<Page 2 of 2>"],
354 )
355
356 def test_get_elided_page_range(self):
357 # Paginator.validate_number() must be called:
358 paginator = Paginator([1, 2, 3], 2)
359 with unittest.mock.patch.object(paginator, "validate_number") as mock:
360 mock.assert_not_called()
361 list(paginator.get_elided_page_range(2))
362 mock.assert_called_with(2)
363
364 ELLIPSIS = Paginator.ELLIPSIS
365
366 # Range is not elided if not enough pages when using default arguments:
367 paginator = Paginator(range(10 * 100), 100)
368 page_range = paginator.get_elided_page_range(1)
369 self.assertIsInstance(page_range, collections.abc.Generator)
370 self.assertNotIn(ELLIPSIS, page_range)
371 paginator = Paginator(range(10 * 100 + 1), 100)
372 self.assertIsInstance(page_range, collections.abc.Generator)
373 page_range = paginator.get_elided_page_range(1)
374 self.assertIn(ELLIPSIS, page_range)
375
376 # Range should be elided if enough pages when using default arguments:
377 tests = [
378 # on_each_side=3, on_ends=2
379 (1, [1, 2, 3, 4, ELLIPSIS, 49, 50]),
380 (6, [1, 2, 3, 4, 5, 6, 7, 8, 9, ELLIPSIS, 49, 50]),
381 (7, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ELLIPSIS, 49, 50]),
382 (8, [1, 2, ELLIPSIS, 5, 6, 7, 8, 9, 10, 11, ELLIPSIS, 49, 50]),
383 (43, [1, 2, ELLIPSIS, 40, 41, 42, 43, 44, 45, 46, ELLIPSIS, 49, 50]),
384 (44, [1, 2, ELLIPSIS, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]),
385 (45, [1, 2, ELLIPSIS, 42, 43, 44, 45, 46, 47, 48, 49, 50]),
386 (50, [1, 2, ELLIPSIS, 47, 48, 49, 50]),
387 ]
388 paginator = Paginator(range(5000), 100)
389 for number, expected in tests:
390 with self.subTest(number=number):
391 page_range = paginator.get_elided_page_range(number)
392 self.assertIsInstance(page_range, collections.abc.Generator)
393 self.assertEqual(list(page_range), expected)
394
395 # Range is not elided if not enough pages when using custom arguments:
396 tests = [
397 (6, 2, 1, 1),
398 (8, 1, 3, 1),
399 (8, 4, 0, 1),
400 (4, 1, 1, 1),
401 # When on_each_side and on_ends are both <= 1 but not both == 1 it
402 # is a special case where the range is not elided until an extra
403 # page is added.
404 (2, 0, 1, 2),
405 (2, 1, 0, 2),
406 (1, 0, 0, 2),
407 ]
408 for pages, on_each_side, on_ends, elided_after in tests:
409 for offset in range(elided_after + 1):
410 with self.subTest(
411 pages=pages,
412 offset=elided_after,
413 on_each_side=on_each_side,
414 on_ends=on_ends,
415 ):
416 paginator = Paginator(range((pages + offset) * 100), 100)
417 page_range = paginator.get_elided_page_range(
418 1,
419 on_each_side=on_each_side,
420 on_ends=on_ends,
421 )
422 self.assertIsInstance(page_range, collections.abc.Generator)
423 if offset < elided_after:
424 self.assertNotIn(ELLIPSIS, page_range)
425 else:
426 self.assertIn(ELLIPSIS, page_range)
427
428 # Range should be elided if enough pages when using custom arguments:
429 tests = [
430 # on_each_side=2, on_ends=1
431 (1, 2, 1, [1, 2, 3, ELLIPSIS, 50]),
432 (4, 2, 1, [1, 2, 3, 4, 5, 6, ELLIPSIS, 50]),
433 (5, 2, 1, [1, 2, 3, 4, 5, 6, 7, ELLIPSIS, 50]),
434 (6, 2, 1, [1, ELLIPSIS, 4, 5, 6, 7, 8, ELLIPSIS, 50]),
435 (45, 2, 1, [1, ELLIPSIS, 43, 44, 45, 46, 47, ELLIPSIS, 50]),
436 (46, 2, 1, [1, ELLIPSIS, 44, 45, 46, 47, 48, 49, 50]),
437 (47, 2, 1, [1, ELLIPSIS, 45, 46, 47, 48, 49, 50]),
438 (50, 2, 1, [1, ELLIPSIS, 48, 49, 50]),
439 # on_each_side=1, on_ends=3
440 (1, 1, 3, [1, 2, ELLIPSIS, 48, 49, 50]),
441 (5, 1, 3, [1, 2, 3, 4, 5, 6, ELLIPSIS, 48, 49, 50]),
442 (6, 1, 3, [1, 2, 3, 4, 5, 6, 7, ELLIPSIS, 48, 49, 50]),
443 (7, 1, 3, [1, 2, 3, ELLIPSIS, 6, 7, 8, ELLIPSIS, 48, 49, 50]),
444 (44, 1, 3, [1, 2, 3, ELLIPSIS, 43, 44, 45, ELLIPSIS, 48, 49, 50]),
445 (45, 1, 3, [1, 2, 3, ELLIPSIS, 44, 45, 46, 47, 48, 49, 50]),
446 (46, 1, 3, [1, 2, 3, ELLIPSIS, 45, 46, 47, 48, 49, 50]),
447 (50, 1, 3, [1, 2, 3, ELLIPSIS, 49, 50]),
448 # on_each_side=4, on_ends=0
449 (1, 4, 0, [1, 2, 3, 4, 5, ELLIPSIS]),
450 (5, 4, 0, [1, 2, 3, 4, 5, 6, 7, 8, 9, ELLIPSIS]),
451 (6, 4, 0, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ELLIPSIS]),
452 (7, 4, 0, [ELLIPSIS, 3, 4, 5, 6, 7, 8, 9, 10, 11, ELLIPSIS]),
453 (44, 4, 0, [ELLIPSIS, 40, 41, 42, 43, 44, 45, 46, 47, 48, ELLIPSIS]),
454 (45, 4, 0, [ELLIPSIS, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]),
455 (46, 4, 0, [ELLIPSIS, 42, 43, 44, 45, 46, 47, 48, 49, 50]),
456 (50, 4, 0, [ELLIPSIS, 46, 47, 48, 49, 50]),
457 # on_each_side=0, on_ends=1
458 (1, 0, 1, [1, ELLIPSIS, 50]),
459 (2, 0, 1, [1, 2, ELLIPSIS, 50]),
460 (3, 0, 1, [1, 2, 3, ELLIPSIS, 50]),
461 (4, 0, 1, [1, ELLIPSIS, 4, ELLIPSIS, 50]),
462 (47, 0, 1, [1, ELLIPSIS, 47, ELLIPSIS, 50]),
463 (48, 0, 1, [1, ELLIPSIS, 48, 49, 50]),
464 (49, 0, 1, [1, ELLIPSIS, 49, 50]),
465 (50, 0, 1, [1, ELLIPSIS, 50]),
466 # on_each_side=0, on_ends=0
467 (1, 0, 0, [1, ELLIPSIS]),
468 (2, 0, 0, [1, 2, ELLIPSIS]),
469 (3, 0, 0, [ELLIPSIS, 3, ELLIPSIS]),
470 (48, 0, 0, [ELLIPSIS, 48, ELLIPSIS]),
471 (49, 0, 0, [ELLIPSIS, 49, 50]),
472 (50, 0, 0, [ELLIPSIS, 50]),
473 ]
474 paginator = Paginator(range(5000), 100)
475 for number, on_each_side, on_ends, expected in tests:
476 with self.subTest(
477 number=number, on_each_side=on_each_side, on_ends=on_ends
478 ):
479 page_range = paginator.get_elided_page_range(
480 number,
481 on_each_side=on_each_side,
482 on_ends=on_ends,
483 )
484 self.assertIsInstance(page_range, collections.abc.Generator)
485 self.assertEqual(list(page_range), expected)
486
487
488 class ModelPaginationTests(TestCase):
489 """
490 Test pagination with Django model instances
491 """
492
493 @classmethod
494 def setUpTestData(cls):
495 # Prepare a list of objects for pagination.
496 pub_date = datetime(2005, 7, 29)
497 cls.articles = [
498 Article.objects.create(headline=f"Article {x}", pub_date=pub_date)
499 for x in range(1, 10)
500 ]
501
502 def test_first_page(self):
503 paginator = Paginator(Article.objects.order_by("id"), 5)
504 p = paginator.page(1)
505 self.assertEqual("<Page 1 of 2>", str(p))
506 self.assertSequenceEqual(p.object_list, self.articles[:5])
507 self.assertTrue(p.has_next())
508 self.assertFalse(p.has_previous())
509 self.assertTrue(p.has_other_pages())
510 self.assertEqual(2, p.next_page_number())
511 with self.assertRaises(InvalidPage):
512 p.previous_page_number()
513 self.assertEqual(1, p.start_index())
514 self.assertEqual(5, p.end_index())
515
516 def test_last_page(self):
517 paginator = Paginator(Article.objects.order_by("id"), 5)
518 p = paginator.page(2)
519 self.assertEqual("<Page 2 of 2>", str(p))
520 self.assertSequenceEqual(p.object_list, self.articles[5:])
521 self.assertFalse(p.has_next())
522 self.assertTrue(p.has_previous())
523 self.assertTrue(p.has_other_pages())
524 with self.assertRaises(InvalidPage):
525 p.next_page_number()
526 self.assertEqual(1, p.previous_page_number())
527 self.assertEqual(6, p.start_index())
528 self.assertEqual(9, p.end_index())
529
530 def test_page_getitem(self):
531 """
532 Tests proper behavior of a paginator page __getitem__ (queryset
533 evaluation, slicing, exception raised).
534 """
535 paginator = Paginator(Article.objects.order_by("id"), 5)
536 p = paginator.page(1)
537
538 # object_list queryset is not evaluated by an invalid __getitem__ call.
539 # (this happens from the template engine when using e.g.:
540 # {% page_obj.has_previous %}).
541 self.assertIsNone(p.object_list._result_cache)
542 msg = "Page indices must be integers or slices, not str."
543 with self.assertRaisesMessage(TypeError, msg):
544 p["has_previous"]
545 self.assertIsNone(p.object_list._result_cache)
546 self.assertNotIsInstance(p.object_list, list)
547
548 # Make sure slicing the Page object with numbers and slice objects work.
549 self.assertEqual(p[0], self.articles[0])
550 self.assertSequenceEqual(p[slice(2)], self.articles[:2])
551 # After __getitem__ is called, object_list is a list
552 self.assertIsInstance(p.object_list, list)
553
554 def test_paginating_unordered_queryset_raises_warning(self):
555 msg = (
556 "Pagination may yield inconsistent results with an unordered "
557 "object_list: <class 'pagination.models.Article'> QuerySet."
558 )
559 with self.assertWarnsMessage(UnorderedObjectListWarning, msg) as cm:
560 Paginator(Article.objects.all(), 5)
561 # The warning points at the Paginator caller (i.e. the stacklevel
562 # is appropriate).
563 self.assertEqual(cm.filename, __file__)
564
565 def test_paginating_empty_queryset_does_not_warn(self):
566 with warnings.catch_warnings(record=True) as recorded:
567 Paginator(Article.objects.none(), 5)
568 self.assertEqual(len(recorded), 0)
569
570 def test_paginating_unordered_object_list_raises_warning(self):
571 """
572 Unordered object list warning with an object that has an ordered
573 attribute but not a model attribute.
574 """
575
576 class ObjectList:
577 ordered = False
578
579 object_list = ObjectList()
580 msg = (
581 "Pagination may yield inconsistent results with an unordered "
582 "object_list: {!r}.".format(object_list)
583 )
584 with self.assertWarnsMessage(UnorderedObjectListWarning, msg):
585 Paginator(object_list, 5)