Debian Codegraph @

tests/admin_filters/tests.py

raw
1 import datetime
2 import sys
3 import unittest
4
5 from django.contrib.admin import (
6 AllValuesFieldListFilter,
7 BooleanFieldListFilter,
8 EmptyFieldListFilter,
9 FieldListFilter,
10 ModelAdmin,
11 RelatedOnlyFieldListFilter,
12 SimpleListFilter,
13 site,
14 )
15 from django.contrib.admin.filters import FacetsMixin
16 from django.contrib.admin.options import IncorrectLookupParameters, ShowFacets
17 from django.contrib.auth.admin import UserAdmin
18 from django.contrib.auth.models import User
19 from django.core.exceptions import ImproperlyConfigured
20 from django.db import connection, models
21 from django.test import RequestFactory, SimpleTestCase, TestCase, override_settings
22
23 from .models import Book, Bookmark, Department, Employee, ImprovedBook, TaggedItem
24
25
26 def select_by(dictlist, key, value):
27 return [x for x in dictlist if x[key] == value][0]
28
29
30 class DecadeListFilter(SimpleListFilter):
31 def lookups(self, request, model_admin):
32 return (
33 ("the 80s", "the 1980's"),
34 ("the 90s", "the 1990's"),
35 ("the 00s", "the 2000's"),
36 ("other", "other decades"),
37 )
38
39 def queryset(self, request, queryset):
40 decade = self.value()
41 if decade == "the 80s":
42 return queryset.filter(year__gte=1980, year__lte=1989)
43 if decade == "the 90s":
44 return queryset.filter(year__gte=1990, year__lte=1999)
45 if decade == "the 00s":
46 return queryset.filter(year__gte=2000, year__lte=2009)
47
48
49 class NotNinetiesListFilter(SimpleListFilter):
50 title = "Not nineties books"
51 parameter_name = "book_year"
52
53 def lookups(self, request, model_admin):
54 return (("the 90s", "the 1990's"),)
55
56 def queryset(self, request, queryset):
57 if self.value() == "the 90s":
58 return queryset.filter(year__gte=1990, year__lte=1999)
59 else:
60 return queryset.exclude(year__gte=1990, year__lte=1999)
61
62
63 class DecadeListFilterWithTitleAndParameter(DecadeListFilter):
64 title = "publication decade"
65 parameter_name = "publication-decade"
66
67
68 class DecadeListFilterWithoutTitle(DecadeListFilter):
69 parameter_name = "publication-decade"
70
71
72 class DecadeListFilterWithoutParameter(DecadeListFilter):
73 title = "publication decade"
74
75
76 class DecadeListFilterWithNoneReturningLookups(DecadeListFilterWithTitleAndParameter):
77 def lookups(self, request, model_admin):
78 pass
79
80
81 class DecadeListFilterWithFailingQueryset(DecadeListFilterWithTitleAndParameter):
82 def queryset(self, request, queryset):
83 raise 1 / 0
84
85
86 class DecadeListFilterWithQuerysetBasedLookups(DecadeListFilterWithTitleAndParameter):
87 def lookups(self, request, model_admin):
88 qs = model_admin.get_queryset(request)
89 if qs.filter(year__gte=1980, year__lte=1989).exists():
90 yield ("the 80s", "the 1980's")
91 if qs.filter(year__gte=1990, year__lte=1999).exists():
92 yield ("the 90s", "the 1990's")
93 if qs.filter(year__gte=2000, year__lte=2009).exists():
94 yield ("the 00s", "the 2000's")
95
96
97 class DecadeListFilterParameterEndsWith__In(DecadeListFilter):
98 title = "publication decade"
99 parameter_name = "decade__in" # Ends with '__in"
100
101
102 class DecadeListFilterParameterEndsWith__Isnull(DecadeListFilter):
103 title = "publication decade"
104 parameter_name = "decade__isnull" # Ends with '__isnull"
105
106
107 class DepartmentListFilterLookupWithNonStringValue(SimpleListFilter):
108 title = "department"
109 parameter_name = "department"
110
111 def lookups(self, request, model_admin):
112 return sorted(
113 {
114 (
115 employee.department.id, # Intentionally not a string (Refs #19318)
116 employee.department.code,
117 )
118 for employee in model_admin.get_queryset(request)
119 }
120 )
121
122 def queryset(self, request, queryset):
123 if self.value():
124 return queryset.filter(department__id=self.value())
125
126
127 class DepartmentListFilterLookupWithUnderscoredParameter(
128 DepartmentListFilterLookupWithNonStringValue
129 ):
130 parameter_name = "department__whatever"
131
132
133 class DepartmentListFilterLookupWithDynamicValue(DecadeListFilterWithTitleAndParameter):
134 def lookups(self, request, model_admin):
135 if self.value() == "the 80s":
136 return (("the 90s", "the 1990's"),)
137 elif self.value() == "the 90s":
138 return (("the 80s", "the 1980's"),)
139 else:
140 return (
141 ("the 80s", "the 1980's"),
142 ("the 90s", "the 1990's"),
143 )
144
145
146 class EmployeeNameCustomDividerFilter(FieldListFilter):
147 list_separator = "|"
148
149 def __init__(self, field, request, params, model, model_admin, field_path):
150 self.lookup_kwarg = "%s__in" % field_path
151 super().__init__(field, request, params, model, model_admin, field_path)
152
153 def expected_parameters(self):
154 return [self.lookup_kwarg]
155
156
157 class DepartmentOwnershipListFilter(SimpleListFilter):
158 title = "Department Ownership"
159 parameter_name = "department_ownership"
160
161 def lookups(self, request, model_admin):
162 return [
163 ("DEV_OWNED", "Owned by Dev Department"),
164 ("OTHER", "Other"),
165 ]
166
167 def queryset(self, request, queryset):
168 queryset = queryset.annotate(
169 owned_book_count=models.Count(
170 "employee__department",
171 filter=models.Q(employee__department__code="DEV"),
172 ),
173 )
174
175 if self.value() == "DEV_OWNED":
176 return queryset.filter(owned_book_count__gt=0)
177 elif self.value() == "OTHER":
178 return queryset.filter(owned_book_count=0)
179
180
181 class CustomUserAdmin(UserAdmin):
182 list_filter = ("books_authored", "books_contributed")
183
184
185 class BookAdmin(ModelAdmin):
186 list_filter = (
187 "year",
188 "author",
189 "contributors",
190 "is_best_seller",
191 "date_registered",
192 "no",
193 "availability",
194 )
195 ordering = ("-id",)
196
197
198 class BookAdminWithTupleBooleanFilter(BookAdmin):
199 list_filter = (
200 "year",
201 "author",
202 "contributors",
203 ("is_best_seller", BooleanFieldListFilter),
204 "date_registered",
205 "no",
206 ("availability", BooleanFieldListFilter),
207 )
208
209
210 class BookAdminWithUnderscoreLookupAndTuple(BookAdmin):
211 list_filter = (
212 "year",
213 ("author__email", AllValuesFieldListFilter),
214 "contributors",
215 "is_best_seller",
216 "date_registered",
217 "no",
218 )
219
220
221 class BookAdminWithCustomQueryset(ModelAdmin):
222 def __init__(self, user, *args, **kwargs):
223 self.user = user
224 super().__init__(*args, **kwargs)
225
226 list_filter = ("year",)
227
228 def get_queryset(self, request):
229 return super().get_queryset(request).filter(author=self.user)
230
231
232 class BookAdminRelatedOnlyFilter(ModelAdmin):
233 list_filter = (
234 "year",
235 "is_best_seller",
236 "date_registered",
237 "no",
238 ("author", RelatedOnlyFieldListFilter),
239 ("contributors", RelatedOnlyFieldListFilter),
240 ("employee__department", RelatedOnlyFieldListFilter),
241 )
242 ordering = ("-id",)
243
244
245 class DecadeFilterBookAdmin(ModelAdmin):
246 empty_value_display = "???"
247 list_filter = (
248 "author",
249 DecadeListFilterWithTitleAndParameter,
250 "is_best_seller",
251 "category",
252 "date_registered",
253 ("author__email", AllValuesFieldListFilter),
254 ("contributors", RelatedOnlyFieldListFilter),
255 ("category", EmptyFieldListFilter),
256 DepartmentOwnershipListFilter,
257 )
258 ordering = ("-id",)
259
260
261 class DecadeFilterBookAdminWithAlwaysFacets(DecadeFilterBookAdmin):
262 show_facets = ShowFacets.ALWAYS
263
264
265 class DecadeFilterBookAdminDisallowFacets(DecadeFilterBookAdmin):
266 show_facets = ShowFacets.NEVER
267
268
269 class NotNinetiesListFilterAdmin(ModelAdmin):
270 list_filter = (NotNinetiesListFilter,)
271
272
273 class DecadeFilterBookAdminWithoutTitle(ModelAdmin):
274 list_filter = (DecadeListFilterWithoutTitle,)
275
276
277 class DecadeFilterBookAdminWithoutParameter(ModelAdmin):
278 list_filter = (DecadeListFilterWithoutParameter,)
279
280
281 class DecadeFilterBookAdminWithNoneReturningLookups(ModelAdmin):
282 list_filter = (DecadeListFilterWithNoneReturningLookups,)
283
284
285 class DecadeFilterBookAdminWithFailingQueryset(ModelAdmin):
286 list_filter = (DecadeListFilterWithFailingQueryset,)
287
288
289 class DecadeFilterBookAdminWithQuerysetBasedLookups(ModelAdmin):
290 list_filter = (DecadeListFilterWithQuerysetBasedLookups,)
291
292
293 class DecadeFilterBookAdminParameterEndsWith__In(ModelAdmin):
294 list_filter = (DecadeListFilterParameterEndsWith__In,)
295
296
297 class DecadeFilterBookAdminParameterEndsWith__Isnull(ModelAdmin):
298 list_filter = (DecadeListFilterParameterEndsWith__Isnull,)
299
300
301 class EmployeeAdmin(ModelAdmin):
302 list_display = ["name", "department"]
303 list_filter = ["department"]
304
305
306 class EmployeeCustomDividerFilterAdmin(EmployeeAdmin):
307 list_filter = [
308 ("name", EmployeeNameCustomDividerFilter),
309 ]
310
311
312 class DepartmentFilterEmployeeAdmin(EmployeeAdmin):
313 list_filter = [DepartmentListFilterLookupWithNonStringValue]
314
315
316 class DepartmentFilterUnderscoredEmployeeAdmin(EmployeeAdmin):
317 list_filter = [DepartmentListFilterLookupWithUnderscoredParameter]
318
319
320 class DepartmentFilterDynamicValueBookAdmin(EmployeeAdmin):
321 list_filter = [DepartmentListFilterLookupWithDynamicValue]
322
323
324 class BookmarkAdminGenericRelation(ModelAdmin):
325 list_filter = ["tags__tag"]
326
327
328 class BookAdminWithEmptyFieldListFilter(ModelAdmin):
329 list_filter = [
330 ("author", EmptyFieldListFilter),
331 ("title", EmptyFieldListFilter),
332 ("improvedbook", EmptyFieldListFilter),
333 ]
334
335
336 class DepartmentAdminWithEmptyFieldListFilter(ModelAdmin):
337 list_filter = [
338 ("description", EmptyFieldListFilter),
339 ("employee", EmptyFieldListFilter),
340 ]
341
342
343 class ListFiltersTests(TestCase):
344 request_factory = RequestFactory()
345
346 @classmethod
347 def setUpTestData(cls):
348 cls.today = datetime.date.today()
349 cls.tomorrow = cls.today + datetime.timedelta(days=1)
350 cls.one_week_ago = cls.today - datetime.timedelta(days=7)
351 if cls.today.month == 12:
352 cls.next_month = cls.today.replace(year=cls.today.year + 1, month=1, day=1)
353 else:
354 cls.next_month = cls.today.replace(month=cls.today.month + 1, day=1)
355 cls.next_year = cls.today.replace(year=cls.today.year + 1, month=1, day=1)
356
357 # Users
358 cls.alfred = User.objects.create_superuser(
359 "alfred", "[email protected]", "password"
360 )
361 cls.bob = User.objects.create_user("bob", "[email protected]")
362 cls.lisa = User.objects.create_user("lisa", "[email protected]")
363
364 # Departments
365 cls.dev = Department.objects.create(code="DEV", description="Development")
366 cls.design = Department.objects.create(code="DSN", description="Design")
367
368 # Employees
369 cls.john = Employee.objects.create(name="John Blue", department=cls.dev)
370 cls.jack = Employee.objects.create(name="Jack Red", department=cls.design)
371
372 # Books
373 cls.djangonaut_book = Book.objects.create(
374 title="Djangonaut: an art of living",
375 year=2009,
376 author=cls.alfred,
377 is_best_seller=True,
378 date_registered=cls.today,
379 availability=True,
380 category="non-fiction",
381 employee=cls.john,
382 )
383 cls.bio_book = Book.objects.create(
384 title="Django: a biography",
385 year=1999,
386 author=cls.alfred,
387 is_best_seller=False,
388 no=207,
389 availability=False,
390 category="fiction",
391 employee=cls.john,
392 )
393 cls.django_book = Book.objects.create(
394 title="The Django Book",
395 year=None,
396 author=cls.bob,
397 is_best_seller=None,
398 date_registered=cls.today,
399 no=103,
400 availability=True,
401 employee=cls.jack,
402 )
403 cls.guitar_book = Book.objects.create(
404 title="Guitar for dummies",
405 year=2002,
406 is_best_seller=True,
407 date_registered=cls.one_week_ago,
408 availability=None,
409 category="",
410 )
411 cls.guitar_book.contributors.set([cls.bob, cls.lisa])
412
413 def assertChoicesDisplay(self, choices, expected_displays):
414 for choice, expected_display in zip(choices, expected_displays, strict=True):
415 self.assertEqual(choice["display"], expected_display)
416
417 def test_choicesfieldlistfilter_has_none_choice(self):
418 """
419 The last choice is for the None value.
420 """
421
422 class BookmarkChoicesAdmin(ModelAdmin):
423 list_display = ["none_or_null"]
424 list_filter = ["none_or_null"]
425
426 modeladmin = BookmarkChoicesAdmin(Bookmark, site)
427 request = self.request_factory.get("/", {})
428 request.user = self.alfred
429 changelist = modeladmin.get_changelist_instance(request)
430 filterspec = changelist.get_filters(request)[0][0]
431 choices = list(filterspec.choices(changelist))
432 self.assertEqual(choices[-1]["display"], "None")
433 self.assertEqual(choices[-1]["query_string"], "?none_or_null__isnull=True")
434
435 def test_datefieldlistfilter(self):
436 modeladmin = BookAdmin(Book, site)
437
438 request = self.request_factory.get("/")
439 request.user = self.alfred
440 changelist = modeladmin.get_changelist(request)
441
442 request = self.request_factory.get(
443 "/",
444 {"date_registered__gte": self.today, "date_registered__lt": self.tomorrow},
445 )
446 request.user = self.alfred
447 changelist = modeladmin.get_changelist_instance(request)
448
449 # Make sure the correct queryset is returned
450 queryset = changelist.get_queryset(request)
451 self.assertEqual(list(queryset), [self.django_book, self.djangonaut_book])
452
453 # Make sure the correct choice is selected
454 filterspec = changelist.get_filters(request)[0][4]
455 self.assertEqual(filterspec.title, "date registered")
456 choice = select_by(filterspec.choices(changelist), "display", "Today")
457 self.assertIs(choice["selected"], True)
458 self.assertEqual(
459 choice["query_string"],
460 "?date_registered__gte=%s&date_registered__lt=%s"
461 % (
462 self.today,
463 self.tomorrow,
464 ),
465 )
466
467 request = self.request_factory.get(
468 "/",
469 {
470 "date_registered__gte": self.today.replace(day=1),
471 "date_registered__lt": self.next_month,
472 },
473 )
474 request.user = self.alfred
475 changelist = modeladmin.get_changelist_instance(request)
476
477 # Make sure the correct queryset is returned
478 queryset = changelist.get_queryset(request)
479 if (self.today.year, self.today.month) == (
480 self.one_week_ago.year,
481 self.one_week_ago.month,
482 ):
483 # In case one week ago is in the same month.
484 self.assertEqual(
485 list(queryset),
486 [self.guitar_book, self.django_book, self.djangonaut_book],
487 )
488 else:
489 self.assertEqual(list(queryset), [self.django_book, self.djangonaut_book])
490
491 # Make sure the correct choice is selected
492 filterspec = changelist.get_filters(request)[0][4]
493 self.assertEqual(filterspec.title, "date registered")
494 choice = select_by(filterspec.choices(changelist), "display", "This month")
495 self.assertIs(choice["selected"], True)
496 self.assertEqual(
497 choice["query_string"],
498 "?date_registered__gte=%s&date_registered__lt=%s"
499 % (
500 self.today.replace(day=1),
501 self.next_month,
502 ),
503 )
504
505 request = self.request_factory.get(
506 "/",
507 {
508 "date_registered__gte": self.today.replace(month=1, day=1),
509 "date_registered__lt": self.next_year,
510 },
511 )
512 request.user = self.alfred
513 changelist = modeladmin.get_changelist_instance(request)
514
515 # Make sure the correct queryset is returned
516 queryset = changelist.get_queryset(request)
517 if self.today.year == self.one_week_ago.year:
518 # In case one week ago is in the same year.
519 self.assertEqual(
520 list(queryset),
521 [self.guitar_book, self.django_book, self.djangonaut_book],
522 )
523 else:
524 self.assertEqual(list(queryset), [self.django_book, self.djangonaut_book])
525
526 # Make sure the correct choice is selected
527 filterspec = changelist.get_filters(request)[0][4]
528 self.assertEqual(filterspec.title, "date registered")
529 choice = select_by(filterspec.choices(changelist), "display", "This year")
530 self.assertIs(choice["selected"], True)
531 self.assertEqual(
532 choice["query_string"],
533 "?date_registered__gte=%s&date_registered__lt=%s"
534 % (
535 self.today.replace(month=1, day=1),
536 self.next_year,
537 ),
538 )
539
540 request = self.request_factory.get(
541 "/",
542 {
543 "date_registered__gte": str(self.one_week_ago),
544 "date_registered__lt": str(self.tomorrow),
545 },
546 )
547 request.user = self.alfred
548 changelist = modeladmin.get_changelist_instance(request)
549
550 # Make sure the correct queryset is returned
551 queryset = changelist.get_queryset(request)
552 self.assertEqual(
553 list(queryset), [self.guitar_book, self.django_book, self.djangonaut_book]
554 )
555
556 # Make sure the correct choice is selected
557 filterspec = changelist.get_filters(request)[0][4]
558 self.assertEqual(filterspec.title, "date registered")
559 choice = select_by(filterspec.choices(changelist), "display", "Past 7 days")
560 self.assertIs(choice["selected"], True)
561 self.assertEqual(
562 choice["query_string"],
563 "?date_registered__gte=%s&date_registered__lt=%s"
564 % (
565 str(self.one_week_ago),
566 str(self.tomorrow),
567 ),
568 )
569
570 # Null/not null queries
571 request = self.request_factory.get("/", {"date_registered__isnull": "True"})
572 request.user = self.alfred
573 changelist = modeladmin.get_changelist_instance(request)
574
575 # Make sure the correct queryset is returned
576 queryset = changelist.get_queryset(request)
577 self.assertEqual(queryset.count(), 1)
578 self.assertEqual(queryset[0], self.bio_book)
579
580 # Make sure the correct choice is selected
581 filterspec = changelist.get_filters(request)[0][4]
582 self.assertEqual(filterspec.title, "date registered")
583 choice = select_by(filterspec.choices(changelist), "display", "No date")
584 self.assertIs(choice["selected"], True)
585 self.assertEqual(choice["query_string"], "?date_registered__isnull=True")
586
587 request = self.request_factory.get("/", {"date_registered__isnull": "False"})
588 request.user = self.alfred
589 changelist = modeladmin.get_changelist_instance(request)
590
591 # Make sure the correct queryset is returned
592 queryset = changelist.get_queryset(request)
593 self.assertEqual(queryset.count(), 3)
594 self.assertEqual(
595 list(queryset), [self.guitar_book, self.django_book, self.djangonaut_book]
596 )
597
598 # Make sure the correct choice is selected
599 filterspec = changelist.get_filters(request)[0][4]
600 self.assertEqual(filterspec.title, "date registered")
601 choice = select_by(filterspec.choices(changelist), "display", "Has date")
602 self.assertIs(choice["selected"], True)
603 self.assertEqual(choice["query_string"], "?date_registered__isnull=False")
604
605 @unittest.skipIf(
606 sys.platform == "win32",
607 "Windows doesn't support setting a timezone that differs from the "
608 "system timezone.",
609 )
610 @override_settings(USE_TZ=True)
611 def test_datefieldlistfilter_with_time_zone_support(self):
612 # Regression for #17830
613 self.test_datefieldlistfilter()
614
615 def test_allvaluesfieldlistfilter(self):
616 modeladmin = BookAdmin(Book, site)
617
618 request = self.request_factory.get("/", {"year__isnull": "True"})
619 request.user = self.alfred
620 changelist = modeladmin.get_changelist_instance(request)
621
622 # Make sure the correct queryset is returned
623 queryset = changelist.get_queryset(request)
624 self.assertEqual(list(queryset), [self.django_book])
625
626 # Make sure the last choice is None and is selected
627 filterspec = changelist.get_filters(request)[0][0]
628 self.assertEqual(filterspec.title, "year")
629 choices = list(filterspec.choices(changelist))
630 self.assertIs(choices[-1]["selected"], True)
631 self.assertEqual(choices[-1]["query_string"], "?year__isnull=True")
632
633 request = self.request_factory.get("/", {"year": "2002"})
634 request.user = self.alfred
635 changelist = modeladmin.get_changelist_instance(request)
636
637 # Make sure the correct choice is selected
638 filterspec = changelist.get_filters(request)[0][0]
639 self.assertEqual(filterspec.title, "year")
640 choices = list(filterspec.choices(changelist))
641 self.assertIs(choices[2]["selected"], True)
642 self.assertEqual(choices[2]["query_string"], "?year=2002")
643
644 def test_allvaluesfieldlistfilter_custom_qs(self):
645 # Make sure that correct filters are returned with custom querysets
646 modeladmin = BookAdminWithCustomQueryset(self.alfred, Book, site)
647 request = self.request_factory.get("/")
648 request.user = self.alfred
649 changelist = modeladmin.get_changelist_instance(request)
650
651 filterspec = changelist.get_filters(request)[0][0]
652 choices = list(filterspec.choices(changelist))
653 # Should have 'All', 1999 and 2009 options i.e. the subset of years of
654 # books written by alfred (which is the filtering criteria set by
655 # BookAdminWithCustomQueryset.get_queryset())
656 self.assertEqual(3, len(choices))
657 self.assertEqual(choices[0]["query_string"], "?")
658 self.assertEqual(choices[1]["query_string"], "?year=1999")
659 self.assertEqual(choices[2]["query_string"], "?year=2009")
660
661 def test_relatedfieldlistfilter_foreignkey(self):
662 modeladmin = BookAdmin(Book, site)
663
664 request = self.request_factory.get("/")
665 request.user = self.alfred
666 changelist = modeladmin.get_changelist_instance(request)
667
668 # Make sure that all users are present in the author's list filter
669 filterspec = changelist.get_filters(request)[0][1]
670 expected = [
671 (self.alfred.pk, "alfred"),
672 (self.bob.pk, "bob"),
673 (self.lisa.pk, "lisa"),
674 ]
675 self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
676
677 request = self.request_factory.get("/", {"author__isnull": "True"})
678 request.user = self.alfred
679 changelist = modeladmin.get_changelist_instance(request)
680
681 # Make sure the correct queryset is returned
682 queryset = changelist.get_queryset(request)
683 self.assertEqual(list(queryset), [self.guitar_book])
684
685 # Make sure the last choice is None and is selected
686 filterspec = changelist.get_filters(request)[0][1]
687 self.assertEqual(filterspec.title, "Verbose Author")
688 choices = list(filterspec.choices(changelist))
689 self.assertIs(choices[-1]["selected"], True)
690 self.assertEqual(choices[-1]["query_string"], "?author__isnull=True")
691
692 request = self.request_factory.get("/", {"author__id__exact": self.alfred.pk})
693 request.user = self.alfred
694 changelist = modeladmin.get_changelist_instance(request)
695
696 # Make sure the correct choice is selected
697 filterspec = changelist.get_filters(request)[0][1]
698 self.assertEqual(filterspec.title, "Verbose Author")
699 # order of choices depends on User model, which has no order
700 choice = select_by(filterspec.choices(changelist), "display", "alfred")
701 self.assertIs(choice["selected"], True)
702 self.assertEqual(
703 choice["query_string"], "?author__id__exact=%d" % self.alfred.pk
704 )
705
706 def test_relatedfieldlistfilter_foreignkey_ordering(self):
707 """RelatedFieldListFilter ordering respects ModelAdmin.ordering."""
708
709 class EmployeeAdminWithOrdering(ModelAdmin):
710 ordering = ("name",)
711
712 class BookAdmin(ModelAdmin):
713 list_filter = ("employee",)
714
715 site.register(Employee, EmployeeAdminWithOrdering)
716 self.addCleanup(lambda: site.unregister(Employee))
717 modeladmin = BookAdmin(Book, site)
718
719 request = self.request_factory.get("/")
720 request.user = self.alfred
721 changelist = modeladmin.get_changelist_instance(request)
722 filterspec = changelist.get_filters(request)[0][0]
723 expected = [(self.jack.pk, "Jack Red"), (self.john.pk, "John Blue")]
724 self.assertEqual(filterspec.lookup_choices, expected)
725
726 def test_relatedfieldlistfilter_foreignkey_ordering_reverse(self):
727 class EmployeeAdminWithOrdering(ModelAdmin):
728 ordering = ("-name",)
729
730 class BookAdmin(ModelAdmin):
731 list_filter = ("employee",)
732
733 site.register(Employee, EmployeeAdminWithOrdering)
734 self.addCleanup(lambda: site.unregister(Employee))
735 modeladmin = BookAdmin(Book, site)
736
737 request = self.request_factory.get("/")
738 request.user = self.alfred
739 changelist = modeladmin.get_changelist_instance(request)
740 filterspec = changelist.get_filters(request)[0][0]
741 expected = [(self.john.pk, "John Blue"), (self.jack.pk, "Jack Red")]
742 self.assertEqual(filterspec.lookup_choices, expected)
743
744 def test_relatedfieldlistfilter_foreignkey_default_ordering(self):
745 """RelatedFieldListFilter ordering respects Model.ordering."""
746
747 class BookAdmin(ModelAdmin):
748 list_filter = ("employee",)
749
750 self.addCleanup(setattr, Employee._meta, "ordering", Employee._meta.ordering)
751 Employee._meta.ordering = ("name",)
752 modeladmin = BookAdmin(Book, site)
753
754 request = self.request_factory.get("/")
755 request.user = self.alfred
756 changelist = modeladmin.get_changelist_instance(request)
757 filterspec = changelist.get_filters(request)[0][0]
758 expected = [(self.jack.pk, "Jack Red"), (self.john.pk, "John Blue")]
759 self.assertEqual(filterspec.lookup_choices, expected)
760
761 def test_relatedfieldlistfilter_manytomany(self):
762 modeladmin = BookAdmin(Book, site)
763
764 request = self.request_factory.get("/")
765 request.user = self.alfred
766 changelist = modeladmin.get_changelist_instance(request)
767
768 # Make sure that all users are present in the contrib's list filter
769 filterspec = changelist.get_filters(request)[0][2]
770 expected = [
771 (self.alfred.pk, "alfred"),
772 (self.bob.pk, "bob"),
773 (self.lisa.pk, "lisa"),
774 ]
775 self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
776
777 request = self.request_factory.get("/", {"contributors__isnull": "True"})
778 request.user = self.alfred
779 changelist = modeladmin.get_changelist_instance(request)
780
781 # Make sure the correct queryset is returned
782 queryset = changelist.get_queryset(request)
783 self.assertEqual(
784 list(queryset), [self.django_book, self.bio_book, self.djangonaut_book]
785 )
786
787 # Make sure the last choice is None and is selected
788 filterspec = changelist.get_filters(request)[0][2]
789 self.assertEqual(filterspec.title, "Verbose Contributors")
790 choices = list(filterspec.choices(changelist))
791 self.assertIs(choices[-1]["selected"], True)
792 self.assertEqual(choices[-1]["query_string"], "?contributors__isnull=True")
793
794 request = self.request_factory.get(
795 "/", {"contributors__id__exact": self.bob.pk}
796 )
797 request.user = self.alfred
798 changelist = modeladmin.get_changelist_instance(request)
799
800 # Make sure the correct choice is selected
801 filterspec = changelist.get_filters(request)[0][2]
802 self.assertEqual(filterspec.title, "Verbose Contributors")
803 choice = select_by(filterspec.choices(changelist), "display", "bob")
804 self.assertIs(choice["selected"], True)
805 self.assertEqual(
806 choice["query_string"], "?contributors__id__exact=%d" % self.bob.pk
807 )
808
809 def test_relatedfieldlistfilter_reverse_relationships(self):
810 modeladmin = CustomUserAdmin(User, site)
811
812 # FK relationship -----
813 request = self.request_factory.get("/", {"books_authored__isnull": "True"})
814 request.user = self.alfred
815 changelist = modeladmin.get_changelist_instance(request)
816
817 # Make sure the correct queryset is returned
818 queryset = changelist.get_queryset(request)
819 self.assertEqual(list(queryset), [self.lisa])
820
821 # Make sure the last choice is None and is selected
822 filterspec = changelist.get_filters(request)[0][0]
823 self.assertEqual(filterspec.title, "book")
824 choices = list(filterspec.choices(changelist))
825 self.assertIs(choices[-1]["selected"], True)
826 self.assertEqual(choices[-1]["query_string"], "?books_authored__isnull=True")
827
828 request = self.request_factory.get(
829 "/", {"books_authored__id__exact": self.bio_book.pk}
830 )
831 request.user = self.alfred
832 changelist = modeladmin.get_changelist_instance(request)
833
834 # Make sure the correct choice is selected
835 filterspec = changelist.get_filters(request)[0][0]
836 self.assertEqual(filterspec.title, "book")
837 choice = select_by(
838 filterspec.choices(changelist), "display", self.bio_book.title
839 )
840 self.assertIs(choice["selected"], True)
841 self.assertEqual(
842 choice["query_string"], "?books_authored__id__exact=%d" % self.bio_book.pk
843 )
844
845 # M2M relationship -----
846 request = self.request_factory.get("/", {"books_contributed__isnull": "True"})
847 request.user = self.alfred
848 changelist = modeladmin.get_changelist_instance(request)
849
850 # Make sure the correct queryset is returned
851 queryset = changelist.get_queryset(request)
852 self.assertEqual(list(queryset), [self.alfred])
853
854 # Make sure the last choice is None and is selected
855 filterspec = changelist.get_filters(request)[0][1]
856 self.assertEqual(filterspec.title, "book")
857 choices = list(filterspec.choices(changelist))
858 self.assertIs(choices[-1]["selected"], True)
859 self.assertEqual(choices[-1]["query_string"], "?books_contributed__isnull=True")
860
861 request = self.request_factory.get(
862 "/", {"books_contributed__id__exact": self.django_book.pk}
863 )
864 request.user = self.alfred
865 changelist = modeladmin.get_changelist_instance(request)
866
867 # Make sure the correct choice is selected
868 filterspec = changelist.get_filters(request)[0][1]
869 self.assertEqual(filterspec.title, "book")
870 choice = select_by(
871 filterspec.choices(changelist), "display", self.django_book.title
872 )
873 self.assertIs(choice["selected"], True)
874 self.assertEqual(
875 choice["query_string"],
876 "?books_contributed__id__exact=%d" % self.django_book.pk,
877 )
878
879 # With one book, the list filter should appear because there is also a
880 # (None) option.
881 Book.objects.exclude(pk=self.djangonaut_book.pk).delete()
882 filterspec = changelist.get_filters(request)[0]
883 self.assertEqual(len(filterspec), 2)
884 # With no books remaining, no list filters should appear.
885 Book.objects.all().delete()
886 filterspec = changelist.get_filters(request)[0]
887 self.assertEqual(len(filterspec), 0)
888
889 def test_relatedfieldlistfilter_reverse_relationships_default_ordering(self):
890 self.addCleanup(setattr, Book._meta, "ordering", Book._meta.ordering)
891 Book._meta.ordering = ("title",)
892 modeladmin = CustomUserAdmin(User, site)
893
894 request = self.request_factory.get("/")
895 request.user = self.alfred
896 changelist = modeladmin.get_changelist_instance(request)
897 filterspec = changelist.get_filters(request)[0][0]
898 expected = [
899 (self.bio_book.pk, "Django: a biography"),
900 (self.djangonaut_book.pk, "Djangonaut: an art of living"),
901 (self.guitar_book.pk, "Guitar for dummies"),
902 (self.django_book.pk, "The Django Book"),
903 ]
904 self.assertEqual(filterspec.lookup_choices, expected)
905
906 def test_relatedonlyfieldlistfilter_foreignkey(self):
907 modeladmin = BookAdminRelatedOnlyFilter(Book, site)
908
909 request = self.request_factory.get("/")
910 request.user = self.alfred
911 changelist = modeladmin.get_changelist_instance(request)
912
913 # Make sure that only actual authors are present in author's list filter
914 filterspec = changelist.get_filters(request)[0][4]
915 expected = [(self.alfred.pk, "alfred"), (self.bob.pk, "bob")]
916 self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
917
918 def test_relatedonlyfieldlistfilter_foreignkey_reverse_relationships(self):
919 class EmployeeAdminReverseRelationship(ModelAdmin):
920 list_filter = (("book", RelatedOnlyFieldListFilter),)
921
922 self.djangonaut_book.employee = self.john
923 self.djangonaut_book.save()
924 self.django_book.employee = self.jack
925 self.django_book.save()
926
927 modeladmin = EmployeeAdminReverseRelationship(Employee, site)
928 request = self.request_factory.get("/")
929 request.user = self.alfred
930 changelist = modeladmin.get_changelist_instance(request)
931 filterspec = changelist.get_filters(request)[0][0]
932 self.assertCountEqual(
933 filterspec.lookup_choices,
934 [
935 (self.djangonaut_book.pk, "Djangonaut: an art of living"),
936 (self.bio_book.pk, "Django: a biography"),
937 (self.django_book.pk, "The Django Book"),
938 ],
939 )
940
941 def test_relatedonlyfieldlistfilter_manytomany_reverse_relationships(self):
942 class UserAdminReverseRelationship(ModelAdmin):
943 list_filter = (("books_contributed", RelatedOnlyFieldListFilter),)
944
945 modeladmin = UserAdminReverseRelationship(User, site)
946 request = self.request_factory.get("/")
947 request.user = self.alfred
948 changelist = modeladmin.get_changelist_instance(request)
949 filterspec = changelist.get_filters(request)[0][0]
950 self.assertEqual(
951 filterspec.lookup_choices,
952 [(self.guitar_book.pk, "Guitar for dummies")],
953 )
954
955 def test_relatedonlyfieldlistfilter_foreignkey_ordering(self):
956 """RelatedOnlyFieldListFilter ordering respects ModelAdmin.ordering."""
957
958 class EmployeeAdminWithOrdering(ModelAdmin):
959 ordering = ("name",)
960
961 class BookAdmin(ModelAdmin):
962 list_filter = (("employee", RelatedOnlyFieldListFilter),)
963
964 albert = Employee.objects.create(name="Albert Green", department=self.dev)
965 self.djangonaut_book.employee = albert
966 self.djangonaut_book.save()
967 self.bio_book.employee = self.jack
968 self.bio_book.save()
969
970 site.register(Employee, EmployeeAdminWithOrdering)
971 self.addCleanup(lambda: site.unregister(Employee))
972 modeladmin = BookAdmin(Book, site)
973
974 request = self.request_factory.get("/")
975 request.user = self.alfred
976 changelist = modeladmin.get_changelist_instance(request)
977 filterspec = changelist.get_filters(request)[0][0]
978 expected = [(albert.pk, "Albert Green"), (self.jack.pk, "Jack Red")]
979 self.assertEqual(filterspec.lookup_choices, expected)
980
981 def test_relatedonlyfieldlistfilter_foreignkey_default_ordering(self):
982 """RelatedOnlyFieldListFilter ordering respects Meta.ordering."""
983
984 class BookAdmin(ModelAdmin):
985 list_filter = (("employee", RelatedOnlyFieldListFilter),)
986
987 albert = Employee.objects.create(name="Albert Green", department=self.dev)
988 self.djangonaut_book.employee = albert
989 self.djangonaut_book.save()
990 self.bio_book.employee = self.jack
991 self.bio_book.save()
992
993 self.addCleanup(setattr, Employee._meta, "ordering", Employee._meta.ordering)
994 Employee._meta.ordering = ("name",)
995 modeladmin = BookAdmin(Book, site)
996
997 request = self.request_factory.get("/")
998 request.user = self.alfred
999 changelist = modeladmin.get_changelist_instance(request)
1000 filterspec = changelist.get_filters(request)[0][0]
1001 expected = [(albert.pk, "Albert Green"), (self.jack.pk, "Jack Red")]
1002 self.assertEqual(filterspec.lookup_choices, expected)
1003
1004 def test_relatedonlyfieldlistfilter_underscorelookup_foreignkey(self):
1005 Department.objects.create(code="TEST", description="Testing")
1006 self.djangonaut_book.employee = self.john
1007 self.djangonaut_book.save()
1008 self.bio_book.employee = self.jack
1009 self.bio_book.save()
1010
1011 modeladmin = BookAdminRelatedOnlyFilter(Book, site)
1012 request = self.request_factory.get("/")
1013 request.user = self.alfred
1014 changelist = modeladmin.get_changelist_instance(request)
1015
1016 # Only actual departments should be present in employee__department's
1017 # list filter.
1018 filterspec = changelist.get_filters(request)[0][6]
1019 expected = [
1020 (self.dev.code, str(self.dev)),
1021 (self.design.code, str(self.design)),
1022 ]
1023 self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
1024
1025 def test_relatedonlyfieldlistfilter_manytomany(self):
1026 modeladmin = BookAdminRelatedOnlyFilter(Book, site)
1027
1028 request = self.request_factory.get("/")
1029 request.user = self.alfred
1030 changelist = modeladmin.get_changelist_instance(request)
1031
1032 # Make sure that only actual contributors are present in contrib's list filter
1033 filterspec = changelist.get_filters(request)[0][5]
1034 expected = [(self.bob.pk, "bob"), (self.lisa.pk, "lisa")]
1035 self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
1036
1037 def test_listfilter_genericrelation(self):
1038 django_bookmark = Bookmark.objects.create(url="https://www.djangoproject.com/")
1039 python_bookmark = Bookmark.objects.create(url="https://www.python.org/")
1040 kernel_bookmark = Bookmark.objects.create(url="https://www.kernel.org/")
1041
1042 TaggedItem.objects.create(content_object=django_bookmark, tag="python")
1043 TaggedItem.objects.create(content_object=python_bookmark, tag="python")
1044 TaggedItem.objects.create(content_object=kernel_bookmark, tag="linux")
1045
1046 modeladmin = BookmarkAdminGenericRelation(Bookmark, site)
1047
1048 request = self.request_factory.get("/", {"tags__tag": "python"})
1049 request.user = self.alfred
1050 changelist = modeladmin.get_changelist_instance(request)
1051 queryset = changelist.get_queryset(request)
1052
1053 expected = [python_bookmark, django_bookmark]
1054 self.assertEqual(list(queryset), expected)
1055
1056 def test_booleanfieldlistfilter(self):
1057 modeladmin = BookAdmin(Book, site)
1058 self.verify_booleanfieldlistfilter(modeladmin)
1059
1060 def test_booleanfieldlistfilter_tuple(self):
1061 modeladmin = BookAdminWithTupleBooleanFilter(Book, site)
1062 self.verify_booleanfieldlistfilter(modeladmin)
1063
1064 def verify_booleanfieldlistfilter(self, modeladmin):
1065 request = self.request_factory.get("/")
1066 request.user = self.alfred
1067 changelist = modeladmin.get_changelist_instance(request)
1068
1069 request = self.request_factory.get("/", {"is_best_seller__exact": 0})
1070 request.user = self.alfred
1071 changelist = modeladmin.get_changelist_instance(request)
1072
1073 # Make sure the correct queryset is returned
1074 queryset = changelist.get_queryset(request)
1075 self.assertEqual(list(queryset), [self.bio_book])
1076
1077 # Make sure the correct choice is selected
1078 filterspec = changelist.get_filters(request)[0][3]
1079 self.assertEqual(filterspec.title, "is best seller")
1080 choice = select_by(filterspec.choices(changelist), "display", "No")
1081 self.assertIs(choice["selected"], True)
1082 self.assertEqual(choice["query_string"], "?is_best_seller__exact=0")
1083
1084 request = self.request_factory.get("/", {"is_best_seller__exact": 1})
1085 request.user = self.alfred
1086 changelist = modeladmin.get_changelist_instance(request)
1087
1088 # Make sure the correct queryset is returned
1089 queryset = changelist.get_queryset(request)
1090 self.assertEqual(list(queryset), [self.guitar_book, self.djangonaut_book])
1091
1092 # Make sure the correct choice is selected
1093 filterspec = changelist.get_filters(request)[0][3]
1094 self.assertEqual(filterspec.title, "is best seller")
1095 choice = select_by(filterspec.choices(changelist), "display", "Yes")
1096 self.assertIs(choice["selected"], True)
1097 self.assertEqual(choice["query_string"], "?is_best_seller__exact=1")
1098
1099 request = self.request_factory.get("/", {"is_best_seller__isnull": "True"})
1100 request.user = self.alfred
1101 changelist = modeladmin.get_changelist_instance(request)
1102
1103 # Make sure the correct queryset is returned
1104 queryset = changelist.get_queryset(request)
1105 self.assertEqual(list(queryset), [self.django_book])
1106
1107 # Make sure the correct choice is selected
1108 filterspec = changelist.get_filters(request)[0][3]
1109 self.assertEqual(filterspec.title, "is best seller")
1110 choice = select_by(filterspec.choices(changelist), "display", "Unknown")
1111 self.assertIs(choice["selected"], True)
1112 self.assertEqual(choice["query_string"], "?is_best_seller__isnull=True")
1113
1114 def test_booleanfieldlistfilter_choices(self):
1115 modeladmin = BookAdmin(Book, site)
1116 self.verify_booleanfieldlistfilter_choices(modeladmin)
1117
1118 def test_booleanfieldlistfilter_tuple_choices(self):
1119 modeladmin = BookAdminWithTupleBooleanFilter(Book, site)
1120 self.verify_booleanfieldlistfilter_choices(modeladmin)
1121
1122 def verify_booleanfieldlistfilter_choices(self, modeladmin):
1123 # False.
1124 request = self.request_factory.get("/", {"availability__exact": 0})
1125 request.user = self.alfred
1126 changelist = modeladmin.get_changelist_instance(request)
1127 queryset = changelist.get_queryset(request)
1128 self.assertEqual(list(queryset), [self.bio_book])
1129 filterspec = changelist.get_filters(request)[0][6]
1130 self.assertEqual(filterspec.title, "availability")
1131 choice = select_by(filterspec.choices(changelist), "display", "Paid")
1132 self.assertIs(choice["selected"], True)
1133 self.assertEqual(choice["query_string"], "?availability__exact=0")
1134 # True.
1135 request = self.request_factory.get("/", {"availability__exact": 1})
1136 request.user = self.alfred
1137 changelist = modeladmin.get_changelist_instance(request)
1138 queryset = changelist.get_queryset(request)
1139 self.assertEqual(list(queryset), [self.django_book, self.djangonaut_book])
1140 filterspec = changelist.get_filters(request)[0][6]
1141 self.assertEqual(filterspec.title, "availability")
1142 choice = select_by(filterspec.choices(changelist), "display", "Free")
1143 self.assertIs(choice["selected"], True)
1144 self.assertEqual(choice["query_string"], "?availability__exact=1")
1145 # None.
1146 request = self.request_factory.get("/", {"availability__isnull": "True"})
1147 request.user = self.alfred
1148 changelist = modeladmin.get_changelist_instance(request)
1149 queryset = changelist.get_queryset(request)
1150 self.assertEqual(list(queryset), [self.guitar_book])
1151 filterspec = changelist.get_filters(request)[0][6]
1152 self.assertEqual(filterspec.title, "availability")
1153 choice = select_by(filterspec.choices(changelist), "display", "Obscure")
1154 self.assertIs(choice["selected"], True)
1155 self.assertEqual(choice["query_string"], "?availability__isnull=True")
1156 # All.
1157 request = self.request_factory.get("/")
1158 request.user = self.alfred
1159 changelist = modeladmin.get_changelist_instance(request)
1160 queryset = changelist.get_queryset(request)
1161 self.assertEqual(
1162 list(queryset),
1163 [self.guitar_book, self.django_book, self.bio_book, self.djangonaut_book],
1164 )
1165 filterspec = changelist.get_filters(request)[0][6]
1166 self.assertEqual(filterspec.title, "availability")
1167 choice = select_by(filterspec.choices(changelist), "display", "All")
1168 self.assertIs(choice["selected"], True)
1169 self.assertEqual(choice["query_string"], "?")
1170
1171 def test_fieldlistfilter_underscorelookup_tuple(self):
1172 """
1173 Ensure ('fieldpath', ClassName ) lookups pass lookup_allowed checks
1174 when fieldpath contains double underscore in value (#19182).
1175 """
1176 modeladmin = BookAdminWithUnderscoreLookupAndTuple(Book, site)
1177 request = self.request_factory.get("/")
1178 request.user = self.alfred
1179 changelist = modeladmin.get_changelist_instance(request)
1180
1181 request = self.request_factory.get("/", {"author__email": "[email protected]"})
1182 request.user = self.alfred
1183 changelist = modeladmin.get_changelist_instance(request)
1184
1185 # Make sure the correct queryset is returned
1186 queryset = changelist.get_queryset(request)
1187 self.assertEqual(list(queryset), [self.bio_book, self.djangonaut_book])
1188
1189 def test_fieldlistfilter_invalid_lookup_parameters(self):
1190 """Filtering by an invalid value."""
1191 modeladmin = BookAdmin(Book, site)
1192 request = self.request_factory.get(
1193 "/", {"author__id__exact": "StringNotInteger!"}
1194 )
1195 request.user = self.alfred
1196 with self.assertRaises(IncorrectLookupParameters):
1197 modeladmin.get_changelist_instance(request)
1198
1199 def test_fieldlistfilter_multiple_invalid_lookup_parameters(self):
1200 modeladmin = BookAdmin(Book, site)
1201 request = self.request_factory.get(
1202 "/", {"author__id__exact": f"{self.alfred.pk},{self.bob.pk}"}
1203 )
1204 request.user = self.alfred
1205 with self.assertRaises(IncorrectLookupParameters):
1206 modeladmin.get_changelist_instance(request)
1207
1208 def test_simplelistfilter(self):
1209 modeladmin = DecadeFilterBookAdmin(Book, site)
1210
1211 # Make sure that the first option is 'All' ---------------------------
1212 request = self.request_factory.get("/", {})
1213 request.user = self.alfred
1214 changelist = modeladmin.get_changelist_instance(request)
1215
1216 # Make sure the correct queryset is returned
1217 queryset = changelist.get_queryset(request)
1218 self.assertEqual(list(queryset), list(Book.objects.order_by("-id")))
1219
1220 # Make sure the correct choice is selected
1221 filterspec = changelist.get_filters(request)[0][1]
1222 self.assertEqual(filterspec.title, "publication decade")
1223 choices = list(filterspec.choices(changelist))
1224 self.assertEqual(choices[0]["display"], "All")
1225 self.assertIs(choices[0]["selected"], True)
1226 self.assertEqual(choices[0]["query_string"], "?")
1227
1228 # Look for books in the 1980s ----------------------------------------
1229 request = self.request_factory.get("/", {"publication-decade": "the 80s"})
1230 request.user = self.alfred
1231 changelist = modeladmin.get_changelist_instance(request)
1232
1233 # Make sure the correct queryset is returned
1234 queryset = changelist.get_queryset(request)
1235 self.assertEqual(list(queryset), [])
1236
1237 # Make sure the correct choice is selected
1238 filterspec = changelist.get_filters(request)[0][1]
1239 self.assertEqual(filterspec.title, "publication decade")
1240 choices = list(filterspec.choices(changelist))
1241 self.assertEqual(choices[1]["display"], "the 1980's")
1242 self.assertIs(choices[1]["selected"], True)
1243 self.assertEqual(choices[1]["query_string"], "?publication-decade=the+80s")
1244
1245 # Look for books in the 1990s ----------------------------------------
1246 request = self.request_factory.get("/", {"publication-decade": "the 90s"})
1247 request.user = self.alfred
1248 changelist = modeladmin.get_changelist_instance(request)
1249
1250 # Make sure the correct queryset is returned
1251 queryset = changelist.get_queryset(request)
1252 self.assertEqual(list(queryset), [self.bio_book])
1253
1254 # Make sure the correct choice is selected
1255 filterspec = changelist.get_filters(request)[0][1]
1256 self.assertEqual(filterspec.title, "publication decade")
1257 choices = list(filterspec.choices(changelist))
1258 self.assertEqual(choices[2]["display"], "the 1990's")
1259 self.assertIs(choices[2]["selected"], True)
1260 self.assertEqual(choices[2]["query_string"], "?publication-decade=the+90s")
1261
1262 # Look for books in the 2000s ----------------------------------------
1263 request = self.request_factory.get("/", {"publication-decade": "the 00s"})
1264 request.user = self.alfred
1265 changelist = modeladmin.get_changelist_instance(request)
1266
1267 # Make sure the correct queryset is returned
1268 queryset = changelist.get_queryset(request)
1269 self.assertEqual(list(queryset), [self.guitar_book, self.djangonaut_book])
1270
1271 # Make sure the correct choice is selected
1272 filterspec = changelist.get_filters(request)[0][1]
1273 self.assertEqual(filterspec.title, "publication decade")
1274 choices = list(filterspec.choices(changelist))
1275 self.assertEqual(choices[3]["display"], "the 2000's")
1276 self.assertIs(choices[3]["selected"], True)
1277 self.assertEqual(choices[3]["query_string"], "?publication-decade=the+00s")
1278
1279 # Combine multiple filters -------------------------------------------
1280 request = self.request_factory.get(
1281 "/", {"publication-decade": "the 00s", "author__id__exact": self.alfred.pk}
1282 )
1283 request.user = self.alfred
1284 changelist = modeladmin.get_changelist_instance(request)
1285
1286 # Make sure the correct queryset is returned
1287 queryset = changelist.get_queryset(request)
1288 self.assertEqual(list(queryset), [self.djangonaut_book])
1289
1290 # Make sure the correct choices are selected
1291 filterspec = changelist.get_filters(request)[0][1]
1292 self.assertEqual(filterspec.title, "publication decade")
1293 choices = list(filterspec.choices(changelist))
1294 self.assertEqual(choices[3]["display"], "the 2000's")
1295 self.assertIs(choices[3]["selected"], True)
1296 self.assertEqual(
1297 choices[3]["query_string"],
1298 "?author__id__exact=%s&publication-decade=the+00s" % self.alfred.pk,
1299 )
1300
1301 filterspec = changelist.get_filters(request)[0][0]
1302 self.assertEqual(filterspec.title, "Verbose Author")
1303 choice = select_by(filterspec.choices(changelist), "display", "alfred")
1304 self.assertIs(choice["selected"], True)
1305 self.assertEqual(
1306 choice["query_string"],
1307 "?author__id__exact=%s&publication-decade=the+00s" % self.alfred.pk,
1308 )
1309
1310 def test_listfilter_without_title(self):
1311 """
1312 Any filter must define a title.
1313 """
1314 modeladmin = DecadeFilterBookAdminWithoutTitle(Book, site)
1315 request = self.request_factory.get("/", {})
1316 request.user = self.alfred
1317 msg = (
1318 "The list filter 'DecadeListFilterWithoutTitle' does not specify a 'title'."
1319 )
1320 with self.assertRaisesMessage(ImproperlyConfigured, msg):
1321 modeladmin.get_changelist_instance(request)
1322
1323 def test_simplelistfilter_without_parameter(self):
1324 """
1325 Any SimpleListFilter must define a parameter_name.
1326 """
1327 modeladmin = DecadeFilterBookAdminWithoutParameter(Book, site)
1328 request = self.request_factory.get("/", {})
1329 request.user = self.alfred
1330 msg = (
1331 "The list filter 'DecadeListFilterWithoutParameter' does not specify a "
1332 "'parameter_name'."
1333 )
1334 with self.assertRaisesMessage(ImproperlyConfigured, msg):
1335 modeladmin.get_changelist_instance(request)
1336
1337 def test_simplelistfilter_with_none_returning_lookups(self):
1338 """
1339 A SimpleListFilter lookups method can return None but disables the
1340 filter completely.
1341 """
1342 modeladmin = DecadeFilterBookAdminWithNoneReturningLookups(Book, site)
1343 request = self.request_factory.get("/", {})
1344 request.user = self.alfred
1345 changelist = modeladmin.get_changelist_instance(request)
1346 filterspec = changelist.get_filters(request)[0]
1347 self.assertEqual(len(filterspec), 0)
1348
1349 def test_filter_with_failing_queryset(self):
1350 """
1351 When a filter's queryset method fails, it fails loudly and
1352 the corresponding exception doesn't get swallowed (#17828).
1353 """
1354 modeladmin = DecadeFilterBookAdminWithFailingQueryset(Book, site)
1355 request = self.request_factory.get("/", {})
1356 request.user = self.alfred
1357 with self.assertRaises(ZeroDivisionError):
1358 modeladmin.get_changelist_instance(request)
1359
1360 def test_simplelistfilter_with_queryset_based_lookups(self):
1361 modeladmin = DecadeFilterBookAdminWithQuerysetBasedLookups(Book, site)
1362 request = self.request_factory.get("/", {})
1363 request.user = self.alfred
1364 changelist = modeladmin.get_changelist_instance(request)
1365
1366 filterspec = changelist.get_filters(request)[0][0]
1367 self.assertEqual(filterspec.title, "publication decade")
1368 choices = list(filterspec.choices(changelist))
1369 self.assertEqual(len(choices), 3)
1370
1371 self.assertEqual(choices[0]["display"], "All")
1372 self.assertIs(choices[0]["selected"], True)
1373 self.assertEqual(choices[0]["query_string"], "?")
1374
1375 self.assertEqual(choices[1]["display"], "the 1990's")
1376 self.assertIs(choices[1]["selected"], False)
1377 self.assertEqual(choices[1]["query_string"], "?publication-decade=the+90s")
1378
1379 self.assertEqual(choices[2]["display"], "the 2000's")
1380 self.assertIs(choices[2]["selected"], False)
1381 self.assertEqual(choices[2]["query_string"], "?publication-decade=the+00s")
1382
1383 def _test_facets(self, modeladmin, request, query_string=None):
1384 request.user = self.alfred
1385 changelist = modeladmin.get_changelist_instance(request)
1386 queryset = changelist.get_queryset(request)
1387 self.assertSequenceEqual(queryset, list(Book.objects.order_by("-id")))
1388 filters = changelist.get_filters(request)[0]
1389 # Filters for DateFieldListFilter.
1390 expected_date_filters = ["Any date (4)", "Today (2)", "Past 7 days (3)"]
1391 if (
1392 self.today.month == self.one_week_ago.month
1393 and self.today.year == self.one_week_ago.year
1394 ):
1395 expected_date_filters.extend(["This month (3)", "This year (3)"])
1396 elif self.today.year == self.one_week_ago.year:
1397 expected_date_filters.extend(["This month (2)", "This year (3)"])
1398 else:
1399 expected_date_filters.extend(["This month (2)", "This year (2)"])
1400 expected_date_filters.extend(["No date (1)", "Has date (3)"])
1401
1402 empty_choice_count = (
1403 2 if connection.features.interprets_empty_strings_as_nulls else 1
1404 )
1405 tests = [
1406 # RelatedFieldListFilter.
1407 ["All", "alfred (2)", "bob (1)", "lisa (0)", "??? (1)"],
1408 # SimpleListFilter.
1409 [
1410 "All",
1411 "the 1980's (0)",
1412 "the 1990's (1)",
1413 "the 2000's (2)",
1414 "other decades (-)",
1415 ],
1416 # BooleanFieldListFilter.
1417 ["All", "Yes (2)", "No (1)", "Unknown (1)"],
1418 # ChoicesFieldListFilter.
1419 [
1420 "All",
1421 "Non-Fictional (1)",
1422 "Fictional (1)",
1423 f"We don't know ({empty_choice_count})",
1424 f"Not categorized ({empty_choice_count})",
1425 ],
1426 # DateFieldListFilter.
1427 expected_date_filters,
1428 # AllValuesFieldListFilter.
1429 [
1430 "All",
1431 "[email protected] (2)",
1432 "[email protected] (1)",
1433 "[email protected] (0)",
1434 ],
1435 # RelatedOnlyFieldListFilter.
1436 ["All", "bob (1)", "lisa (1)", "??? (3)"],
1437 # EmptyFieldListFilter.
1438 ["All", "Empty (2)", "Not empty (2)"],
1439 # SimpleListFilter with join relations.
1440 ["All", "Owned by Dev Department (2)", "Other (2)"],
1441 ]
1442 for filterspec, expected_displays in zip(filters, tests, strict=True):
1443 with self.subTest(filterspec.__class__.__name__):
1444 choices = list(filterspec.choices(changelist))
1445 self.assertChoicesDisplay(choices, expected_displays)
1446 if query_string:
1447 for choice in choices:
1448 self.assertIn(query_string, choice["query_string"])
1449
1450 def test_facets_always(self):
1451 modeladmin = DecadeFilterBookAdminWithAlwaysFacets(Book, site)
1452 request = self.request_factory.get("/")
1453 self._test_facets(modeladmin, request)
1454
1455 def test_facets_no_filter(self):
1456 modeladmin = DecadeFilterBookAdmin(Book, site)
1457 request = self.request_factory.get("/?_facets")
1458 self._test_facets(modeladmin, request, query_string="_facets")
1459
1460 def test_facets_filter(self):
1461 modeladmin = DecadeFilterBookAdmin(Book, site)
1462 request = self.request_factory.get(
1463 "/", {"author__id__exact": self.alfred.pk, "_facets": ""}
1464 )
1465 request.user = self.alfred
1466 changelist = modeladmin.get_changelist_instance(request)
1467 queryset = changelist.get_queryset(request)
1468 self.assertSequenceEqual(
1469 queryset,
1470 list(Book.objects.filter(author=self.alfred).order_by("-id")),
1471 )
1472 filters = changelist.get_filters(request)[0]
1473
1474 tests = [
1475 # RelatedFieldListFilter.
1476 ["All", "alfred (2)", "bob (1)", "lisa (0)", "??? (1)"],
1477 # SimpleListFilter.
1478 [
1479 "All",
1480 "the 1980's (0)",
1481 "the 1990's (1)",
1482 "the 2000's (1)",
1483 "other decades (-)",
1484 ],
1485 # BooleanFieldListFilter.
1486 ["All", "Yes (1)", "No (1)", "Unknown (0)"],
1487 # ChoicesFieldListFilter.
1488 [
1489 "All",
1490 "Non-Fictional (1)",
1491 "Fictional (1)",
1492 "We don't know (0)",
1493 "Not categorized (0)",
1494 ],
1495 # DateFieldListFilter.
1496 [
1497 "Any date (2)",
1498 "Today (1)",
1499 "Past 7 days (1)",
1500 "This month (1)",
1501 "This year (1)",
1502 "No date (1)",
1503 "Has date (1)",
1504 ],
1505 # AllValuesFieldListFilter.
1506 [
1507 "All",
1508 "[email protected] (2)",
1509 "[email protected] (0)",
1510 "[email protected] (0)",
1511 ],
1512 # RelatedOnlyFieldListFilter.
1513 ["All", "bob (0)", "lisa (0)", "??? (2)"],
1514 # EmptyFieldListFilter.
1515 ["All", "Empty (0)", "Not empty (2)"],
1516 # SimpleListFilter with join relations.
1517 ["All", "Owned by Dev Department (2)", "Other (0)"],
1518 ]
1519 for filterspec, expected_displays in zip(filters, tests, strict=True):
1520 with self.subTest(filterspec.__class__.__name__):
1521 choices = list(filterspec.choices(changelist))
1522 self.assertChoicesDisplay(choices, expected_displays)
1523 for choice in choices:
1524 self.assertIn("_facets", choice["query_string"])
1525
1526 def test_facets_disallowed(self):
1527 modeladmin = DecadeFilterBookAdminDisallowFacets(Book, site)
1528 # Facets are not visible even when in the url query.
1529 request = self.request_factory.get("/?_facets")
1530 request.user = self.alfred
1531 changelist = modeladmin.get_changelist_instance(request)
1532 queryset = changelist.get_queryset(request)
1533 self.assertSequenceEqual(queryset, list(Book.objects.order_by("-id")))
1534 filters = changelist.get_filters(request)[0]
1535
1536 tests = [
1537 # RelatedFieldListFilter.
1538 ["All", "alfred", "bob", "lisa", "???"],
1539 # SimpleListFilter.
1540 ["All", "the 1980's", "the 1990's", "the 2000's", "other decades"],
1541 # BooleanFieldListFilter.
1542 ["All", "Yes", "No", "Unknown"],
1543 # ChoicesFieldListFilter.
1544 ["All", "Non-Fictional", "Fictional", "We don't know", "Not categorized"],
1545 # DateFieldListFilter.
1546 [
1547 "Any date",
1548 "Today",
1549 "Past 7 days",
1550 "This month",
1551 "This year",
1552 "No date",
1553 "Has date",
1554 ],
1555 # AllValuesFieldListFilter.
1556 ["All", "[email protected]", "[email protected]", "[email protected]"],
1557 # RelatedOnlyFieldListFilter.
1558 ["All", "bob", "lisa", "???"],
1559 # EmptyFieldListFilter.
1560 ["All", "Empty", "Not empty"],
1561 # SimpleListFilter with join relations.
1562 ["All", "Owned by Dev Department", "Other"],
1563 ]
1564 for filterspec, expected_displays in zip(filters, tests, strict=True):
1565 with self.subTest(filterspec.__class__.__name__):
1566 self.assertChoicesDisplay(
1567 filterspec.choices(changelist),
1568 expected_displays,
1569 )
1570
1571 def test_multi_related_field_filter(self):
1572 modeladmin = DecadeFilterBookAdmin(Book, site)
1573 request = self.request_factory.get(
1574 "/",
1575 [("author__id__exact", self.alfred.pk), ("author__id__exact", self.bob.pk)],
1576 )
1577 request.user = self.alfred
1578 changelist = modeladmin.get_changelist_instance(request)
1579 queryset = changelist.get_queryset(request)
1580 self.assertSequenceEqual(
1581 queryset,
1582 list(
1583 Book.objects.filter(
1584 author__pk__in=[self.alfred.pk, self.bob.pk]
1585 ).order_by("-id")
1586 ),
1587 )
1588 filterspec = changelist.get_filters(request)[0][0]
1589 choices = list(filterspec.choices(changelist))
1590 expected_choice_values = [
1591 ("All", False, "?"),
1592 ("alfred", True, f"?author__id__exact={self.alfred.pk}"),
1593 ("bob", True, f"?author__id__exact={self.bob.pk}"),
1594 ("lisa", False, f"?author__id__exact={self.lisa.pk}"),
1595 ]
1596 for i, (display, selected, query_string) in enumerate(expected_choice_values):
1597 self.assertEqual(choices[i]["display"], display)
1598 self.assertIs(choices[i]["selected"], selected)
1599 self.assertEqual(choices[i]["query_string"], query_string)
1600
1601 def test_multi_choice_field_filter(self):
1602 modeladmin = DecadeFilterBookAdmin(Book, site)
1603 request = self.request_factory.get(
1604 "/",
1605 [("category__exact", "non-fiction"), ("category__exact", "fiction")],
1606 )
1607 request.user = self.alfred
1608 changelist = modeladmin.get_changelist_instance(request)
1609 queryset = changelist.get_queryset(request)
1610 self.assertSequenceEqual(
1611 queryset,
1612 list(
1613 Book.objects.filter(category__in=["non-fiction", "fiction"]).order_by(
1614 "-id"
1615 )
1616 ),
1617 )
1618 filterspec = changelist.get_filters(request)[0][3]
1619 choices = list(filterspec.choices(changelist))
1620 expected_choice_values = [
1621 ("All", False, "?"),
1622 ("Non-Fictional", True, "?category__exact=non-fiction"),
1623 ("Fictional", True, "?category__exact=fiction"),
1624 ("We don't know", False, "?category__exact="),
1625 ("Not categorized", False, "?category__isnull=True"),
1626 ]
1627 for i, (display, selected, query_string) in enumerate(expected_choice_values):
1628 self.assertEqual(choices[i]["display"], display)
1629 self.assertIs(choices[i]["selected"], selected)
1630 self.assertEqual(choices[i]["query_string"], query_string)
1631
1632 def test_multi_all_values_field_filter(self):
1633 modeladmin = DecadeFilterBookAdmin(Book, site)
1634 request = self.request_factory.get(
1635 "/",
1636 [
1637 ("author__email", "[email protected]"),
1638 ("author__email", "[email protected]"),
1639 ],
1640 )
1641 request.user = self.alfred
1642 changelist = modeladmin.get_changelist_instance(request)
1643 queryset = changelist.get_queryset(request)
1644 self.assertSequenceEqual(
1645 queryset,
1646 list(
1647 Book.objects.filter(
1648 author__email__in=["[email protected]", "[email protected]"]
1649 ).order_by("-id")
1650 ),
1651 )
1652 filterspec = changelist.get_filters(request)[0][5]
1653 choices = list(filterspec.choices(changelist))
1654 expected_choice_values = [
1655 ("All", False, "?"),
1656 ("[email protected]", False, "?author__email=alfred%40example.com"),
1657 ("[email protected]", True, "?author__email=bob%40example.com"),
1658 ("[email protected]", True, "?author__email=lisa%40example.com"),
1659 ]
1660 for i, (display, selected, query_string) in enumerate(expected_choice_values):
1661 self.assertEqual(choices[i]["display"], display)
1662 self.assertIs(choices[i]["selected"], selected)
1663 self.assertEqual(choices[i]["query_string"], query_string)
1664
1665 def test_two_characters_long_field(self):
1666 """
1667 list_filter works with two-characters long field names (#16080).
1668 """
1669 modeladmin = BookAdmin(Book, site)
1670 request = self.request_factory.get("/", {"no": "207"})
1671 request.user = self.alfred
1672 changelist = modeladmin.get_changelist_instance(request)
1673
1674 # Make sure the correct queryset is returned
1675 queryset = changelist.get_queryset(request)
1676 self.assertEqual(list(queryset), [self.bio_book])
1677
1678 filterspec = changelist.get_filters(request)[0][5]
1679 self.assertEqual(filterspec.title, "number")
1680 choices = list(filterspec.choices(changelist))
1681 self.assertIs(choices[2]["selected"], True)
1682 self.assertEqual(choices[2]["query_string"], "?no=207")
1683
1684 def test_parameter_ends_with__in__or__isnull(self):
1685 """
1686 A SimpleListFilter's parameter name is not mistaken for a model field
1687 if it ends with '__isnull' or '__in' (#17091).
1688 """
1689 # When it ends with '__in' -----------------------------------------
1690 modeladmin = DecadeFilterBookAdminParameterEndsWith__In(Book, site)
1691 request = self.request_factory.get("/", {"decade__in": "the 90s"})
1692 request.user = self.alfred
1693 changelist = modeladmin.get_changelist_instance(request)
1694
1695 # Make sure the correct queryset is returned
1696 queryset = changelist.get_queryset(request)
1697 self.assertEqual(list(queryset), [self.bio_book])
1698
1699 # Make sure the correct choice is selected
1700 filterspec = changelist.get_filters(request)[0][0]
1701 self.assertEqual(filterspec.title, "publication decade")
1702 choices = list(filterspec.choices(changelist))
1703 self.assertEqual(choices[2]["display"], "the 1990's")
1704 self.assertIs(choices[2]["selected"], True)
1705 self.assertEqual(choices[2]["query_string"], "?decade__in=the+90s")
1706
1707 # When it ends with '__isnull' ---------------------------------------
1708 modeladmin = DecadeFilterBookAdminParameterEndsWith__Isnull(Book, site)
1709 request = self.request_factory.get("/", {"decade__isnull": "the 90s"})
1710 request.user = self.alfred
1711 changelist = modeladmin.get_changelist_instance(request)
1712
1713 # Make sure the correct queryset is returned
1714 queryset = changelist.get_queryset(request)
1715 self.assertEqual(list(queryset), [self.bio_book])
1716
1717 # Make sure the correct choice is selected
1718 filterspec = changelist.get_filters(request)[0][0]
1719 self.assertEqual(filterspec.title, "publication decade")
1720 choices = list(filterspec.choices(changelist))
1721 self.assertEqual(choices[2]["display"], "the 1990's")
1722 self.assertIs(choices[2]["selected"], True)
1723 self.assertEqual(choices[2]["query_string"], "?decade__isnull=the+90s")
1724
1725 def test_lookup_with_non_string_value(self):
1726 """
1727 Ensure choices are set the selected class when using non-string values
1728 for lookups in SimpleListFilters (#19318).
1729 """
1730 modeladmin = DepartmentFilterEmployeeAdmin(Employee, site)
1731 request = self.request_factory.get("/", {"department": self.john.department.pk})
1732 request.user = self.alfred
1733 changelist = modeladmin.get_changelist_instance(request)
1734
1735 queryset = changelist.get_queryset(request)
1736
1737 self.assertEqual(list(queryset), [self.john])
1738
1739 filterspec = changelist.get_filters(request)[0][-1]
1740 self.assertEqual(filterspec.title, "department")
1741 choices = list(filterspec.choices(changelist))
1742 self.assertEqual(choices[1]["display"], "DEV")
1743 self.assertIs(choices[1]["selected"], True)
1744 self.assertEqual(
1745 choices[1]["query_string"], "?department=%s" % self.john.department.pk
1746 )
1747
1748 def test_lookup_with_non_string_value_underscored(self):
1749 """
1750 Ensure SimpleListFilter lookups pass lookup_allowed checks when
1751 parameter_name attribute contains double-underscore value (#19182).
1752 """
1753 modeladmin = DepartmentFilterUnderscoredEmployeeAdmin(Employee, site)
1754 request = self.request_factory.get(
1755 "/", {"department__whatever": self.john.department.pk}
1756 )
1757 request.user = self.alfred
1758 changelist = modeladmin.get_changelist_instance(request)
1759
1760 queryset = changelist.get_queryset(request)
1761
1762 self.assertEqual(list(queryset), [self.john])
1763
1764 filterspec = changelist.get_filters(request)[0][-1]
1765 self.assertEqual(filterspec.title, "department")
1766 choices = list(filterspec.choices(changelist))
1767 self.assertEqual(choices[1]["display"], "DEV")
1768 self.assertIs(choices[1]["selected"], True)
1769 self.assertEqual(
1770 choices[1]["query_string"],
1771 "?department__whatever=%s" % self.john.department.pk,
1772 )
1773
1774 def test_fk_with_to_field(self):
1775 """
1776 A filter on a FK respects the FK's to_field attribute (#17972).
1777 """
1778 modeladmin = EmployeeAdmin(Employee, site)
1779
1780 request = self.request_factory.get("/", {})
1781 request.user = self.alfred
1782 changelist = modeladmin.get_changelist_instance(request)
1783
1784 # Make sure the correct queryset is returned
1785 queryset = changelist.get_queryset(request)
1786 self.assertEqual(list(queryset), [self.jack, self.john])
1787
1788 filterspec = changelist.get_filters(request)[0][-1]
1789 self.assertEqual(filterspec.title, "department")
1790 choices = [
1791 (choice["display"], choice["selected"], choice["query_string"])
1792 for choice in filterspec.choices(changelist)
1793 ]
1794 self.assertCountEqual(
1795 choices,
1796 [
1797 ("All", True, "?"),
1798 ("Development", False, "?department__code__exact=DEV"),
1799 ("Design", False, "?department__code__exact=DSN"),
1800 ],
1801 )
1802
1803 # Filter by Department=='Development' --------------------------------
1804
1805 request = self.request_factory.get("/", {"department__code__exact": "DEV"})
1806 request.user = self.alfred
1807 changelist = modeladmin.get_changelist_instance(request)
1808
1809 # Make sure the correct queryset is returned
1810 queryset = changelist.get_queryset(request)
1811 self.assertEqual(list(queryset), [self.john])
1812
1813 filterspec = changelist.get_filters(request)[0][-1]
1814 self.assertEqual(filterspec.title, "department")
1815 choices = [
1816 (choice["display"], choice["selected"], choice["query_string"])
1817 for choice in filterspec.choices(changelist)
1818 ]
1819 self.assertCountEqual(
1820 choices,
1821 [
1822 ("All", False, "?"),
1823 ("Development", True, "?department__code__exact=DEV"),
1824 ("Design", False, "?department__code__exact=DSN"),
1825 ],
1826 )
1827
1828 def test_lookup_with_dynamic_value(self):
1829 """
1830 Ensure SimpleListFilter can access self.value() inside the lookup.
1831 """
1832 modeladmin = DepartmentFilterDynamicValueBookAdmin(Book, site)
1833
1834 def _test_choices(request, expected_displays):
1835 request.user = self.alfred
1836 changelist = modeladmin.get_changelist_instance(request)
1837 filterspec = changelist.get_filters(request)[0][0]
1838 self.assertEqual(filterspec.title, "publication decade")
1839 choices = tuple(c["display"] for c in filterspec.choices(changelist))
1840 self.assertEqual(choices, expected_displays)
1841
1842 _test_choices(
1843 self.request_factory.get("/", {}), ("All", "the 1980's", "the 1990's")
1844 )
1845
1846 _test_choices(
1847 self.request_factory.get("/", {"publication-decade": "the 80s"}),
1848 ("All", "the 1990's"),
1849 )
1850
1851 _test_choices(
1852 self.request_factory.get("/", {"publication-decade": "the 90s"}),
1853 ("All", "the 1980's"),
1854 )
1855
1856 def test_list_filter_queryset_filtered_by_default(self):
1857 """
1858 A list filter that filters the queryset by default gives the correct
1859 full_result_count.
1860 """
1861 modeladmin = NotNinetiesListFilterAdmin(Book, site)
1862 request = self.request_factory.get("/", {})
1863 request.user = self.alfred
1864 changelist = modeladmin.get_changelist_instance(request)
1865 changelist.get_results(request)
1866 self.assertEqual(changelist.full_result_count, 4)
1867
1868 def test_emptylistfieldfilter(self):
1869 empty_description = Department.objects.create(code="EMPT", description="")
1870 none_description = Department.objects.create(code="NONE", description=None)
1871 empty_title = Book.objects.create(title="", author=self.alfred)
1872
1873 department_admin = DepartmentAdminWithEmptyFieldListFilter(Department, site)
1874 book_admin = BookAdminWithEmptyFieldListFilter(Book, site)
1875
1876 tests = [
1877 # Allows nulls and empty strings.
1878 (
1879 department_admin,
1880 {"description__isempty": "1"},
1881 [empty_description, none_description],
1882 ),
1883 (
1884 department_admin,
1885 {"description__isempty": "0"},
1886 [self.dev, self.design],
1887 ),
1888 # Allows nulls.
1889 (book_admin, {"author__isempty": "1"}, [self.guitar_book]),
1890 (
1891 book_admin,
1892 {"author__isempty": "0"},
1893 [self.django_book, self.bio_book, self.djangonaut_book, empty_title],
1894 ),
1895 # Allows empty strings.
1896 (book_admin, {"title__isempty": "1"}, [empty_title]),
1897 (
1898 book_admin,
1899 {"title__isempty": "0"},
1900 [
1901 self.django_book,
1902 self.bio_book,
1903 self.djangonaut_book,
1904 self.guitar_book,
1905 ],
1906 ),
1907 ]
1908 for modeladmin, query_string, expected_result in tests:
1909 with self.subTest(
1910 modeladmin=modeladmin.__class__.__name__,
1911 query_string=query_string,
1912 ):
1913 request = self.request_factory.get("/", query_string)
1914 request.user = self.alfred
1915 changelist = modeladmin.get_changelist_instance(request)
1916 queryset = changelist.get_queryset(request)
1917 self.assertCountEqual(queryset, expected_result)
1918
1919 def test_emptylistfieldfilter_reverse_relationships(self):
1920 class UserAdminReverseRelationship(UserAdmin):
1921 list_filter = (("books_contributed", EmptyFieldListFilter),)
1922
1923 ImprovedBook.objects.create(book=self.guitar_book)
1924 no_employees = Department.objects.create(code="NONE", description=None)
1925
1926 book_admin = BookAdminWithEmptyFieldListFilter(Book, site)
1927 department_admin = DepartmentAdminWithEmptyFieldListFilter(Department, site)
1928 user_admin = UserAdminReverseRelationship(User, site)
1929
1930 tests = [
1931 # Reverse one-to-one relationship.
1932 (
1933 book_admin,
1934 {"improvedbook__isempty": "1"},
1935 [self.django_book, self.bio_book, self.djangonaut_book],
1936 ),
1937 (book_admin, {"improvedbook__isempty": "0"}, [self.guitar_book]),
1938 # Reverse foreign key relationship.
1939 (department_admin, {"employee__isempty": "1"}, [no_employees]),
1940 (department_admin, {"employee__isempty": "0"}, [self.dev, self.design]),
1941 # Reverse many-to-many relationship.
1942 (user_admin, {"books_contributed__isempty": "1"}, [self.alfred]),
1943 (user_admin, {"books_contributed__isempty": "0"}, [self.bob, self.lisa]),
1944 ]
1945 for modeladmin, query_string, expected_result in tests:
1946 with self.subTest(
1947 modeladmin=modeladmin.__class__.__name__,
1948 query_string=query_string,
1949 ):
1950 request = self.request_factory.get("/", query_string)
1951 request.user = self.alfred
1952 changelist = modeladmin.get_changelist_instance(request)
1953 queryset = changelist.get_queryset(request)
1954 self.assertCountEqual(queryset, expected_result)
1955
1956 def test_emptylistfieldfilter_genericrelation(self):
1957 class BookmarkGenericRelation(ModelAdmin):
1958 list_filter = (("tags", EmptyFieldListFilter),)
1959
1960 modeladmin = BookmarkGenericRelation(Bookmark, site)
1961
1962 django_bookmark = Bookmark.objects.create(url="https://www.djangoproject.com/")
1963 python_bookmark = Bookmark.objects.create(url="https://www.python.org/")
1964 none_tags = Bookmark.objects.create(url="https://www.kernel.org/")
1965 TaggedItem.objects.create(content_object=django_bookmark, tag="python")
1966 TaggedItem.objects.create(content_object=python_bookmark, tag="python")
1967
1968 tests = [
1969 ({"tags__isempty": "1"}, [none_tags]),
1970 ({"tags__isempty": "0"}, [django_bookmark, python_bookmark]),
1971 ]
1972 for query_string, expected_result in tests:
1973 with self.subTest(query_string=query_string):
1974 request = self.request_factory.get("/", query_string)
1975 request.user = self.alfred
1976 changelist = modeladmin.get_changelist_instance(request)
1977 queryset = changelist.get_queryset(request)
1978 self.assertCountEqual(queryset, expected_result)
1979
1980 def test_emptylistfieldfilter_choices(self):
1981 modeladmin = BookAdminWithEmptyFieldListFilter(Book, site)
1982 request = self.request_factory.get("/")
1983 request.user = self.alfred
1984 changelist = modeladmin.get_changelist_instance(request)
1985 filterspec = changelist.get_filters(request)[0][0]
1986 self.assertEqual(filterspec.title, "Verbose Author")
1987 choices = list(filterspec.choices(changelist))
1988 self.assertEqual(len(choices), 3)
1989
1990 self.assertEqual(choices[0]["display"], "All")
1991 self.assertIs(choices[0]["selected"], True)
1992 self.assertEqual(choices[0]["query_string"], "?")
1993
1994 self.assertEqual(choices[1]["display"], "Empty")
1995 self.assertIs(choices[1]["selected"], False)
1996 self.assertEqual(choices[1]["query_string"], "?author__isempty=1")
1997
1998 self.assertEqual(choices[2]["display"], "Not empty")
1999 self.assertIs(choices[2]["selected"], False)
2000 self.assertEqual(choices[2]["query_string"], "?author__isempty=0")
2001
2002 def test_emptylistfieldfilter_non_empty_field(self):
2003 class EmployeeAdminWithEmptyFieldListFilter(ModelAdmin):
2004 list_filter = [("department", EmptyFieldListFilter)]
2005
2006 modeladmin = EmployeeAdminWithEmptyFieldListFilter(Employee, site)
2007 request = self.request_factory.get("/")
2008 request.user = self.alfred
2009 msg = (
2010 "The list filter 'EmptyFieldListFilter' cannot be used with field "
2011 "'department' which doesn't allow empty strings and nulls."
2012 )
2013 with self.assertRaisesMessage(ImproperlyConfigured, msg):
2014 modeladmin.get_changelist_instance(request)
2015
2016 def test_emptylistfieldfilter_invalid_lookup_parameters(self):
2017 modeladmin = BookAdminWithEmptyFieldListFilter(Book, site)
2018 request = self.request_factory.get("/", {"author__isempty": 42})
2019 request.user = self.alfred
2020 with self.assertRaises(IncorrectLookupParameters):
2021 modeladmin.get_changelist_instance(request)
2022
2023 def test_lookup_using_custom_divider(self):
2024 """
2025 Filter __in lookups with a custom divider.
2026 """
2027 jane = Employee.objects.create(name="Jane,Green", department=self.design)
2028 modeladmin = EmployeeCustomDividerFilterAdmin(Employee, site)
2029 employees = [jane, self.jack]
2030
2031 request = self.request_factory.get(
2032 "/", {"name__in": "|".join(e.name for e in employees)}
2033 )
2034 # test for lookup with custom divider
2035 request.user = self.alfred
2036 changelist = modeladmin.get_changelist_instance(request)
2037 # Make sure the correct queryset is returned
2038 queryset = changelist.get_queryset(request)
2039 self.assertEqual(list(queryset), employees)
2040
2041 # test for lookup with comma in the lookup string
2042 request = self.request_factory.get("/", {"name": jane.name})
2043 request.user = self.alfred
2044 changelist = modeladmin.get_changelist_instance(request)
2045 # Make sure the correct queryset is returned
2046 queryset = changelist.get_queryset(request)
2047 self.assertEqual(list(queryset), [jane])
2048
2049
2050 class FacetsMixinTests(SimpleTestCase):
2051 def test_get_facet_counts(self):
2052 msg = "subclasses of FacetsMixin must provide a get_facet_counts() method."
2053 with self.assertRaisesMessage(NotImplementedError, msg):
2054 FacetsMixin().get_facet_counts(None, None)