Debian Codegraph @

tests/admin_changelist/tests.py

raw
1 import datetime
2 from unittest import mock
3
4 from django.contrib import admin
5 from django.contrib.admin.models import LogEntry
6 from django.contrib.admin.options import IncorrectLookupParameters
7 from django.contrib.admin.templatetags.admin_list import pagination
8 from django.contrib.admin.tests import AdminSeleniumTestCase
9 from django.contrib.admin.views.main import (
10 ALL_VAR,
11 IS_FACETS_VAR,
12 IS_POPUP_VAR,
13 ORDER_VAR,
14 PAGE_VAR,
15 SEARCH_VAR,
16 TO_FIELD_VAR,
17 )
18 from django.contrib.auth.models import User
19 from django.contrib.messages.storage.cookie import CookieStorage
20 from django.db import DatabaseError, connection, models
21 from django.db.models import F, Field, IntegerField
22 from django.db.models.functions import Upper
23 from django.db.models.lookups import Contains, Exact
24 from django.template import Context, Template, TemplateSyntaxError
25 from django.test import TestCase, override_settings, skipUnlessDBFeature
26 from django.test.client import RequestFactory
27 from django.test.utils import CaptureQueriesContext, isolate_apps, register_lookup
28 from django.urls import reverse
29 from django.utils import formats
30
31 from .admin import (
32 BandAdmin,
33 ChildAdmin,
34 ChordsBandAdmin,
35 ConcertAdmin,
36 CustomPaginationAdmin,
37 CustomPaginator,
38 DynamicListDisplayChildAdmin,
39 DynamicListDisplayLinksChildAdmin,
40 DynamicListFilterChildAdmin,
41 DynamicSearchFieldsChildAdmin,
42 EmptyValueChildAdmin,
43 EventAdmin,
44 FilteredChildAdmin,
45 GrandChildAdmin,
46 GroupAdmin,
47 InvitationAdmin,
48 NoListDisplayLinksParentAdmin,
49 ParentAdmin,
50 ParentAdminTwoSearchFields,
51 QuartetAdmin,
52 SwallowAdmin,
53 )
54 from .admin import site as custom_site
55 from .models import (
56 Band,
57 CharPK,
58 Child,
59 ChordsBand,
60 ChordsMusician,
61 Concert,
62 CustomIdUser,
63 Event,
64 Genre,
65 GrandChild,
66 Group,
67 Invitation,
68 Membership,
69 Musician,
70 OrderedObject,
71 Parent,
72 Quartet,
73 Swallow,
74 SwallowOneToOne,
75 UnorderedObject,
76 )
77
78
79 def build_tbody_html(obj, href, field_name, extra_fields):
80 return (
81 "<tbody><tr>"
82 '<td class="action-checkbox">'
83 '<input type="checkbox" name="_selected_action" value="{}" '
84 'class="action-select" aria-label="Select this object for an action - {}"></td>'
85 '<th class="field-name"><a href="{}">{}</a></th>'
86 "{}</tr></tbody>"
87 ).format(obj.pk, str(obj), href, field_name, extra_fields)
88
89
90 @override_settings(ROOT_URLCONF="admin_changelist.urls")
91 class ChangeListTests(TestCase):
92 factory = RequestFactory()
93
94 @classmethod
95 def setUpTestData(cls):
96 cls.superuser = User.objects.create_superuser(
97 username="super", email="[email protected]", password="xxx"
98 )
99
100 def _create_superuser(self, username):
101 return User.objects.create_superuser(
102 username=username, email="[email protected]", password="xxx"
103 )
104
105 def _mocked_authenticated_request(self, url, user):
106 request = self.factory.get(url)
107 request.user = user
108 return request
109
110 def test_repr(self):
111 m = ChildAdmin(Child, custom_site)
112 request = self.factory.get("/child/")
113 request.user = self.superuser
114 cl = m.get_changelist_instance(request)
115 self.assertEqual(repr(cl), "<ChangeList: model=Child model_admin=ChildAdmin>")
116
117 def test_specified_ordering_by_f_expression(self):
118 class OrderedByFBandAdmin(admin.ModelAdmin):
119 list_display = ["name", "genres", "nr_of_members"]
120 ordering = (
121 F("nr_of_members").desc(nulls_last=True),
122 Upper(F("name")).asc(),
123 F("genres").asc(),
124 )
125
126 m = OrderedByFBandAdmin(Band, custom_site)
127 request = self.factory.get("/band/")
128 request.user = self.superuser
129 cl = m.get_changelist_instance(request)
130 self.assertEqual(cl.get_ordering_field_columns(), {3: "desc", 2: "asc"})
131
132 def test_specified_ordering_by_f_expression_without_asc_desc(self):
133 class OrderedByFBandAdmin(admin.ModelAdmin):
134 list_display = ["name", "genres", "nr_of_members"]
135 ordering = (F("nr_of_members"), Upper("name"), F("genres"))
136
137 m = OrderedByFBandAdmin(Band, custom_site)
138 request = self.factory.get("/band/")
139 request.user = self.superuser
140 cl = m.get_changelist_instance(request)
141 self.assertEqual(cl.get_ordering_field_columns(), {3: "asc", 2: "asc"})
142
143 def test_select_related_preserved(self):
144 """
145 Regression test for #10348: ChangeList.get_queryset() shouldn't
146 overwrite a custom select_related provided by ModelAdmin.get_queryset().
147 """
148 m = ChildAdmin(Child, custom_site)
149 request = self.factory.get("/child/")
150 request.user = self.superuser
151 cl = m.get_changelist_instance(request)
152 self.assertEqual(cl.queryset.query.select_related, {"parent": {}})
153
154 def test_select_related_preserved_when_multi_valued_in_search_fields(self):
155 parent = Parent.objects.create(name="Mary")
156 Child.objects.create(parent=parent, name="Danielle")
157 Child.objects.create(parent=parent, name="Daniel")
158
159 m = ParentAdmin(Parent, custom_site)
160 request = self.factory.get("/parent/", data={SEARCH_VAR: "daniel"})
161 request.user = self.superuser
162
163 cl = m.get_changelist_instance(request)
164 self.assertEqual(cl.queryset.count(), 1)
165 # select_related is preserved.
166 self.assertEqual(cl.queryset.query.select_related, {"child": {}})
167
168 def test_select_related_as_tuple(self):
169 ia = InvitationAdmin(Invitation, custom_site)
170 request = self.factory.get("/invitation/")
171 request.user = self.superuser
172 cl = ia.get_changelist_instance(request)
173 self.assertEqual(cl.queryset.query.select_related, {"player": {}})
174
175 def test_select_related_as_empty_tuple(self):
176 ia = InvitationAdmin(Invitation, custom_site)
177 ia.list_select_related = ()
178 request = self.factory.get("/invitation/")
179 request.user = self.superuser
180 cl = ia.get_changelist_instance(request)
181 self.assertIs(cl.queryset.query.select_related, False)
182
183 def test_get_select_related_custom_method(self):
184 class GetListSelectRelatedAdmin(admin.ModelAdmin):
185 list_display = ("band", "player")
186
187 def get_list_select_related(self, request):
188 return ("band", "player")
189
190 ia = GetListSelectRelatedAdmin(Invitation, custom_site)
191 request = self.factory.get("/invitation/")
192 request.user = self.superuser
193 cl = ia.get_changelist_instance(request)
194 self.assertEqual(cl.queryset.query.select_related, {"player": {}, "band": {}})
195
196 def test_many_search_terms(self):
197 parent = Parent.objects.create(name="Mary")
198 Child.objects.create(parent=parent, name="Danielle")
199 Child.objects.create(parent=parent, name="Daniel")
200
201 m = ParentAdmin(Parent, custom_site)
202 request = self.factory.get("/parent/", data={SEARCH_VAR: "daniel " * 80})
203 request.user = self.superuser
204
205 cl = m.get_changelist_instance(request)
206 with CaptureQueriesContext(connection) as context:
207 object_count = cl.queryset.count()
208 self.assertEqual(object_count, 1)
209 self.assertEqual(context.captured_queries[0]["sql"].count("JOIN"), 1)
210
211 def test_related_field_multiple_search_terms(self):
212 """
213 Searches over multi-valued relationships return rows from related
214 models only when all searched fields match that row.
215 """
216 parent = Parent.objects.create(name="Mary")
217 Child.objects.create(parent=parent, name="Danielle", age=18)
218 Child.objects.create(parent=parent, name="Daniel", age=19)
219
220 m = ParentAdminTwoSearchFields(Parent, custom_site)
221
222 request = self.factory.get("/parent/", data={SEARCH_VAR: "danielle 19"})
223 request.user = self.superuser
224 cl = m.get_changelist_instance(request)
225 self.assertEqual(cl.queryset.count(), 0)
226
227 request = self.factory.get("/parent/", data={SEARCH_VAR: "daniel 19"})
228 request.user = self.superuser
229 cl = m.get_changelist_instance(request)
230 self.assertEqual(cl.queryset.count(), 1)
231
232 def test_result_list_empty_changelist_value(self):
233 """
234 Regression test for #14982: EMPTY_CHANGELIST_VALUE should be honored
235 for relationship fields
236 """
237 new_child = Child.objects.create(name="name", parent=None)
238 request = self.factory.get("/child/")
239 request.user = self.superuser
240 m = ChildAdmin(Child, custom_site)
241 cl = m.get_changelist_instance(request)
242 cl.formset = None
243 template = Template(
244 "{% load admin_list %}{% spaceless %}{% result_list cl %}{% endspaceless %}"
245 )
246 context = Context({"cl": cl, "opts": Child._meta})
247 table_output = template.render(context)
248 link = reverse("admin:admin_changelist_child_change", args=(new_child.id,))
249 row_html = build_tbody_html(
250 new_child, link, "name", '<td class="field-parent nowrap">-</td>'
251 )
252 self.assertNotEqual(
253 table_output.find(row_html),
254 -1,
255 "Failed to find expected row element: %s" % table_output,
256 )
257
258 def test_result_list_empty_changelist_value_blank_string(self):
259 new_child = Child.objects.create(name="", parent=None)
260 request = self.factory.get("/child/")
261 request.user = self.superuser
262 m = ChildAdmin(Child, custom_site)
263 cl = m.get_changelist_instance(request)
264 cl.formset = None
265 template = Template(
266 "{% load admin_list %}{% spaceless %}{% result_list cl %}{% endspaceless %}"
267 )
268 context = Context({"cl": cl, "opts": Child._meta})
269 table_output = template.render(context)
270 link = reverse("admin:admin_changelist_child_change", args=(new_child.id,))
271 row_html = build_tbody_html(
272 new_child, link, "-", '<td class="field-parent nowrap">-</td>'
273 )
274 self.assertInHTML(row_html, table_output)
275
276 def test_result_list_set_empty_value_display_on_admin_site(self):
277 """
278 Empty value display can be set on AdminSite.
279 """
280 new_child = Child.objects.create(name="name", parent=None)
281 request = self.factory.get("/child/")
282 request.user = self.superuser
283 # Set a new empty display value on AdminSite.
284 admin.site.empty_value_display = "???"
285 m = ChildAdmin(Child, admin.site)
286 cl = m.get_changelist_instance(request)
287 cl.formset = None
288 template = Template(
289 "{% load admin_list %}{% spaceless %}{% result_list cl %}{% endspaceless %}"
290 )
291 context = Context({"cl": cl, "opts": Child._meta})
292 table_output = template.render(context)
293 link = reverse("admin:admin_changelist_child_change", args=(new_child.id,))
294 row_html = build_tbody_html(
295 new_child, link, "name", '<td class="field-parent nowrap">???</td>'
296 )
297 self.assertNotEqual(
298 table_output.find(row_html),
299 -1,
300 "Failed to find expected row element: %s" % table_output,
301 )
302
303 def test_result_list_set_empty_value_display_in_model_admin(self):
304 """
305 Empty value display can be set in ModelAdmin or individual fields.
306 """
307 new_child = Child.objects.create(name="name", parent=None)
308 request = self.factory.get("/child/")
309 request.user = self.superuser
310 m = EmptyValueChildAdmin(Child, admin.site)
311 cl = m.get_changelist_instance(request)
312 cl.formset = None
313 template = Template(
314 "{% load admin_list %}{% spaceless %}{% result_list cl %}{% endspaceless %}"
315 )
316 context = Context({"cl": cl, "opts": Child._meta})
317 table_output = template.render(context)
318 link = reverse("admin:admin_changelist_child_change", args=(new_child.id,))
319 row_html = build_tbody_html(
320 new_child,
321 link,
322 "name",
323 '<td class="field-age_display">&amp;dagger;</td>'
324 '<td class="field-age">-empty-</td>',
325 )
326 self.assertNotEqual(
327 table_output.find(row_html),
328 -1,
329 "Failed to find expected row element: %s" % table_output,
330 )
331
332 def test_result_list_html(self):
333 """
334 Inclusion tag result_list generates a table when with default
335 ModelAdmin settings.
336 """
337 new_parent = Parent.objects.create(name="parent")
338 new_child = Child.objects.create(name="name", parent=new_parent)
339 request = self.factory.get("/child/")
340 request.user = self.superuser
341 m = ChildAdmin(Child, custom_site)
342 cl = m.get_changelist_instance(request)
343 cl.formset = None
344 template = Template(
345 "{% load admin_list %}{% spaceless %}{% result_list cl %}{% endspaceless %}"
346 )
347 context = Context({"cl": cl, "opts": Child._meta})
348 table_output = template.render(context)
349 link = reverse("admin:admin_changelist_child_change", args=(new_child.id,))
350 row_html = build_tbody_html(
351 new_child,
352 link,
353 "name",
354 '<td class="field-parent nowrap">%s</td>' % new_parent,
355 )
356 self.assertNotEqual(
357 table_output.find(row_html),
358 -1,
359 "Failed to find expected row element: %s" % table_output,
360 )
361 self.assertInHTML(
362 '<input type="checkbox" id="action-toggle" '
363 'aria-label="Select all objects on this page for an action">',
364 table_output,
365 )
366
367 def test_action_checkbox_for_model_with_dunder_html(self):
368 grandchild = GrandChild.objects.create(name="name")
369 request = self._mocked_authenticated_request("/grandchild/", self.superuser)
370 m = GrandChildAdmin(GrandChild, custom_site)
371 cl = m.get_changelist_instance(request)
372 cl.formset = None
373 template = Template(
374 "{% load admin_list %}{% spaceless %}{% result_list cl %}{% endspaceless %}"
375 )
376 context = Context({"cl": cl, "opts": GrandChild._meta})
377 table_output = template.render(context)
378 link = reverse(
379 "admin:admin_changelist_grandchild_change", args=(grandchild.id,)
380 )
381 row_html = build_tbody_html(
382 grandchild,
383 link,
384 "name",
385 '<td class="field-parent__name">-</td>'
386 '<td class="field-parent__parent__name">-</td>',
387 )
388 self.assertNotEqual(
389 table_output.find(row_html),
390 -1,
391 "Failed to find expected row element: %s" % table_output,
392 )
393
394 def test_result_list_editable_html(self):
395 """
396 Regression tests for #11791: Inclusion tag result_list generates a
397 table and this checks that the items are nested within the table
398 element tags.
399 Also a regression test for #13599, verifies that hidden fields
400 when list_editable is enabled are rendered in a div outside the
401 table.
402 """
403 new_parent = Parent.objects.create(name="parent")
404 new_child = Child.objects.create(name="name", parent=new_parent)
405 request = self.factory.get("/child/")
406 request.user = self.superuser
407 m = ChildAdmin(Child, custom_site)
408
409 # Test with list_editable fields
410 m.list_display = ["id", "name", "parent"]
411 m.list_display_links = ["id"]
412 m.list_editable = ["name"]
413 cl = m.get_changelist_instance(request)
414 FormSet = m.get_changelist_formset(request)
415 cl.formset = FormSet(queryset=cl.result_list)
416 template = Template(
417 "{% load admin_list %}{% spaceless %}{% result_list cl %}{% endspaceless %}"
418 )
419 context = Context({"cl": cl, "opts": Child._meta})
420 table_output = template.render(context)
421 # make sure that hidden fields are in the correct place
422 hiddenfields_div = (
423 '<div class="hiddenfields">'
424 '<input type="hidden" name="form-0-id" value="%d" id="id_form-0-id">'
425 "</div>"
426 ) % new_child.id
427 self.assertInHTML(
428 hiddenfields_div, table_output, msg_prefix="Failed to find hidden fields"
429 )
430
431 # make sure that list editable fields are rendered in divs correctly
432 editable_name_field = (
433 '<input name="form-0-name" value="name" class="vTextField" '
434 'maxlength="30" type="text" id="id_form-0-name">'
435 )
436 self.assertInHTML(
437 '<td class="field-name">%s</td>' % editable_name_field,
438 table_output,
439 msg_prefix='Failed to find "name" list_editable field',
440 )
441
442 def test_result_list_editable(self):
443 """
444 Regression test for #14312: list_editable with pagination
445 """
446 new_parent = Parent.objects.create(name="parent")
447 for i in range(1, 201):
448 Child.objects.create(name="name %s" % i, parent=new_parent)
449 request = self.factory.get("/child/", data={"p": -1}) # Anything outside range
450 request.user = self.superuser
451 m = ChildAdmin(Child, custom_site)
452
453 # Test with list_editable fields
454 m.list_display = ["id", "name", "parent"]
455 m.list_display_links = ["id"]
456 m.list_editable = ["name"]
457 with self.assertRaises(IncorrectLookupParameters):
458 m.get_changelist_instance(request)
459
460 @skipUnlessDBFeature("supports_transactions")
461 def test_list_editable_atomicity(self):
462 a = Swallow.objects.create(origin="Swallow A", load=4, speed=1)
463 b = Swallow.objects.create(origin="Swallow B", load=2, speed=2)
464
465 self.client.force_login(self.superuser)
466 changelist_url = reverse("admin:admin_changelist_swallow_changelist")
467 data = {
468 "form-TOTAL_FORMS": "2",
469 "form-INITIAL_FORMS": "2",
470 "form-MIN_NUM_FORMS": "0",
471 "form-MAX_NUM_FORMS": "1000",
472 "form-0-uuid": str(a.pk),
473 "form-1-uuid": str(b.pk),
474 "form-0-load": "9.0",
475 "form-0-speed": "3.0",
476 "form-1-load": "5.0",
477 "form-1-speed": "1.0",
478 "_save": "Save",
479 }
480 with mock.patch(
481 "django.contrib.admin.ModelAdmin.log_change", side_effect=DatabaseError
482 ):
483 with self.assertRaises(DatabaseError):
484 self.client.post(changelist_url, data)
485 # Original values are preserved.
486 a.refresh_from_db()
487 self.assertEqual(a.load, 4)
488 self.assertEqual(a.speed, 1)
489 b.refresh_from_db()
490 self.assertEqual(b.load, 2)
491 self.assertEqual(b.speed, 2)
492
493 with mock.patch(
494 "django.contrib.admin.ModelAdmin.log_change",
495 side_effect=[None, DatabaseError],
496 ):
497 with self.assertRaises(DatabaseError):
498 self.client.post(changelist_url, data)
499 # Original values are preserved.
500 a.refresh_from_db()
501 self.assertEqual(a.load, 4)
502 self.assertEqual(a.speed, 1)
503 b.refresh_from_db()
504 self.assertEqual(b.load, 2)
505 self.assertEqual(b.speed, 2)
506
507 def test_custom_paginator(self):
508 new_parent = Parent.objects.create(name="parent")
509 for i in range(1, 201):
510 Child.objects.create(name="name %s" % i, parent=new_parent)
511
512 request = self.factory.get("/child/")
513 request.user = self.superuser
514 m = CustomPaginationAdmin(Child, custom_site)
515
516 cl = m.get_changelist_instance(request)
517 cl.get_results(request)
518 self.assertIsInstance(cl.paginator, CustomPaginator)
519
520 def test_distinct_for_m2m_in_list_filter(self):
521 """
522 Regression test for #13902: When using a ManyToMany in list_filter,
523 results shouldn't appear more than once. Basic ManyToMany.
524 """
525 blues = Genre.objects.create(name="Blues")
526 band = Band.objects.create(name="B.B. King Review", nr_of_members=11)
527
528 band.genres.add(blues)
529 band.genres.add(blues)
530
531 m = BandAdmin(Band, custom_site)
532 request = self.factory.get("/band/", data={"genres": blues.pk})
533 request.user = self.superuser
534
535 cl = m.get_changelist_instance(request)
536 cl.get_results(request)
537
538 # There's only one Group instance
539 self.assertEqual(cl.result_count, 1)
540 # Queryset must be deletable.
541 cl.queryset.delete()
542 self.assertEqual(cl.queryset.count(), 0)
543
544 def test_distinct_for_through_m2m_in_list_filter(self):
545 """
546 Regression test for #13902: When using a ManyToMany in list_filter,
547 results shouldn't appear more than once. With an intermediate model.
548 """
549 lead = Musician.objects.create(name="Vox")
550 band = Group.objects.create(name="The Hype")
551 Membership.objects.create(group=band, music=lead, role="lead voice")
552 Membership.objects.create(group=band, music=lead, role="bass player")
553
554 m = GroupAdmin(Group, custom_site)
555 request = self.factory.get("/group/", data={"members": lead.pk})
556 request.user = self.superuser
557
558 cl = m.get_changelist_instance(request)
559 cl.get_results(request)
560
561 # There's only one Group instance
562 self.assertEqual(cl.result_count, 1)
563 # Queryset must be deletable.
564 cl.queryset.delete()
565 self.assertEqual(cl.queryset.count(), 0)
566
567 def test_distinct_for_through_m2m_at_second_level_in_list_filter(self):
568 """
569 When using a ManyToMany in list_filter at the second level behind a
570 ForeignKey, distinct() must be called and results shouldn't appear more
571 than once.
572 """
573 lead = Musician.objects.create(name="Vox")
574 band = Group.objects.create(name="The Hype")
575 Concert.objects.create(name="Woodstock", group=band)
576 Membership.objects.create(group=band, music=lead, role="lead voice")
577 Membership.objects.create(group=band, music=lead, role="bass player")
578
579 m = ConcertAdmin(Concert, custom_site)
580 request = self.factory.get("/concert/", data={"group__members": lead.pk})
581 request.user = self.superuser
582
583 cl = m.get_changelist_instance(request)
584 cl.get_results(request)
585
586 # There's only one Concert instance
587 self.assertEqual(cl.result_count, 1)
588 # Queryset must be deletable.
589 cl.queryset.delete()
590 self.assertEqual(cl.queryset.count(), 0)
591
592 def test_distinct_for_inherited_m2m_in_list_filter(self):
593 """
594 Regression test for #13902: When using a ManyToMany in list_filter,
595 results shouldn't appear more than once. Model managed in the
596 admin inherits from the one that defines the relationship.
597 """
598 lead = Musician.objects.create(name="John")
599 four = Quartet.objects.create(name="The Beatles")
600 Membership.objects.create(group=four, music=lead, role="lead voice")
601 Membership.objects.create(group=four, music=lead, role="guitar player")
602
603 m = QuartetAdmin(Quartet, custom_site)
604 request = self.factory.get("/quartet/", data={"members": lead.pk})
605 request.user = self.superuser
606
607 cl = m.get_changelist_instance(request)
608 cl.get_results(request)
609
610 # There's only one Quartet instance
611 self.assertEqual(cl.result_count, 1)
612 # Queryset must be deletable.
613 cl.queryset.delete()
614 self.assertEqual(cl.queryset.count(), 0)
615
616 def test_distinct_for_m2m_to_inherited_in_list_filter(self):
617 """
618 Regression test for #13902: When using a ManyToMany in list_filter,
619 results shouldn't appear more than once. Target of the relationship
620 inherits from another.
621 """
622 lead = ChordsMusician.objects.create(name="Player A")
623 three = ChordsBand.objects.create(name="The Chords Trio")
624 Invitation.objects.create(band=three, player=lead, instrument="guitar")
625 Invitation.objects.create(band=three, player=lead, instrument="bass")
626
627 m = ChordsBandAdmin(ChordsBand, custom_site)
628 request = self.factory.get("/chordsband/", data={"members": lead.pk})
629 request.user = self.superuser
630
631 cl = m.get_changelist_instance(request)
632 cl.get_results(request)
633
634 # There's only one ChordsBand instance
635 self.assertEqual(cl.result_count, 1)
636
637 def test_distinct_for_non_unique_related_object_in_list_filter(self):
638 """
639 Regressions tests for #15819: If a field listed in list_filters
640 is a non-unique related object, distinct() must be called.
641 """
642 parent = Parent.objects.create(name="Mary")
643 # Two children with the same name
644 Child.objects.create(parent=parent, name="Daniel")
645 Child.objects.create(parent=parent, name="Daniel")
646
647 m = ParentAdmin(Parent, custom_site)
648 request = self.factory.get("/parent/", data={"child__name": "Daniel"})
649 request.user = self.superuser
650
651 cl = m.get_changelist_instance(request)
652 # Make sure distinct() was called
653 self.assertEqual(cl.queryset.count(), 1)
654 # Queryset must be deletable.
655 cl.queryset.delete()
656 self.assertEqual(cl.queryset.count(), 0)
657
658 def test_changelist_search_form_validation(self):
659 m = ConcertAdmin(Concert, custom_site)
660 tests = [
661 ({SEARCH_VAR: "\x00"}, "Null characters are not allowed."),
662 ({SEARCH_VAR: "some\x00thing"}, "Null characters are not allowed."),
663 ]
664 for case, error in tests:
665 with self.subTest(case=case):
666 request = self.factory.get("/concert/", case)
667 request.user = self.superuser
668 request._messages = CookieStorage(request)
669 m.get_changelist_instance(request)
670 messages = [m.message for m in request._messages]
671 self.assertEqual(1, len(messages))
672 self.assertEqual(error, messages[0])
673
674 def test_distinct_for_non_unique_related_object_in_search_fields(self):
675 """
676 Regressions tests for #15819: If a field listed in search_fields
677 is a non-unique related object, distinct() must be called.
678 """
679 parent = Parent.objects.create(name="Mary")
680 Child.objects.create(parent=parent, name="Danielle")
681 Child.objects.create(parent=parent, name="Daniel")
682
683 m = ParentAdmin(Parent, custom_site)
684 request = self.factory.get("/parent/", data={SEARCH_VAR: "daniel"})
685 request.user = self.superuser
686
687 cl = m.get_changelist_instance(request)
688 # Make sure distinct() was called
689 self.assertEqual(cl.queryset.count(), 1)
690 # Queryset must be deletable.
691 cl.queryset.delete()
692 self.assertEqual(cl.queryset.count(), 0)
693
694 def test_distinct_for_many_to_many_at_second_level_in_search_fields(self):
695 """
696 When using a ManyToMany in search_fields at the second level behind a
697 ForeignKey, distinct() must be called and results shouldn't appear more
698 than once.
699 """
700 lead = Musician.objects.create(name="Vox")
701 band = Group.objects.create(name="The Hype")
702 Concert.objects.create(name="Woodstock", group=band)
703 Membership.objects.create(group=band, music=lead, role="lead voice")
704 Membership.objects.create(group=band, music=lead, role="bass player")
705
706 m = ConcertAdmin(Concert, custom_site)
707 request = self.factory.get("/concert/", data={SEARCH_VAR: "vox"})
708 request.user = self.superuser
709
710 cl = m.get_changelist_instance(request)
711 # There's only one Concert instance
712 self.assertEqual(cl.queryset.count(), 1)
713 # Queryset must be deletable.
714 cl.queryset.delete()
715 self.assertEqual(cl.queryset.count(), 0)
716
717 def test_multiple_search_fields(self):
718 """
719 All rows containing each of the searched words are returned, where each
720 word must be in one of search_fields.
721 """
722 band_duo = Group.objects.create(name="Duo")
723 band_hype = Group.objects.create(name="The Hype")
724 mary = Musician.objects.create(name="Mary Halvorson")
725 jonathan = Musician.objects.create(name="Jonathan Finlayson")
726 band_duo.members.set([mary, jonathan])
727 Concert.objects.create(name="Tiny desk concert", group=band_duo)
728 Concert.objects.create(name="Woodstock concert", group=band_hype)
729 # FK lookup.
730 concert_model_admin = ConcertAdmin(Concert, custom_site)
731 concert_model_admin.search_fields = ["group__name", "name"]
732 # Reverse FK lookup.
733 group_model_admin = GroupAdmin(Group, custom_site)
734 group_model_admin.search_fields = ["name", "concert__name", "members__name"]
735 for search_string, result_count in (
736 ("Duo Concert", 1),
737 ("Tiny Desk Concert", 1),
738 ("Concert", 2),
739 ("Other Concert", 0),
740 ("Duo Woodstock", 0),
741 ):
742 with self.subTest(search_string=search_string):
743 # FK lookup.
744 request = self.factory.get(
745 "/concert/", data={SEARCH_VAR: search_string}
746 )
747 request.user = self.superuser
748 concert_changelist = concert_model_admin.get_changelist_instance(
749 request
750 )
751 self.assertEqual(concert_changelist.queryset.count(), result_count)
752 # Reverse FK lookup.
753 request = self.factory.get("/group/", data={SEARCH_VAR: search_string})
754 request.user = self.superuser
755 group_changelist = group_model_admin.get_changelist_instance(request)
756 self.assertEqual(group_changelist.queryset.count(), result_count)
757 # Many-to-many lookup.
758 for search_string, result_count in (
759 ("Finlayson Duo Tiny", 1),
760 ("Finlayson", 1),
761 ("Finlayson Hype", 0),
762 ("Jonathan Finlayson Duo", 1),
763 ("Mary Jonathan Duo", 0),
764 ("Oscar Finlayson Duo", 0),
765 ):
766 with self.subTest(search_string=search_string):
767 request = self.factory.get("/group/", data={SEARCH_VAR: search_string})
768 request.user = self.superuser
769 group_changelist = group_model_admin.get_changelist_instance(request)
770 self.assertEqual(group_changelist.queryset.count(), result_count)
771
772 def test_pk_in_search_fields(self):
773 band = Group.objects.create(name="The Hype")
774 Concert.objects.create(name="Woodstock", group=band)
775
776 m = ConcertAdmin(Concert, custom_site)
777 m.search_fields = ["group__pk"]
778
779 request = self.factory.get("/concert/", data={SEARCH_VAR: band.pk})
780 request.user = self.superuser
781 cl = m.get_changelist_instance(request)
782 self.assertEqual(cl.queryset.count(), 1)
783
784 request = self.factory.get("/concert/", data={SEARCH_VAR: band.pk + 5})
785 request.user = self.superuser
786 cl = m.get_changelist_instance(request)
787 self.assertEqual(cl.queryset.count(), 0)
788
789 def test_builtin_lookup_in_search_fields(self):
790 band = Group.objects.create(name="The Hype")
791 concert = Concert.objects.create(name="Woodstock", group=band)
792
793 m = ConcertAdmin(Concert, custom_site)
794 m.search_fields = ["name__iexact"]
795
796 request = self.factory.get("/", data={SEARCH_VAR: "woodstock"})
797 request.user = self.superuser
798 cl = m.get_changelist_instance(request)
799 self.assertCountEqual(cl.queryset, [concert])
800
801 request = self.factory.get("/", data={SEARCH_VAR: "wood"})
802 request.user = self.superuser
803 cl = m.get_changelist_instance(request)
804 self.assertCountEqual(cl.queryset, [])
805
806 def test_custom_lookup_in_search_fields(self):
807 band = Group.objects.create(name="The Hype")
808 concert = Concert.objects.create(name="Woodstock", group=band)
809
810 m = ConcertAdmin(Concert, custom_site)
811 m.search_fields = ["group__name__cc"]
812 with register_lookup(Field, Contains, lookup_name="cc"):
813 request = self.factory.get("/", data={SEARCH_VAR: "Hype"})
814 request.user = self.superuser
815 cl = m.get_changelist_instance(request)
816 self.assertCountEqual(cl.queryset, [concert])
817
818 request = self.factory.get("/", data={SEARCH_VAR: "Woodstock"})
819 request.user = self.superuser
820 cl = m.get_changelist_instance(request)
821 self.assertCountEqual(cl.queryset, [])
822
823 def test_spanning_relations_with_custom_lookup_in_search_fields(self):
824 hype = Group.objects.create(name="The Hype")
825 concert = Concert.objects.create(name="Woodstock", group=hype)
826 vox = Musician.objects.create(name="Vox", age=20)
827 Membership.objects.create(music=vox, group=hype)
828 # Register a custom lookup on IntegerField to ensure that field
829 # traversing logic in ModelAdmin.get_search_results() works.
830 with register_lookup(IntegerField, Exact, lookup_name="exactly"):
831 m = ConcertAdmin(Concert, custom_site)
832 m.search_fields = ["group__members__age__exactly"]
833
834 request = self.factory.get("/", data={SEARCH_VAR: "20"})
835 request.user = self.superuser
836 cl = m.get_changelist_instance(request)
837 self.assertCountEqual(cl.queryset, [concert])
838
839 request = self.factory.get("/", data={SEARCH_VAR: "21"})
840 request.user = self.superuser
841 cl = m.get_changelist_instance(request)
842 self.assertCountEqual(cl.queryset, [])
843
844 def test_custom_lookup_with_pk_shortcut(self):
845 self.assertEqual(CharPK._meta.pk.name, "char_pk") # Not equal to 'pk'.
846 m = admin.ModelAdmin(CustomIdUser, custom_site)
847
848 abc = CharPK.objects.create(char_pk="abc")
849 abcd = CharPK.objects.create(char_pk="abcd")
850 m = admin.ModelAdmin(CharPK, custom_site)
851 m.search_fields = ["pk__exact"]
852
853 request = self.factory.get("/", data={SEARCH_VAR: "abc"})
854 request.user = self.superuser
855 cl = m.get_changelist_instance(request)
856 self.assertCountEqual(cl.queryset, [abc])
857
858 request = self.factory.get("/", data={SEARCH_VAR: "abcd"})
859 request.user = self.superuser
860 cl = m.get_changelist_instance(request)
861 self.assertCountEqual(cl.queryset, [abcd])
862
863 def test_search_with_exact_lookup_for_non_string_field(self):
864 child = Child.objects.create(name="Asher", age=11)
865 model_admin = ChildAdmin(Child, custom_site)
866
867 for search_term, expected_result in [
868 ("11", [child]),
869 ("Asher", [child]),
870 ("1", []),
871 ("A", []),
872 ("random", []),
873 ]:
874 request = self.factory.get("/", data={SEARCH_VAR: search_term})
875 request.user = self.superuser
876 with self.subTest(search_term=search_term):
877 # 1 query for filtered result, 1 for filtered count, 1 for total count.
878 with self.assertNumQueries(3):
879 cl = model_admin.get_changelist_instance(request)
880 self.assertCountEqual(cl.queryset, expected_result)
881
882 def test_search_with_exact_lookup_relationship_field(self):
883 child = Child.objects.create(name="I am a child", age=11)
884 grandchild = GrandChild.objects.create(name="I am a grandchild", parent=child)
885 model_admin = GrandChildAdmin(GrandChild, custom_site)
886
887 request = self.factory.get("/", data={SEARCH_VAR: "'I am a child'"})
888 request.user = self.superuser
889 cl = model_admin.get_changelist_instance(request)
890 self.assertCountEqual(cl.queryset, [grandchild])
891 for search_term, expected_result in [
892 ("11", [grandchild]),
893 ("'I am a child'", [grandchild]),
894 ("1", []),
895 ("A", []),
896 ("random", []),
897 ]:
898 request = self.factory.get("/", data={SEARCH_VAR: search_term})
899 request.user = self.superuser
900 with self.subTest(search_term=search_term):
901 cl = model_admin.get_changelist_instance(request)
902 self.assertCountEqual(cl.queryset, expected_result)
903
904 def test_no_distinct_for_m2m_in_list_filter_without_params(self):
905 """
906 If a ManyToManyField is in list_filter but isn't in any lookup params,
907 the changelist's query shouldn't have distinct.
908 """
909 m = BandAdmin(Band, custom_site)
910 for lookup_params in ({}, {"name": "test"}):
911 request = self.factory.get("/band/", lookup_params)
912 request.user = self.superuser
913 cl = m.get_changelist_instance(request)
914 self.assertIs(cl.queryset.query.distinct, False)
915
916 # A ManyToManyField in params does have distinct applied.
917 request = self.factory.get("/band/", {"genres": "0"})
918 request.user = self.superuser
919 cl = m.get_changelist_instance(request)
920 self.assertIs(cl.queryset.query.distinct, True)
921
922 def test_pagination(self):
923 """
924 Regression tests for #12893: Pagination in admins changelist doesn't
925 use queryset set by modeladmin.
926 """
927 parent = Parent.objects.create(name="anything")
928 for i in range(1, 31):
929 Child.objects.create(name="name %s" % i, parent=parent)
930 Child.objects.create(name="filtered %s" % i, parent=parent)
931
932 request = self.factory.get("/child/")
933 request.user = self.superuser
934
935 # Test default queryset
936 m = ChildAdmin(Child, custom_site)
937 cl = m.get_changelist_instance(request)
938 self.assertEqual(cl.queryset.count(), 60)
939 self.assertEqual(cl.paginator.count, 60)
940 self.assertEqual(list(cl.paginator.page_range), [1, 2, 3, 4, 5, 6])
941
942 # Test custom queryset
943 m = FilteredChildAdmin(Child, custom_site)
944 cl = m.get_changelist_instance(request)
945 self.assertEqual(cl.queryset.count(), 30)
946 self.assertEqual(cl.paginator.count, 30)
947 self.assertEqual(list(cl.paginator.page_range), [1, 2, 3])
948
949 def test_computed_list_display_localization(self):
950 """
951 Regression test for #13196: output of functions should be localized
952 in the changelist.
953 """
954 self.client.force_login(self.superuser)
955 event = Event.objects.create(date=datetime.date.today())
956 response = self.client.get(reverse("admin:admin_changelist_event_changelist"))
957 self.assertContains(response, formats.localize(event.date))
958 self.assertNotContains(response, str(event.date))
959
960 def test_dynamic_list_display(self):
961 """
962 Regression tests for #14206: dynamic list_display support.
963 """
964 parent = Parent.objects.create(name="parent")
965 for i in range(10):
966 Child.objects.create(name="child %s" % i, parent=parent)
967
968 user_noparents = self._create_superuser("noparents")
969 user_parents = self._create_superuser("parents")
970
971 # Test with user 'noparents'
972 m = custom_site.get_model_admin(Child)
973 request = self._mocked_authenticated_request("/child/", user_noparents)
974 response = m.changelist_view(request)
975 self.assertNotContains(response, "Parent object")
976
977 list_display = m.get_list_display(request)
978 list_display_links = m.get_list_display_links(request, list_display)
979 self.assertEqual(list_display, ["name", "age"])
980 self.assertEqual(list_display_links, ["name"])
981
982 # Test with user 'parents'
983 m = DynamicListDisplayChildAdmin(Child, custom_site)
984 request = self._mocked_authenticated_request("/child/", user_parents)
985 response = m.changelist_view(request)
986 self.assertContains(response, "Parent object")
987
988 custom_site.unregister(Child)
989
990 list_display = m.get_list_display(request)
991 list_display_links = m.get_list_display_links(request, list_display)
992 self.assertEqual(list_display, ("parent", "name", "age"))
993 self.assertEqual(list_display_links, ["parent"])
994
995 # Test default implementation
996 custom_site.register(Child, ChildAdmin)
997 m = custom_site.get_model_admin(Child)
998 request = self._mocked_authenticated_request("/child/", user_noparents)
999 response = m.changelist_view(request)
1000 self.assertContains(response, "Parent object")
1001
1002 def test_show_all(self):
1003 parent = Parent.objects.create(name="anything")
1004 for i in range(1, 31):
1005 Child.objects.create(name="name %s" % i, parent=parent)
1006 Child.objects.create(name="filtered %s" % i, parent=parent)
1007
1008 # Add "show all" parameter to request
1009 request = self.factory.get("/child/", data={ALL_VAR: ""})
1010 request.user = self.superuser
1011
1012 # Test valid "show all" request (number of total objects is under max)
1013 m = ChildAdmin(Child, custom_site)
1014 m.list_max_show_all = 200
1015 # 200 is the max we'll pass to ChangeList
1016 cl = m.get_changelist_instance(request)
1017 cl.get_results(request)
1018 self.assertEqual(len(cl.result_list), 60)
1019
1020 # Test invalid "show all" request (number of total objects over max)
1021 # falls back to paginated pages
1022 m = ChildAdmin(Child, custom_site)
1023 m.list_max_show_all = 30
1024 # 30 is the max we'll pass to ChangeList for this test
1025 cl = m.get_changelist_instance(request)
1026 cl.get_results(request)
1027 self.assertEqual(len(cl.result_list), 10)
1028
1029 def test_dynamic_list_display_links(self):
1030 """
1031 Regression tests for #16257: dynamic list_display_links support.
1032 """
1033 parent = Parent.objects.create(name="parent")
1034 for i in range(1, 10):
1035 Child.objects.create(id=i, name="child %s" % i, parent=parent, age=i)
1036
1037 m = DynamicListDisplayLinksChildAdmin(Child, custom_site)
1038 superuser = self._create_superuser("superuser")
1039 request = self._mocked_authenticated_request("/child/", superuser)
1040 response = m.changelist_view(request)
1041 for i in range(1, 10):
1042 link = reverse("admin:admin_changelist_child_change", args=(i,))
1043 self.assertContains(response, '<a href="%s">%s</a>' % (link, i))
1044
1045 list_display = m.get_list_display(request)
1046 list_display_links = m.get_list_display_links(request, list_display)
1047 self.assertEqual(list_display, ("parent", "name", "age"))
1048 self.assertEqual(list_display_links, ["age"])
1049
1050 def test_no_list_display_links(self):
1051 """#15185 -- Allow no links from the 'change list' view grid."""
1052 p = Parent.objects.create(name="parent")
1053 m = NoListDisplayLinksParentAdmin(Parent, custom_site)
1054 superuser = self._create_superuser("superuser")
1055 request = self._mocked_authenticated_request("/parent/", superuser)
1056 response = m.changelist_view(request)
1057 link = reverse("admin:admin_changelist_parent_change", args=(p.pk,))
1058 self.assertNotContains(response, '<a href="%s">' % link)
1059
1060 def test_link_field_display_links(self):
1061 self.client.force_login(self.superuser)
1062 g = Genre.objects.create(
1063 name="Blues",
1064 file="documents/blues_history.txt",
1065 url="http://blues_history.com",
1066 )
1067 response = self.client.get(reverse("admin:admin_changelist_genre_changelist"))
1068 self.assertContains(
1069 response,
1070 '<a href="/admin/admin_changelist/genre/%s/change/">'
1071 "documents/blues_history.txt</a>" % g.pk,
1072 )
1073 self.assertContains(
1074 response,
1075 '<a href="/admin/admin_changelist/genre/%s/change/">'
1076 "http://blues_history.com</a>" % g.pk,
1077 )
1078
1079 def test_blank_str_display_links(self):
1080 self.client.force_login(self.superuser)
1081 gc = GrandChild.objects.create(name=" ")
1082 response = self.client.get(
1083 reverse("admin:admin_changelist_grandchild_changelist")
1084 )
1085 self.assertContains(
1086 response,
1087 '<a href="/admin/admin_changelist/grandchild/%s/change/">-</a>' % gc.pk,
1088 )
1089
1090 def test_clear_all_filters_link(self):
1091 self.client.force_login(self.superuser)
1092 url = reverse("admin:auth_user_changelist")
1093 response = self.client.get(url)
1094 self.assertNotContains(response, "&#10006; Clear all filters")
1095 link = '<a href="%s">&#10006; Clear all filters</a>'
1096 for data, href in (
1097 ({"is_staff__exact": "0"}, "?"),
1098 (
1099 {"is_staff__exact": "0", "username__startswith": "test"},
1100 "?username__startswith=test",
1101 ),
1102 (
1103 {"is_staff__exact": "0", SEARCH_VAR: "test"},
1104 "?%s=test" % SEARCH_VAR,
1105 ),
1106 (
1107 {"is_staff__exact": "0", IS_POPUP_VAR: "id"},
1108 "?%s=id" % IS_POPUP_VAR,
1109 ),
1110 ):
1111 with self.subTest(data=data):
1112 response = self.client.get(url, data=data)
1113 self.assertContains(response, link % href)
1114
1115 def test_clear_all_filters_link_callable_filter(self):
1116 self.client.force_login(self.superuser)
1117 url = reverse("admin:admin_changelist_band_changelist")
1118 response = self.client.get(url)
1119 self.assertNotContains(response, "&#10006; Clear all filters")
1120 link = '<a href="%s">&#10006; Clear all filters</a>'
1121 for data, href in (
1122 ({"nr_of_members_partition": "5"}, "?"),
1123 (
1124 {"nr_of_members_partition": "more", "name__startswith": "test"},
1125 "?name__startswith=test",
1126 ),
1127 (
1128 {"nr_of_members_partition": "5", IS_POPUP_VAR: "id"},
1129 "?%s=id" % IS_POPUP_VAR,
1130 ),
1131 ):
1132 with self.subTest(data=data):
1133 response = self.client.get(url, data=data)
1134 self.assertContains(response, link % href)
1135
1136 def test_no_clear_all_filters_link(self):
1137 self.client.force_login(self.superuser)
1138 url = reverse("admin:auth_user_changelist")
1139 link = ">&#10006; Clear all filters</a>"
1140 for data in (
1141 {SEARCH_VAR: "test"},
1142 {ORDER_VAR: "-1"},
1143 {TO_FIELD_VAR: "id"},
1144 {PAGE_VAR: "1"},
1145 {IS_POPUP_VAR: "1"},
1146 {IS_FACETS_VAR: ""},
1147 {"username__startswith": "test"},
1148 ):
1149 with self.subTest(data=data):
1150 response = self.client.get(url, data=data)
1151 self.assertNotContains(response, link)
1152
1153 def test_tuple_list_display(self):
1154 swallow = Swallow.objects.create(origin="Africa", load="12.34", speed="22.2")
1155 swallow2 = Swallow.objects.create(origin="Africa", load="12.34", speed="22.2")
1156 swallow_o2o = SwallowOneToOne.objects.create(swallow=swallow2)
1157
1158 model_admin = SwallowAdmin(Swallow, custom_site)
1159 superuser = self._create_superuser("superuser")
1160 request = self._mocked_authenticated_request("/swallow/", superuser)
1161 response = model_admin.changelist_view(request)
1162 # just want to ensure it doesn't blow up during rendering
1163 self.assertContains(response, str(swallow.origin))
1164 self.assertContains(response, str(swallow.load))
1165 self.assertContains(response, str(swallow.speed))
1166 # Reverse one-to-one relations should work.
1167 self.assertContains(response, '<td class="field-swallowonetoone">-</td>')
1168 self.assertContains(
1169 response, '<td class="field-swallowonetoone">%s</td>' % swallow_o2o
1170 )
1171
1172 def test_multiuser_edit(self):
1173 """
1174 Simultaneous edits of list_editable fields on the changelist by
1175 different users must not result in one user's edits creating a new
1176 object instead of modifying the correct existing object (#11313).
1177 """
1178 # To replicate this issue, simulate the following steps:
1179 # 1. User1 opens an admin changelist with list_editable fields.
1180 # 2. User2 edits object "Foo" such that it moves to another page in
1181 # the pagination order and saves.
1182 # 3. User1 edits object "Foo" and saves.
1183 # 4. The edit made by User1 does not get applied to object "Foo" but
1184 # instead is used to create a new object (bug).
1185
1186 # For this test, order the changelist by the 'speed' attribute and
1187 # display 3 objects per page (SwallowAdmin.list_per_page = 3).
1188
1189 # Setup the test to reflect the DB state after step 2 where User2 has
1190 # edited the first swallow object's speed from '4' to '1'.
1191 a = Swallow.objects.create(origin="Swallow A", load=4, speed=1)
1192 b = Swallow.objects.create(origin="Swallow B", load=2, speed=2)
1193 c = Swallow.objects.create(origin="Swallow C", load=5, speed=5)
1194 d = Swallow.objects.create(origin="Swallow D", load=9, speed=9)
1195
1196 superuser = self._create_superuser("superuser")
1197 self.client.force_login(superuser)
1198 changelist_url = reverse("admin:admin_changelist_swallow_changelist")
1199
1200 # Send the POST from User1 for step 3. It's still using the changelist
1201 # ordering from before User2's edits in step 2.
1202 data = {
1203 "form-TOTAL_FORMS": "3",
1204 "form-INITIAL_FORMS": "3",
1205 "form-MIN_NUM_FORMS": "0",
1206 "form-MAX_NUM_FORMS": "1000",
1207 "form-0-uuid": str(d.pk),
1208 "form-1-uuid": str(c.pk),
1209 "form-2-uuid": str(a.pk),
1210 "form-0-load": "9.0",
1211 "form-0-speed": "9.0",
1212 "form-1-load": "5.0",
1213 "form-1-speed": "5.0",
1214 "form-2-load": "5.0",
1215 "form-2-speed": "4.0",
1216 "_save": "Save",
1217 }
1218 response = self.client.post(
1219 changelist_url, data, follow=True, extra={"o": "-2"}
1220 )
1221
1222 # The object User1 edited in step 3 is displayed on the changelist and
1223 # has the correct edits applied.
1224 self.assertContains(response, "1 swallow was changed successfully.")
1225 self.assertContains(response, a.origin)
1226 a.refresh_from_db()
1227 self.assertEqual(a.load, float(data["form-2-load"]))
1228 self.assertEqual(a.speed, float(data["form-2-speed"]))
1229 b.refresh_from_db()
1230 self.assertEqual(b.load, 2)
1231 self.assertEqual(b.speed, 2)
1232 c.refresh_from_db()
1233 self.assertEqual(c.load, float(data["form-1-load"]))
1234 self.assertEqual(c.speed, float(data["form-1-speed"]))
1235 d.refresh_from_db()
1236 self.assertEqual(d.load, float(data["form-0-load"]))
1237 self.assertEqual(d.speed, float(data["form-0-speed"]))
1238 # No new swallows were created.
1239 self.assertEqual(len(Swallow.objects.all()), 4)
1240
1241 def test_get_edited_object_ids(self):
1242 a = Swallow.objects.create(origin="Swallow A", load=4, speed=1)
1243 b = Swallow.objects.create(origin="Swallow B", load=2, speed=2)
1244 c = Swallow.objects.create(origin="Swallow C", load=5, speed=5)
1245 superuser = self._create_superuser("superuser")
1246 self.client.force_login(superuser)
1247 changelist_url = reverse("admin:admin_changelist_swallow_changelist")
1248 m = SwallowAdmin(Swallow, custom_site)
1249 data = {
1250 "form-TOTAL_FORMS": "3",
1251 "form-INITIAL_FORMS": "3",
1252 "form-MIN_NUM_FORMS": "0",
1253 "form-MAX_NUM_FORMS": "1000",
1254 "form-0-uuid": str(a.pk),
1255 "form-1-uuid": str(b.pk),
1256 "form-2-uuid": str(c.pk),
1257 "form-0-load": "9.0",
1258 "form-0-speed": "9.0",
1259 "form-1-load": "5.0",
1260 "form-1-speed": "5.0",
1261 "form-2-load": "5.0",
1262 "form-2-speed": "4.0",
1263 "_save": "Save",
1264 }
1265 request = self.factory.post(changelist_url, data=data)
1266 pks = m._get_edited_object_pks(request, prefix="form")
1267 self.assertEqual(sorted(pks), sorted([str(a.pk), str(b.pk), str(c.pk)]))
1268
1269 def test_get_list_editable_queryset(self):
1270 a = Swallow.objects.create(origin="Swallow A", load=4, speed=1)
1271 Swallow.objects.create(origin="Swallow B", load=2, speed=2)
1272 data = {
1273 "form-TOTAL_FORMS": "2",
1274 "form-INITIAL_FORMS": "2",
1275 "form-MIN_NUM_FORMS": "0",
1276 "form-MAX_NUM_FORMS": "1000",
1277 "form-0-uuid": str(a.pk),
1278 "form-0-load": "10",
1279 "_save": "Save",
1280 }
1281 superuser = self._create_superuser("superuser")
1282 self.client.force_login(superuser)
1283 changelist_url = reverse("admin:admin_changelist_swallow_changelist")
1284 m = SwallowAdmin(Swallow, custom_site)
1285 request = self.factory.post(changelist_url, data=data)
1286 queryset = m._get_list_editable_queryset(request, prefix="form")
1287 self.assertEqual(queryset.count(), 1)
1288 data["form-0-uuid"] = "INVALD_PRIMARY_KEY"
1289 # The unfiltered queryset is returned if there's invalid data.
1290 request = self.factory.post(changelist_url, data=data)
1291 queryset = m._get_list_editable_queryset(request, prefix="form")
1292 self.assertEqual(queryset.count(), 2)
1293
1294 def test_get_list_editable_queryset_with_regex_chars_in_prefix(self):
1295 a = Swallow.objects.create(origin="Swallow A", load=4, speed=1)
1296 Swallow.objects.create(origin="Swallow B", load=2, speed=2)
1297 data = {
1298 "form$-TOTAL_FORMS": "2",
1299 "form$-INITIAL_FORMS": "2",
1300 "form$-MIN_NUM_FORMS": "0",
1301 "form$-MAX_NUM_FORMS": "1000",
1302 "form$-0-uuid": str(a.pk),
1303 "form$-0-load": "10",
1304 "_save": "Save",
1305 }
1306 superuser = self._create_superuser("superuser")
1307 self.client.force_login(superuser)
1308 changelist_url = reverse("admin:admin_changelist_swallow_changelist")
1309 m = SwallowAdmin(Swallow, custom_site)
1310 request = self.factory.post(changelist_url, data=data)
1311 queryset = m._get_list_editable_queryset(request, prefix="form$")
1312 self.assertEqual(queryset.count(), 1)
1313
1314 def test_changelist_view_list_editable_changed_objects_uses_filter(self):
1315 """list_editable edits use a filtered queryset to limit memory usage."""
1316 a = Swallow.objects.create(origin="Swallow A", load=4, speed=1)
1317 Swallow.objects.create(origin="Swallow B", load=2, speed=2)
1318 data = {
1319 "form-TOTAL_FORMS": "2",
1320 "form-INITIAL_FORMS": "2",
1321 "form-MIN_NUM_FORMS": "0",
1322 "form-MAX_NUM_FORMS": "1000",
1323 "form-0-uuid": str(a.pk),
1324 "form-0-load": "10",
1325 "_save": "Save",
1326 }
1327 superuser = self._create_superuser("superuser")
1328 self.client.force_login(superuser)
1329 changelist_url = reverse("admin:admin_changelist_swallow_changelist")
1330 with CaptureQueriesContext(connection) as context:
1331 response = self.client.post(changelist_url, data=data)
1332 self.assertEqual(response.status_code, 200)
1333 self.assertIn("WHERE", context.captured_queries[4]["sql"])
1334 self.assertIn("IN", context.captured_queries[4]["sql"])
1335 # Check only the first few characters since the UUID may have dashes.
1336 self.assertIn(str(a.pk)[:8], context.captured_queries[4]["sql"])
1337
1338 def test_list_editable_error_title(self):
1339 a = Swallow.objects.create(origin="Swallow A", load=4, speed=1)
1340 Swallow.objects.create(origin="Swallow B", load=2, speed=2)
1341 data = {
1342 "form-TOTAL_FORMS": "2",
1343 "form-INITIAL_FORMS": "2",
1344 "form-MIN_NUM_FORMS": "0",
1345 "form-MAX_NUM_FORMS": "1000",
1346 "form-0-uuid": str(a.pk),
1347 "form-0-load": "invalid",
1348 "_save": "Save",
1349 }
1350 superuser = self._create_superuser("superuser")
1351 self.client.force_login(superuser)
1352 changelist_url = reverse("admin:admin_changelist_swallow_changelist")
1353 response = self.client.post(changelist_url, data=data)
1354 self.assertContains(response, "Error: Select swallow to change")
1355
1356 def test_deterministic_order_for_unordered_model(self):
1357 """
1358 The primary key is used in the ordering of the changelist's results to
1359 guarantee a deterministic order, even when the model doesn't have any
1360 default ordering defined (#17198).
1361 """
1362 superuser = self._create_superuser("superuser")
1363
1364 for counter in range(1, 51):
1365 UnorderedObject.objects.create(id=counter, bool=True)
1366
1367 class UnorderedObjectAdmin(admin.ModelAdmin):
1368 list_per_page = 10
1369
1370 def check_results_order(ascending=False):
1371 custom_site.register(UnorderedObject, UnorderedObjectAdmin)
1372 model_admin = UnorderedObjectAdmin(UnorderedObject, custom_site)
1373 counter = 0 if ascending else 51
1374 for page in range(1, 6):
1375 request = self._mocked_authenticated_request(
1376 "/unorderedobject/?p=%s" % page, superuser
1377 )
1378 response = model_admin.changelist_view(request)
1379 for result in response.context_data["cl"].result_list:
1380 counter += 1 if ascending else -1
1381 self.assertEqual(result.id, counter)
1382 custom_site.unregister(UnorderedObject)
1383
1384 # When no order is defined at all, everything is ordered by '-pk'.
1385 check_results_order()
1386
1387 # When an order field is defined but multiple records have the same
1388 # value for that field, make sure everything gets ordered by -pk as well.
1389 UnorderedObjectAdmin.ordering = ["bool"]
1390 check_results_order()
1391
1392 # When order fields are defined, including the pk itself, use them.
1393 UnorderedObjectAdmin.ordering = ["bool", "-pk"]
1394 check_results_order()
1395 UnorderedObjectAdmin.ordering = ["bool", "pk"]
1396 check_results_order(ascending=True)
1397 UnorderedObjectAdmin.ordering = ["-id", "bool"]
1398 check_results_order()
1399 UnorderedObjectAdmin.ordering = ["id", "bool"]
1400 check_results_order(ascending=True)
1401
1402 def test_ordering_from_model_meta(self):
1403 Swallow.objects.create(origin="Swallow A", load=4, speed=2)
1404 Swallow.objects.create(origin="Swallow B", load=2, speed=1)
1405 Swallow.objects.create(origin="Swallow C", load=5, speed=1)
1406 m = SwallowAdmin(Swallow, custom_site)
1407 request = self._mocked_authenticated_request("/swallow/?o=", self.superuser)
1408 changelist = m.get_changelist_instance(request)
1409 queryset = changelist.get_queryset(request)
1410 self.assertQuerySetEqual(
1411 queryset,
1412 [(1.0, 2.0), (1.0, 5.0), (2.0, 4.0)],
1413 lambda s: (s.speed, s.load),
1414 )
1415
1416 def test_deterministic_order_for_model_ordered_by_its_manager(self):
1417 """
1418 The primary key is used in the ordering of the changelist's results to
1419 guarantee a deterministic order, even when the model has a manager that
1420 defines a default ordering (#17198).
1421 """
1422 superuser = self._create_superuser("superuser")
1423
1424 for counter in range(1, 51):
1425 OrderedObject.objects.create(id=counter, bool=True, number=counter)
1426
1427 class OrderedObjectAdmin(admin.ModelAdmin):
1428 list_per_page = 10
1429
1430 def check_results_order(ascending=False):
1431 custom_site.register(OrderedObject, OrderedObjectAdmin)
1432 model_admin = OrderedObjectAdmin(OrderedObject, custom_site)
1433 counter = 0 if ascending else 51
1434 for page in range(1, 6):
1435 request = self._mocked_authenticated_request(
1436 "/orderedobject/?p=%s" % page, superuser
1437 )
1438 response = model_admin.changelist_view(request)
1439 for result in response.context_data["cl"].result_list:
1440 counter += 1 if ascending else -1
1441 self.assertEqual(result.id, counter)
1442 custom_site.unregister(OrderedObject)
1443
1444 # When no order is defined at all, use the model's default ordering
1445 # (i.e. 'number').
1446 check_results_order(ascending=True)
1447
1448 # When an order field is defined but multiple records have the same
1449 # value for that field, make sure everything gets ordered by -pk as well.
1450 OrderedObjectAdmin.ordering = ["bool"]
1451 check_results_order()
1452
1453 # When order fields are defined, including the pk itself, use them.
1454 OrderedObjectAdmin.ordering = ["bool", "-pk"]
1455 check_results_order()
1456 OrderedObjectAdmin.ordering = ["bool", "pk"]
1457 check_results_order(ascending=True)
1458 OrderedObjectAdmin.ordering = ["-id", "bool"]
1459 check_results_order()
1460 OrderedObjectAdmin.ordering = ["id", "bool"]
1461 check_results_order(ascending=True)
1462
1463 @isolate_apps("admin_changelist")
1464 def test_total_ordering_optimization(self):
1465 class Related(models.Model):
1466 unique_field = models.BooleanField(unique=True)
1467
1468 class Meta:
1469 ordering = ("unique_field",)
1470
1471 class Model(models.Model):
1472 unique_field = models.BooleanField(unique=True)
1473 unique_nullable_field = models.BooleanField(unique=True, null=True)
1474 related = models.ForeignKey(Related, models.CASCADE)
1475 other_related = models.ForeignKey(Related, models.CASCADE)
1476 related_unique = models.OneToOneField(Related, models.CASCADE)
1477 field = models.BooleanField()
1478 other_field = models.BooleanField()
1479 null_field = models.BooleanField(null=True)
1480
1481 class Meta:
1482 unique_together = {
1483 ("field", "other_field"),
1484 ("field", "null_field"),
1485 ("related", "other_related_id"),
1486 }
1487
1488 class ModelAdmin(admin.ModelAdmin):
1489 def get_queryset(self, request):
1490 return Model.objects.none()
1491
1492 request = self._mocked_authenticated_request("/", self.superuser)
1493 site = admin.AdminSite(name="admin")
1494 model_admin = ModelAdmin(Model, site)
1495 change_list = model_admin.get_changelist_instance(request)
1496 tests = (
1497 ([], ["-pk"]),
1498 # Unique non-nullable field.
1499 (["unique_field"], ["unique_field"]),
1500 (["-unique_field"], ["-unique_field"]),
1501 # Unique nullable field.
1502 (["unique_nullable_field"], ["unique_nullable_field", "-pk"]),
1503 # Field.
1504 (["field"], ["field", "-pk"]),
1505 # Related field introspection is not implemented.
1506 (["related__unique_field"], ["related__unique_field", "-pk"]),
1507 # Related attname unique.
1508 (["related_unique_id"], ["related_unique_id"]),
1509 # Related ordering introspection is not implemented.
1510 (["related_unique"], ["related_unique", "-pk"]),
1511 # Composite unique.
1512 (["field", "-other_field"], ["field", "-other_field"]),
1513 # Composite unique nullable.
1514 (["-field", "null_field"], ["-field", "null_field", "-pk"]),
1515 # Composite unique and nullable.
1516 (
1517 ["-field", "null_field", "other_field"],
1518 ["-field", "null_field", "other_field"],
1519 ),
1520 # Composite unique attnames.
1521 (["related_id", "-other_related_id"], ["related_id", "-other_related_id"]),
1522 # Composite unique names.
1523 (["related", "-other_related_id"], ["related", "-other_related_id", "-pk"]),
1524 )
1525 # F() objects composite unique.
1526 total_ordering = [F("field"), F("other_field").desc(nulls_last=True)]
1527 # F() objects composite unique nullable.
1528 non_total_ordering = [F("field"), F("null_field").desc(nulls_last=True)]
1529 tests += (
1530 (total_ordering, total_ordering),
1531 (non_total_ordering, non_total_ordering + ["-pk"]),
1532 )
1533 for ordering, expected in tests:
1534 with self.subTest(ordering=ordering):
1535 self.assertEqual(
1536 change_list._get_deterministic_ordering(ordering), expected
1537 )
1538
1539 @isolate_apps("admin_changelist")
1540 def test_total_ordering_optimization_meta_constraints(self):
1541 class Related(models.Model):
1542 unique_field = models.BooleanField(unique=True)
1543
1544 class Meta:
1545 ordering = ("unique_field",)
1546
1547 class Model(models.Model):
1548 field_1 = models.BooleanField()
1549 field_2 = models.BooleanField()
1550 field_3 = models.BooleanField()
1551 field_4 = models.BooleanField()
1552 field_5 = models.BooleanField()
1553 field_6 = models.BooleanField()
1554 nullable_1 = models.BooleanField(null=True)
1555 nullable_2 = models.BooleanField(null=True)
1556 related_1 = models.ForeignKey(Related, models.CASCADE)
1557 related_2 = models.ForeignKey(Related, models.CASCADE)
1558 related_3 = models.ForeignKey(Related, models.CASCADE)
1559 related_4 = models.ForeignKey(Related, models.CASCADE)
1560
1561 class Meta:
1562 constraints = [
1563 *[
1564 models.UniqueConstraint(fields=fields, name="".join(fields))
1565 for fields in (
1566 ["field_1"],
1567 ["nullable_1"],
1568 ["related_1"],
1569 ["related_2_id"],
1570 ["field_2", "field_3"],
1571 ["field_2", "nullable_2"],
1572 ["field_2", "related_3"],
1573 ["field_3", "related_4_id"],
1574 )
1575 ],
1576 models.CheckConstraint(condition=models.Q(id__gt=0), name="foo"),
1577 models.UniqueConstraint(
1578 fields=["field_5"],
1579 condition=models.Q(id__gt=10),
1580 name="total_ordering_1",
1581 ),
1582 models.UniqueConstraint(
1583 fields=["field_6"],
1584 condition=models.Q(),
1585 name="total_ordering",
1586 ),
1587 ]
1588
1589 class ModelAdmin(admin.ModelAdmin):
1590 def get_queryset(self, request):
1591 return Model.objects.none()
1592
1593 request = self._mocked_authenticated_request("/", self.superuser)
1594 site = admin.AdminSite(name="admin")
1595 model_admin = ModelAdmin(Model, site)
1596 change_list = model_admin.get_changelist_instance(request)
1597 tests = (
1598 # Unique non-nullable field.
1599 (["field_1"], ["field_1"]),
1600 # Unique nullable field.
1601 (["nullable_1"], ["nullable_1", "-pk"]),
1602 # Related attname unique.
1603 (["related_1_id"], ["related_1_id"]),
1604 (["related_2_id"], ["related_2_id"]),
1605 # Related ordering introspection is not implemented.
1606 (["related_1"], ["related_1", "-pk"]),
1607 # Composite unique.
1608 (["-field_2", "field_3"], ["-field_2", "field_3"]),
1609 # Composite unique nullable.
1610 (["field_2", "-nullable_2"], ["field_2", "-nullable_2", "-pk"]),
1611 # Composite unique and nullable.
1612 (
1613 ["field_2", "-nullable_2", "field_3"],
1614 ["field_2", "-nullable_2", "field_3"],
1615 ),
1616 # Composite field and related field name.
1617 (["field_2", "-related_3"], ["field_2", "-related_3", "-pk"]),
1618 (["field_3", "related_4"], ["field_3", "related_4", "-pk"]),
1619 # Composite field and related field attname.
1620 (["field_2", "related_3_id"], ["field_2", "related_3_id"]),
1621 (["field_3", "-related_4_id"], ["field_3", "-related_4_id"]),
1622 # Partial unique constraint is ignored.
1623 (["field_5"], ["field_5", "-pk"]),
1624 # Unique constraint with an empty condition.
1625 (["field_6"], ["field_6"]),
1626 )
1627 for ordering, expected in tests:
1628 with self.subTest(ordering=ordering):
1629 self.assertEqual(
1630 change_list._get_deterministic_ordering(ordering), expected
1631 )
1632
1633 def test_dynamic_list_filter(self):
1634 """
1635 Regression tests for ticket #17646: dynamic list_filter support.
1636 """
1637 parent = Parent.objects.create(name="parent")
1638 for i in range(10):
1639 Child.objects.create(name="child %s" % i, parent=parent)
1640
1641 user_noparents = self._create_superuser("noparents")
1642 user_parents = self._create_superuser("parents")
1643
1644 # Test with user 'noparents'
1645 m = DynamicListFilterChildAdmin(Child, custom_site)
1646 request = self._mocked_authenticated_request("/child/", user_noparents)
1647 response = m.changelist_view(request)
1648 self.assertEqual(response.context_data["cl"].list_filter, ["name", "age"])
1649
1650 # Test with user 'parents'
1651 m = DynamicListFilterChildAdmin(Child, custom_site)
1652 request = self._mocked_authenticated_request("/child/", user_parents)
1653 response = m.changelist_view(request)
1654 self.assertEqual(
1655 response.context_data["cl"].list_filter, ("parent", "name", "age")
1656 )
1657
1658 def test_dynamic_search_fields(self):
1659 child = self._create_superuser("child")
1660 m = DynamicSearchFieldsChildAdmin(Child, custom_site)
1661 request = self._mocked_authenticated_request("/child/", child)
1662 response = m.changelist_view(request)
1663 self.assertEqual(response.context_data["cl"].search_fields, ("name", "age"))
1664
1665 def test_pagination_page_range(self):
1666 """
1667 Regression tests for ticket #15653: ensure the number of pages
1668 generated for changelist views are correct.
1669 """
1670 # instantiating and setting up ChangeList object
1671 m = GroupAdmin(Group, custom_site)
1672 request = self.factory.get("/group/")
1673 request.user = self.superuser
1674 cl = m.get_changelist_instance(request)
1675 cl.list_per_page = 10
1676
1677 ELLIPSIS = cl.paginator.ELLIPSIS
1678 for number, pages, expected in [
1679 (1, 1, []),
1680 (1, 2, [1, 2]),
1681 (6, 11, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]),
1682 (6, 12, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]),
1683 (6, 13, [1, 2, 3, 4, 5, 6, 7, 8, 9, ELLIPSIS, 12, 13]),
1684 (7, 12, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]),
1685 (7, 13, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]),
1686 (7, 14, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ELLIPSIS, 13, 14]),
1687 (8, 13, [1, 2, ELLIPSIS, 5, 6, 7, 8, 9, 10, 11, 12, 13]),
1688 (8, 14, [1, 2, ELLIPSIS, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]),
1689 (8, 15, [1, 2, ELLIPSIS, 5, 6, 7, 8, 9, 10, 11, ELLIPSIS, 14, 15]),
1690 ]:
1691 with self.subTest(number=number, pages=pages):
1692 # assuming exactly `pages * cl.list_per_page` objects
1693 Group.objects.all().delete()
1694 for i in range(pages * cl.list_per_page):
1695 Group.objects.create(name="test band")
1696
1697 # setting page number and calculating page range
1698 cl.page_num = number
1699 cl.get_results(request)
1700 self.assertEqual(list(pagination(cl)["page_range"]), expected)
1701
1702 def test_object_tools_displayed_no_add_permission(self):
1703 """
1704 When ModelAdmin.has_add_permission() returns False, the object-tools
1705 block is still shown.
1706 """
1707 superuser = self._create_superuser("superuser")
1708 m = EventAdmin(Event, custom_site)
1709 request = self._mocked_authenticated_request("/event/", superuser)
1710 self.assertFalse(m.has_add_permission(request))
1711 response = m.changelist_view(request)
1712 self.assertIn('<ul class="object-tools">', response.rendered_content)
1713 # The "Add" button inside the object-tools shouldn't appear.
1714 self.assertNotIn("Add event", response.rendered_content)
1715
1716 def test_search_help_text(self):
1717 superuser = self._create_superuser("superuser")
1718 m = BandAdmin(Band, custom_site)
1719 # search_fields without search_help_text.
1720 m.search_fields = ["name"]
1721 request = self._mocked_authenticated_request("/band/", superuser)
1722 response = m.changelist_view(request)
1723 self.assertIsNone(response.context_data["cl"].search_help_text)
1724 self.assertNotContains(response, '<div class="help id="searchbar_helptext">')
1725 # search_fields with search_help_text.
1726 m.search_help_text = "Search help text"
1727 request = self._mocked_authenticated_request("/band/", superuser)
1728 response = m.changelist_view(request)
1729 self.assertEqual(
1730 response.context_data["cl"].search_help_text, "Search help text"
1731 )
1732 self.assertContains(
1733 response, '<div class="help" id="searchbar_helptext">Search help text</div>'
1734 )
1735 self.assertContains(
1736 response,
1737 '<input type="text" size="40" name="q" value="" id="searchbar" '
1738 'aria-describedby="searchbar_helptext">',
1739 )
1740
1741 def test_search_role(self):
1742 m = BandAdmin(Band, custom_site)
1743 m.search_fields = ["name"]
1744 request = self._mocked_authenticated_request("/band/", self.superuser)
1745 response = m.changelist_view(request)
1746 self.assertContains(
1747 response,
1748 '<form id="changelist-search" method="get" role="search">',
1749 )
1750
1751 def test_search_bar_total_link_preserves_options(self):
1752 self.client.force_login(self.superuser)
1753 url = reverse("admin:auth_user_changelist")
1754 for data, href in (
1755 ({"is_staff__exact": "0"}, "?"),
1756 ({"is_staff__exact": "0", IS_POPUP_VAR: "1"}, f"?{IS_POPUP_VAR}=1"),
1757 ({"is_staff__exact": "0", IS_FACETS_VAR: ""}, f"?{IS_FACETS_VAR}"),
1758 (
1759 {"is_staff__exact": "0", IS_POPUP_VAR: "1", IS_FACETS_VAR: ""},
1760 f"?{IS_POPUP_VAR}=1&{IS_FACETS_VAR}",
1761 ),
1762 ):
1763 with self.subTest(data=data):
1764 response = self.client.get(url, data=data)
1765 self.assertContains(
1766 response, f'0 results (<a href="{href}">1 total</a>)'
1767 )
1768
1769 def test_list_display_related_field(self):
1770 parent = Parent.objects.create(name="I am your father")
1771 child = Child.objects.create(name="I am your child", parent=parent)
1772 GrandChild.objects.create(name="I am your grandchild", parent=child)
1773 request = self._mocked_authenticated_request("/grandchild/", self.superuser)
1774
1775 m = GrandChildAdmin(GrandChild, custom_site)
1776 response = m.changelist_view(request)
1777 self.assertContains(response, parent.name)
1778 self.assertContains(response, child.name)
1779
1780 def test_list_display_related_field_null(self):
1781 GrandChild.objects.create(name="I am parentless", parent=None)
1782 request = self._mocked_authenticated_request("/grandchild/", self.superuser)
1783
1784 m = GrandChildAdmin(GrandChild, custom_site)
1785 response = m.changelist_view(request)
1786 self.assertContains(response, '<td class="field-parent__name">-</td>')
1787 self.assertContains(response, '<td class="field-parent__parent__name">-</td>')
1788
1789 def test_list_display_related_field_ordering(self):
1790 parent_a = Parent.objects.create(name="Alice")
1791 parent_z = Parent.objects.create(name="Zara")
1792 Child.objects.create(name="Alice's child", parent=parent_a)
1793 Child.objects.create(name="Zara's child", parent=parent_z)
1794
1795 class ChildAdmin(admin.ModelAdmin):
1796 list_display = ["name", "parent__name"]
1797 list_per_page = 1
1798
1799 m = ChildAdmin(Child, custom_site)
1800
1801 # Order ascending.
1802 request = self._mocked_authenticated_request("/grandchild/?o=1", self.superuser)
1803 response = m.changelist_view(request)
1804 self.assertContains(response, parent_a.name)
1805 self.assertNotContains(response, parent_z.name)
1806
1807 # Order descending.
1808 request = self._mocked_authenticated_request(
1809 "/grandchild/?o=-1", self.superuser
1810 )
1811 response = m.changelist_view(request)
1812 self.assertNotContains(response, parent_a.name)
1813 self.assertContains(response, parent_z.name)
1814
1815 def test_list_display_related_field_ordering_fields(self):
1816 class ChildAdmin(admin.ModelAdmin):
1817 list_display = ["name", "parent__name"]
1818 ordering = ["parent__name"]
1819
1820 m = ChildAdmin(Child, custom_site)
1821 request = self._mocked_authenticated_request("/", self.superuser)
1822 cl = m.get_changelist_instance(request)
1823 self.assertEqual(cl.get_ordering_field_columns(), {2: "asc"})
1824
1825
1826 class GetAdminLogTests(TestCase):
1827 def test_custom_user_pk_not_named_id(self):
1828 """
1829 {% get_admin_log %} works if the user model's primary key isn't named
1830 'id'.
1831 """
1832 context = Context(
1833 {
1834 "user": CustomIdUser(),
1835 "log_entries": LogEntry.objects.all(),
1836 }
1837 )
1838 template = Template(
1839 "{% load log %}{% get_admin_log 10 as admin_log for_user user %}"
1840 )
1841 # This template tag just logs.
1842 self.assertEqual(template.render(context), "")
1843
1844 def test_no_user(self):
1845 """{% get_admin_log %} works without specifying a user."""
1846 user = User(username="jondoe", password="secret", email="[email protected]")
1847 user.save()
1848 LogEntry.objects.log_actions(user.pk, [user], 1)
1849 context = Context({"log_entries": LogEntry.objects.all()})
1850 t = Template(
1851 "{% load log %}"
1852 "{% get_admin_log 100 as admin_log %}"
1853 "{% for entry in admin_log %}"
1854 "{{ entry|safe }}"
1855 "{% endfor %}"
1856 )
1857 self.assertEqual(t.render(context), "Added “jondoe”.")
1858
1859 def test_missing_args(self):
1860 msg = "'get_admin_log' statements require two arguments"
1861 with self.assertRaisesMessage(TemplateSyntaxError, msg):
1862 Template("{% load log %}{% get_admin_log 10 as %}")
1863
1864 def test_non_integer_limit(self):
1865 msg = "First argument to 'get_admin_log' must be an integer"
1866 with self.assertRaisesMessage(TemplateSyntaxError, msg):
1867 Template(
1868 '{% load log %}{% get_admin_log "10" as admin_log for_user user %}'
1869 )
1870
1871 def test_without_as(self):
1872 msg = "Second argument to 'get_admin_log' must be 'as'"
1873 with self.assertRaisesMessage(TemplateSyntaxError, msg):
1874 Template("{% load log %}{% get_admin_log 10 ad admin_log for_user user %}")
1875
1876 def test_without_for_user(self):
1877 msg = "Fourth argument to 'get_admin_log' must be 'for_user'"
1878 with self.assertRaisesMessage(TemplateSyntaxError, msg):
1879 Template("{% load log %}{% get_admin_log 10 as admin_log foruser user %}")
1880
1881
1882 @override_settings(ROOT_URLCONF="admin_changelist.urls")
1883 class SeleniumTests(AdminSeleniumTestCase):
1884 available_apps = ["admin_changelist"] + AdminSeleniumTestCase.available_apps
1885
1886 def setUp(self):
1887 User.objects.create_superuser(username="super", password="secret", email=None)
1888
1889 def test_add_row_selection(self):
1890 """
1891 The status line for selected rows gets updated correctly (#22038).
1892 """
1893 from selenium.webdriver.common.by import By
1894
1895 self.admin_login(username="super", password="secret")
1896 self.selenium.get(self.live_server_url + reverse("admin:auth_user_changelist"))
1897
1898 form_id = "#changelist-form"
1899
1900 # Test amount of rows in the Changelist
1901 rows = self.selenium.find_elements(
1902 By.CSS_SELECTOR, "%s #result_list tbody tr" % form_id
1903 )
1904 self.assertEqual(len(rows), 1)
1905 row = rows[0]
1906
1907 selection_indicator = self.selenium.find_element(
1908 By.CSS_SELECTOR, "%s .action-counter" % form_id
1909 )
1910 all_selector = self.selenium.find_element(By.ID, "action-toggle")
1911 row_selector = self.selenium.find_element(
1912 By.CSS_SELECTOR,
1913 "%s #result_list tbody tr:first-child .action-select" % form_id,
1914 )
1915
1916 # Test current selection
1917 self.assertEqual(selection_indicator.text, "0 of 1 selected")
1918 self.assertIs(all_selector.get_property("checked"), False)
1919 self.assertEqual(row.get_attribute("class"), "")
1920
1921 # Select a row and check again
1922 row_selector.click()
1923 self.assertEqual(selection_indicator.text, "1 of 1 selected")
1924 self.assertIs(all_selector.get_property("checked"), True)
1925 self.assertEqual(row.get_attribute("class"), "selected")
1926
1927 # Deselect a row and check again
1928 row_selector.click()
1929 self.assertEqual(selection_indicator.text, "0 of 1 selected")
1930 self.assertIs(all_selector.get_property("checked"), False)
1931 self.assertEqual(row.get_attribute("class"), "")
1932
1933 def test_modifier_allows_multiple_section(self):
1934 """
1935 Selecting a row and then selecting another row whilst holding shift
1936 should select all rows in-between.
1937 """
1938 from selenium.webdriver.common.action_chains import ActionChains
1939 from selenium.webdriver.common.by import By
1940 from selenium.webdriver.common.keys import Keys
1941
1942 Parent.objects.bulk_create([Parent(name="parent%d" % i) for i in range(5)])
1943 self.admin_login(username="super", password="secret")
1944 self.selenium.get(
1945 self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
1946 )
1947 checkboxes = self.selenium.find_elements(
1948 By.CSS_SELECTOR, "tr input.action-select"
1949 )
1950 self.assertEqual(len(checkboxes), 5)
1951 for c in checkboxes:
1952 self.assertIs(c.get_property("checked"), False)
1953 # Check first row. Hold-shift and check next-to-last row.
1954 checkboxes[0].click()
1955 ActionChains(self.selenium).key_down(Keys.SHIFT).click(checkboxes[-2]).key_up(
1956 Keys.SHIFT
1957 ).perform()
1958 for c in checkboxes[:-2]:
1959 self.assertIs(c.get_property("checked"), True)
1960 self.assertIs(checkboxes[-1].get_property("checked"), False)
1961
1962 def test_selection_counter_is_synced_when_page_is_shown(self):
1963 from selenium.webdriver.common.by import By
1964
1965 self.admin_login(username="super", password="secret")
1966 self.selenium.get(self.live_server_url + reverse("admin:auth_user_changelist"))
1967
1968 form_id = "#changelist-form"
1969 first_row_checkbox_selector = (
1970 f"{form_id} #result_list tbody tr:first-child .action-select"
1971 )
1972 selection_indicator_selector = f"{form_id} .action-counter"
1973 selection_indicator = self.selenium.find_element(
1974 By.CSS_SELECTOR, selection_indicator_selector
1975 )
1976 row_checkbox = self.selenium.find_element(
1977 By.CSS_SELECTOR, first_row_checkbox_selector
1978 )
1979 # Select a row.
1980 row_checkbox.click()
1981 self.assertEqual(selection_indicator.text, "1 of 1 selected")
1982 # Go to another page and get back.
1983 self.selenium.get(
1984 self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
1985 )
1986 self.selenium.back()
1987 # The selection indicator is synced with the selected checkboxes.
1988 selection_indicator = self.selenium.find_element(
1989 By.CSS_SELECTOR, selection_indicator_selector
1990 )
1991 row_checkbox = self.selenium.find_element(
1992 By.CSS_SELECTOR, first_row_checkbox_selector
1993 )
1994 selected_rows = 1 if row_checkbox.is_selected() else 0
1995 self.assertEqual(selection_indicator.text, f"{selected_rows} of 1 selected")
1996
1997 def test_select_all_across_pages(self):
1998 from selenium.webdriver.common.by import By
1999
2000 Parent.objects.bulk_create([Parent(name="parent%d" % i) for i in range(101)])
2001 self.admin_login(username="super", password="secret")
2002 self.selenium.get(
2003 self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
2004 )
2005
2006 selection_indicator = self.selenium.find_element(
2007 By.CSS_SELECTOR, ".action-counter"
2008 )
2009 select_all_indicator = self.selenium.find_element(
2010 By.CSS_SELECTOR, ".actions .all"
2011 )
2012 question = self.selenium.find_element(By.CSS_SELECTOR, ".actions > .question")
2013 clear = self.selenium.find_element(By.CSS_SELECTOR, ".actions > .clear")
2014 select_all = self.selenium.find_element(By.ID, "action-toggle")
2015 select_across = self.selenium.find_elements(By.NAME, "select_across")
2016
2017 self.assertIs(question.is_displayed(), False)
2018 self.assertIs(clear.is_displayed(), False)
2019 self.assertIs(select_all.get_property("checked"), False)
2020 for hidden_input in select_across:
2021 self.assertEqual(hidden_input.get_property("value"), "0")
2022 self.assertIs(selection_indicator.is_displayed(), True)
2023 self.assertEqual(selection_indicator.text, "0 of 100 selected")
2024 self.assertIs(select_all_indicator.is_displayed(), False)
2025
2026 select_all.click()
2027 self.assertIs(question.is_displayed(), True)
2028 self.assertIs(clear.is_displayed(), False)
2029 self.assertIs(select_all.get_property("checked"), True)
2030 for hidden_input in select_across:
2031 self.assertEqual(hidden_input.get_property("value"), "0")
2032 self.assertIs(selection_indicator.is_displayed(), True)
2033 self.assertEqual(selection_indicator.text, "100 of 100 selected")
2034 self.assertIs(select_all_indicator.is_displayed(), False)
2035
2036 question.click()
2037 self.assertIs(question.is_displayed(), False)
2038 self.assertIs(clear.is_displayed(), True)
2039 self.assertIs(select_all.get_property("checked"), True)
2040 for hidden_input in select_across:
2041 self.assertEqual(hidden_input.get_property("value"), "1")
2042 self.assertIs(selection_indicator.is_displayed(), False)
2043 self.assertIs(select_all_indicator.is_displayed(), True)
2044
2045 clear.click()
2046 self.assertIs(question.is_displayed(), False)
2047 self.assertIs(clear.is_displayed(), False)
2048 self.assertIs(select_all.get_property("checked"), False)
2049 for hidden_input in select_across:
2050 self.assertEqual(hidden_input.get_property("value"), "0")
2051 self.assertIs(selection_indicator.is_displayed(), True)
2052 self.assertEqual(selection_indicator.text, "0 of 100 selected")
2053 self.assertIs(select_all_indicator.is_displayed(), False)
2054
2055 def test_actions_warn_on_pending_edits(self):
2056 from selenium.webdriver.common.by import By
2057
2058 Parent.objects.create(name="foo")
2059
2060 self.admin_login(username="super", password="secret")
2061 self.selenium.get(
2062 self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
2063 )
2064
2065 name_input = self.selenium.find_element(By.ID, "id_form-0-name")
2066 name_input.clear()
2067 name_input.send_keys("bar")
2068 self.selenium.find_element(By.ID, "action-toggle").click()
2069 self.selenium.find_element(By.NAME, "index").click() # Go
2070 alert = self.selenium.switch_to.alert
2071 try:
2072 self.assertEqual(
2073 alert.text,
2074 "You have unsaved changes on individual editable fields. If you "
2075 "run an action, your unsaved changes will be lost.",
2076 )
2077 finally:
2078 alert.dismiss()
2079
2080 def test_save_with_changes_warns_on_pending_action(self):
2081 from selenium.webdriver.common.by import By
2082 from selenium.webdriver.support.ui import Select
2083
2084 Parent.objects.create(name="parent")
2085
2086 self.admin_login(username="super", password="secret")
2087 self.selenium.get(
2088 self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
2089 )
2090
2091 name_input = self.selenium.find_element(By.ID, "id_form-0-name")
2092 name_input.clear()
2093 name_input.send_keys("other name")
2094 Select(self.selenium.find_element(By.NAME, "action")).select_by_value(
2095 "delete_selected"
2096 )
2097 self.selenium.find_element(By.NAME, "_save").click()
2098 alert = self.selenium.switch_to.alert
2099 try:
2100 self.assertEqual(
2101 alert.text,
2102 "You have selected an action, but you haven’t saved your "
2103 "changes to individual fields yet. Please click OK to save. "
2104 "You’ll need to re-run the action.",
2105 )
2106 finally:
2107 alert.dismiss()
2108
2109 def test_save_without_changes_warns_on_pending_action(self):
2110 from selenium.webdriver.common.by import By
2111 from selenium.webdriver.support.ui import Select
2112
2113 Parent.objects.create(name="parent")
2114
2115 self.admin_login(username="super", password="secret")
2116 self.selenium.get(
2117 self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
2118 )
2119
2120 Select(self.selenium.find_element(By.NAME, "action")).select_by_value(
2121 "delete_selected"
2122 )
2123 self.selenium.find_element(By.NAME, "_save").click()
2124 alert = self.selenium.switch_to.alert
2125 try:
2126 self.assertEqual(
2127 alert.text,
2128 "You have selected an action, and you haven’t made any "
2129 "changes on individual fields. You’re probably looking for "
2130 "the Go button rather than the Save button.",
2131 )
2132 finally:
2133 alert.dismiss()
2134
2135 def test_collapse_filters(self):
2136 from selenium.webdriver.common.by import By
2137
2138 self.admin_login(username="super", password="secret")
2139 self.selenium.get(self.live_server_url + reverse("admin:auth_user_changelist"))
2140
2141 # The UserAdmin has 3 field filters by default: "staff status",
2142 # "superuser status", and "active".
2143 details = self.selenium.find_elements(By.CSS_SELECTOR, "details")
2144 # All filters are opened at first.
2145 for detail in details:
2146 self.assertTrue(detail.get_attribute("open"))
2147 # Collapse "staff' and "superuser" filters.
2148 for detail in details[:2]:
2149 summary = detail.find_element(By.CSS_SELECTOR, "summary")
2150 summary.click()
2151 self.assertFalse(detail.get_attribute("open"))
2152 # Filters are in the same state after refresh.
2153 self.selenium.refresh()
2154 self.assertFalse(
2155 self.selenium.find_element(
2156 By.CSS_SELECTOR, "[data-filter-title='staff status']"
2157 ).get_attribute("open")
2158 )
2159 self.assertFalse(
2160 self.selenium.find_element(
2161 By.CSS_SELECTOR, "[data-filter-title='superuser status']"
2162 ).get_attribute("open")
2163 )
2164 self.assertTrue(
2165 self.selenium.find_element(
2166 By.CSS_SELECTOR, "[data-filter-title='active']"
2167 ).get_attribute("open")
2168 )
2169 # Collapse a filter on another view (Bands).
2170 self.selenium.get(
2171 self.live_server_url + reverse("admin:admin_changelist_band_changelist")
2172 )
2173 self.selenium.find_element(By.CSS_SELECTOR, "summary").click()
2174 # Go to Users view and then, back again to Bands view.
2175 self.selenium.get(self.live_server_url + reverse("admin:auth_user_changelist"))
2176 self.selenium.get(
2177 self.live_server_url + reverse("admin:admin_changelist_band_changelist")
2178 )
2179 # The filter remains in the same state.
2180 self.assertFalse(
2181 self.selenium.find_element(
2182 By.CSS_SELECTOR,
2183 "[data-filter-title='number of members']",
2184 ).get_attribute("open")
2185 )
2186
2187 def test_collapse_filter_with_unescaped_title(self):
2188 from selenium.webdriver.common.by import By
2189
2190 self.admin_login(username="super", password="secret")
2191 changelist_url = reverse("admin:admin_changelist_proxyuser_changelist")
2192 self.selenium.get(self.live_server_url + changelist_url)
2193 # Title is escaped.
2194 filter_title = self.selenium.find_element(
2195 By.CSS_SELECTOR, "[data-filter-title='It\\'s OK']"
2196 )
2197 filter_title.find_element(By.CSS_SELECTOR, "summary").click()
2198 self.assertFalse(filter_title.get_attribute("open"))
2199 # Filter is in the same state after refresh.
2200 self.selenium.refresh()
2201 self.assertFalse(
2202 self.selenium.find_element(
2203 By.CSS_SELECTOR, "[data-filter-title='It\\'s OK']"
2204 ).get_attribute("open")
2205 )
2206
2207 def test_list_display_ordering(self):
2208 from selenium.webdriver.common.by import By
2209
2210 parent_a = Parent.objects.create(name="Parent A")
2211 child_l = Child.objects.create(name="Child L", parent=None)
2212 child_m = Child.objects.create(name="Child M", parent=parent_a)
2213 GrandChild.objects.create(name="Grandchild X", parent=child_m)
2214 GrandChild.objects.create(name="Grandchild Y", parent=child_l)
2215 GrandChild.objects.create(name="Grandchild Z", parent=None)
2216
2217 self.admin_login(username="super", password="secret")
2218 changelist_url = reverse("admin:admin_changelist_grandchild_changelist")
2219 self.selenium.get(self.live_server_url + changelist_url)
2220
2221 def find_result_row_texts():
2222 table = self.selenium.find_element(By.ID, "result_list")
2223 # Drop header from the result list
2224 return [row.text for row in table.find_elements(By.TAG_NAME, "tr")][1:]
2225
2226 def expected_from_queryset(qs):
2227 return [
2228 " ".join("-" if i is None else i for i in item)
2229 for item in qs.values_list(
2230 "name", "parent__name", "parent__parent__name"
2231 )
2232 ]
2233
2234 cases = [
2235 # Order ascending by `name`.
2236 ("th.sortable.column-name", ("name",)),
2237 # Order descending by `name`.
2238 ("th.sortable.column-name", ("-name",)),
2239 # Order ascending by `parent__name`.
2240 ("th.sortable.column-parent__name", ("parent__name", "-name")),
2241 # Order descending by `parent__name`.
2242 ("th.sortable.column-parent__name", ("-parent__name", "-name")),
2243 # Order ascending by `parent__parent__name`.
2244 (
2245 "th.sortable.column-parent__parent__name",
2246 ("parent__parent__name", "-parent__name", "-name"),
2247 ),
2248 # Order descending by `parent__parent__name`.
2249 (
2250 "th.sortable.column-parent__parent__name",
2251 ("-parent__parent__name", "-parent__name", "-name"),
2252 ),
2253 ]
2254 for css_selector, ordering in cases:
2255 with self.subTest(ordering=ordering):
2256 self.selenium.find_element(By.CSS_SELECTOR, css_selector).click()
2257 expected = expected_from_queryset(
2258 GrandChild.objects.all().order_by(*ordering)
2259 )
2260 self.assertEqual(find_result_row_texts(), expected)