Debian Codegraph @

tests/admin_views/tests.py

raw
1 import datetime
2 import os
3 import re
4 import unittest
5 import zoneinfo
6 from http import HTTPStatus
7 from unittest import mock
8 from urllib.parse import parse_qsl, urljoin, urlsplit
9
10 from django import forms
11 from django.contrib import admin
12 from django.contrib.admin import AdminSite, ModelAdmin
13 from django.contrib.admin.helpers import ACTION_CHECKBOX_NAME
14 from django.contrib.admin.models import ADDITION, DELETION, LogEntry
15 from django.contrib.admin.options import TO_FIELD_VAR
16 from django.contrib.admin.templatetags.admin_urls import add_preserved_filters
17 from django.contrib.admin.tests import AdminSeleniumTestCase
18 from django.contrib.admin.utils import quote
19 from django.contrib.admin.views.main import IS_POPUP_VAR
20 from django.contrib.auth import REDIRECT_FIELD_NAME, get_permission_codename
21 from django.contrib.auth.admin import UserAdmin
22 from django.contrib.auth.forms import AdminPasswordChangeForm
23 from django.contrib.auth.models import Group, Permission, User
24 from django.contrib.contenttypes.models import ContentType
25 from django.core import mail
26 from django.core.checks import Error
27 from django.core.files import temp as tempfile
28 from django.forms.utils import ErrorList
29 from django.template.response import TemplateResponse
30 from django.test import (
31 RequestFactory,
32 TestCase,
33 ignore_warnings,
34 modify_settings,
35 override_settings,
36 skipUnlessDBFeature,
37 )
38 from django.test.selenium import screenshot_cases
39 from django.test.utils import override_script_prefix
40 from django.urls import NoReverseMatch, resolve, reverse
41 from django.utils import formats, translation
42 from django.utils.cache import get_max_age
43 from django.utils.deprecation import RemovedInDjango60Warning
44 from django.utils.encoding import iri_to_uri
45 from django.utils.html import escape
46 from django.utils.http import urlencode
47
48 from . import customadmin
49 from .admin import CityAdmin, site, site2
50 from .models import (
51 Actor,
52 AdminOrderedAdminMethod,
53 AdminOrderedCallable,
54 AdminOrderedField,
55 AdminOrderedModelMethod,
56 Album,
57 Answer,
58 Answer2,
59 Article,
60 BarAccount,
61 Book,
62 Bookmark,
63 Box,
64 Category,
65 Chapter,
66 ChapterXtra1,
67 ChapterXtra2,
68 Character,
69 Child,
70 Choice,
71 City,
72 Collector,
73 Color,
74 ComplexSortedPerson,
75 CoverLetter,
76 CustomArticle,
77 CyclicOne,
78 CyclicTwo,
79 DooHickey,
80 Employee,
81 EmptyModel,
82 Fabric,
83 FancyDoodad,
84 FieldOverridePost,
85 FilteredManager,
86 FooAccount,
87 FoodDelivery,
88 FunkyTag,
89 Gallery,
90 Grommet,
91 Inquisition,
92 Language,
93 Link,
94 MainPrepopulated,
95 Media,
96 ModelWithStringPrimaryKey,
97 OtherStory,
98 Paper,
99 Parent,
100 ParentWithDependentChildren,
101 ParentWithUUIDPK,
102 Person,
103 Persona,
104 Picture,
105 Pizza,
106 Plot,
107 PlotDetails,
108 PluggableSearchPerson,
109 Podcast,
110 Post,
111 PrePopulatedPost,
112 Promo,
113 Question,
114 ReadablePizza,
115 ReadOnlyPizza,
116 ReadOnlyRelatedField,
117 Recommendation,
118 Recommender,
119 RelatedPrepopulated,
120 RelatedWithUUIDPKModel,
121 Report,
122 Restaurant,
123 RowLevelChangePermissionModel,
124 SecretHideout,
125 Section,
126 ShortMessage,
127 Simple,
128 Song,
129 State,
130 Story,
131 SuperSecretHideout,
132 SuperVillain,
133 Telegram,
134 TitleTranslation,
135 Topping,
136 Traveler,
137 UnchangeableObject,
138 UndeletableObject,
139 UnorderedObject,
140 UserProxy,
141 Villain,
142 Vodcast,
143 Whatsit,
144 Widget,
145 Worker,
146 WorkHour,
147 )
148
149 ERROR_MESSAGE = "Please enter the correct username and password \
150 for a staff account. Note that both fields may be case-sensitive."
151
152 MULTIPART_ENCTYPE = 'enctype="multipart/form-data"'
153
154
155 def make_aware_datetimes(dt, iana_key):
156 """Makes one aware datetime for each supported time zone provider."""
157 yield dt.replace(tzinfo=zoneinfo.ZoneInfo(iana_key))
158
159
160 class AdminFieldExtractionMixin:
161 """
162 Helper methods for extracting data from AdminForm.
163 """
164
165 def get_admin_form_fields(self, response):
166 """
167 Return a list of AdminFields for the AdminForm in the response.
168 """
169 fields = []
170 for fieldset in response.context["adminform"]:
171 for field_line in fieldset:
172 fields.extend(field_line)
173 return fields
174
175 def get_admin_readonly_fields(self, response):
176 """
177 Return the readonly fields for the response's AdminForm.
178 """
179 return [f for f in self.get_admin_form_fields(response) if f.is_readonly]
180
181 def get_admin_readonly_field(self, response, field_name):
182 """
183 Return the readonly field for the given field_name.
184 """
185 admin_readonly_fields = self.get_admin_readonly_fields(response)
186 for field in admin_readonly_fields:
187 if field.field["name"] == field_name:
188 return field
189
190
191 @override_settings(ROOT_URLCONF="admin_views.urls", USE_I18N=True, LANGUAGE_CODE="en")
192 class AdminViewBasicTestCase(TestCase):
193 @classmethod
194 def setUpTestData(cls):
195 cls.superuser = User.objects.create_superuser(
196 username="super", password="secret", email="[email protected]"
197 )
198 cls.s1 = Section.objects.create(name="Test section")
199 cls.a1 = Article.objects.create(
200 content="<p>Middle content</p>",
201 date=datetime.datetime(2008, 3, 18, 11, 54, 58),
202 section=cls.s1,
203 title="Article 1",
204 )
205 cls.a2 = Article.objects.create(
206 content="<p>Oldest content</p>",
207 date=datetime.datetime(2000, 3, 18, 11, 54, 58),
208 section=cls.s1,
209 title="Article 2",
210 )
211 cls.a3 = Article.objects.create(
212 content="<p>Newest content</p>",
213 date=datetime.datetime(2009, 3, 18, 11, 54, 58),
214 section=cls.s1,
215 )
216 cls.p1 = PrePopulatedPost.objects.create(
217 title="A Long Title", published=True, slug="a-long-title"
218 )
219 cls.color1 = Color.objects.create(value="Red", warm=True)
220 cls.color2 = Color.objects.create(value="Orange", warm=True)
221 cls.color3 = Color.objects.create(value="Blue", warm=False)
222 cls.color4 = Color.objects.create(value="Green", warm=False)
223 cls.fab1 = Fabric.objects.create(surface="x")
224 cls.fab2 = Fabric.objects.create(surface="y")
225 cls.fab3 = Fabric.objects.create(surface="plain")
226 cls.b1 = Book.objects.create(name="Book 1")
227 cls.b2 = Book.objects.create(name="Book 2")
228 cls.pro1 = Promo.objects.create(name="Promo 1", book=cls.b1)
229 cls.pro1 = Promo.objects.create(name="Promo 2", book=cls.b2)
230 cls.chap1 = Chapter.objects.create(
231 title="Chapter 1", content="[ insert contents here ]", book=cls.b1
232 )
233 cls.chap2 = Chapter.objects.create(
234 title="Chapter 2", content="[ insert contents here ]", book=cls.b1
235 )
236 cls.chap3 = Chapter.objects.create(
237 title="Chapter 1", content="[ insert contents here ]", book=cls.b2
238 )
239 cls.chap4 = Chapter.objects.create(
240 title="Chapter 2", content="[ insert contents here ]", book=cls.b2
241 )
242 cls.cx1 = ChapterXtra1.objects.create(chap=cls.chap1, xtra="ChapterXtra1 1")
243 cls.cx2 = ChapterXtra1.objects.create(chap=cls.chap3, xtra="ChapterXtra1 2")
244 Actor.objects.create(name="Palin", age=27)
245
246 # Post data for edit inline
247 cls.inline_post_data = {
248 "name": "Test section",
249 # inline data
250 "article_set-TOTAL_FORMS": "6",
251 "article_set-INITIAL_FORMS": "3",
252 "article_set-MAX_NUM_FORMS": "0",
253 "article_set-0-id": cls.a1.pk,
254 # there is no title in database, give one here or formset will fail.
255 "article_set-0-title": "Norske bostaver æøå skaper problemer",
256 "article_set-0-content": "&lt;p&gt;Middle content&lt;/p&gt;",
257 "article_set-0-date_0": "2008-03-18",
258 "article_set-0-date_1": "11:54:58",
259 "article_set-0-section": cls.s1.pk,
260 "article_set-1-id": cls.a2.pk,
261 "article_set-1-title": "Need a title.",
262 "article_set-1-content": "&lt;p&gt;Oldest content&lt;/p&gt;",
263 "article_set-1-date_0": "2000-03-18",
264 "article_set-1-date_1": "11:54:58",
265 "article_set-2-id": cls.a3.pk,
266 "article_set-2-title": "Need a title.",
267 "article_set-2-content": "&lt;p&gt;Newest content&lt;/p&gt;",
268 "article_set-2-date_0": "2009-03-18",
269 "article_set-2-date_1": "11:54:58",
270 "article_set-3-id": "",
271 "article_set-3-title": "",
272 "article_set-3-content": "",
273 "article_set-3-date_0": "",
274 "article_set-3-date_1": "",
275 "article_set-4-id": "",
276 "article_set-4-title": "",
277 "article_set-4-content": "",
278 "article_set-4-date_0": "",
279 "article_set-4-date_1": "",
280 "article_set-5-id": "",
281 "article_set-5-title": "",
282 "article_set-5-content": "",
283 "article_set-5-date_0": "",
284 "article_set-5-date_1": "",
285 }
286
287 def setUp(self):
288 self.client.force_login(self.superuser)
289
290 def assertContentBefore(self, response, text1, text2, failing_msg=None):
291 """
292 Testing utility asserting that text1 appears before text2 in response
293 content.
294 """
295 self.assertEqual(response.status_code, 200)
296 self.assertLess(
297 response.content.index(text1.encode()),
298 response.content.index(text2.encode()),
299 (failing_msg or "") + "\nResponse:\n" + response.text,
300 )
301
302
303 class AdminViewBasicTest(AdminViewBasicTestCase):
304 def test_trailing_slash_required(self):
305 """
306 If you leave off the trailing slash, app should redirect and add it.
307 """
308 add_url = reverse("admin:admin_views_article_add")
309 response = self.client.get(add_url[:-1])
310 self.assertRedirects(response, add_url, status_code=301)
311
312 def test_basic_add_GET(self):
313 """
314 A smoke test to ensure GET on the add_view works.
315 """
316 response = self.client.get(reverse("admin:admin_views_section_add"))
317 self.assertIsInstance(response, TemplateResponse)
318 self.assertEqual(response.status_code, 200)
319
320 def test_add_with_GET_args(self):
321 response = self.client.get(
322 reverse("admin:admin_views_section_add"), {"name": "My Section"}
323 )
324 self.assertContains(
325 response,
326 'value="My Section"',
327 msg_prefix="Couldn't find an input with the right value in the response",
328 )
329
330 def test_add_query_string_persists(self):
331 save_options = [
332 {"_addanother": "1"}, # "Save and add another".
333 {"_continue": "1"}, # "Save and continue editing".
334 {"_saveasnew": "1"}, # "Save as new".
335 ]
336 other_options = [
337 "",
338 "_changelist_filters=is_staff__exact%3D0",
339 f"{IS_POPUP_VAR}=1",
340 f"{TO_FIELD_VAR}=id",
341 ]
342 url = reverse("admin:auth_user_add")
343 for i, save_option in enumerate(save_options):
344 for j, other_option in enumerate(other_options):
345 with self.subTest(save_option=save_option, other_option=other_option):
346 qsl = "username=newuser"
347 if other_option:
348 qsl = f"{qsl}&{other_option}"
349 response = self.client.post(
350 f"{url}?{qsl}",
351 {
352 "username": f"newuser{i}{j}",
353 "password1": "newpassword",
354 "password2": "newpassword",
355 **save_option,
356 },
357 )
358 parsed_url = urlsplit(response.url)
359 self.assertEqual(parsed_url.query, qsl)
360
361 def test_change_query_string_persists(self):
362 save_options = [
363 {"_addanother": "1"}, # "Save and add another".
364 {"_continue": "1"}, # "Save and continue editing".
365 ]
366 other_options = [
367 "",
368 "_changelist_filters=warm%3D1",
369 f"{IS_POPUP_VAR}=1",
370 f"{TO_FIELD_VAR}=id",
371 ]
372 url = reverse("admin:admin_views_color_change", args=(self.color1.pk,))
373 for save_option in save_options:
374 for other_option in other_options:
375 with self.subTest(save_option=save_option, other_option=other_option):
376 qsl = "value=blue"
377 if other_option:
378 qsl = f"{qsl}&{other_option}"
379 response = self.client.post(
380 f"{url}?{qsl}",
381 {
382 "value": "gold",
383 "warm": True,
384 **save_option,
385 },
386 )
387 parsed_url = urlsplit(response.url)
388 self.assertEqual(parsed_url.query, qsl)
389
390 def test_basic_edit_GET(self):
391 """
392 A smoke test to ensure GET on the change_view works.
393 """
394 response = self.client.get(
395 reverse("admin:admin_views_section_change", args=(self.s1.pk,))
396 )
397 self.assertIsInstance(response, TemplateResponse)
398 self.assertEqual(response.status_code, 200)
399
400 def test_basic_edit_GET_string_PK(self):
401 """
402 GET on the change_view (when passing a string as the PK argument for a
403 model with an integer PK field) redirects to the index page with a
404 message saying the object doesn't exist.
405 """
406 response = self.client.get(
407 reverse("admin:admin_views_section_change", args=(quote("abc/<b>"),)),
408 follow=True,
409 )
410 self.assertRedirects(response, reverse("admin:index"))
411 self.assertEqual(
412 [m.message for m in response.context["messages"]],
413 ["section with ID “abc/<b>” doesn’t exist. Perhaps it was deleted?"],
414 )
415
416 def test_basic_edit_GET_old_url_redirect(self):
417 """
418 The change URL changed in Django 1.9, but the old one still redirects.
419 """
420 response = self.client.get(
421 reverse("admin:admin_views_section_change", args=(self.s1.pk,)).replace(
422 "change/", ""
423 )
424 )
425 self.assertRedirects(
426 response, reverse("admin:admin_views_section_change", args=(self.s1.pk,))
427 )
428
429 def test_basic_inheritance_GET_string_PK(self):
430 """
431 GET on the change_view (for inherited models) redirects to the index
432 page with a message saying the object doesn't exist.
433 """
434 response = self.client.get(
435 reverse("admin:admin_views_supervillain_change", args=("abc",)), follow=True
436 )
437 self.assertRedirects(response, reverse("admin:index"))
438 self.assertEqual(
439 [m.message for m in response.context["messages"]],
440 ["super villain with ID “abc” doesn’t exist. Perhaps it was deleted?"],
441 )
442
443 def test_basic_add_POST(self):
444 """
445 A smoke test to ensure POST on add_view works.
446 """
447 post_data = {
448 "name": "Another Section",
449 # inline data
450 "article_set-TOTAL_FORMS": "3",
451 "article_set-INITIAL_FORMS": "0",
452 "article_set-MAX_NUM_FORMS": "0",
453 }
454 response = self.client.post(reverse("admin:admin_views_section_add"), post_data)
455 self.assertEqual(response.status_code, 302) # redirect somewhere
456
457 def test_popup_add_POST(self):
458 """HTTP response from a popup is properly escaped."""
459 post_data = {
460 IS_POPUP_VAR: "1",
461 "title": "title with a new\nline",
462 "content": "some content",
463 "date_0": "2010-09-10",
464 "date_1": "14:55:39",
465 }
466 response = self.client.post(reverse("admin:admin_views_article_add"), post_data)
467 self.assertContains(response, "title with a new\\nline")
468
469 def test_basic_edit_POST(self):
470 """
471 A smoke test to ensure POST on edit_view works.
472 """
473 url = reverse("admin:admin_views_section_change", args=(self.s1.pk,))
474 response = self.client.post(url, self.inline_post_data)
475 self.assertEqual(response.status_code, 302) # redirect somewhere
476
477 def test_edit_save_as(self):
478 """
479 Test "save as".
480 """
481 post_data = self.inline_post_data.copy()
482 post_data.update(
483 {
484 "_saveasnew": "Save+as+new",
485 "article_set-1-section": "1",
486 "article_set-2-section": "1",
487 "article_set-3-section": "1",
488 "article_set-4-section": "1",
489 "article_set-5-section": "1",
490 }
491 )
492 response = self.client.post(
493 reverse("admin:admin_views_section_change", args=(self.s1.pk,)), post_data
494 )
495 self.assertEqual(response.status_code, 302) # redirect somewhere
496
497 def test_edit_save_as_delete_inline(self):
498 """
499 Should be able to "Save as new" while also deleting an inline.
500 """
501 post_data = self.inline_post_data.copy()
502 post_data.update(
503 {
504 "_saveasnew": "Save+as+new",
505 "article_set-1-section": "1",
506 "article_set-2-section": "1",
507 "article_set-2-DELETE": "1",
508 "article_set-3-section": "1",
509 }
510 )
511 response = self.client.post(
512 reverse("admin:admin_views_section_change", args=(self.s1.pk,)), post_data
513 )
514 self.assertEqual(response.status_code, 302)
515 # started with 3 articles, one was deleted.
516 self.assertEqual(Section.objects.latest("id").article_set.count(), 2)
517
518 def test_change_list_column_field_classes(self):
519 response = self.client.get(reverse("admin:admin_views_article_changelist"))
520 # callables display the callable name.
521 self.assertContains(response, "column-callable_year")
522 self.assertContains(response, "field-callable_year")
523 # lambdas display as "lambda" + index that they appear in list_display.
524 self.assertContains(response, "column-lambda8")
525 self.assertContains(response, "field-lambda8")
526
527 def test_change_list_sorting_callable(self):
528 """
529 Ensure we can sort on a list_display field that is a callable
530 (column 2 is callable_year in ArticleAdmin)
531 """
532 response = self.client.get(
533 reverse("admin:admin_views_article_changelist"), {"o": 2}
534 )
535 self.assertContentBefore(
536 response,
537 "Oldest content",
538 "Middle content",
539 "Results of sorting on callable are out of order.",
540 )
541 self.assertContentBefore(
542 response,
543 "Middle content",
544 "Newest content",
545 "Results of sorting on callable are out of order.",
546 )
547
548 def test_change_list_boolean_display_property(self):
549 response = self.client.get(reverse("admin:admin_views_article_changelist"))
550 self.assertContains(
551 response,
552 '<td class="field-model_property_is_from_past">'
553 '<img src="/static/admin/img/icon-yes.svg" alt="True"></td>',
554 )
555
556 def test_change_list_sorting_property(self):
557 """
558 Sort on a list_display field that is a property (column 10 is
559 a property in Article model).
560 """
561 response = self.client.get(
562 reverse("admin:admin_views_article_changelist"), {"o": 10}
563 )
564 self.assertContentBefore(
565 response,
566 "Oldest content",
567 "Middle content",
568 "Results of sorting on property are out of order.",
569 )
570 self.assertContentBefore(
571 response,
572 "Middle content",
573 "Newest content",
574 "Results of sorting on property are out of order.",
575 )
576
577 def test_change_list_sorting_callable_query_expression(self):
578 """Query expressions may be used for admin_order_field."""
579 tests = [
580 ("order_by_expression", 9),
581 ("order_by_f_expression", 12),
582 ("order_by_orderby_expression", 13),
583 ]
584 for admin_order_field, index in tests:
585 with self.subTest(admin_order_field):
586 response = self.client.get(
587 reverse("admin:admin_views_article_changelist"),
588 {"o": index},
589 )
590 self.assertContentBefore(
591 response,
592 "Oldest content",
593 "Middle content",
594 "Results of sorting on callable are out of order.",
595 )
596 self.assertContentBefore(
597 response,
598 "Middle content",
599 "Newest content",
600 "Results of sorting on callable are out of order.",
601 )
602
603 def test_change_list_sorting_callable_query_expression_reverse(self):
604 tests = [
605 ("order_by_expression", -9),
606 ("order_by_f_expression", -12),
607 ("order_by_orderby_expression", -13),
608 ]
609 for admin_order_field, index in tests:
610 with self.subTest(admin_order_field):
611 response = self.client.get(
612 reverse("admin:admin_views_article_changelist"),
613 {"o": index},
614 )
615 self.assertContentBefore(
616 response,
617 "Middle content",
618 "Oldest content",
619 "Results of sorting on callable are out of order.",
620 )
621 self.assertContentBefore(
622 response,
623 "Newest content",
624 "Middle content",
625 "Results of sorting on callable are out of order.",
626 )
627
628 def test_change_list_sorting_model(self):
629 """
630 Ensure we can sort on a list_display field that is a Model method
631 (column 3 is 'model_year' in ArticleAdmin)
632 """
633 response = self.client.get(
634 reverse("admin:admin_views_article_changelist"), {"o": "-3"}
635 )
636 self.assertContentBefore(
637 response,
638 "Newest content",
639 "Middle content",
640 "Results of sorting on Model method are out of order.",
641 )
642 self.assertContentBefore(
643 response,
644 "Middle content",
645 "Oldest content",
646 "Results of sorting on Model method are out of order.",
647 )
648
649 def test_change_list_sorting_model_admin(self):
650 """
651 Ensure we can sort on a list_display field that is a ModelAdmin method
652 (column 4 is 'modeladmin_year' in ArticleAdmin)
653 """
654 response = self.client.get(
655 reverse("admin:admin_views_article_changelist"), {"o": "4"}
656 )
657 self.assertContentBefore(
658 response,
659 "Oldest content",
660 "Middle content",
661 "Results of sorting on ModelAdmin method are out of order.",
662 )
663 self.assertContentBefore(
664 response,
665 "Middle content",
666 "Newest content",
667 "Results of sorting on ModelAdmin method are out of order.",
668 )
669
670 def test_change_list_sorting_model_admin_reverse(self):
671 """
672 Ensure we can sort on a list_display field that is a ModelAdmin
673 method in reverse order (i.e. admin_order_field uses the '-' prefix)
674 (column 6 is 'model_year_reverse' in ArticleAdmin)
675 """
676 td = '<td class="field-model_property_year">%s</td>'
677 td_2000, td_2008, td_2009 = td % 2000, td % 2008, td % 2009
678 response = self.client.get(
679 reverse("admin:admin_views_article_changelist"), {"o": "6"}
680 )
681 self.assertContentBefore(
682 response,
683 td_2009,
684 td_2008,
685 "Results of sorting on ModelAdmin method are out of order.",
686 )
687 self.assertContentBefore(
688 response,
689 td_2008,
690 td_2000,
691 "Results of sorting on ModelAdmin method are out of order.",
692 )
693 # Let's make sure the ordering is right and that we don't get a
694 # FieldError when we change to descending order
695 response = self.client.get(
696 reverse("admin:admin_views_article_changelist"), {"o": "-6"}
697 )
698 self.assertContentBefore(
699 response,
700 td_2000,
701 td_2008,
702 "Results of sorting on ModelAdmin method are out of order.",
703 )
704 self.assertContentBefore(
705 response,
706 td_2008,
707 td_2009,
708 "Results of sorting on ModelAdmin method are out of order.",
709 )
710
711 def test_change_list_sorting_multiple(self):
712 p1 = Person.objects.create(name="Chris", gender=1, alive=True)
713 p2 = Person.objects.create(name="Chris", gender=2, alive=True)
714 p3 = Person.objects.create(name="Bob", gender=1, alive=True)
715 link1 = reverse("admin:admin_views_person_change", args=(p1.pk,))
716 link2 = reverse("admin:admin_views_person_change", args=(p2.pk,))
717 link3 = reverse("admin:admin_views_person_change", args=(p3.pk,))
718
719 # Sort by name, gender
720 response = self.client.get(
721 reverse("admin:admin_views_person_changelist"), {"o": "1.2"}
722 )
723 self.assertContentBefore(response, link3, link1)
724 self.assertContentBefore(response, link1, link2)
725
726 # Sort by gender descending, name
727 response = self.client.get(
728 reverse("admin:admin_views_person_changelist"), {"o": "-2.1"}
729 )
730 self.assertContentBefore(response, link2, link3)
731 self.assertContentBefore(response, link3, link1)
732
733 def test_change_list_sorting_preserve_queryset_ordering(self):
734 """
735 If no ordering is defined in `ModelAdmin.ordering` or in the query
736 string, then the underlying order of the queryset should not be
737 changed, even if it is defined in `Modeladmin.get_queryset()`.
738 Refs #11868, #7309.
739 """
740 p1 = Person.objects.create(name="Amy", gender=1, alive=True, age=80)
741 p2 = Person.objects.create(name="Bob", gender=1, alive=True, age=70)
742 p3 = Person.objects.create(name="Chris", gender=2, alive=False, age=60)
743 link1 = reverse("admin:admin_views_person_change", args=(p1.pk,))
744 link2 = reverse("admin:admin_views_person_change", args=(p2.pk,))
745 link3 = reverse("admin:admin_views_person_change", args=(p3.pk,))
746
747 response = self.client.get(reverse("admin:admin_views_person_changelist"), {})
748 self.assertContentBefore(response, link3, link2)
749 self.assertContentBefore(response, link2, link1)
750
751 def test_change_list_sorting_model_meta(self):
752 # Test ordering on Model Meta is respected
753
754 l1 = Language.objects.create(iso="ur", name="Urdu")
755 l2 = Language.objects.create(iso="ar", name="Arabic")
756 link1 = reverse("admin:admin_views_language_change", args=(quote(l1.pk),))
757 link2 = reverse("admin:admin_views_language_change", args=(quote(l2.pk),))
758
759 response = self.client.get(reverse("admin:admin_views_language_changelist"), {})
760 self.assertContentBefore(response, link2, link1)
761
762 # Test we can override with query string
763 response = self.client.get(
764 reverse("admin:admin_views_language_changelist"), {"o": "-1"}
765 )
766 self.assertContentBefore(response, link1, link2)
767
768 def test_change_list_sorting_override_model_admin(self):
769 # Test ordering on Model Admin is respected, and overrides Model Meta
770 dt = datetime.datetime.now()
771 p1 = Podcast.objects.create(name="A", release_date=dt)
772 p2 = Podcast.objects.create(name="B", release_date=dt - datetime.timedelta(10))
773 link1 = reverse("admin:admin_views_podcast_change", args=(p1.pk,))
774 link2 = reverse("admin:admin_views_podcast_change", args=(p2.pk,))
775
776 response = self.client.get(reverse("admin:admin_views_podcast_changelist"), {})
777 self.assertContentBefore(response, link1, link2)
778
779 def test_multiple_sort_same_field(self):
780 # The changelist displays the correct columns if two columns correspond
781 # to the same ordering field.
782 dt = datetime.datetime.now()
783 p1 = Podcast.objects.create(name="A", release_date=dt)
784 p2 = Podcast.objects.create(name="B", release_date=dt - datetime.timedelta(10))
785 link1 = reverse("admin:admin_views_podcast_change", args=(quote(p1.pk),))
786 link2 = reverse("admin:admin_views_podcast_change", args=(quote(p2.pk),))
787
788 response = self.client.get(reverse("admin:admin_views_podcast_changelist"), {})
789 self.assertContentBefore(response, link1, link2)
790
791 p1 = ComplexSortedPerson.objects.create(name="Bob", age=10)
792 p2 = ComplexSortedPerson.objects.create(name="Amy", age=20)
793 link1 = reverse("admin:admin_views_complexsortedperson_change", args=(p1.pk,))
794 link2 = reverse("admin:admin_views_complexsortedperson_change", args=(p2.pk,))
795
796 response = self.client.get(
797 reverse("admin:admin_views_complexsortedperson_changelist"), {}
798 )
799 # Should have 5 columns (including action checkbox col)
800 result_list_table_re = re.compile('<table id="result_list">(.*?)</thead>')
801 result_list_table_head = result_list_table_re.search(str(response.content))[0]
802 self.assertEqual(result_list_table_head.count('<th scope="col"'), 5)
803
804 self.assertContains(response, "Name")
805 self.assertContains(response, "Colored name")
806
807 # Check order
808 self.assertContentBefore(response, "Name", "Colored name")
809
810 # Check sorting - should be by name
811 self.assertContentBefore(response, link2, link1)
812
813 def test_sort_indicators_admin_order(self):
814 """
815 The admin shows default sort indicators for all kinds of 'ordering'
816 fields: field names, method on the model admin and model itself, and
817 other callables. See #17252.
818 """
819 models = [
820 (AdminOrderedField, "adminorderedfield"),
821 (AdminOrderedModelMethod, "adminorderedmodelmethod"),
822 (AdminOrderedAdminMethod, "adminorderedadminmethod"),
823 (AdminOrderedCallable, "adminorderedcallable"),
824 ]
825 for model, url in models:
826 model.objects.create(stuff="The Last Item", order=3)
827 model.objects.create(stuff="The First Item", order=1)
828 model.objects.create(stuff="The Middle Item", order=2)
829 response = self.client.get(
830 reverse("admin:admin_views_%s_changelist" % url), {}
831 )
832 # Should have 3 columns including action checkbox col.
833 result_list_table_re = re.compile('<table id="result_list">(.*?)</thead>')
834 result_list_table_head = result_list_table_re.search(str(response.content))[
835 0
836 ]
837 self.assertEqual(result_list_table_head.count('<th scope="col"'), 3)
838 # Check if the correct column was selected. 2 is the index of the
839 # 'order' column in the model admin's 'list_display' with 0 being
840 # the implicit 'action_checkbox' and 1 being the column 'stuff'.
841 self.assertEqual(
842 response.context["cl"].get_ordering_field_columns(), {2: "asc"}
843 )
844 # Check order of records.
845 self.assertContentBefore(response, "The First Item", "The Middle Item")
846 self.assertContentBefore(response, "The Middle Item", "The Last Item")
847
848 def test_has_related_field_in_list_display_fk(self):
849 """Joins shouldn't be performed for <FK>_id fields in list display."""
850 state = State.objects.create(name="Karnataka")
851 City.objects.create(state=state, name="Bangalore")
852 response = self.client.get(reverse("admin:admin_views_city_changelist"), {})
853
854 response.context["cl"].list_display = ["id", "name", "state"]
855 self.assertIs(response.context["cl"].has_related_field_in_list_display(), True)
856
857 response.context["cl"].list_display = ["id", "name", "state_id"]
858 self.assertIs(response.context["cl"].has_related_field_in_list_display(), False)
859
860 def test_has_related_field_in_list_display_o2o(self):
861 """Joins shouldn't be performed for <O2O>_id fields in list display."""
862 media = Media.objects.create(name="Foo")
863 Vodcast.objects.create(media=media)
864 response = self.client.get(reverse("admin:admin_views_vodcast_changelist"), {})
865
866 response.context["cl"].list_display = ["media"]
867 self.assertIs(response.context["cl"].has_related_field_in_list_display(), True)
868
869 response.context["cl"].list_display = ["media_id"]
870 self.assertIs(response.context["cl"].has_related_field_in_list_display(), False)
871
872 def test_limited_filter(self):
873 """
874 Admin changelist filters do not contain objects excluded via
875 limit_choices_to.
876 """
877 response = self.client.get(reverse("admin:admin_views_thing_changelist"))
878 self.assertContains(
879 response,
880 '<nav id="changelist-filter" aria-labelledby="changelist-filter-header">',
881 msg_prefix="Expected filter not found in changelist view",
882 )
883 self.assertNotContains(
884 response,
885 '<a href="?color__id__exact=3">Blue</a>',
886 msg_prefix="Changelist filter not correctly limited by limit_choices_to",
887 )
888
889 def test_change_list_facet_toggle(self):
890 # Toggle is visible when show_facet is the default of
891 # admin.ShowFacets.ALLOW.
892 admin_url = reverse("admin:admin_views_album_changelist")
893 response = self.client.get(admin_url)
894 self.assertContains(
895 response,
896 '<a href="?_facets=True" class="viewlink">Show counts</a>',
897 msg_prefix="Expected facet filter toggle not found in changelist view",
898 )
899 response = self.client.get(f"{admin_url}?_facets=True")
900 self.assertContains(
901 response,
902 '<a href="?" class="hidelink">Hide counts</a>',
903 msg_prefix="Expected facet filter toggle not found in changelist view",
904 )
905 # Toggle is not visible when show_facet is admin.ShowFacets.ALWAYS.
906 response = self.client.get(reverse("admin:admin_views_workhour_changelist"))
907 self.assertNotContains(
908 response,
909 "Show counts",
910 msg_prefix="Expected not to find facet filter toggle in changelist view",
911 )
912 self.assertNotContains(
913 response,
914 "Hide counts",
915 msg_prefix="Expected not to find facet filter toggle in changelist view",
916 )
917 # Toggle is not visible when show_facet is admin.ShowFacets.NEVER.
918 response = self.client.get(reverse("admin:admin_views_fooddelivery_changelist"))
919 self.assertNotContains(
920 response,
921 "Show counts",
922 msg_prefix="Expected not to find facet filter toggle in changelist view",
923 )
924 self.assertNotContains(
925 response,
926 "Hide counts",
927 msg_prefix="Expected not to find facet filter toggle in changelist view",
928 )
929
930 def test_relation_spanning_filters(self):
931 changelist_url = reverse("admin:admin_views_chapterxtra1_changelist")
932 response = self.client.get(changelist_url)
933 self.assertContains(
934 response,
935 '<nav id="changelist-filter" aria-labelledby="changelist-filter-header">',
936 )
937 filters = {
938 "chap__id__exact": {
939 "values": [c.id for c in Chapter.objects.all()],
940 "test": lambda obj, value: obj.chap.id == value,
941 },
942 "chap__title": {
943 "values": [c.title for c in Chapter.objects.all()],
944 "test": lambda obj, value: obj.chap.title == value,
945 },
946 "chap__book__id__exact": {
947 "values": [b.id for b in Book.objects.all()],
948 "test": lambda obj, value: obj.chap.book.id == value,
949 },
950 "chap__book__name": {
951 "values": [b.name for b in Book.objects.all()],
952 "test": lambda obj, value: obj.chap.book.name == value,
953 },
954 "chap__book__promo__id__exact": {
955 "values": [p.id for p in Promo.objects.all()],
956 "test": lambda obj, value: obj.chap.book.promo_set.filter(
957 id=value
958 ).exists(),
959 },
960 "chap__book__promo__name": {
961 "values": [p.name for p in Promo.objects.all()],
962 "test": lambda obj, value: obj.chap.book.promo_set.filter(
963 name=value
964 ).exists(),
965 },
966 # A forward relation (book) after a reverse relation (promo).
967 "guest_author__promo__book__id__exact": {
968 "values": [p.id for p in Book.objects.all()],
969 "test": lambda obj, value: obj.guest_author.promo_set.filter(
970 book=value
971 ).exists(),
972 },
973 }
974 for filter_path, params in filters.items():
975 for value in params["values"]:
976 query_string = urlencode({filter_path: value})
977 # ensure filter link exists
978 self.assertContains(response, '<a href="?%s"' % query_string)
979 # ensure link works
980 filtered_response = self.client.get(
981 "%s?%s" % (changelist_url, query_string)
982 )
983 self.assertEqual(filtered_response.status_code, 200)
984 # ensure changelist contains only valid objects
985 for obj in filtered_response.context["cl"].queryset.all():
986 self.assertTrue(params["test"](obj, value))
987
988 def test_incorrect_lookup_parameters(self):
989 """Ensure incorrect lookup parameters are handled gracefully."""
990 changelist_url = reverse("admin:admin_views_thing_changelist")
991 response = self.client.get(changelist_url, {"notarealfield": "5"})
992 self.assertRedirects(response, "%s?e=1" % changelist_url)
993
994 # Spanning relationships through a nonexistent related object (Refs #16716)
995 response = self.client.get(changelist_url, {"notarealfield__whatever": "5"})
996 self.assertRedirects(response, "%s?e=1" % changelist_url)
997
998 response = self.client.get(
999 changelist_url, {"color__id__exact": "StringNotInteger!"}
1000 )
1001 self.assertRedirects(response, "%s?e=1" % changelist_url)
1002
1003 # Regression test for #18530
1004 response = self.client.get(changelist_url, {"pub_date__gte": "foo"})
1005 self.assertRedirects(response, "%s?e=1" % changelist_url)
1006
1007 def test_isnull_lookups(self):
1008 """Ensure is_null is handled correctly."""
1009 Article.objects.create(
1010 title="I Could Go Anywhere",
1011 content="Versatile",
1012 date=datetime.datetime.now(),
1013 )
1014 changelist_url = reverse("admin:admin_views_article_changelist")
1015 response = self.client.get(changelist_url)
1016 self.assertContains(response, "4 articles")
1017 response = self.client.get(changelist_url, {"section__isnull": "false"})
1018 self.assertContains(response, "3 articles")
1019 response = self.client.get(changelist_url, {"section__isnull": "0"})
1020 self.assertContains(response, "3 articles")
1021 response = self.client.get(changelist_url, {"section__isnull": "true"})
1022 self.assertContains(response, "1 article")
1023 response = self.client.get(changelist_url, {"section__isnull": "1"})
1024 self.assertContains(response, "1 article")
1025
1026 def test_logout_and_password_change_URLs(self):
1027 response = self.client.get(reverse("admin:admin_views_article_changelist"))
1028 self.assertContains(
1029 response,
1030 '<form id="logout-form" method="post" action="%s">'
1031 % reverse("admin:logout"),
1032 )
1033 self.assertContains(
1034 response, '<a href="%s">' % reverse("admin:password_change")
1035 )
1036
1037 def test_named_group_field_choices_change_list(self):
1038 """
1039 Ensures the admin changelist shows correct values in the relevant column
1040 for rows corresponding to instances of a model in which a named group
1041 has been used in the choices option of a field.
1042 """
1043 link1 = reverse("admin:admin_views_fabric_change", args=(self.fab1.pk,))
1044 link2 = reverse("admin:admin_views_fabric_change", args=(self.fab2.pk,))
1045 response = self.client.get(reverse("admin:admin_views_fabric_changelist"))
1046 fail_msg = (
1047 "Changelist table isn't showing the right human-readable values "
1048 "set by a model field 'choices' option named group."
1049 )
1050 self.assertContains(
1051 response,
1052 '<a href="%s">Horizontal</a>' % link1,
1053 msg_prefix=fail_msg,
1054 html=True,
1055 )
1056 self.assertContains(
1057 response,
1058 '<a href="%s">Vertical</a>' % link2,
1059 msg_prefix=fail_msg,
1060 html=True,
1061 )
1062
1063 def test_named_group_field_choices_filter(self):
1064 """
1065 Ensures the filter UI shows correctly when at least one named group has
1066 been used in the choices option of a model field.
1067 """
1068 response = self.client.get(reverse("admin:admin_views_fabric_changelist"))
1069 fail_msg = (
1070 "Changelist filter isn't showing options contained inside a model "
1071 "field 'choices' option named group."
1072 )
1073 self.assertContains(
1074 response,
1075 '<nav id="changelist-filter" aria-labelledby="changelist-filter-header">',
1076 )
1077 self.assertContains(
1078 response,
1079 '<a href="?surface__exact=x">Horizontal</a>',
1080 msg_prefix=fail_msg,
1081 html=True,
1082 )
1083 self.assertContains(
1084 response,
1085 '<a href="?surface__exact=y">Vertical</a>',
1086 msg_prefix=fail_msg,
1087 html=True,
1088 )
1089
1090 def test_change_list_null_boolean_display(self):
1091 Post.objects.create(public=None)
1092 response = self.client.get(reverse("admin:admin_views_post_changelist"))
1093 self.assertContains(response, "icon-unknown.svg")
1094
1095 def test_display_decorator_with_boolean_and_empty_value(self):
1096 msg = (
1097 "The boolean and empty_value arguments to the @display decorator "
1098 "are mutually exclusive."
1099 )
1100 with self.assertRaisesMessage(ValueError, msg):
1101
1102 class BookAdmin(admin.ModelAdmin):
1103 @admin.display(boolean=True, empty_value="(Missing)")
1104 def is_published(self, obj):
1105 return obj.publish_date is not None
1106
1107 def test_i18n_language_non_english_default(self):
1108 """
1109 Check if the JavaScript i18n view returns an empty language catalog
1110 if the default language is non-English but the selected language
1111 is English. See #13388 and #3594 for more details.
1112 """
1113 with self.settings(LANGUAGE_CODE="fr"), translation.override("en-us"):
1114 response = self.client.get(reverse("admin:jsi18n"))
1115 self.assertNotContains(response, "Choisir une heure")
1116
1117 def test_i18n_language_non_english_fallback(self):
1118 """
1119 Makes sure that the fallback language is still working properly
1120 in cases where the selected language cannot be found.
1121 """
1122 with self.settings(LANGUAGE_CODE="fr"), translation.override("none"):
1123 response = self.client.get(reverse("admin:jsi18n"))
1124 self.assertContains(response, "Choisir une heure")
1125
1126 def test_jsi18n_with_context(self):
1127 response = self.client.get(reverse("admin-extra-context:jsi18n"))
1128 self.assertEqual(response.status_code, 200)
1129
1130 def test_jsi18n_format_fallback(self):
1131 """
1132 The JavaScript i18n view doesn't return localized date/time formats
1133 when the selected language cannot be found.
1134 """
1135 with self.settings(LANGUAGE_CODE="ru"), translation.override("none"):
1136 response = self.client.get(reverse("admin:jsi18n"))
1137 self.assertNotContains(response, "%d.%m.%Y %H:%M:%S")
1138 self.assertContains(response, "%Y-%m-%d %H:%M:%S")
1139
1140 def test_disallowed_filtering(self):
1141 with self.assertLogs("django.security.DisallowedModelAdminLookup", "ERROR"):
1142 response = self.client.get(
1143 "%s?owner__email__startswith=fuzzy"
1144 % reverse("admin:admin_views_album_changelist")
1145 )
1146 self.assertEqual(response.status_code, 400)
1147
1148 # Filters are allowed if explicitly included in list_filter
1149 response = self.client.get(
1150 "%s?color__value__startswith=red"
1151 % reverse("admin:admin_views_thing_changelist")
1152 )
1153 self.assertEqual(response.status_code, 200)
1154 response = self.client.get(
1155 "%s?color__value=red" % reverse("admin:admin_views_thing_changelist")
1156 )
1157 self.assertEqual(response.status_code, 200)
1158
1159 # Filters should be allowed if they involve a local field without the
1160 # need to allow them in list_filter or date_hierarchy.
1161 response = self.client.get(
1162 "%s?age__gt=30" % reverse("admin:admin_views_person_changelist")
1163 )
1164 self.assertEqual(response.status_code, 200)
1165
1166 e1 = Employee.objects.create(
1167 name="Anonymous", gender=1, age=22, alive=True, code="123"
1168 )
1169 e2 = Employee.objects.create(
1170 name="Visitor", gender=2, age=19, alive=True, code="124"
1171 )
1172 WorkHour.objects.create(datum=datetime.datetime.now(), employee=e1)
1173 WorkHour.objects.create(datum=datetime.datetime.now(), employee=e2)
1174 response = self.client.get(reverse("admin:admin_views_workhour_changelist"))
1175 self.assertContains(response, "employee__person_ptr__exact")
1176 response = self.client.get(
1177 "%s?employee__person_ptr__exact=%d"
1178 % (reverse("admin:admin_views_workhour_changelist"), e1.pk)
1179 )
1180 self.assertEqual(response.status_code, 200)
1181
1182 def test_disallowed_to_field(self):
1183 url = reverse("admin:admin_views_section_changelist")
1184 with self.assertLogs("django.security.DisallowedModelAdminToField", "ERROR"):
1185 response = self.client.get(url, {TO_FIELD_VAR: "missing_field"})
1186 self.assertEqual(response.status_code, 400)
1187
1188 # Specifying a field that is not referred by any other model registered
1189 # to this admin site should raise an exception.
1190 with self.assertLogs("django.security.DisallowedModelAdminToField", "ERROR"):
1191 response = self.client.get(
1192 reverse("admin:admin_views_section_changelist"), {TO_FIELD_VAR: "name"}
1193 )
1194 self.assertEqual(response.status_code, 400)
1195
1196 # Primary key should always be allowed, even if the referenced model
1197 # isn't registered.
1198 response = self.client.get(
1199 reverse("admin:admin_views_notreferenced_changelist"), {TO_FIELD_VAR: "id"}
1200 )
1201 self.assertEqual(response.status_code, 200)
1202
1203 # Specifying a field referenced by another model though a m2m should be
1204 # allowed.
1205 response = self.client.get(
1206 reverse("admin:admin_views_recipe_changelist"), {TO_FIELD_VAR: "rname"}
1207 )
1208 self.assertEqual(response.status_code, 200)
1209
1210 # Specifying a field referenced through a reverse m2m relationship
1211 # should be allowed.
1212 response = self.client.get(
1213 reverse("admin:admin_views_ingredient_changelist"), {TO_FIELD_VAR: "iname"}
1214 )
1215 self.assertEqual(response.status_code, 200)
1216
1217 # Specifying a field that is not referred by any other model directly
1218 # registered to this admin site but registered through inheritance
1219 # should be allowed.
1220 response = self.client.get(
1221 reverse("admin:admin_views_referencedbyparent_changelist"),
1222 {TO_FIELD_VAR: "name"},
1223 )
1224 self.assertEqual(response.status_code, 200)
1225
1226 # Specifying a field that is only referred to by a inline of a
1227 # registered model should be allowed.
1228 response = self.client.get(
1229 reverse("admin:admin_views_referencedbyinline_changelist"),
1230 {TO_FIELD_VAR: "name"},
1231 )
1232 self.assertEqual(response.status_code, 200)
1233
1234 # #25622 - Specifying a field of a model only referred by a generic
1235 # relation should raise DisallowedModelAdminToField.
1236 url = reverse("admin:admin_views_referencedbygenrel_changelist")
1237 with self.assertLogs("django.security.DisallowedModelAdminToField", "ERROR"):
1238 response = self.client.get(url, {TO_FIELD_VAR: "object_id"})
1239 self.assertEqual(response.status_code, 400)
1240
1241 # We also want to prevent the add, change, and delete views from
1242 # leaking a disallowed field value.
1243 with self.assertLogs("django.security.DisallowedModelAdminToField", "ERROR"):
1244 response = self.client.post(
1245 reverse("admin:admin_views_section_add"), {TO_FIELD_VAR: "name"}
1246 )
1247 self.assertEqual(response.status_code, 400)
1248
1249 section = Section.objects.create()
1250 url = reverse("admin:admin_views_section_change", args=(section.pk,))
1251 with self.assertLogs("django.security.DisallowedModelAdminToField", "ERROR"):
1252 response = self.client.post(url, {TO_FIELD_VAR: "name"})
1253 self.assertEqual(response.status_code, 400)
1254
1255 url = reverse("admin:admin_views_section_delete", args=(section.pk,))
1256 with self.assertLogs("django.security.DisallowedModelAdminToField", "ERROR"):
1257 response = self.client.post(url, {TO_FIELD_VAR: "name"})
1258 self.assertEqual(response.status_code, 400)
1259
1260 def test_allowed_filtering_15103(self):
1261 """
1262 Regressions test for ticket 15103 - filtering on fields defined in a
1263 ForeignKey 'limit_choices_to' should be allowed, otherwise raw_id_fields
1264 can break.
1265 """
1266 # Filters should be allowed if they are defined on a ForeignKey
1267 # pointing to this model.
1268 url = "%s?leader__name=Palin&leader__age=27" % reverse(
1269 "admin:admin_views_inquisition_changelist"
1270 )
1271 response = self.client.get(url)
1272 self.assertEqual(response.status_code, 200)
1273
1274 def test_popup_dismiss_related(self):
1275 """
1276 Regression test for ticket 20664 - ensure the pk is properly quoted.
1277 """
1278 actor = Actor.objects.create(name="Palin", age=27)
1279 response = self.client.get(
1280 "%s?%s" % (reverse("admin:admin_views_actor_changelist"), IS_POPUP_VAR)
1281 )
1282 self.assertContains(response, 'data-popup-opener="%s"' % actor.pk)
1283
1284 def test_hide_change_password(self):
1285 """
1286 Tests if the "change password" link in the admin is hidden if the User
1287 does not have a usable password set.
1288 (against 9bea85795705d015cdadc82c68b99196a8554f5c)
1289 """
1290 user = User.objects.get(username="super")
1291 user.set_unusable_password()
1292 user.save()
1293 self.client.force_login(user)
1294 response = self.client.get(reverse("admin:index"))
1295 self.assertNotContains(
1296 response,
1297 reverse("admin:password_change"),
1298 msg_prefix=(
1299 'The "change password" link should not be displayed if a user does not '
1300 "have a usable password."
1301 ),
1302 )
1303
1304 def test_change_view_with_show_delete_extra_context(self):
1305 """
1306 The 'show_delete' context variable in the admin's change view controls
1307 the display of the delete button.
1308 """
1309 instance = UndeletableObject.objects.create(name="foo")
1310 response = self.client.get(
1311 reverse("admin:admin_views_undeletableobject_change", args=(instance.pk,))
1312 )
1313 self.assertNotContains(response, "deletelink")
1314
1315 def test_change_view_logs_m2m_field_changes(self):
1316 """Changes to ManyToManyFields are included in the object's history."""
1317 pizza = ReadablePizza.objects.create(name="Cheese")
1318 cheese = Topping.objects.create(name="cheese")
1319 post_data = {"name": pizza.name, "toppings": [cheese.pk]}
1320 response = self.client.post(
1321 reverse("admin:admin_views_readablepizza_change", args=(pizza.pk,)),
1322 post_data,
1323 )
1324 self.assertRedirects(
1325 response, reverse("admin:admin_views_readablepizza_changelist")
1326 )
1327 pizza_ctype = ContentType.objects.get_for_model(
1328 ReadablePizza, for_concrete_model=False
1329 )
1330 log = LogEntry.objects.filter(
1331 content_type=pizza_ctype, object_id=pizza.pk
1332 ).first()
1333 self.assertEqual(log.get_change_message(), "Changed Toppings.")
1334
1335 def test_allows_attributeerror_to_bubble_up(self):
1336 """
1337 AttributeErrors are allowed to bubble when raised inside a change list
1338 view. Requires a model to be created so there's something to display.
1339 Refs: #16655, #18593, and #18747
1340 """
1341 Simple.objects.create()
1342 with self.assertRaises(AttributeError):
1343 self.client.get(reverse("admin:admin_views_simple_changelist"))
1344
1345 def test_changelist_with_no_change_url(self):
1346 """
1347 ModelAdmin.changelist_view shouldn't result in a NoReverseMatch if url
1348 for change_view is removed from get_urls (#20934).
1349 """
1350 o = UnchangeableObject.objects.create()
1351 response = self.client.get(
1352 reverse("admin:admin_views_unchangeableobject_changelist")
1353 )
1354 # Check the format of the shown object -- shouldn't contain a change link
1355 self.assertContains(
1356 response, '<th class="field-__str__">%s</th>' % o, html=True
1357 )
1358
1359 def test_invalid_appindex_url(self):
1360 """
1361 #21056 -- URL reversing shouldn't work for nonexistent apps.
1362 """
1363 good_url = "/test_admin/admin/admin_views/"
1364 confirm_good_url = reverse(
1365 "admin:app_list", kwargs={"app_label": "admin_views"}
1366 )
1367 self.assertEqual(good_url, confirm_good_url)
1368
1369 with self.assertRaises(NoReverseMatch):
1370 reverse("admin:app_list", kwargs={"app_label": "this_should_fail"})
1371 with self.assertRaises(NoReverseMatch):
1372 reverse("admin:app_list", args=("admin_views2",))
1373
1374 def test_resolve_admin_views(self):
1375 index_match = resolve("/test_admin/admin4/")
1376 list_match = resolve("/test_admin/admin4/auth/user/")
1377 self.assertIs(index_match.func.admin_site, customadmin.simple_site)
1378 self.assertIsInstance(
1379 list_match.func.model_admin, customadmin.CustomPwdTemplateUserAdmin
1380 )
1381
1382 def test_adminsite_display_site_url(self):
1383 """
1384 #13749 - Admin should display link to front-end site 'View site'
1385 """
1386 url = reverse("admin:index")
1387 response = self.client.get(url)
1388 self.assertEqual(response.context["site_url"], "/my-site-url/")
1389 self.assertContains(response, '<a href="/my-site-url/">View site</a>')
1390
1391 def test_date_hierarchy_empty_queryset(self):
1392 self.assertIs(Question.objects.exists(), False)
1393 response = self.client.get(reverse("admin:admin_views_answer2_changelist"))
1394 self.assertEqual(response.status_code, 200)
1395
1396 @override_settings(TIME_ZONE="America/Sao_Paulo", USE_TZ=True)
1397 def test_date_hierarchy_timezone_dst(self):
1398 # This datetime doesn't exist in this timezone due to DST.
1399 for date in make_aware_datetimes(
1400 datetime.datetime(2016, 10, 16, 15), "America/Sao_Paulo"
1401 ):
1402 with self.subTest(repr(date.tzinfo)):
1403 q = Question.objects.create(question="Why?", expires=date)
1404 Answer2.objects.create(question=q, answer="Because.")
1405 response = self.client.get(
1406 reverse("admin:admin_views_answer2_changelist")
1407 )
1408 self.assertContains(response, "question__expires__day=16")
1409 self.assertContains(response, "question__expires__month=10")
1410 self.assertContains(response, "question__expires__year=2016")
1411
1412 @override_settings(TIME_ZONE="America/Los_Angeles", USE_TZ=True)
1413 def test_date_hierarchy_local_date_differ_from_utc(self):
1414 # This datetime is 2017-01-01 in UTC.
1415 for date in make_aware_datetimes(
1416 datetime.datetime(2016, 12, 31, 16), "America/Los_Angeles"
1417 ):
1418 with self.subTest(repr(date.tzinfo)):
1419 q = Question.objects.create(question="Why?", expires=date)
1420 Answer2.objects.create(question=q, answer="Because.")
1421 response = self.client.get(
1422 reverse("admin:admin_views_answer2_changelist")
1423 )
1424 self.assertContains(response, "question__expires__day=31")
1425 self.assertContains(response, "question__expires__month=12")
1426 self.assertContains(response, "question__expires__year=2016")
1427
1428 def test_sortable_by_columns_subset(self):
1429 expected_sortable_fields = ("date", "callable_year")
1430 expected_not_sortable_fields = (
1431 "content",
1432 "model_year",
1433 "modeladmin_year",
1434 "model_year_reversed",
1435 "section",
1436 )
1437 response = self.client.get(reverse("admin6:admin_views_article_changelist"))
1438 for field_name in expected_sortable_fields:
1439 self.assertContains(
1440 response, '<th scope="col" class="sortable column-%s">' % field_name
1441 )
1442 for field_name in expected_not_sortable_fields:
1443 self.assertContains(
1444 response, '<th scope="col" class="column-%s">' % field_name
1445 )
1446
1447 def test_get_sortable_by_columns_subset(self):
1448 response = self.client.get(reverse("admin6:admin_views_actor_changelist"))
1449 self.assertContains(response, '<th scope="col" class="sortable column-age">')
1450 self.assertContains(response, '<th scope="col" class="column-name">')
1451
1452 def test_sortable_by_no_column(self):
1453 expected_not_sortable_fields = ("title", "book")
1454 response = self.client.get(reverse("admin6:admin_views_chapter_changelist"))
1455 for field_name in expected_not_sortable_fields:
1456 self.assertContains(
1457 response, '<th scope="col" class="column-%s">' % field_name
1458 )
1459 self.assertNotContains(response, '<th scope="col" class="sortable column')
1460
1461 def test_get_sortable_by_no_column(self):
1462 response = self.client.get(reverse("admin6:admin_views_color_changelist"))
1463 self.assertContains(response, '<th scope="col" class="column-value">')
1464 self.assertNotContains(response, '<th scope="col" class="sortable column')
1465
1466 def test_app_index_context(self):
1467 response = self.client.get(reverse("admin:app_list", args=("admin_views",)))
1468 self.assertContains(
1469 response,
1470 "<title>Admin_Views administration | Django site admin</title>",
1471 )
1472 self.assertEqual(response.context["title"], "Admin_Views administration")
1473 self.assertEqual(response.context["app_label"], "admin_views")
1474 # Models are sorted alphabetically by default.
1475 models = [model["name"] for model in response.context["app_list"][0]["models"]]
1476 self.assertSequenceEqual(models, sorted(models))
1477
1478 def test_app_index_context_reordered(self):
1479 self.client.force_login(self.superuser)
1480 response = self.client.get(reverse("admin2:app_list", args=("admin_views",)))
1481 self.assertContains(
1482 response,
1483 "<title>Admin_Views administration | Django site admin</title>",
1484 )
1485 # Models are in reverse order.
1486 models = [model["name"] for model in response.context["app_list"][0]["models"]]
1487 self.assertSequenceEqual(models, sorted(models, reverse=True))
1488
1489 def test_change_view_subtitle_per_object(self):
1490 response = self.client.get(
1491 reverse("admin:admin_views_article_change", args=(self.a1.pk,)),
1492 )
1493 self.assertContains(
1494 response,
1495 "<title>Article 1 | Change article | Django site admin</title>",
1496 )
1497 self.assertContains(response, "<h1>Change article</h1>")
1498 self.assertContains(response, "<h2>Article 1</h2>")
1499 response = self.client.get(
1500 reverse("admin:admin_views_article_change", args=(self.a2.pk,)),
1501 )
1502 self.assertContains(
1503 response,
1504 "<title>Article 2 | Change article | Django site admin</title>",
1505 )
1506 self.assertContains(response, "<h1>Change article</h1>")
1507 self.assertContains(response, "<h2>Article 2</h2>")
1508
1509 def test_error_in_titles(self):
1510 for url, subtitle in [
1511 (
1512 reverse("admin:admin_views_article_change", args=(self.a1.pk,)),
1513 "Article 1 | Change article",
1514 ),
1515 (reverse("admin:admin_views_article_add"), "Add article"),
1516 (reverse("admin:login"), "Log in"),
1517 (reverse("admin:password_change"), "Password change"),
1518 (
1519 reverse("admin:auth_user_password_change", args=(self.superuser.id,)),
1520 "Change password: super",
1521 ),
1522 ]:
1523 with self.subTest(url=url, subtitle=subtitle):
1524 response = self.client.post(url, {})
1525 self.assertContains(response, f"<title>Error: {subtitle}")
1526
1527 def test_view_subtitle_per_object(self):
1528 viewuser = User.objects.create_user(
1529 username="viewuser",
1530 password="secret",
1531 is_staff=True,
1532 )
1533 viewuser.user_permissions.add(
1534 get_perm(Article, get_permission_codename("view", Article._meta)),
1535 )
1536 self.client.force_login(viewuser)
1537 response = self.client.get(
1538 reverse("admin:admin_views_article_change", args=(self.a1.pk,)),
1539 )
1540 self.assertContains(
1541 response,
1542 "<title>Article 1 | View article | Django site admin</title>",
1543 )
1544 self.assertContains(response, "<h1>View article</h1>")
1545 self.assertContains(response, "<h2>Article 1</h2>")
1546 response = self.client.get(
1547 reverse("admin:admin_views_article_change", args=(self.a2.pk,)),
1548 )
1549 self.assertContains(
1550 response,
1551 "<title>Article 2 | View article | Django site admin</title>",
1552 )
1553 self.assertContains(response, "<h1>View article</h1>")
1554 self.assertContains(response, "<h2>Article 2</h2>")
1555
1556 def test_formset_kwargs_can_be_overridden(self):
1557 response = self.client.get(reverse("admin:admin_views_city_add"))
1558 self.assertContains(response, "overridden_name")
1559
1560 def test_render_views_no_subtitle(self):
1561 tests = [
1562 reverse("admin:index"),
1563 reverse("admin:password_change"),
1564 reverse("admin:app_list", args=("admin_views",)),
1565 reverse("admin:admin_views_article_delete", args=(self.a1.pk,)),
1566 reverse("admin:admin_views_article_history", args=(self.a1.pk,)),
1567 ]
1568 for url in tests:
1569 with self.subTest(url=url):
1570 with self.assertNoLogs("django.template", "DEBUG"):
1571 self.client.get(url)
1572 # Login must be after logout.
1573 with self.assertNoLogs("django.template", "DEBUG"):
1574 self.client.post(reverse("admin:logout"))
1575 self.client.get(reverse("admin:login"))
1576
1577 def test_render_delete_selected_confirmation_no_subtitle(self):
1578 post_data = {
1579 "action": "delete_selected",
1580 "selected_across": "0",
1581 "index": "0",
1582 "_selected_action": self.a1.pk,
1583 }
1584 with self.assertNoLogs("django.template", "DEBUG"):
1585 self.client.post(reverse("admin:admin_views_article_changelist"), post_data)
1586
1587 @override_settings(
1588 AUTH_PASSWORD_VALIDATORS=[
1589 {
1590 "NAME": (
1591 "django.contrib.auth.password_validation."
1592 "UserAttributeSimilarityValidator"
1593 )
1594 },
1595 {
1596 "NAME": (
1597 "django.contrib.auth.password_validation."
1598 "NumericPasswordValidator"
1599 )
1600 },
1601 ]
1602 )
1603 def test_password_change_helptext(self):
1604 response = self.client.get(reverse("admin:password_change"))
1605 self.assertContains(
1606 response, '<div class="help" id="id_new_password1_helptext">'
1607 )
1608
1609 def test_enable_zooming_on_mobile(self):
1610 response = self.client.get(reverse("admin:index"))
1611 self.assertContains(
1612 response,
1613 '<meta name="viewport" content="width=device-width, initial-scale=1.0">',
1614 )
1615
1616 def test_header(self):
1617 response = self.client.get(reverse("admin:index"))
1618 self.assertContains(response, '<header id="header">')
1619 self.client.logout()
1620 response = self.client.get(reverse("admin:login"))
1621 self.assertContains(response, '<header id="header">')
1622
1623 def test_main_content(self):
1624 response = self.client.get(reverse("admin:index"))
1625 self.assertContains(
1626 response,
1627 '<main id="content-start" class="content" tabindex="-1">',
1628 )
1629
1630 def test_footer(self):
1631 response = self.client.get(reverse("admin:index"))
1632 self.assertContains(response, '<footer id="footer">')
1633 self.client.logout()
1634 response = self.client.get(reverse("admin:login"))
1635 self.assertContains(response, '<footer id="footer">')
1636
1637 def test_aria_describedby_for_add_and_change_links(self):
1638 response = self.client.get(reverse("admin:index"))
1639 tests = [
1640 ("admin_views", "actor"),
1641 ("admin_views", "worker"),
1642 ("auth", "group"),
1643 ("auth", "user"),
1644 ]
1645 for app_label, model_name in tests:
1646 with self.subTest(app_label=app_label, model_name=model_name):
1647 row_id = f"{app_label}-{model_name}"
1648 self.assertContains(response, f'<th scope="row" id="{row_id}">')
1649 self.assertContains(
1650 response,
1651 f'<a href="/test_admin/admin/{app_label}/{model_name}/" '
1652 f'class="changelink" aria-describedby="{row_id}">Change</a>',
1653 )
1654 self.assertContains(
1655 response,
1656 f'<a href="/test_admin/admin/{app_label}/{model_name}/add/" '
1657 f'class="addlink" aria-describedby="{row_id}">Add</a>',
1658 )
1659
1660
1661 @override_settings(
1662 AUTH_PASSWORD_VALIDATORS=[
1663 {
1664 "NAME": (
1665 "django.contrib.auth.password_validation."
1666 "UserAttributeSimilarityValidator"
1667 )
1668 },
1669 {
1670 "NAME": (
1671 "django.contrib.auth.password_validation." "NumericPasswordValidator"
1672 )
1673 },
1674 ],
1675 TEMPLATES=[
1676 {
1677 "BACKEND": "django.template.backends.django.DjangoTemplates",
1678 # Put this app's and the shared tests templates dirs in DIRS to
1679 # take precedence over the admin's templates dir.
1680 "DIRS": [
1681 os.path.join(os.path.dirname(__file__), "templates"),
1682 os.path.join(os.path.dirname(os.path.dirname(__file__)), "templates"),
1683 ],
1684 "APP_DIRS": True,
1685 "OPTIONS": {
1686 "context_processors": [
1687 "django.template.context_processors.request",
1688 "django.contrib.auth.context_processors.auth",
1689 "django.contrib.messages.context_processors.messages",
1690 ],
1691 },
1692 }
1693 ],
1694 )
1695 class AdminCustomTemplateTests(AdminViewBasicTestCase):
1696 def test_custom_model_admin_templates(self):
1697 # Test custom change list template with custom extra context
1698 response = self.client.get(
1699 reverse("admin:admin_views_customarticle_changelist")
1700 )
1701 self.assertContains(response, "var hello = 'Hello!';")
1702 self.assertTemplateUsed(response, "custom_admin/change_list.html")
1703
1704 # Test custom add form template
1705 response = self.client.get(reverse("admin:admin_views_customarticle_add"))
1706 self.assertTemplateUsed(response, "custom_admin/add_form.html")
1707
1708 # Add an article so we can test delete, change, and history views
1709 post = self.client.post(
1710 reverse("admin:admin_views_customarticle_add"),
1711 {
1712 "content": "<p>great article</p>",
1713 "date_0": "2008-03-18",
1714 "date_1": "10:54:39",
1715 },
1716 )
1717 self.assertRedirects(
1718 post, reverse("admin:admin_views_customarticle_changelist")
1719 )
1720 self.assertEqual(CustomArticle.objects.count(), 1)
1721 article_pk = CustomArticle.objects.all()[0].pk
1722
1723 # Test custom delete, change, and object history templates
1724 # Test custom change form template
1725 response = self.client.get(
1726 reverse("admin:admin_views_customarticle_change", args=(article_pk,))
1727 )
1728 self.assertTemplateUsed(response, "custom_admin/change_form.html")
1729 response = self.client.get(
1730 reverse("admin:admin_views_customarticle_delete", args=(article_pk,))
1731 )
1732 self.assertTemplateUsed(response, "custom_admin/delete_confirmation.html")
1733 response = self.client.post(
1734 reverse("admin:admin_views_customarticle_changelist"),
1735 data={
1736 "index": 0,
1737 "action": ["delete_selected"],
1738 "_selected_action": ["1"],
1739 },
1740 )
1741 self.assertTemplateUsed(
1742 response, "custom_admin/delete_selected_confirmation.html"
1743 )
1744 response = self.client.get(
1745 reverse("admin:admin_views_customarticle_history", args=(article_pk,))
1746 )
1747 self.assertTemplateUsed(response, "custom_admin/object_history.html")
1748
1749 # A custom popup response template may be specified by
1750 # ModelAdmin.popup_response_template.
1751 response = self.client.post(
1752 reverse("admin:admin_views_customarticle_add") + "?%s=1" % IS_POPUP_VAR,
1753 {
1754 "content": "<p>great article</p>",
1755 "date_0": "2008-03-18",
1756 "date_1": "10:54:39",
1757 IS_POPUP_VAR: "1",
1758 },
1759 )
1760 self.assertEqual(response.template_name, "custom_admin/popup_response.html")
1761
1762 def test_extended_bodyclass_template_change_form(self):
1763 """
1764 The admin/change_form.html template uses block.super in the
1765 bodyclass block.
1766 """
1767 response = self.client.get(reverse("admin:admin_views_section_add"))
1768 self.assertContains(response, "bodyclass_consistency_check ")
1769
1770 def test_extended_extrabody(self):
1771 response = self.client.get(reverse("admin:admin_views_section_add"))
1772 self.assertContains(response, "extrabody_check\n</body>")
1773
1774 def test_change_password_template(self):
1775 user = User.objects.get(username="super")
1776 response = self.client.get(
1777 reverse("admin:auth_user_password_change", args=(user.id,))
1778 )
1779 # The auth/user/change_password.html template uses super in the
1780 # bodyclass block.
1781 self.assertContains(response, "bodyclass_consistency_check ")
1782
1783 # When a site has multiple passwords in the browser's password manager,
1784 # a browser pop up asks which user the new password is for. To prevent
1785 # this, the username is added to the change password form.
1786 self.assertContains(
1787 response, '<input type="text" name="username" value="super" class="hidden">'
1788 )
1789
1790 # help text for passwords has an id.
1791 self.assertContains(
1792 response,
1793 '<div class="help" id="id_password1_helptext"><ul><li>'
1794 "Your password can’t be too similar to your other personal information."
1795 "</li><li>Your password can’t be entirely numeric.</li></ul></div>",
1796 )
1797 self.assertContains(
1798 response,
1799 '<div class="help" id="id_password2_helptext">'
1800 "Enter the same password as before, for verification.</div>",
1801 )
1802
1803 def test_change_password_template_helptext_no_id(self):
1804 user = User.objects.get(username="super")
1805
1806 class EmptyIdForLabelTextInput(forms.TextInput):
1807 def id_for_label(self, id):
1808 return None
1809
1810 class EmptyIdForLabelHelpTextPasswordChangeForm(AdminPasswordChangeForm):
1811 password1 = forms.CharField(
1812 help_text="Your new password", widget=EmptyIdForLabelTextInput()
1813 )
1814
1815 class CustomUserAdmin(UserAdmin):
1816 change_password_form = EmptyIdForLabelHelpTextPasswordChangeForm
1817
1818 request = RequestFactory().get(
1819 reverse("admin:auth_user_password_change", args=(user.id,))
1820 )
1821 request.user = user
1822 user_admin = CustomUserAdmin(User, site)
1823 response = user_admin.user_change_password(request, str(user.pk))
1824 self.assertContains(response, '<div class="help">')
1825
1826 def test_extended_bodyclass_template_index(self):
1827 """
1828 The admin/index.html template uses block.super in the bodyclass block.
1829 """
1830 response = self.client.get(reverse("admin:index"))
1831 self.assertContains(response, "bodyclass_consistency_check ")
1832
1833 def test_extended_bodyclass_change_list(self):
1834 """
1835 The admin/change_list.html' template uses block.super
1836 in the bodyclass block.
1837 """
1838 response = self.client.get(reverse("admin:admin_views_article_changelist"))
1839 self.assertContains(response, "bodyclass_consistency_check ")
1840
1841 def test_extended_bodyclass_template_login(self):
1842 """
1843 The admin/login.html template uses block.super in the
1844 bodyclass block.
1845 """
1846 self.client.logout()
1847 response = self.client.get(reverse("admin:login"))
1848 self.assertContains(response, "bodyclass_consistency_check ")
1849
1850 def test_extended_bodyclass_template_delete_confirmation(self):
1851 """
1852 The admin/delete_confirmation.html template uses
1853 block.super in the bodyclass block.
1854 """
1855 group = Group.objects.create(name="foogroup")
1856 response = self.client.get(reverse("admin:auth_group_delete", args=(group.id,)))
1857 self.assertContains(response, "bodyclass_consistency_check ")
1858
1859 def test_extended_bodyclass_template_delete_selected_confirmation(self):
1860 """
1861 The admin/delete_selected_confirmation.html template uses
1862 block.super in bodyclass block.
1863 """
1864 group = Group.objects.create(name="foogroup")
1865 post_data = {
1866 "action": "delete_selected",
1867 "selected_across": "0",
1868 "index": "0",
1869 "_selected_action": group.id,
1870 }
1871 response = self.client.post(reverse("admin:auth_group_changelist"), post_data)
1872 self.assertEqual(response.context["site_header"], "Django administration")
1873 self.assertContains(response, "bodyclass_consistency_check ")
1874
1875 def test_filter_with_custom_template(self):
1876 """
1877 A custom template can be used to render an admin filter.
1878 """
1879 response = self.client.get(reverse("admin:admin_views_color2_changelist"))
1880 self.assertTemplateUsed(response, "custom_filter_template.html")
1881
1882
1883 @override_settings(ROOT_URLCONF="admin_views.urls")
1884 class AdminViewFormUrlTest(TestCase):
1885 current_app = "admin3"
1886
1887 @classmethod
1888 def setUpTestData(cls):
1889 cls.superuser = User.objects.create_superuser(
1890 username="super", password="secret", email="[email protected]"
1891 )
1892 cls.s1 = Section.objects.create(name="Test section")
1893 cls.a1 = Article.objects.create(
1894 content="<p>Middle content</p>",
1895 date=datetime.datetime(2008, 3, 18, 11, 54, 58),
1896 section=cls.s1,
1897 )
1898 cls.a2 = Article.objects.create(
1899 content="<p>Oldest content</p>",
1900 date=datetime.datetime(2000, 3, 18, 11, 54, 58),
1901 section=cls.s1,
1902 )
1903 cls.a3 = Article.objects.create(
1904 content="<p>Newest content</p>",
1905 date=datetime.datetime(2009, 3, 18, 11, 54, 58),
1906 section=cls.s1,
1907 )
1908 cls.p1 = PrePopulatedPost.objects.create(
1909 title="A Long Title", published=True, slug="a-long-title"
1910 )
1911
1912 def setUp(self):
1913 self.client.force_login(self.superuser)
1914
1915 def test_change_form_URL_has_correct_value(self):
1916 """
1917 change_view has form_url in response.context
1918 """
1919 response = self.client.get(
1920 reverse(
1921 "admin:admin_views_section_change",
1922 args=(self.s1.pk,),
1923 current_app=self.current_app,
1924 )
1925 )
1926 self.assertIn(
1927 "form_url", response.context, msg="form_url not present in response.context"
1928 )
1929 self.assertEqual(response.context["form_url"], "pony")
1930
1931 def test_initial_data_can_be_overridden(self):
1932 """
1933 The behavior for setting initial form data can be overridden in the
1934 ModelAdmin class. Usually, the initial value is set via the GET params.
1935 """
1936 response = self.client.get(
1937 reverse("admin:admin_views_restaurant_add", current_app=self.current_app),
1938 {"name": "test_value"},
1939 )
1940 # this would be the usual behaviour
1941 self.assertNotContains(response, 'value="test_value"')
1942 # this is the overridden behaviour
1943 self.assertContains(response, 'value="overridden_value"')
1944
1945
1946 @override_settings(ROOT_URLCONF="admin_views.urls")
1947 class AdminJavaScriptTest(TestCase):
1948 @classmethod
1949 def setUpTestData(cls):
1950 cls.superuser = User.objects.create_superuser(
1951 username="super", password="secret", email="[email protected]"
1952 )
1953
1954 def setUp(self):
1955 self.client.force_login(self.superuser)
1956
1957 def test_js_minified_only_if_debug_is_false(self):
1958 """
1959 The minified versions of the JS files are only used when DEBUG is False.
1960 """
1961 with override_settings(DEBUG=False):
1962 response = self.client.get(reverse("admin:admin_views_section_add"))
1963 self.assertNotContains(response, "vendor/jquery/jquery.js")
1964 self.assertContains(response, "vendor/jquery/jquery.min.js")
1965 self.assertContains(response, "prepopulate.js")
1966 self.assertContains(response, "actions.js")
1967 self.assertContains(response, "inlines.js")
1968 with override_settings(DEBUG=True):
1969 response = self.client.get(reverse("admin:admin_views_section_add"))
1970 self.assertContains(response, "vendor/jquery/jquery.js")
1971 self.assertNotContains(response, "vendor/jquery/jquery.min.js")
1972 self.assertContains(response, "prepopulate.js")
1973 self.assertContains(response, "actions.js")
1974 self.assertContains(response, "inlines.js")
1975
1976
1977 @override_settings(ROOT_URLCONF="admin_views.urls")
1978 class SaveAsTests(TestCase):
1979 @classmethod
1980 def setUpTestData(cls):
1981 cls.superuser = User.objects.create_superuser(
1982 username="super", password="secret", email="[email protected]"
1983 )
1984 cls.per1 = Person.objects.create(name="John Mauchly", gender=1, alive=True)
1985
1986 def setUp(self):
1987 self.client.force_login(self.superuser)
1988
1989 def test_save_as_duplication(self):
1990 """'save as' creates a new person"""
1991 post_data = {"_saveasnew": "", "name": "John M", "gender": 1, "age": 42}
1992 response = self.client.post(
1993 reverse("admin:admin_views_person_change", args=(self.per1.pk,)), post_data
1994 )
1995 self.assertEqual(len(Person.objects.filter(name="John M")), 1)
1996 self.assertEqual(len(Person.objects.filter(id=self.per1.pk)), 1)
1997 new_person = Person.objects.latest("id")
1998 self.assertRedirects(
1999 response, reverse("admin:admin_views_person_change", args=(new_person.pk,))
2000 )
2001
2002 def test_save_as_continue_false(self):
2003 """
2004 Saving a new object using "Save as new" redirects to the changelist
2005 instead of the change view when ModelAdmin.save_as_continue=False.
2006 """
2007 post_data = {"_saveasnew": "", "name": "John M", "gender": 1, "age": 42}
2008 url = reverse(
2009 "admin:admin_views_person_change",
2010 args=(self.per1.pk,),
2011 current_app=site2.name,
2012 )
2013 response = self.client.post(url, post_data)
2014 self.assertEqual(len(Person.objects.filter(name="John M")), 1)
2015 self.assertEqual(len(Person.objects.filter(id=self.per1.pk)), 1)
2016 self.assertRedirects(
2017 response,
2018 reverse("admin:admin_views_person_changelist", current_app=site2.name),
2019 )
2020
2021 def test_save_as_new_with_validation_errors(self):
2022 """
2023 When you click "Save as new" and have a validation error,
2024 you only see the "Save as new" button and not the other save buttons,
2025 and that only the "Save as" button is visible.
2026 """
2027 response = self.client.post(
2028 reverse("admin:admin_views_person_change", args=(self.per1.pk,)),
2029 {
2030 "_saveasnew": "",
2031 "gender": "invalid",
2032 "_addanother": "fail",
2033 },
2034 )
2035 self.assertContains(response, "Please correct the errors below.")
2036 self.assertFalse(response.context["show_save_and_add_another"])
2037 self.assertFalse(response.context["show_save_and_continue"])
2038 self.assertTrue(response.context["show_save_as_new"])
2039
2040 def test_save_as_new_with_validation_errors_with_inlines(self):
2041 parent = Parent.objects.create(name="Father")
2042 child = Child.objects.create(parent=parent, name="Child")
2043 response = self.client.post(
2044 reverse("admin:admin_views_parent_change", args=(parent.pk,)),
2045 {
2046 "_saveasnew": "Save as new",
2047 "child_set-0-parent": parent.pk,
2048 "child_set-0-id": child.pk,
2049 "child_set-0-name": "Child",
2050 "child_set-INITIAL_FORMS": 1,
2051 "child_set-MAX_NUM_FORMS": 1000,
2052 "child_set-MIN_NUM_FORMS": 0,
2053 "child_set-TOTAL_FORMS": 4,
2054 "name": "_invalid",
2055 },
2056 )
2057 self.assertContains(response, "Please correct the error below.")
2058 self.assertFalse(response.context["show_save_and_add_another"])
2059 self.assertFalse(response.context["show_save_and_continue"])
2060 self.assertTrue(response.context["show_save_as_new"])
2061
2062 def test_save_as_new_with_inlines_with_validation_errors(self):
2063 parent = Parent.objects.create(name="Father")
2064 child = Child.objects.create(parent=parent, name="Child")
2065 response = self.client.post(
2066 reverse("admin:admin_views_parent_change", args=(parent.pk,)),
2067 {
2068 "_saveasnew": "Save as new",
2069 "child_set-0-parent": parent.pk,
2070 "child_set-0-id": child.pk,
2071 "child_set-0-name": "_invalid",
2072 "child_set-INITIAL_FORMS": 1,
2073 "child_set-MAX_NUM_FORMS": 1000,
2074 "child_set-MIN_NUM_FORMS": 0,
2075 "child_set-TOTAL_FORMS": 4,
2076 "name": "Father",
2077 },
2078 )
2079 self.assertContains(response, "Please correct the error below.")
2080 self.assertFalse(response.context["show_save_and_add_another"])
2081 self.assertFalse(response.context["show_save_and_continue"])
2082 self.assertTrue(response.context["show_save_as_new"])
2083
2084
2085 @override_settings(ROOT_URLCONF="admin_views.urls")
2086 class CustomModelAdminTest(AdminViewBasicTestCase):
2087 def test_custom_admin_site_login_form(self):
2088 self.client.logout()
2089 response = self.client.get(reverse("admin2:index"), follow=True)
2090 self.assertIsInstance(response, TemplateResponse)
2091 self.assertEqual(response.status_code, 200)
2092 login = self.client.post(
2093 reverse("admin2:login"),
2094 {
2095 REDIRECT_FIELD_NAME: reverse("admin2:index"),
2096 "username": "customform",
2097 "password": "secret",
2098 },
2099 follow=True,
2100 )
2101 self.assertIsInstance(login, TemplateResponse)
2102 self.assertContains(login, "custom form error")
2103 self.assertContains(login, "path/to/media.css")
2104
2105 def test_custom_admin_site_login_template(self):
2106 self.client.logout()
2107 response = self.client.get(reverse("admin2:index"), follow=True)
2108 self.assertIsInstance(response, TemplateResponse)
2109 self.assertTemplateUsed(response, "custom_admin/login.html")
2110 self.assertContains(response, "Hello from a custom login template")
2111
2112 def test_custom_admin_site_logout_template(self):
2113 response = self.client.post(reverse("admin2:logout"))
2114 self.assertIsInstance(response, TemplateResponse)
2115 self.assertTemplateUsed(response, "custom_admin/logout.html")
2116 self.assertContains(response, "Hello from a custom logout template")
2117
2118 def test_custom_admin_site_index_view_and_template(self):
2119 response = self.client.get(reverse("admin2:index"))
2120 self.assertIsInstance(response, TemplateResponse)
2121 self.assertTemplateUsed(response, "custom_admin/index.html")
2122 self.assertContains(response, "Hello from a custom index template *bar*")
2123
2124 def test_custom_admin_site_app_index_view_and_template(self):
2125 response = self.client.get(reverse("admin2:app_list", args=("admin_views",)))
2126 self.assertIsInstance(response, TemplateResponse)
2127 self.assertTemplateUsed(response, "custom_admin/app_index.html")
2128 self.assertContains(response, "Hello from a custom app_index template")
2129
2130 def test_custom_admin_site_password_change_template(self):
2131 response = self.client.get(reverse("admin2:password_change"))
2132 self.assertIsInstance(response, TemplateResponse)
2133 self.assertTemplateUsed(response, "custom_admin/password_change_form.html")
2134 self.assertContains(
2135 response, "Hello from a custom password change form template"
2136 )
2137
2138 def test_custom_admin_site_password_change_with_extra_context(self):
2139 response = self.client.get(reverse("admin2:password_change"))
2140 self.assertIsInstance(response, TemplateResponse)
2141 self.assertTemplateUsed(response, "custom_admin/password_change_form.html")
2142 self.assertContains(response, "eggs")
2143
2144 def test_custom_admin_site_password_change_done_template(self):
2145 response = self.client.get(reverse("admin2:password_change_done"))
2146 self.assertIsInstance(response, TemplateResponse)
2147 self.assertTemplateUsed(response, "custom_admin/password_change_done.html")
2148 self.assertContains(
2149 response, "Hello from a custom password change done template"
2150 )
2151
2152 def test_custom_admin_site_view(self):
2153 self.client.force_login(self.superuser)
2154 response = self.client.get(reverse("admin2:my_view"))
2155 self.assertEqual(response.content, b"Django is a magical pony!")
2156
2157 def test_pwd_change_custom_template(self):
2158 self.client.force_login(self.superuser)
2159 su = User.objects.get(username="super")
2160 response = self.client.get(
2161 reverse("admin4:auth_user_password_change", args=(su.pk,))
2162 )
2163 self.assertEqual(response.status_code, 200)
2164
2165
2166 def get_perm(Model, codename):
2167 """Return the permission object, for the Model"""
2168 ct = ContentType.objects.get_for_model(Model, for_concrete_model=False)
2169 return Permission.objects.get(content_type=ct, codename=codename)
2170
2171
2172 @override_settings(
2173 ROOT_URLCONF="admin_views.urls",
2174 # Test with the admin's documented list of required context processors.
2175 TEMPLATES=[
2176 {
2177 "BACKEND": "django.template.backends.django.DjangoTemplates",
2178 "APP_DIRS": True,
2179 "OPTIONS": {
2180 "context_processors": [
2181 "django.template.context_processors.request",
2182 "django.contrib.auth.context_processors.auth",
2183 "django.contrib.messages.context_processors.messages",
2184 ],
2185 },
2186 }
2187 ],
2188 )
2189 class AdminViewPermissionsTest(TestCase):
2190 """Tests for Admin Views Permissions."""
2191
2192 @classmethod
2193 def setUpTestData(cls):
2194 cls.superuser = User.objects.create_superuser(
2195 username="super", password="secret", email="[email protected]"
2196 )
2197 cls.viewuser = User.objects.create_user(
2198 username="viewuser", password="secret", is_staff=True
2199 )
2200 cls.adduser = User.objects.create_user(
2201 username="adduser", password="secret", is_staff=True
2202 )
2203 cls.changeuser = User.objects.create_user(
2204 username="changeuser", password="secret", is_staff=True
2205 )
2206 cls.deleteuser = User.objects.create_user(
2207 username="deleteuser", password="secret", is_staff=True
2208 )
2209 cls.joepublicuser = User.objects.create_user(
2210 username="joepublic", password="secret"
2211 )
2212 cls.nostaffuser = User.objects.create_user(
2213 username="nostaff", password="secret"
2214 )
2215 cls.s1 = Section.objects.create(name="Test section")
2216 cls.a1 = Article.objects.create(
2217 content="<p>Middle content</p>",
2218 date=datetime.datetime(2008, 3, 18, 11, 54, 58),
2219 section=cls.s1,
2220 another_section=cls.s1,
2221 )
2222 cls.a2 = Article.objects.create(
2223 content="<p>Oldest content</p>",
2224 date=datetime.datetime(2000, 3, 18, 11, 54, 58),
2225 section=cls.s1,
2226 )
2227 cls.a3 = Article.objects.create(
2228 content="<p>Newest content</p>",
2229 date=datetime.datetime(2009, 3, 18, 11, 54, 58),
2230 section=cls.s1,
2231 )
2232 cls.p1 = PrePopulatedPost.objects.create(
2233 title="A Long Title", published=True, slug="a-long-title"
2234 )
2235
2236 # Setup permissions, for our users who can add, change, and delete.
2237 opts = Article._meta
2238
2239 # User who can view Articles
2240 cls.viewuser.user_permissions.add(
2241 get_perm(Article, get_permission_codename("view", opts))
2242 )
2243 # User who can add Articles
2244 cls.adduser.user_permissions.add(
2245 get_perm(Article, get_permission_codename("add", opts))
2246 )
2247 # User who can change Articles
2248 cls.changeuser.user_permissions.add(
2249 get_perm(Article, get_permission_codename("change", opts))
2250 )
2251 cls.nostaffuser.user_permissions.add(
2252 get_perm(Article, get_permission_codename("change", opts))
2253 )
2254
2255 # User who can delete Articles
2256 cls.deleteuser.user_permissions.add(
2257 get_perm(Article, get_permission_codename("delete", opts))
2258 )
2259 cls.deleteuser.user_permissions.add(
2260 get_perm(Section, get_permission_codename("delete", Section._meta))
2261 )
2262
2263 # login POST dicts
2264 cls.index_url = reverse("admin:index")
2265 cls.super_login = {
2266 REDIRECT_FIELD_NAME: cls.index_url,
2267 "username": "super",
2268 "password": "secret",
2269 }
2270 cls.super_email_login = {
2271 REDIRECT_FIELD_NAME: cls.index_url,
2272 "username": "[email protected]",
2273 "password": "secret",
2274 }
2275 cls.super_email_bad_login = {
2276 REDIRECT_FIELD_NAME: cls.index_url,
2277 "username": "[email protected]",
2278 "password": "notsecret",
2279 }
2280 cls.adduser_login = {
2281 REDIRECT_FIELD_NAME: cls.index_url,
2282 "username": "adduser",
2283 "password": "secret",
2284 }
2285 cls.changeuser_login = {
2286 REDIRECT_FIELD_NAME: cls.index_url,
2287 "username": "changeuser",
2288 "password": "secret",
2289 }
2290 cls.deleteuser_login = {
2291 REDIRECT_FIELD_NAME: cls.index_url,
2292 "username": "deleteuser",
2293 "password": "secret",
2294 }
2295 cls.nostaff_login = {
2296 REDIRECT_FIELD_NAME: reverse("has_permission_admin:index"),
2297 "username": "nostaff",
2298 "password": "secret",
2299 }
2300 cls.joepublic_login = {
2301 REDIRECT_FIELD_NAME: cls.index_url,
2302 "username": "joepublic",
2303 "password": "secret",
2304 }
2305 cls.viewuser_login = {
2306 REDIRECT_FIELD_NAME: cls.index_url,
2307 "username": "viewuser",
2308 "password": "secret",
2309 }
2310 cls.no_username_login = {
2311 REDIRECT_FIELD_NAME: cls.index_url,
2312 "password": "secret",
2313 }
2314
2315 def test_login(self):
2316 """
2317 Make sure only staff members can log in.
2318
2319 Successful posts to the login page will redirect to the original url.
2320 Unsuccessful attempts will continue to render the login page with
2321 a 200 status code.
2322 """
2323 login_url = "%s?next=%s" % (reverse("admin:login"), reverse("admin:index"))
2324 # Super User
2325 response = self.client.get(self.index_url)
2326 self.assertRedirects(response, login_url)
2327 login = self.client.post(login_url, self.super_login)
2328 self.assertRedirects(login, self.index_url)
2329 self.assertFalse(login.context)
2330 self.client.post(reverse("admin:logout"))
2331
2332 # Test if user enters email address
2333 response = self.client.get(self.index_url)
2334 self.assertEqual(response.status_code, 302)
2335 login = self.client.post(login_url, self.super_email_login)
2336 self.assertContains(login, ERROR_MESSAGE)
2337 # only correct passwords get a username hint
2338 login = self.client.post(login_url, self.super_email_bad_login)
2339 self.assertContains(login, ERROR_MESSAGE)
2340 new_user = User(username="jondoe", password="secret", email="[email protected]")
2341 new_user.save()
2342 # check to ensure if there are multiple email addresses a user doesn't get a 500
2343 login = self.client.post(login_url, self.super_email_login)
2344 self.assertContains(login, ERROR_MESSAGE)
2345
2346 # View User
2347 response = self.client.get(self.index_url)
2348 self.assertEqual(response.status_code, 302)
2349 login = self.client.post(login_url, self.viewuser_login)
2350 self.assertRedirects(login, self.index_url)
2351 self.assertFalse(login.context)
2352 self.client.post(reverse("admin:logout"))
2353
2354 # Add User
2355 response = self.client.get(self.index_url)
2356 self.assertEqual(response.status_code, 302)
2357 login = self.client.post(login_url, self.adduser_login)
2358 self.assertRedirects(login, self.index_url)
2359 self.assertFalse(login.context)
2360 self.client.post(reverse("admin:logout"))
2361
2362 # Change User
2363 response = self.client.get(self.index_url)
2364 self.assertEqual(response.status_code, 302)
2365 login = self.client.post(login_url, self.changeuser_login)
2366 self.assertRedirects(login, self.index_url)
2367 self.assertFalse(login.context)
2368 self.client.post(reverse("admin:logout"))
2369
2370 # Delete User
2371 response = self.client.get(self.index_url)
2372 self.assertEqual(response.status_code, 302)
2373 login = self.client.post(login_url, self.deleteuser_login)
2374 self.assertRedirects(login, self.index_url)
2375 self.assertFalse(login.context)
2376 self.client.post(reverse("admin:logout"))
2377
2378 # Regular User should not be able to login.
2379 response = self.client.get(self.index_url)
2380 self.assertEqual(response.status_code, 302)
2381 login = self.client.post(login_url, self.joepublic_login)
2382 self.assertContains(login, ERROR_MESSAGE)
2383
2384 # Requests without username should not return 500 errors.
2385 response = self.client.get(self.index_url)
2386 self.assertEqual(response.status_code, 302)
2387 login = self.client.post(login_url, self.no_username_login)
2388 self.assertEqual(login.status_code, 200)
2389 self.assertFormError(
2390 login.context["form"], "username", ["This field is required."]
2391 )
2392
2393 def test_login_redirect_for_direct_get(self):
2394 """
2395 Login redirect should be to the admin index page when going directly to
2396 /admin/login/.
2397 """
2398 response = self.client.get(reverse("admin:login"))
2399 self.assertEqual(response.status_code, 200)
2400 self.assertEqual(response.context[REDIRECT_FIELD_NAME], reverse("admin:index"))
2401
2402 def test_login_has_permission(self):
2403 # Regular User should not be able to login.
2404 response = self.client.get(reverse("has_permission_admin:index"))
2405 self.assertEqual(response.status_code, 302)
2406 login = self.client.post(
2407 reverse("has_permission_admin:login"), self.joepublic_login
2408 )
2409 self.assertContains(login, "permission denied")
2410
2411 # User with permissions should be able to login.
2412 response = self.client.get(reverse("has_permission_admin:index"))
2413 self.assertEqual(response.status_code, 302)
2414 login = self.client.post(
2415 reverse("has_permission_admin:login"), self.nostaff_login
2416 )
2417 self.assertRedirects(login, reverse("has_permission_admin:index"))
2418 self.assertFalse(login.context)
2419 self.client.post(reverse("has_permission_admin:logout"))
2420
2421 # Staff should be able to login.
2422 response = self.client.get(reverse("has_permission_admin:index"))
2423 self.assertEqual(response.status_code, 302)
2424 login = self.client.post(
2425 reverse("has_permission_admin:login"),
2426 {
2427 REDIRECT_FIELD_NAME: reverse("has_permission_admin:index"),
2428 "username": "deleteuser",
2429 "password": "secret",
2430 },
2431 )
2432 self.assertRedirects(login, reverse("has_permission_admin:index"))
2433 self.assertFalse(login.context)
2434 self.client.post(reverse("has_permission_admin:logout"))
2435
2436 def test_login_successfully_redirects_to_original_URL(self):
2437 response = self.client.get(self.index_url)
2438 self.assertEqual(response.status_code, 302)
2439 query_string = "the-answer=42"
2440 redirect_url = "%s?%s" % (self.index_url, query_string)
2441 new_next = {REDIRECT_FIELD_NAME: redirect_url}
2442 post_data = self.super_login.copy()
2443 post_data.pop(REDIRECT_FIELD_NAME)
2444 login = self.client.post(
2445 "%s?%s" % (reverse("admin:login"), urlencode(new_next)), post_data
2446 )
2447 self.assertRedirects(login, redirect_url)
2448
2449 def test_double_login_is_not_allowed(self):
2450 """Regression test for #19327"""
2451 login_url = "%s?next=%s" % (reverse("admin:login"), reverse("admin:index"))
2452
2453 response = self.client.get(self.index_url)
2454 self.assertEqual(response.status_code, 302)
2455
2456 # Establish a valid admin session
2457 login = self.client.post(login_url, self.super_login)
2458 self.assertRedirects(login, self.index_url)
2459 self.assertFalse(login.context)
2460
2461 # Logging in with non-admin user fails
2462 login = self.client.post(login_url, self.joepublic_login)
2463 self.assertContains(login, ERROR_MESSAGE)
2464
2465 # Establish a valid admin session
2466 login = self.client.post(login_url, self.super_login)
2467 self.assertRedirects(login, self.index_url)
2468 self.assertFalse(login.context)
2469
2470 # Logging in with admin user while already logged in
2471 login = self.client.post(login_url, self.super_login)
2472 self.assertRedirects(login, self.index_url)
2473 self.assertFalse(login.context)
2474 self.client.post(reverse("admin:logout"))
2475
2476 def test_login_page_notice_for_non_staff_users(self):
2477 """
2478 A logged-in non-staff user trying to access the admin index should be
2479 presented with the login page and a hint indicating that the current
2480 user doesn't have access to it.
2481 """
2482 hint_template = "You are authenticated as {}"
2483
2484 # Anonymous user should not be shown the hint
2485 response = self.client.get(self.index_url, follow=True)
2486 self.assertContains(response, "login-form")
2487 self.assertNotContains(response, hint_template.format(""), status_code=200)
2488
2489 # Non-staff user should be shown the hint
2490 self.client.force_login(self.nostaffuser)
2491 response = self.client.get(self.index_url, follow=True)
2492 self.assertContains(response, "login-form")
2493 self.assertContains(
2494 response, hint_template.format(self.nostaffuser.username), status_code=200
2495 )
2496
2497 def test_add_view(self):
2498 """Test add view restricts access and actually adds items."""
2499 add_dict = {
2500 "title": "Døm ikke",
2501 "content": "<p>great article</p>",
2502 "date_0": "2008-03-18",
2503 "date_1": "10:54:39",
2504 "section": self.s1.pk,
2505 }
2506 # Change User should not have access to add articles
2507 self.client.force_login(self.changeuser)
2508 # make sure the view removes test cookie
2509 self.assertIs(self.client.session.test_cookie_worked(), False)
2510 response = self.client.get(reverse("admin:admin_views_article_add"))
2511 self.assertEqual(response.status_code, 403)
2512 # Try POST just to make sure
2513 post = self.client.post(reverse("admin:admin_views_article_add"), add_dict)
2514 self.assertEqual(post.status_code, 403)
2515 self.assertEqual(Article.objects.count(), 3)
2516 self.client.post(reverse("admin:logout"))
2517
2518 # View User should not have access to add articles
2519 self.client.force_login(self.viewuser)
2520 response = self.client.get(reverse("admin:admin_views_article_add"))
2521 self.assertEqual(response.status_code, 403)
2522 # Try POST just to make sure
2523 post = self.client.post(reverse("admin:admin_views_article_add"), add_dict)
2524 self.assertEqual(post.status_code, 403)
2525 self.assertEqual(Article.objects.count(), 3)
2526 # Now give the user permission to add but not change.
2527 self.viewuser.user_permissions.add(
2528 get_perm(Article, get_permission_codename("add", Article._meta))
2529 )
2530 response = self.client.get(reverse("admin:admin_views_article_add"))
2531 self.assertEqual(response.context["title"], "Add article")
2532 self.assertContains(response, "<title>Add article | Django site admin</title>")
2533 self.assertContains(
2534 response, '<input type="submit" value="Save and view" name="_continue">'
2535 )
2536 self.assertContains(
2537 response,
2538 '<h2 id="fieldset-0-0-heading" class="fieldset-heading">Some fields</h2>',
2539 )
2540 self.assertContains(
2541 response,
2542 '<h2 id="fieldset-0-1-heading" class="fieldset-heading">'
2543 "Some other fields</h2>",
2544 )
2545 self.assertContains(
2546 response,
2547 '<h2 id="fieldset-0-2-heading" class="fieldset-heading">이름</h2>',
2548 )
2549 post = self.client.post(
2550 reverse("admin:admin_views_article_add"), add_dict, follow=False
2551 )
2552 self.assertEqual(post.status_code, 302)
2553 self.assertEqual(Article.objects.count(), 4)
2554 article = Article.objects.latest("pk")
2555 response = self.client.get(
2556 reverse("admin:admin_views_article_change", args=(article.pk,))
2557 )
2558 self.assertContains(
2559 response,
2560 '<li class="success">The article “Døm ikke” was added successfully.</li>',
2561 )
2562 article.delete()
2563 self.client.post(reverse("admin:logout"))
2564
2565 # Add user may login and POST to add view, then redirect to admin root
2566 self.client.force_login(self.adduser)
2567 addpage = self.client.get(reverse("admin:admin_views_article_add"))
2568 change_list_link = '&rsaquo; <a href="%s">Articles</a>' % reverse(
2569 "admin:admin_views_article_changelist"
2570 )
2571 self.assertNotContains(
2572 addpage,
2573 change_list_link,
2574 msg_prefix=(
2575 "User restricted to add permission is given link to change list view "
2576 "in breadcrumbs."
2577 ),
2578 )
2579 post = self.client.post(reverse("admin:admin_views_article_add"), add_dict)
2580 self.assertRedirects(post, self.index_url)
2581 self.assertEqual(Article.objects.count(), 4)
2582 self.assertEqual(len(mail.outbox), 2)
2583 self.assertEqual(mail.outbox[0].subject, "Greetings from a created object")
2584 self.client.post(reverse("admin:logout"))
2585
2586 # The addition was logged correctly
2587 addition_log = LogEntry.objects.all()[0]
2588 new_article = Article.objects.last()
2589 article_ct = ContentType.objects.get_for_model(Article)
2590 self.assertEqual(addition_log.user_id, self.adduser.pk)
2591 self.assertEqual(addition_log.content_type_id, article_ct.pk)
2592 self.assertEqual(addition_log.object_id, str(new_article.pk))
2593 self.assertEqual(addition_log.object_repr, "Døm ikke")
2594 self.assertEqual(addition_log.action_flag, ADDITION)
2595 self.assertEqual(addition_log.get_change_message(), "Added.")
2596
2597 # Super can add too, but is redirected to the change list view
2598 self.client.force_login(self.superuser)
2599 addpage = self.client.get(reverse("admin:admin_views_article_add"))
2600 self.assertContains(
2601 addpage,
2602 change_list_link,
2603 msg_prefix=(
2604 "Unrestricted user is not given link to change list view in "
2605 "breadcrumbs."
2606 ),
2607 )
2608 post = self.client.post(reverse("admin:admin_views_article_add"), add_dict)
2609 self.assertRedirects(post, reverse("admin:admin_views_article_changelist"))
2610 self.assertEqual(Article.objects.count(), 5)
2611 self.client.post(reverse("admin:logout"))
2612
2613 # 8509 - if a normal user is already logged in, it is possible
2614 # to change user into the superuser without error
2615 self.client.force_login(self.joepublicuser)
2616 # Check and make sure that if user expires, data still persists
2617 self.client.force_login(self.superuser)
2618 # make sure the view removes test cookie
2619 self.assertIs(self.client.session.test_cookie_worked(), False)
2620
2621 @mock.patch("django.contrib.admin.options.InlineModelAdmin.has_change_permission")
2622 def test_add_view_with_view_only_inlines(self, has_change_permission):
2623 """User with add permission to a section but view-only for inlines."""
2624 self.viewuser.user_permissions.add(
2625 get_perm(Section, get_permission_codename("add", Section._meta))
2626 )
2627 self.client.force_login(self.viewuser)
2628 # Valid POST creates a new section.
2629 data = {
2630 "name": "New obj",
2631 "article_set-TOTAL_FORMS": 0,
2632 "article_set-INITIAL_FORMS": 0,
2633 }
2634 response = self.client.post(reverse("admin:admin_views_section_add"), data)
2635 self.assertRedirects(response, reverse("admin:index"))
2636 self.assertEqual(Section.objects.latest("id").name, data["name"])
2637 # InlineModelAdmin.has_change_permission()'s obj argument is always
2638 # None during object add.
2639 self.assertEqual(
2640 [obj for (request, obj), _ in has_change_permission.call_args_list],
2641 [None, None],
2642 )
2643
2644 def test_change_view(self):
2645 """Change view should restrict access and allow users to edit items."""
2646 change_dict = {
2647 "title": "Ikke fordømt",
2648 "content": "<p>edited article</p>",
2649 "date_0": "2008-03-18",
2650 "date_1": "10:54:39",
2651 "section": self.s1.pk,
2652 }
2653 article_change_url = reverse(
2654 "admin:admin_views_article_change", args=(self.a1.pk,)
2655 )
2656 article_changelist_url = reverse("admin:admin_views_article_changelist")
2657
2658 # add user should not be able to view the list of article or change any of them
2659 self.client.force_login(self.adduser)
2660 response = self.client.get(article_changelist_url)
2661 self.assertEqual(response.status_code, 403)
2662 response = self.client.get(article_change_url)
2663 self.assertEqual(response.status_code, 403)
2664 post = self.client.post(article_change_url, change_dict)
2665 self.assertEqual(post.status_code, 403)
2666 self.client.post(reverse("admin:logout"))
2667
2668 # view user can view articles but not make changes.
2669 self.client.force_login(self.viewuser)
2670 response = self.client.get(article_changelist_url)
2671 self.assertContains(
2672 response,
2673 "<title>Select article to view | Django site admin</title>",
2674 )
2675 self.assertContains(response, "<h1>Select article to view</h1>")
2676 self.assertEqual(response.context["title"], "Select article to view")
2677 response = self.client.get(article_change_url)
2678 self.assertContains(response, "<title>View article | Django site admin</title>")
2679 self.assertContains(response, "<h1>View article</h1>")
2680 self.assertContains(response, "<label>Extra form field:</label>")
2681 self.assertContains(
2682 response,
2683 '<a href="/test_admin/admin/admin_views/article/" class="closelink">Close'
2684 "</a>",
2685 )
2686 self.assertEqual(response.context["title"], "View article")
2687 post = self.client.post(article_change_url, change_dict)
2688 self.assertEqual(post.status_code, 403)
2689 self.assertEqual(
2690 Article.objects.get(pk=self.a1.pk).content, "<p>Middle content</p>"
2691 )
2692 self.client.post(reverse("admin:logout"))
2693
2694 # change user can view all items and edit them
2695 self.client.force_login(self.changeuser)
2696 response = self.client.get(article_changelist_url)
2697 self.assertEqual(response.context["title"], "Select article to change")
2698 self.assertContains(
2699 response,
2700 "<title>Select article to change | Django site admin</title>",
2701 )
2702 self.assertContains(response, "<h1>Select article to change</h1>")
2703 response = self.client.get(article_change_url)
2704 self.assertEqual(response.context["title"], "Change article")
2705 self.assertContains(
2706 response,
2707 "<title>Change article | Django site admin</title>",
2708 )
2709 self.assertContains(response, "<h1>Change article</h1>")
2710 post = self.client.post(article_change_url, change_dict)
2711 self.assertRedirects(post, article_changelist_url)
2712 self.assertEqual(
2713 Article.objects.get(pk=self.a1.pk).content, "<p>edited article</p>"
2714 )
2715
2716 # one error in form should produce singular error message, multiple
2717 # errors plural.
2718 change_dict["title"] = ""
2719 post = self.client.post(article_change_url, change_dict)
2720 self.assertContains(
2721 post,
2722 "Please correct the error below.",
2723 msg_prefix=(
2724 "Singular error message not found in response to post with one error"
2725 ),
2726 )
2727
2728 change_dict["content"] = ""
2729 post = self.client.post(article_change_url, change_dict)
2730 self.assertContains(
2731 post,
2732 "Please correct the errors below.",
2733 msg_prefix=(
2734 "Plural error message not found in response to post with multiple "
2735 "errors"
2736 ),
2737 )
2738 self.client.post(reverse("admin:logout"))
2739
2740 # Test redirection when using row-level change permissions. Refs #11513.
2741 r1 = RowLevelChangePermissionModel.objects.create(id=1, name="odd id")
2742 r2 = RowLevelChangePermissionModel.objects.create(id=2, name="even id")
2743 r3 = RowLevelChangePermissionModel.objects.create(id=3, name="odd id mult 3")
2744 r6 = RowLevelChangePermissionModel.objects.create(id=6, name="even id mult 3")
2745 change_url_1 = reverse(
2746 "admin:admin_views_rowlevelchangepermissionmodel_change", args=(r1.pk,)
2747 )
2748 change_url_2 = reverse(
2749 "admin:admin_views_rowlevelchangepermissionmodel_change", args=(r2.pk,)
2750 )
2751 change_url_3 = reverse(
2752 "admin:admin_views_rowlevelchangepermissionmodel_change", args=(r3.pk,)
2753 )
2754 change_url_6 = reverse(
2755 "admin:admin_views_rowlevelchangepermissionmodel_change", args=(r6.pk,)
2756 )
2757 logins = [
2758 self.superuser,
2759 self.viewuser,
2760 self.adduser,
2761 self.changeuser,
2762 self.deleteuser,
2763 ]
2764 for login_user in logins:
2765 with self.subTest(login_user.username):
2766 self.client.force_login(login_user)
2767 response = self.client.get(change_url_1)
2768 self.assertEqual(response.status_code, 403)
2769 response = self.client.post(change_url_1, {"name": "changed"})
2770 self.assertEqual(
2771 RowLevelChangePermissionModel.objects.get(id=1).name, "odd id"
2772 )
2773 self.assertEqual(response.status_code, 403)
2774 response = self.client.get(change_url_2)
2775 self.assertEqual(response.status_code, 200)
2776 response = self.client.post(change_url_2, {"name": "changed"})
2777 self.assertEqual(
2778 RowLevelChangePermissionModel.objects.get(id=2).name, "changed"
2779 )
2780 self.assertRedirects(response, self.index_url)
2781 response = self.client.get(change_url_3)
2782 self.assertEqual(response.status_code, 200)
2783 response = self.client.post(change_url_3, {"name": "changed"})
2784 self.assertEqual(response.status_code, 403)
2785 self.assertEqual(
2786 RowLevelChangePermissionModel.objects.get(id=3).name,
2787 "odd id mult 3",
2788 )
2789 response = self.client.get(change_url_6)
2790 self.assertEqual(response.status_code, 200)
2791 response = self.client.post(change_url_6, {"name": "changed"})
2792 self.assertEqual(
2793 RowLevelChangePermissionModel.objects.get(id=6).name, "changed"
2794 )
2795 self.assertRedirects(response, self.index_url)
2796
2797 self.client.post(reverse("admin:logout"))
2798
2799 for login_user in [self.joepublicuser, self.nostaffuser]:
2800 with self.subTest(login_user.username):
2801 self.client.force_login(login_user)
2802 response = self.client.get(change_url_1, follow=True)
2803 self.assertContains(response, "login-form")
2804 response = self.client.post(
2805 change_url_1, {"name": "changed"}, follow=True
2806 )
2807 self.assertEqual(
2808 RowLevelChangePermissionModel.objects.get(id=1).name, "odd id"
2809 )
2810 self.assertContains(response, "login-form")
2811 response = self.client.get(change_url_2, follow=True)
2812 self.assertContains(response, "login-form")
2813 response = self.client.post(
2814 change_url_2, {"name": "changed again"}, follow=True
2815 )
2816 self.assertEqual(
2817 RowLevelChangePermissionModel.objects.get(id=2).name, "changed"
2818 )
2819 self.assertContains(response, "login-form")
2820 self.client.post(reverse("admin:logout"))
2821
2822 def test_change_view_without_object_change_permission(self):
2823 """
2824 The object should be read-only if the user has permission to view it
2825 and change objects of that type but not to change the current object.
2826 """
2827 change_url = reverse("admin9:admin_views_article_change", args=(self.a1.pk,))
2828 self.client.force_login(self.viewuser)
2829 response = self.client.get(change_url)
2830 self.assertEqual(response.context["title"], "View article")
2831 self.assertContains(response, "<title>View article | Django site admin</title>")
2832 self.assertContains(response, "<h1>View article</h1>")
2833 self.assertContains(
2834 response,
2835 '<a href="/test_admin/admin9/admin_views/article/" class="closelink">Close'
2836 "</a>",
2837 )
2838
2839 def test_change_view_save_as_new(self):
2840 """
2841 'Save as new' should raise PermissionDenied for users without the 'add'
2842 permission.
2843 """
2844 change_dict_save_as_new = {
2845 "_saveasnew": "Save as new",
2846 "title": "Ikke fordømt",
2847 "content": "<p>edited article</p>",
2848 "date_0": "2008-03-18",
2849 "date_1": "10:54:39",
2850 "section": self.s1.pk,
2851 }
2852 article_change_url = reverse(
2853 "admin:admin_views_article_change", args=(self.a1.pk,)
2854 )
2855
2856 # Add user can perform "Save as new".
2857 article_count = Article.objects.count()
2858 self.client.force_login(self.adduser)
2859 post = self.client.post(article_change_url, change_dict_save_as_new)
2860 self.assertRedirects(post, self.index_url)
2861 self.assertEqual(Article.objects.count(), article_count + 1)
2862 self.client.logout()
2863
2864 # Change user cannot perform "Save as new" (no 'add' permission).
2865 article_count = Article.objects.count()
2866 self.client.force_login(self.changeuser)
2867 post = self.client.post(article_change_url, change_dict_save_as_new)
2868 self.assertEqual(post.status_code, 403)
2869 self.assertEqual(Article.objects.count(), article_count)
2870
2871 # User with both add and change permissions should be redirected to the
2872 # change page for the newly created object.
2873 article_count = Article.objects.count()
2874 self.client.force_login(self.superuser)
2875 post = self.client.post(article_change_url, change_dict_save_as_new)
2876 self.assertEqual(Article.objects.count(), article_count + 1)
2877 new_article = Article.objects.latest("id")
2878 self.assertRedirects(
2879 post, reverse("admin:admin_views_article_change", args=(new_article.pk,))
2880 )
2881
2882 def test_change_view_with_view_only_inlines(self):
2883 """
2884 User with change permission to a section but view-only for inlines.
2885 """
2886 self.viewuser.user_permissions.add(
2887 get_perm(Section, get_permission_codename("change", Section._meta))
2888 )
2889 self.client.force_login(self.viewuser)
2890 # GET shows inlines.
2891 response = self.client.get(
2892 reverse("admin:admin_views_section_change", args=(self.s1.pk,))
2893 )
2894 self.assertEqual(len(response.context["inline_admin_formsets"]), 1)
2895 formset = response.context["inline_admin_formsets"][0]
2896 self.assertEqual(len(formset.forms), 3)
2897 # Valid POST changes the name.
2898 data = {
2899 "name": "Can edit name with view-only inlines",
2900 "article_set-TOTAL_FORMS": 3,
2901 "article_set-INITIAL_FORMS": 3,
2902 }
2903 response = self.client.post(
2904 reverse("admin:admin_views_section_change", args=(self.s1.pk,)), data
2905 )
2906 self.assertRedirects(response, reverse("admin:admin_views_section_changelist"))
2907 self.assertEqual(Section.objects.get(pk=self.s1.pk).name, data["name"])
2908 # Invalid POST reshows inlines.
2909 del data["name"]
2910 response = self.client.post(
2911 reverse("admin:admin_views_section_change", args=(self.s1.pk,)), data
2912 )
2913 self.assertEqual(response.status_code, 200)
2914 self.assertEqual(len(response.context["inline_admin_formsets"]), 1)
2915 formset = response.context["inline_admin_formsets"][0]
2916 self.assertEqual(len(formset.forms), 3)
2917
2918 def test_change_view_with_view_only_last_inline(self):
2919 self.viewuser.user_permissions.add(
2920 get_perm(Section, get_permission_codename("view", Section._meta))
2921 )
2922 self.client.force_login(self.viewuser)
2923 response = self.client.get(
2924 reverse("admin:admin_views_section_change", args=(self.s1.pk,))
2925 )
2926 self.assertEqual(len(response.context["inline_admin_formsets"]), 1)
2927 formset = response.context["inline_admin_formsets"][0]
2928 self.assertEqual(len(formset.forms), 3)
2929 # The last inline is not marked as empty.
2930 self.assertContains(response, 'id="article_set-2"')
2931
2932 def test_change_view_with_view_and_add_inlines(self):
2933 """User has view and add permissions on the inline model."""
2934 self.viewuser.user_permissions.add(
2935 get_perm(Section, get_permission_codename("change", Section._meta))
2936 )
2937 self.viewuser.user_permissions.add(
2938 get_perm(Article, get_permission_codename("add", Article._meta))
2939 )
2940 self.client.force_login(self.viewuser)
2941 # GET shows inlines.
2942 response = self.client.get(
2943 reverse("admin:admin_views_section_change", args=(self.s1.pk,))
2944 )
2945 self.assertEqual(len(response.context["inline_admin_formsets"]), 1)
2946 formset = response.context["inline_admin_formsets"][0]
2947 self.assertEqual(len(formset.forms), 6)
2948 # Valid POST creates a new article.
2949 data = {
2950 "name": "Can edit name with view-only inlines",
2951 "article_set-TOTAL_FORMS": 6,
2952 "article_set-INITIAL_FORMS": 3,
2953 "article_set-3-id": [""],
2954 "article_set-3-title": ["A title"],
2955 "article_set-3-content": ["Added content"],
2956 "article_set-3-date_0": ["2008-3-18"],
2957 "article_set-3-date_1": ["11:54:58"],
2958 "article_set-3-section": [str(self.s1.pk)],
2959 }
2960 response = self.client.post(
2961 reverse("admin:admin_views_section_change", args=(self.s1.pk,)), data
2962 )
2963 self.assertRedirects(response, reverse("admin:admin_views_section_changelist"))
2964 self.assertEqual(Section.objects.get(pk=self.s1.pk).name, data["name"])
2965 self.assertEqual(Article.objects.count(), 4)
2966 # Invalid POST reshows inlines.
2967 del data["name"]
2968 response = self.client.post(
2969 reverse("admin:admin_views_section_change", args=(self.s1.pk,)), data
2970 )
2971 self.assertEqual(response.status_code, 200)
2972 self.assertEqual(len(response.context["inline_admin_formsets"]), 1)
2973 formset = response.context["inline_admin_formsets"][0]
2974 self.assertEqual(len(formset.forms), 6)
2975
2976 def test_change_view_with_view_and_delete_inlines(self):
2977 """User has view and delete permissions on the inline model."""
2978 self.viewuser.user_permissions.add(
2979 get_perm(Section, get_permission_codename("change", Section._meta))
2980 )
2981 self.client.force_login(self.viewuser)
2982 data = {
2983 "name": "Name is required.",
2984 "article_set-TOTAL_FORMS": 6,
2985 "article_set-INITIAL_FORMS": 3,
2986 "article_set-0-id": [str(self.a1.pk)],
2987 "article_set-0-DELETE": ["on"],
2988 }
2989 # Inline POST details are ignored without delete permission.
2990 response = self.client.post(
2991 reverse("admin:admin_views_section_change", args=(self.s1.pk,)), data
2992 )
2993 self.assertRedirects(response, reverse("admin:admin_views_section_changelist"))
2994 self.assertEqual(Article.objects.count(), 3)
2995 # Deletion successful when delete permission is added.
2996 self.viewuser.user_permissions.add(
2997 get_perm(Article, get_permission_codename("delete", Article._meta))
2998 )
2999 data = {
3000 "name": "Name is required.",
3001 "article_set-TOTAL_FORMS": 6,
3002 "article_set-INITIAL_FORMS": 3,
3003 "article_set-0-id": [str(self.a1.pk)],
3004 "article_set-0-DELETE": ["on"],
3005 }
3006 response = self.client.post(
3007 reverse("admin:admin_views_section_change", args=(self.s1.pk,)), data
3008 )
3009 self.assertRedirects(response, reverse("admin:admin_views_section_changelist"))
3010 self.assertEqual(Article.objects.count(), 2)
3011
3012 def test_delete_view(self):
3013 """Delete view should restrict access and actually delete items."""
3014 delete_dict = {"post": "yes"}
3015 delete_url = reverse("admin:admin_views_article_delete", args=(self.a1.pk,))
3016
3017 # add user should not be able to delete articles
3018 self.client.force_login(self.adduser)
3019 response = self.client.get(delete_url)
3020 self.assertEqual(response.status_code, 403)
3021 post = self.client.post(delete_url, delete_dict)
3022 self.assertEqual(post.status_code, 403)
3023 self.assertEqual(Article.objects.count(), 3)
3024 self.client.logout()
3025
3026 # view user should not be able to delete articles
3027 self.client.force_login(self.viewuser)
3028 response = self.client.get(delete_url)
3029 self.assertEqual(response.status_code, 403)
3030 post = self.client.post(delete_url, delete_dict)
3031 self.assertEqual(post.status_code, 403)
3032 self.assertEqual(Article.objects.count(), 3)
3033 self.client.logout()
3034
3035 # Delete user can delete
3036 self.client.force_login(self.deleteuser)
3037 response = self.client.get(
3038 reverse("admin:admin_views_section_delete", args=(self.s1.pk,))
3039 )
3040 self.assertContains(response, "<h1>Delete</h1>")
3041 self.assertContains(response, "<h2>Summary</h2>")
3042 self.assertContains(response, "<li>Articles: 3</li>")
3043 # test response contains link to related Article
3044 self.assertContains(response, "admin_views/article/%s/" % self.a1.pk)
3045
3046 response = self.client.get(delete_url)
3047 self.assertContains(response, "admin_views/article/%s/" % self.a1.pk)
3048 self.assertContains(response, "<h2>Summary</h2>")
3049 self.assertContains(response, "<li>Articles: 1</li>")
3050 post = self.client.post(delete_url, delete_dict)
3051 self.assertRedirects(post, self.index_url)
3052 self.assertEqual(Article.objects.count(), 2)
3053 self.assertEqual(len(mail.outbox), 1)
3054 self.assertEqual(mail.outbox[0].subject, "Greetings from a deleted object")
3055 article_ct = ContentType.objects.get_for_model(Article)
3056 logged = LogEntry.objects.get(content_type=article_ct, action_flag=DELETION)
3057 self.assertEqual(logged.object_id, str(self.a1.pk))
3058
3059 def test_delete_view_with_no_default_permissions(self):
3060 """
3061 The delete view allows users to delete collected objects without a
3062 'delete' permission (ReadOnlyPizza.Meta.default_permissions is empty).
3063 """
3064 pizza = ReadOnlyPizza.objects.create(name="Double Cheese")
3065 delete_url = reverse("admin:admin_views_readonlypizza_delete", args=(pizza.pk,))
3066 self.client.force_login(self.adduser)
3067 response = self.client.get(delete_url)
3068 self.assertContains(response, "admin_views/readonlypizza/%s/" % pizza.pk)
3069 self.assertContains(response, "<h2>Summary</h2>")
3070 self.assertContains(response, "<li>Read only pizzas: 1</li>")
3071 post = self.client.post(delete_url, {"post": "yes"})
3072 self.assertRedirects(
3073 post, reverse("admin:admin_views_readonlypizza_changelist")
3074 )
3075 self.assertEqual(ReadOnlyPizza.objects.count(), 0)
3076
3077 def test_delete_view_nonexistent_obj(self):
3078 self.client.force_login(self.deleteuser)
3079 url = reverse("admin:admin_views_article_delete", args=("nonexistent",))
3080 response = self.client.get(url, follow=True)
3081 self.assertRedirects(response, reverse("admin:index"))
3082 self.assertEqual(
3083 [m.message for m in response.context["messages"]],
3084 ["article with ID “nonexistent” doesn’t exist. Perhaps it was deleted?"],
3085 )
3086
3087 def test_history_view(self):
3088 """History view should restrict access."""
3089 # add user should not be able to view the list of article or change any of them
3090 self.client.force_login(self.adduser)
3091 response = self.client.get(
3092 reverse("admin:admin_views_article_history", args=(self.a1.pk,))
3093 )
3094 self.assertEqual(response.status_code, 403)
3095 self.client.post(reverse("admin:logout"))
3096
3097 # view user can view all items
3098 self.client.force_login(self.viewuser)
3099 response = self.client.get(
3100 reverse("admin:admin_views_article_history", args=(self.a1.pk,))
3101 )
3102 self.assertEqual(response.status_code, 200)
3103 self.client.post(reverse("admin:logout"))
3104
3105 # change user can view all items and edit them
3106 self.client.force_login(self.changeuser)
3107 response = self.client.get(
3108 reverse("admin:admin_views_article_history", args=(self.a1.pk,))
3109 )
3110 self.assertEqual(response.status_code, 200)
3111
3112 # Test redirection when using row-level change permissions. Refs #11513.
3113 rl1 = RowLevelChangePermissionModel.objects.create(id=1, name="odd id")
3114 rl2 = RowLevelChangePermissionModel.objects.create(id=2, name="even id")
3115 logins = [
3116 self.superuser,
3117 self.viewuser,
3118 self.adduser,
3119 self.changeuser,
3120 self.deleteuser,
3121 ]
3122 for login_user in logins:
3123 with self.subTest(login_user.username):
3124 self.client.force_login(login_user)
3125 url = reverse(
3126 "admin:admin_views_rowlevelchangepermissionmodel_history",
3127 args=(rl1.pk,),
3128 )
3129 response = self.client.get(url)
3130 self.assertEqual(response.status_code, 403)
3131
3132 url = reverse(
3133 "admin:admin_views_rowlevelchangepermissionmodel_history",
3134 args=(rl2.pk,),
3135 )
3136 response = self.client.get(url)
3137 self.assertEqual(response.status_code, 200)
3138
3139 self.client.post(reverse("admin:logout"))
3140
3141 for login_user in [self.joepublicuser, self.nostaffuser]:
3142 with self.subTest(login_user.username):
3143 self.client.force_login(login_user)
3144 url = reverse(
3145 "admin:admin_views_rowlevelchangepermissionmodel_history",
3146 args=(rl1.pk,),
3147 )
3148 response = self.client.get(url, follow=True)
3149 self.assertContains(response, "login-form")
3150 url = reverse(
3151 "admin:admin_views_rowlevelchangepermissionmodel_history",
3152 args=(rl2.pk,),
3153 )
3154 response = self.client.get(url, follow=True)
3155 self.assertContains(response, "login-form")
3156
3157 self.client.post(reverse("admin:logout"))
3158
3159 def test_history_view_bad_url(self):
3160 self.client.force_login(self.changeuser)
3161 response = self.client.get(
3162 reverse("admin:admin_views_article_history", args=("foo",)), follow=True
3163 )
3164 self.assertRedirects(response, reverse("admin:index"))
3165 self.assertEqual(
3166 [m.message for m in response.context["messages"]],
3167 ["article with ID “foo” doesn’t exist. Perhaps it was deleted?"],
3168 )
3169
3170 def test_conditionally_show_add_section_link(self):
3171 """
3172 The foreign key widget should only show the "add related" button if the
3173 user has permission to add that related item.
3174 """
3175 self.client.force_login(self.adduser)
3176 # The user can't add sections yet, so they shouldn't see the "add section" link.
3177 url = reverse("admin:admin_views_article_add")
3178 add_link_text = "add_id_section"
3179 response = self.client.get(url)
3180 self.assertNotContains(response, add_link_text)
3181 # Allow the user to add sections too. Now they can see the "add section" link.
3182 user = User.objects.get(username="adduser")
3183 perm = get_perm(Section, get_permission_codename("add", Section._meta))
3184 user.user_permissions.add(perm)
3185 response = self.client.get(url)
3186 self.assertContains(response, add_link_text)
3187
3188 def test_conditionally_show_change_section_link(self):
3189 """
3190 The foreign key widget should only show the "change related" button if
3191 the user has permission to change that related item.
3192 """
3193
3194 def get_change_related(response):
3195 return (
3196 response.context["adminform"]
3197 .form.fields["section"]
3198 .widget.can_change_related
3199 )
3200
3201 self.client.force_login(self.adduser)
3202 # The user can't change sections yet, so they shouldn't see the
3203 # "change section" link.
3204 url = reverse("admin:admin_views_article_add")
3205 change_link_text = "change_id_section"
3206 response = self.client.get(url)
3207 self.assertFalse(get_change_related(response))
3208 self.assertNotContains(response, change_link_text)
3209 # Allow the user to change sections too. Now they can see the
3210 # "change section" link.
3211 user = User.objects.get(username="adduser")
3212 perm = get_perm(Section, get_permission_codename("change", Section._meta))
3213 user.user_permissions.add(perm)
3214 response = self.client.get(url)
3215 self.assertTrue(get_change_related(response))
3216 self.assertContains(response, change_link_text)
3217
3218 def test_conditionally_show_delete_section_link(self):
3219 """
3220 The foreign key widget should only show the "delete related" button if
3221 the user has permission to delete that related item.
3222 """
3223
3224 def get_delete_related(response):
3225 return (
3226 response.context["adminform"]
3227 .form.fields["sub_section"]
3228 .widget.can_delete_related
3229 )
3230
3231 self.client.force_login(self.adduser)
3232 # The user can't delete sections yet, so they shouldn't see the
3233 # "delete section" link.
3234 url = reverse("admin:admin_views_article_add")
3235 delete_link_text = "delete_id_sub_section"
3236 response = self.client.get(url)
3237 self.assertFalse(get_delete_related(response))
3238 self.assertNotContains(response, delete_link_text)
3239 # Allow the user to delete sections too. Now they can see the
3240 # "delete section" link.
3241 user = User.objects.get(username="adduser")
3242 perm = get_perm(Section, get_permission_codename("delete", Section._meta))
3243 user.user_permissions.add(perm)
3244 response = self.client.get(url)
3245 self.assertTrue(get_delete_related(response))
3246 self.assertContains(response, delete_link_text)
3247
3248 def test_disabled_permissions_when_logged_in(self):
3249 self.client.force_login(self.superuser)
3250 superuser = User.objects.get(username="super")
3251 superuser.is_active = False
3252 superuser.save()
3253
3254 response = self.client.get(self.index_url, follow=True)
3255 self.assertContains(response, 'id="login-form"')
3256 self.assertNotContains(response, "Log out")
3257
3258 response = self.client.get(reverse("secure_view"), follow=True)
3259 self.assertContains(response, 'id="login-form"')
3260
3261 def test_disabled_staff_permissions_when_logged_in(self):
3262 self.client.force_login(self.superuser)
3263 superuser = User.objects.get(username="super")
3264 superuser.is_staff = False
3265 superuser.save()
3266
3267 response = self.client.get(self.index_url, follow=True)
3268 self.assertContains(response, 'id="login-form"')
3269 self.assertNotContains(response, "Log out")
3270
3271 response = self.client.get(reverse("secure_view"), follow=True)
3272 self.assertContains(response, 'id="login-form"')
3273
3274 def test_app_list_permissions(self):
3275 """
3276 If a user has no module perms, the app list returns a 404.
3277 """
3278 opts = Article._meta
3279 change_user = User.objects.get(username="changeuser")
3280 permission = get_perm(Article, get_permission_codename("change", opts))
3281
3282 self.client.force_login(self.changeuser)
3283
3284 # the user has no module permissions
3285 change_user.user_permissions.remove(permission)
3286 response = self.client.get(reverse("admin:app_list", args=("admin_views",)))
3287 self.assertEqual(response.status_code, 404)
3288
3289 # the user now has module permissions
3290 change_user.user_permissions.add(permission)
3291 response = self.client.get(reverse("admin:app_list", args=("admin_views",)))
3292 self.assertEqual(response.status_code, 200)
3293
3294 def test_shortcut_view_only_available_to_staff(self):
3295 """
3296 Only admin users should be able to use the admin shortcut view.
3297 """
3298 model_ctype = ContentType.objects.get_for_model(ModelWithStringPrimaryKey)
3299 obj = ModelWithStringPrimaryKey.objects.create(string_pk="foo")
3300 shortcut_url = reverse("admin:view_on_site", args=(model_ctype.pk, obj.pk))
3301
3302 # Not logged in: we should see the login page.
3303 response = self.client.get(shortcut_url, follow=True)
3304 self.assertTemplateUsed(response, "admin/login.html")
3305
3306 # Logged in? Redirect.
3307 self.client.force_login(self.superuser)
3308 response = self.client.get(shortcut_url, follow=False)
3309 # Can't use self.assertRedirects() because User.get_absolute_url() is silly.
3310 self.assertEqual(response.status_code, 302)
3311 # Domain may depend on contrib.sites tests also run
3312 self.assertRegex(response.url, "http://(testserver|example.com)/dummy/foo/")
3313
3314 def test_has_module_permission(self):
3315 """
3316 has_module_permission() returns True for all users who
3317 have any permission for that module (add, change, or delete), so that
3318 the module is displayed on the admin index page.
3319 """
3320 self.client.force_login(self.superuser)
3321 response = self.client.get(self.index_url)
3322 self.assertContains(response, "admin_views")
3323 self.assertContains(response, "Articles")
3324 self.client.logout()
3325
3326 self.client.force_login(self.viewuser)
3327 response = self.client.get(self.index_url)
3328 self.assertContains(response, "admin_views")
3329 self.assertContains(response, "Articles")
3330 self.client.logout()
3331
3332 self.client.force_login(self.adduser)
3333 response = self.client.get(self.index_url)
3334 self.assertContains(response, "admin_views")
3335 self.assertContains(response, "Articles")
3336 self.client.logout()
3337
3338 self.client.force_login(self.changeuser)
3339 response = self.client.get(self.index_url)
3340 self.assertContains(response, "admin_views")
3341 self.assertContains(response, "Articles")
3342 self.client.logout()
3343
3344 self.client.force_login(self.deleteuser)
3345 response = self.client.get(self.index_url)
3346 self.assertContains(response, "admin_views")
3347 self.assertContains(response, "Articles")
3348
3349 def test_overriding_has_module_permission(self):
3350 """
3351 If has_module_permission() always returns False, the module shouldn't
3352 be displayed on the admin index page for any users.
3353 """
3354 articles = Article._meta.verbose_name_plural.title()
3355 sections = Section._meta.verbose_name_plural.title()
3356 index_url = reverse("admin7:index")
3357
3358 self.client.force_login(self.superuser)
3359 response = self.client.get(index_url)
3360 self.assertContains(response, sections)
3361 self.assertNotContains(response, articles)
3362 self.client.logout()
3363
3364 self.client.force_login(self.viewuser)
3365 response = self.client.get(index_url)
3366 self.assertNotContains(response, "admin_views")
3367 self.assertNotContains(response, articles)
3368 self.client.logout()
3369
3370 self.client.force_login(self.adduser)
3371 response = self.client.get(index_url)
3372 self.assertNotContains(response, "admin_views")
3373 self.assertNotContains(response, articles)
3374 self.client.logout()
3375
3376 self.client.force_login(self.changeuser)
3377 response = self.client.get(index_url)
3378 self.assertNotContains(response, "admin_views")
3379 self.assertNotContains(response, articles)
3380 self.client.logout()
3381
3382 self.client.force_login(self.deleteuser)
3383 response = self.client.get(index_url)
3384 self.assertNotContains(response, articles)
3385
3386 # The app list displays Sections but not Articles as the latter has
3387 # ModelAdmin.has_module_permission() = False.
3388 self.client.force_login(self.superuser)
3389 response = self.client.get(reverse("admin7:app_list", args=("admin_views",)))
3390 self.assertContains(response, sections)
3391 self.assertNotContains(response, articles)
3392
3393 def test_post_save_message_no_forbidden_links_visible(self):
3394 """
3395 Post-save message shouldn't contain a link to the change form if the
3396 user doesn't have the change permission.
3397 """
3398 self.client.force_login(self.adduser)
3399 # Emulate Article creation for user with add-only permission.
3400 post_data = {
3401 "title": "Fun & games",
3402 "content": "Some content",
3403 "date_0": "2015-10-31",
3404 "date_1": "16:35:00",
3405 "_save": "Save",
3406 }
3407 response = self.client.post(
3408 reverse("admin:admin_views_article_add"), post_data, follow=True
3409 )
3410 self.assertContains(
3411 response,
3412 '<li class="success">The article “Fun &amp; games” was added successfully.'
3413 "</li>",
3414 html=True,
3415 )
3416
3417
3418 @override_settings(
3419 ROOT_URLCONF="admin_views.urls",
3420 TEMPLATES=[
3421 {
3422 "BACKEND": "django.template.backends.django.DjangoTemplates",
3423 "APP_DIRS": True,
3424 "OPTIONS": {
3425 "context_processors": [
3426 "django.template.context_processors.request",
3427 "django.contrib.auth.context_processors.auth",
3428 "django.contrib.messages.context_processors.messages",
3429 ],
3430 },
3431 }
3432 ],
3433 )
3434 class AdminViewProxyModelPermissionsTests(TestCase):
3435 """Tests for proxy models permissions in the admin."""
3436
3437 @classmethod
3438 def setUpTestData(cls):
3439 cls.viewuser = User.objects.create_user(
3440 username="viewuser", password="secret", is_staff=True
3441 )
3442 cls.adduser = User.objects.create_user(
3443 username="adduser", password="secret", is_staff=True
3444 )
3445 cls.changeuser = User.objects.create_user(
3446 username="changeuser", password="secret", is_staff=True
3447 )
3448 cls.deleteuser = User.objects.create_user(
3449 username="deleteuser", password="secret", is_staff=True
3450 )
3451 # Setup permissions.
3452 opts = UserProxy._meta
3453 cls.viewuser.user_permissions.add(
3454 get_perm(UserProxy, get_permission_codename("view", opts))
3455 )
3456 cls.adduser.user_permissions.add(
3457 get_perm(UserProxy, get_permission_codename("add", opts))
3458 )
3459 cls.changeuser.user_permissions.add(
3460 get_perm(UserProxy, get_permission_codename("change", opts))
3461 )
3462 cls.deleteuser.user_permissions.add(
3463 get_perm(UserProxy, get_permission_codename("delete", opts))
3464 )
3465 # UserProxy instances.
3466 cls.user_proxy = UserProxy.objects.create(
3467 username="user_proxy", password="secret"
3468 )
3469
3470 def test_add(self):
3471 self.client.force_login(self.adduser)
3472 url = reverse("admin:admin_views_userproxy_add")
3473 data = {
3474 "username": "can_add",
3475 "password": "secret",
3476 "date_joined_0": "2019-01-15",
3477 "date_joined_1": "16:59:10",
3478 }
3479 response = self.client.post(url, data, follow=True)
3480 self.assertEqual(response.status_code, 200)
3481 self.assertTrue(UserProxy.objects.filter(username="can_add").exists())
3482
3483 def test_view(self):
3484 self.client.force_login(self.viewuser)
3485 response = self.client.get(reverse("admin:admin_views_userproxy_changelist"))
3486 self.assertContains(response, "<h1>Select user proxy to view</h1>")
3487 response = self.client.get(
3488 reverse("admin:admin_views_userproxy_change", args=(self.user_proxy.pk,))
3489 )
3490 self.assertContains(response, "<h1>View user proxy</h1>")
3491 self.assertContains(response, '<div class="readonly">user_proxy</div>')
3492
3493 def test_change(self):
3494 self.client.force_login(self.changeuser)
3495 data = {
3496 "password": self.user_proxy.password,
3497 "username": self.user_proxy.username,
3498 "date_joined_0": self.user_proxy.date_joined.strftime("%Y-%m-%d"),
3499 "date_joined_1": self.user_proxy.date_joined.strftime("%H:%M:%S"),
3500 "first_name": "first_name",
3501 }
3502 url = reverse("admin:admin_views_userproxy_change", args=(self.user_proxy.pk,))
3503 response = self.client.post(url, data)
3504 self.assertRedirects(
3505 response, reverse("admin:admin_views_userproxy_changelist")
3506 )
3507 self.assertEqual(
3508 UserProxy.objects.get(pk=self.user_proxy.pk).first_name, "first_name"
3509 )
3510
3511 def test_delete(self):
3512 self.client.force_login(self.deleteuser)
3513 url = reverse("admin:admin_views_userproxy_delete", args=(self.user_proxy.pk,))
3514 response = self.client.post(url, {"post": "yes"}, follow=True)
3515 self.assertEqual(response.status_code, 200)
3516 self.assertFalse(UserProxy.objects.filter(pk=self.user_proxy.pk).exists())
3517
3518
3519 @override_settings(ROOT_URLCONF="admin_views.urls")
3520 class AdminViewsNoUrlTest(TestCase):
3521 """Regression test for #17333"""
3522
3523 @classmethod
3524 def setUpTestData(cls):
3525 # User who can change Reports
3526 cls.changeuser = User.objects.create_user(
3527 username="changeuser", password="secret", is_staff=True
3528 )
3529 cls.changeuser.user_permissions.add(
3530 get_perm(Report, get_permission_codename("change", Report._meta))
3531 )
3532
3533 def test_no_standard_modeladmin_urls(self):
3534 """Admin index views don't break when user's ModelAdmin removes standard urls"""
3535 self.client.force_login(self.changeuser)
3536 r = self.client.get(reverse("admin:index"))
3537 # we shouldn't get a 500 error caused by a NoReverseMatch
3538 self.assertEqual(r.status_code, 200)
3539 self.client.post(reverse("admin:logout"))
3540
3541
3542 @skipUnlessDBFeature("can_defer_constraint_checks")
3543 @override_settings(ROOT_URLCONF="admin_views.urls")
3544 class AdminViewDeletedObjectsTest(TestCase):
3545 @classmethod
3546 def setUpTestData(cls):
3547 cls.superuser = User.objects.create_superuser(
3548 username="super", password="secret", email="[email protected]"
3549 )
3550 cls.deleteuser = User.objects.create_user(
3551 username="deleteuser", password="secret", is_staff=True
3552 )
3553 cls.s1 = Section.objects.create(name="Test section")
3554 cls.a1 = Article.objects.create(
3555 content="<p>Middle content</p>",
3556 date=datetime.datetime(2008, 3, 18, 11, 54, 58),
3557 section=cls.s1,
3558 )
3559 cls.a2 = Article.objects.create(
3560 content="<p>Oldest content</p>",
3561 date=datetime.datetime(2000, 3, 18, 11, 54, 58),
3562 section=cls.s1,
3563 )
3564 cls.a3 = Article.objects.create(
3565 content="<p>Newest content</p>",
3566 date=datetime.datetime(2009, 3, 18, 11, 54, 58),
3567 section=cls.s1,
3568 )
3569 cls.p1 = PrePopulatedPost.objects.create(
3570 title="A Long Title", published=True, slug="a-long-title"
3571 )
3572
3573 cls.v1 = Villain.objects.create(name="Adam")
3574 cls.v2 = Villain.objects.create(name="Sue")
3575 cls.sv1 = SuperVillain.objects.create(name="Bob")
3576 cls.pl1 = Plot.objects.create(
3577 name="World Domination", team_leader=cls.v1, contact=cls.v2
3578 )
3579 cls.pl2 = Plot.objects.create(
3580 name="World Peace", team_leader=cls.v2, contact=cls.v2
3581 )
3582 cls.pl3 = Plot.objects.create(
3583 name="Corn Conspiracy", team_leader=cls.v1, contact=cls.v1
3584 )
3585 cls.pd1 = PlotDetails.objects.create(details="almost finished", plot=cls.pl1)
3586 cls.sh1 = SecretHideout.objects.create(
3587 location="underground bunker", villain=cls.v1
3588 )
3589 cls.sh2 = SecretHideout.objects.create(
3590 location="floating castle", villain=cls.sv1
3591 )
3592 cls.ssh1 = SuperSecretHideout.objects.create(
3593 location="super floating castle!", supervillain=cls.sv1
3594 )
3595 cls.cy1 = CyclicOne.objects.create(pk=1, name="I am recursive", two_id=1)
3596 cls.cy2 = CyclicTwo.objects.create(pk=1, name="I am recursive too", one_id=1)
3597
3598 def setUp(self):
3599 self.client.force_login(self.superuser)
3600
3601 def test_nesting(self):
3602 """
3603 Objects should be nested to display the relationships that
3604 cause them to be scheduled for deletion.
3605 """
3606 pattern = re.compile(
3607 r'<li>Plot: <a href="%s">World Domination</a>\s*<ul>\s*'
3608 r'<li>Plot details: <a href="%s">almost finished</a>'
3609 % (
3610 reverse("admin:admin_views_plot_change", args=(self.pl1.pk,)),
3611 reverse("admin:admin_views_plotdetails_change", args=(self.pd1.pk,)),
3612 )
3613 )
3614 response = self.client.get(
3615 reverse("admin:admin_views_villain_delete", args=(self.v1.pk,))
3616 )
3617 self.assertRegex(response.text, pattern)
3618
3619 def test_cyclic(self):
3620 """
3621 Cyclic relationships should still cause each object to only be
3622 listed once.
3623 """
3624 one = '<li>Cyclic one: <a href="%s">I am recursive</a>' % (
3625 reverse("admin:admin_views_cyclicone_change", args=(self.cy1.pk,)),
3626 )
3627 two = '<li>Cyclic two: <a href="%s">I am recursive too</a>' % (
3628 reverse("admin:admin_views_cyclictwo_change", args=(self.cy2.pk,)),
3629 )
3630 response = self.client.get(
3631 reverse("admin:admin_views_cyclicone_delete", args=(self.cy1.pk,))
3632 )
3633
3634 self.assertContains(response, one, 1)
3635 self.assertContains(response, two, 1)
3636
3637 def test_perms_needed(self):
3638 self.client.logout()
3639 delete_user = User.objects.get(username="deleteuser")
3640 delete_user.user_permissions.add(
3641 get_perm(Plot, get_permission_codename("delete", Plot._meta))
3642 )
3643
3644 self.client.force_login(self.deleteuser)
3645 response = self.client.get(
3646 reverse("admin:admin_views_plot_delete", args=(self.pl1.pk,))
3647 )
3648 self.assertContains(
3649 response,
3650 "your account doesn't have permission to delete the following types of "
3651 "objects",
3652 )
3653 self.assertContains(response, "<li>plot details</li>")
3654
3655 def test_protected(self):
3656 q = Question.objects.create(question="Why?")
3657 a1 = Answer.objects.create(question=q, answer="Because.")
3658 a2 = Answer.objects.create(question=q, answer="Yes.")
3659
3660 response = self.client.get(
3661 reverse("admin:admin_views_question_delete", args=(q.pk,))
3662 )
3663 self.assertContains(
3664 response, "would require deleting the following protected related objects"
3665 )
3666 self.assertContains(
3667 response,
3668 '<li>Answer: <a href="%s">Because.</a></li>'
3669 % reverse("admin:admin_views_answer_change", args=(a1.pk,)),
3670 )
3671 self.assertContains(
3672 response,
3673 '<li>Answer: <a href="%s">Yes.</a></li>'
3674 % reverse("admin:admin_views_answer_change", args=(a2.pk,)),
3675 )
3676
3677 def test_post_delete_protected(self):
3678 """
3679 A POST request to delete protected objects should display the page
3680 which says the deletion is prohibited.
3681 """
3682 q = Question.objects.create(question="Why?")
3683 Answer.objects.create(question=q, answer="Because.")
3684
3685 response = self.client.post(
3686 reverse("admin:admin_views_question_delete", args=(q.pk,)), {"post": "yes"}
3687 )
3688 self.assertEqual(Question.objects.count(), 1)
3689 self.assertContains(
3690 response, "would require deleting the following protected related objects"
3691 )
3692
3693 def test_restricted(self):
3694 album = Album.objects.create(title="Amaryllis")
3695 song = Song.objects.create(album=album, name="Unity")
3696 response = self.client.get(
3697 reverse("admin:admin_views_album_delete", args=(album.pk,))
3698 )
3699 self.assertContains(
3700 response,
3701 "would require deleting the following protected related objects",
3702 )
3703 self.assertContains(
3704 response,
3705 '<li>Song: <a href="%s">Unity</a></li>'
3706 % reverse("admin:admin_views_song_change", args=(song.pk,)),
3707 )
3708
3709 def test_post_delete_restricted(self):
3710 album = Album.objects.create(title="Amaryllis")
3711 Song.objects.create(album=album, name="Unity")
3712 response = self.client.post(
3713 reverse("admin:admin_views_album_delete", args=(album.pk,)),
3714 {"post": "yes"},
3715 )
3716 self.assertEqual(Album.objects.count(), 1)
3717 self.assertContains(
3718 response,
3719 "would require deleting the following protected related objects",
3720 )
3721
3722 def test_not_registered(self):
3723 should_contain = """<li>Secret hideout: underground bunker"""
3724 response = self.client.get(
3725 reverse("admin:admin_views_villain_delete", args=(self.v1.pk,))
3726 )
3727 self.assertContains(response, should_contain, 1)
3728
3729 def test_multiple_fkeys_to_same_model(self):
3730 """
3731 If a deleted object has two relationships from another model,
3732 both of those should be followed in looking for related
3733 objects to delete.
3734 """
3735 should_contain = '<li>Plot: <a href="%s">World Domination</a>' % reverse(
3736 "admin:admin_views_plot_change", args=(self.pl1.pk,)
3737 )
3738 response = self.client.get(
3739 reverse("admin:admin_views_villain_delete", args=(self.v1.pk,))
3740 )
3741 self.assertContains(response, should_contain)
3742 response = self.client.get(
3743 reverse("admin:admin_views_villain_delete", args=(self.v2.pk,))
3744 )
3745 self.assertContains(response, should_contain)
3746
3747 def test_multiple_fkeys_to_same_instance(self):
3748 """
3749 If a deleted object has two relationships pointing to it from
3750 another object, the other object should still only be listed
3751 once.
3752 """
3753 should_contain = '<li>Plot: <a href="%s">World Peace</a></li>' % reverse(
3754 "admin:admin_views_plot_change", args=(self.pl2.pk,)
3755 )
3756 response = self.client.get(
3757 reverse("admin:admin_views_villain_delete", args=(self.v2.pk,))
3758 )
3759 self.assertContains(response, should_contain, 1)
3760
3761 def test_inheritance(self):
3762 """
3763 In the case of an inherited model, if either the child or
3764 parent-model instance is deleted, both instances are listed
3765 for deletion, as well as any relationships they have.
3766 """
3767 should_contain = [
3768 '<li>Villain: <a href="%s">Bob</a>'
3769 % reverse("admin:admin_views_villain_change", args=(self.sv1.pk,)),
3770 '<li>Super villain: <a href="%s">Bob</a>'
3771 % reverse("admin:admin_views_supervillain_change", args=(self.sv1.pk,)),
3772 "<li>Secret hideout: floating castle",
3773 "<li>Super secret hideout: super floating castle!",
3774 ]
3775 response = self.client.get(
3776 reverse("admin:admin_views_villain_delete", args=(self.sv1.pk,))
3777 )
3778 for should in should_contain:
3779 self.assertContains(response, should, 1)
3780 response = self.client.get(
3781 reverse("admin:admin_views_supervillain_delete", args=(self.sv1.pk,))
3782 )
3783 for should in should_contain:
3784 self.assertContains(response, should, 1)
3785
3786 def test_generic_relations(self):
3787 """
3788 If a deleted object has GenericForeignKeys pointing to it,
3789 those objects should be listed for deletion.
3790 """
3791 plot = self.pl3
3792 tag = FunkyTag.objects.create(content_object=plot, name="hott")
3793 should_contain = '<li>Funky tag: <a href="%s">hott' % reverse(
3794 "admin:admin_views_funkytag_change", args=(tag.id,)
3795 )
3796 response = self.client.get(
3797 reverse("admin:admin_views_plot_delete", args=(plot.pk,))
3798 )
3799 self.assertContains(response, should_contain)
3800
3801 def test_generic_relations_with_related_query_name(self):
3802 """
3803 If a deleted object has GenericForeignKey with
3804 GenericRelation(related_query_name='...') pointing to it, those objects
3805 should be listed for deletion.
3806 """
3807 bookmark = Bookmark.objects.create(name="djangoproject")
3808 tag = FunkyTag.objects.create(content_object=bookmark, name="django")
3809 tag_url = reverse("admin:admin_views_funkytag_change", args=(tag.id,))
3810 should_contain = '<li>Funky tag: <a href="%s">django' % tag_url
3811 response = self.client.get(
3812 reverse("admin:admin_views_bookmark_delete", args=(bookmark.pk,))
3813 )
3814 self.assertContains(response, should_contain)
3815
3816 def test_delete_view_uses_get_deleted_objects(self):
3817 """The delete view uses ModelAdmin.get_deleted_objects()."""
3818 book = Book.objects.create(name="Test Book")
3819 response = self.client.get(
3820 reverse("admin2:admin_views_book_delete", args=(book.pk,))
3821 )
3822 # BookAdmin.get_deleted_objects() returns custom text.
3823 self.assertContains(response, "a deletable object")
3824
3825
3826 @override_settings(ROOT_URLCONF="admin_views.urls")
3827 class TestGenericRelations(TestCase):
3828 @classmethod
3829 def setUpTestData(cls):
3830 cls.superuser = User.objects.create_superuser(
3831 username="super", password="secret", email="[email protected]"
3832 )
3833 cls.v1 = Villain.objects.create(name="Adam")
3834 cls.pl3 = Plot.objects.create(
3835 name="Corn Conspiracy", team_leader=cls.v1, contact=cls.v1
3836 )
3837
3838 def setUp(self):
3839 self.client.force_login(self.superuser)
3840
3841 def test_generic_content_object_in_list_display(self):
3842 FunkyTag.objects.create(content_object=self.pl3, name="hott")
3843 response = self.client.get(reverse("admin:admin_views_funkytag_changelist"))
3844 self.assertContains(response, "%s</td>" % self.pl3)
3845
3846
3847 @override_settings(ROOT_URLCONF="admin_views.urls")
3848 class AdminViewStringPrimaryKeyTest(TestCase):
3849 @classmethod
3850 def setUpTestData(cls):
3851 cls.superuser = User.objects.create_superuser(
3852 username="super", password="secret", email="[email protected]"
3853 )
3854 cls.s1 = Section.objects.create(name="Test section")
3855 cls.a1 = Article.objects.create(
3856 content="<p>Middle content</p>",
3857 date=datetime.datetime(2008, 3, 18, 11, 54, 58),
3858 section=cls.s1,
3859 )
3860 cls.a2 = Article.objects.create(
3861 content="<p>Oldest content</p>",
3862 date=datetime.datetime(2000, 3, 18, 11, 54, 58),
3863 section=cls.s1,
3864 )
3865 cls.a3 = Article.objects.create(
3866 content="<p>Newest content</p>",
3867 date=datetime.datetime(2009, 3, 18, 11, 54, 58),
3868 section=cls.s1,
3869 )
3870 cls.p1 = PrePopulatedPost.objects.create(
3871 title="A Long Title", published=True, slug="a-long-title"
3872 )
3873 cls.pk = (
3874 "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 "
3875 r"""-_.!~*'() ;/?:@&=+$, <>#%" {}|\^[]`"""
3876 )
3877 cls.m1 = ModelWithStringPrimaryKey.objects.create(string_pk=cls.pk)
3878 user_pk = cls.superuser.pk
3879 LogEntry.objects.log_actions(
3880 user_pk,
3881 [cls.m1],
3882 2,
3883 change_message="Changed something",
3884 )
3885 LogEntry.objects.log_actions(
3886 user_pk,
3887 [cls.m1],
3888 1,
3889 change_message="Added something",
3890 )
3891 LogEntry.objects.log_actions(
3892 user_pk,
3893 [cls.m1],
3894 3,
3895 change_message="Deleted something",
3896 )
3897
3898 def setUp(self):
3899 self.client.force_login(self.superuser)
3900
3901 def test_get_history_view(self):
3902 """
3903 Retrieving the history for an object using urlencoded form of primary
3904 key should work.
3905 Refs #12349, #18550.
3906 """
3907 response = self.client.get(
3908 reverse(
3909 "admin:admin_views_modelwithstringprimarykey_history", args=(self.pk,)
3910 )
3911 )
3912 self.assertContains(response, escape(self.pk))
3913 self.assertContains(response, "Changed something")
3914
3915 def test_get_change_view(self):
3916 "Retrieving the object using urlencoded form of primary key should work"
3917 response = self.client.get(
3918 reverse(
3919 "admin:admin_views_modelwithstringprimarykey_change", args=(self.pk,)
3920 )
3921 )
3922 self.assertContains(response, escape(self.pk))
3923
3924 def test_changelist_to_changeform_link(self):
3925 """
3926 Link to the changeform of the object in changelist should use reverse()
3927 and be quoted.
3928 """
3929 response = self.client.get(
3930 reverse("admin:admin_views_modelwithstringprimarykey_changelist")
3931 )
3932 # this URL now comes through reverse(), thus url quoting and iri_to_uri encoding
3933 pk_final_url = escape(iri_to_uri(quote(self.pk)))
3934 change_url = reverse(
3935 "admin:admin_views_modelwithstringprimarykey_change", args=("__fk__",)
3936 ).replace("__fk__", pk_final_url)
3937 should_contain = '<th class="field-__str__"><a href="%s">%s</a></th>' % (
3938 change_url,
3939 escape(self.pk),
3940 )
3941 self.assertContains(response, should_contain)
3942
3943 def test_recentactions_link(self):
3944 """
3945 The link from the recent actions list referring to the changeform of
3946 the object should be quoted.
3947 """
3948 response = self.client.get(reverse("admin:index"))
3949 link = reverse(
3950 "admin:admin_views_modelwithstringprimarykey_change", args=(quote(self.pk),)
3951 )
3952 should_contain = """<a href="%s">%s</a>""" % (escape(link), escape(self.pk))
3953 self.assertContains(response, should_contain)
3954
3955 def test_recentactions_description(self):
3956 response = self.client.get(reverse("admin:index"))
3957 for operation in ["Added", "Changed", "Deleted"]:
3958 with self.subTest(operation):
3959 self.assertContains(
3960 response, f'<span class="visually-hidden">{operation}:'
3961 )
3962
3963 def test_deleteconfirmation_link(self):
3964 """
3965 The link from the delete confirmation page referring back to the
3966 changeform of the object should be quoted.
3967 """
3968 url = reverse(
3969 "admin:admin_views_modelwithstringprimarykey_delete", args=(quote(self.pk),)
3970 )
3971 response = self.client.get(url)
3972 # this URL now comes through reverse(), thus url quoting and iri_to_uri encoding
3973 change_url = reverse(
3974 "admin:admin_views_modelwithstringprimarykey_change", args=("__fk__",)
3975 ).replace("__fk__", escape(iri_to_uri(quote(self.pk))))
3976 should_contain = '<a href="%s">%s</a>' % (change_url, escape(self.pk))
3977 self.assertContains(response, should_contain)
3978
3979 def test_url_conflicts_with_add(self):
3980 "A model with a primary key that ends with add or is `add` should be visible"
3981 add_model = ModelWithStringPrimaryKey.objects.create(
3982 pk="i have something to add"
3983 )
3984 add_model.save()
3985 response = self.client.get(
3986 reverse(
3987 "admin:admin_views_modelwithstringprimarykey_change",
3988 args=(quote(add_model.pk),),
3989 )
3990 )
3991 should_contain = """<h1>Change model with string primary key</h1>"""
3992 self.assertContains(response, should_contain)
3993
3994 add_model2 = ModelWithStringPrimaryKey.objects.create(pk="add")
3995 add_url = reverse("admin:admin_views_modelwithstringprimarykey_add")
3996 change_url = reverse(
3997 "admin:admin_views_modelwithstringprimarykey_change",
3998 args=(quote(add_model2.pk),),
3999 )
4000 self.assertNotEqual(add_url, change_url)
4001
4002 def test_url_conflicts_with_delete(self):
4003 "A model with a primary key that ends with delete should be visible"
4004 delete_model = ModelWithStringPrimaryKey(pk="delete")
4005 delete_model.save()
4006 response = self.client.get(
4007 reverse(
4008 "admin:admin_views_modelwithstringprimarykey_change",
4009 args=(quote(delete_model.pk),),
4010 )
4011 )
4012 should_contain = """<h1>Change model with string primary key</h1>"""
4013 self.assertContains(response, should_contain)
4014
4015 def test_url_conflicts_with_history(self):
4016 "A model with a primary key that ends with history should be visible"
4017 history_model = ModelWithStringPrimaryKey(pk="history")
4018 history_model.save()
4019 response = self.client.get(
4020 reverse(
4021 "admin:admin_views_modelwithstringprimarykey_change",
4022 args=(quote(history_model.pk),),
4023 )
4024 )
4025 should_contain = """<h1>Change model with string primary key</h1>"""
4026 self.assertContains(response, should_contain)
4027
4028 def test_shortcut_view_with_escaping(self):
4029 "'View on site should' work properly with char fields"
4030 model = ModelWithStringPrimaryKey(pk="abc_123")
4031 model.save()
4032 response = self.client.get(
4033 reverse(
4034 "admin:admin_views_modelwithstringprimarykey_change",
4035 args=(quote(model.pk),),
4036 )
4037 )
4038 should_contain = '/%s/" class="viewsitelink">' % model.pk
4039 self.assertContains(response, should_contain)
4040
4041 def test_change_view_history_link(self):
4042 """Object history button link should work and contain the pk value quoted."""
4043 url = reverse(
4044 "admin:%s_modelwithstringprimarykey_change"
4045 % ModelWithStringPrimaryKey._meta.app_label,
4046 args=(quote(self.pk),),
4047 )
4048 response = self.client.get(url)
4049 self.assertEqual(response.status_code, 200)
4050 expected_link = reverse(
4051 "admin:%s_modelwithstringprimarykey_history"
4052 % ModelWithStringPrimaryKey._meta.app_label,
4053 args=(quote(self.pk),),
4054 )
4055 self.assertContains(
4056 response, '<a href="%s" class="historylink"' % escape(expected_link)
4057 )
4058
4059 def test_redirect_on_add_view_continue_button(self):
4060 """As soon as an object is added using "Save and continue editing"
4061 button, the user should be redirected to the object's change_view.
4062
4063 In case primary key is a string containing some special characters
4064 like slash or underscore, these characters must be escaped (see #22266)
4065 """
4066 response = self.client.post(
4067 reverse("admin:admin_views_modelwithstringprimarykey_add"),
4068 {
4069 "string_pk": "123/history",
4070 "_continue": "1", # Save and continue editing
4071 },
4072 )
4073
4074 self.assertEqual(response.status_code, 302) # temporary redirect
4075 self.assertIn("/123_2Fhistory/", response.headers["location"]) # PK is quoted
4076
4077
4078 @override_settings(ROOT_URLCONF="admin_views.urls")
4079 class SecureViewTests(TestCase):
4080 """
4081 Test behavior of a view protected by the staff_member_required decorator.
4082 """
4083
4084 def test_secure_view_shows_login_if_not_logged_in(self):
4085 secure_url = reverse("secure_view")
4086 response = self.client.get(secure_url)
4087 self.assertRedirects(
4088 response, "%s?next=%s" % (reverse("admin:login"), secure_url)
4089 )
4090 response = self.client.get(secure_url, follow=True)
4091 self.assertTemplateUsed(response, "admin/login.html")
4092 self.assertEqual(response.context[REDIRECT_FIELD_NAME], secure_url)
4093
4094 def test_staff_member_required_decorator_works_with_argument(self):
4095 """
4096 Staff_member_required decorator works with an argument
4097 (redirect_field_name).
4098 """
4099 secure_url = "/test_admin/admin/secure-view2/"
4100 response = self.client.get(secure_url)
4101 self.assertRedirects(
4102 response, "%s?myfield=%s" % (reverse("admin:login"), secure_url)
4103 )
4104
4105
4106 @override_settings(ROOT_URLCONF="admin_views.urls")
4107 class AdminViewUnicodeTest(TestCase):
4108 @classmethod
4109 def setUpTestData(cls):
4110 cls.superuser = User.objects.create_superuser(
4111 username="super", password="secret", email="[email protected]"
4112 )
4113 cls.b1 = Book.objects.create(name="Lærdommer")
4114 cls.p1 = Promo.objects.create(name="<Promo for Lærdommer>", book=cls.b1)
4115 cls.chap1 = Chapter.objects.create(
4116 title="Norske bostaver æøå skaper problemer",
4117 content="<p>Svært frustrerende med UnicodeDecodeErro</p>",
4118 book=cls.b1,
4119 )
4120 cls.chap2 = Chapter.objects.create(
4121 title="Kjærlighet",
4122 content="<p>La kjærligheten til de lidende seire.</p>",
4123 book=cls.b1,
4124 )
4125 cls.chap3 = Chapter.objects.create(
4126 title="Kjærlighet", content="<p>Noe innhold</p>", book=cls.b1
4127 )
4128 cls.chap4 = ChapterXtra1.objects.create(
4129 chap=cls.chap1, xtra="<Xtra(1) Norske bostaver æøå skaper problemer>"
4130 )
4131 cls.chap5 = ChapterXtra1.objects.create(
4132 chap=cls.chap2, xtra="<Xtra(1) Kjærlighet>"
4133 )
4134 cls.chap6 = ChapterXtra1.objects.create(
4135 chap=cls.chap3, xtra="<Xtra(1) Kjærlighet>"
4136 )
4137 cls.chap7 = ChapterXtra2.objects.create(
4138 chap=cls.chap1, xtra="<Xtra(2) Norske bostaver æøå skaper problemer>"
4139 )
4140 cls.chap8 = ChapterXtra2.objects.create(
4141 chap=cls.chap2, xtra="<Xtra(2) Kjærlighet>"
4142 )
4143 cls.chap9 = ChapterXtra2.objects.create(
4144 chap=cls.chap3, xtra="<Xtra(2) Kjærlighet>"
4145 )
4146
4147 def setUp(self):
4148 self.client.force_login(self.superuser)
4149
4150 def test_unicode_edit(self):
4151 """
4152 A test to ensure that POST on edit_view handles non-ASCII characters.
4153 """
4154 post_data = {
4155 "name": "Test lærdommer",
4156 # inline data
4157 "chapter_set-TOTAL_FORMS": "6",
4158 "chapter_set-INITIAL_FORMS": "3",
4159 "chapter_set-MAX_NUM_FORMS": "0",
4160 "chapter_set-0-id": self.chap1.pk,
4161 "chapter_set-0-title": "Norske bostaver æøå skaper problemer",
4162 "chapter_set-0-content": (
4163 "&lt;p&gt;Svært frustrerende med UnicodeDecodeError&lt;/p&gt;"
4164 ),
4165 "chapter_set-1-id": self.chap2.id,
4166 "chapter_set-1-title": "Kjærlighet.",
4167 "chapter_set-1-content": (
4168 "&lt;p&gt;La kjærligheten til de lidende seire.&lt;/p&gt;"
4169 ),
4170 "chapter_set-2-id": self.chap3.id,
4171 "chapter_set-2-title": "Need a title.",
4172 "chapter_set-2-content": "&lt;p&gt;Newest content&lt;/p&gt;",
4173 "chapter_set-3-id": "",
4174 "chapter_set-3-title": "",
4175 "chapter_set-3-content": "",
4176 "chapter_set-4-id": "",
4177 "chapter_set-4-title": "",
4178 "chapter_set-4-content": "",
4179 "chapter_set-5-id": "",
4180 "chapter_set-5-title": "",
4181 "chapter_set-5-content": "",
4182 }
4183
4184 response = self.client.post(
4185 reverse("admin:admin_views_book_change", args=(self.b1.pk,)), post_data
4186 )
4187 self.assertEqual(response.status_code, 302) # redirect somewhere
4188
4189 def test_unicode_delete(self):
4190 """
4191 The delete_view handles non-ASCII characters
4192 """
4193 delete_dict = {"post": "yes"}
4194 delete_url = reverse("admin:admin_views_book_delete", args=(self.b1.pk,))
4195 response = self.client.get(delete_url)
4196 self.assertEqual(response.status_code, 200)
4197 response = self.client.post(delete_url, delete_dict)
4198 self.assertRedirects(response, reverse("admin:admin_views_book_changelist"))
4199
4200
4201 @override_settings(ROOT_URLCONF="admin_views.urls")
4202 class AdminViewListEditable(TestCase):
4203 @classmethod
4204 def setUpTestData(cls):
4205 cls.superuser = User.objects.create_superuser(
4206 username="super", password="secret", email="[email protected]"
4207 )
4208 cls.s1 = Section.objects.create(name="Test section")
4209 cls.a1 = Article.objects.create(
4210 content="<p>Middle content</p>",
4211 date=datetime.datetime(2008, 3, 18, 11, 54, 58),
4212 section=cls.s1,
4213 )
4214 cls.a2 = Article.objects.create(
4215 content="<p>Oldest content</p>",
4216 date=datetime.datetime(2000, 3, 18, 11, 54, 58),
4217 section=cls.s1,
4218 )
4219 cls.a3 = Article.objects.create(
4220 content="<p>Newest content</p>",
4221 date=datetime.datetime(2009, 3, 18, 11, 54, 58),
4222 section=cls.s1,
4223 )
4224 cls.p1 = PrePopulatedPost.objects.create(
4225 title="A Long Title", published=True, slug="a-long-title"
4226 )
4227 cls.per1 = Person.objects.create(name="John Mauchly", gender=1, alive=True)
4228 cls.per2 = Person.objects.create(name="Grace Hopper", gender=1, alive=False)
4229 cls.per3 = Person.objects.create(name="Guido van Rossum", gender=1, alive=True)
4230
4231 def setUp(self):
4232 self.client.force_login(self.superuser)
4233
4234 def test_inheritance(self):
4235 Podcast.objects.create(
4236 name="This Week in Django", release_date=datetime.date.today()
4237 )
4238 response = self.client.get(reverse("admin:admin_views_podcast_changelist"))
4239 self.assertEqual(response.status_code, 200)
4240
4241 def test_inheritance_2(self):
4242 Vodcast.objects.create(name="This Week in Django", released=True)
4243 response = self.client.get(reverse("admin:admin_views_vodcast_changelist"))
4244 self.assertEqual(response.status_code, 200)
4245
4246 def test_custom_pk(self):
4247 Language.objects.create(iso="en", name="English", english_name="English")
4248 response = self.client.get(reverse("admin:admin_views_language_changelist"))
4249 self.assertEqual(response.status_code, 200)
4250
4251 def test_changelist_input_html(self):
4252 response = self.client.get(reverse("admin:admin_views_person_changelist"))
4253 # 2 inputs per object(the field and the hidden id field) = 6
4254 # 4 management hidden fields = 4
4255 # 4 action inputs (3 regular checkboxes, 1 checkbox to select all)
4256 # main form submit button = 1
4257 # search field and search submit button = 2
4258 # CSRF field = 2
4259 # field to track 'select all' across paginated views = 1
4260 # 6 + 4 + 4 + 1 + 2 + 2 + 1 = 20 inputs
4261 self.assertContains(response, "<input", count=21)
4262 # 1 select per object = 3 selects
4263 self.assertContains(response, "<select", count=4)
4264
4265 def test_post_messages(self):
4266 # Ticket 12707: Saving inline editable should not show admin
4267 # action warnings
4268 data = {
4269 "form-TOTAL_FORMS": "3",
4270 "form-INITIAL_FORMS": "3",
4271 "form-MAX_NUM_FORMS": "0",
4272 "form-0-gender": "1",
4273 "form-0-id": str(self.per1.pk),
4274 "form-1-gender": "2",
4275 "form-1-id": str(self.per2.pk),
4276 "form-2-alive": "checked",
4277 "form-2-gender": "1",
4278 "form-2-id": str(self.per3.pk),
4279 "_save": "Save",
4280 }
4281 response = self.client.post(
4282 reverse("admin:admin_views_person_changelist"), data, follow=True
4283 )
4284 self.assertEqual(len(response.context["messages"]), 1)
4285
4286 def test_post_submission(self):
4287 data = {
4288 "form-TOTAL_FORMS": "3",
4289 "form-INITIAL_FORMS": "3",
4290 "form-MAX_NUM_FORMS": "0",
4291 "form-0-gender": "1",
4292 "form-0-id": str(self.per1.pk),
4293 "form-1-gender": "2",
4294 "form-1-id": str(self.per2.pk),
4295 "form-2-alive": "checked",
4296 "form-2-gender": "1",
4297 "form-2-id": str(self.per3.pk),
4298 "_save": "Save",
4299 }
4300 self.client.post(reverse("admin:admin_views_person_changelist"), data)
4301
4302 self.assertIs(Person.objects.get(name="John Mauchly").alive, False)
4303 self.assertEqual(Person.objects.get(name="Grace Hopper").gender, 2)
4304
4305 # test a filtered page
4306 data = {
4307 "form-TOTAL_FORMS": "2",
4308 "form-INITIAL_FORMS": "2",
4309 "form-MAX_NUM_FORMS": "0",
4310 "form-0-id": str(self.per1.pk),
4311 "form-0-gender": "1",
4312 "form-0-alive": "checked",
4313 "form-1-id": str(self.per3.pk),
4314 "form-1-gender": "1",
4315 "form-1-alive": "checked",
4316 "_save": "Save",
4317 }
4318 self.client.post(
4319 reverse("admin:admin_views_person_changelist") + "?gender__exact=1", data
4320 )
4321
4322 self.assertIs(Person.objects.get(name="John Mauchly").alive, True)
4323
4324 # test a searched page
4325 data = {
4326 "form-TOTAL_FORMS": "1",
4327 "form-INITIAL_FORMS": "1",
4328 "form-MAX_NUM_FORMS": "0",
4329 "form-0-id": str(self.per1.pk),
4330 "form-0-gender": "1",
4331 "_save": "Save",
4332 }
4333 self.client.post(
4334 reverse("admin:admin_views_person_changelist") + "?q=john", data
4335 )
4336
4337 self.assertIs(Person.objects.get(name="John Mauchly").alive, False)
4338
4339 def test_forged_post_submission_when_no_add_permission(self):
4340 before_count = ParentWithUUIDPK.objects.count()
4341 data = {
4342 "form-TOTAL_FORMS": "1",
4343 "form-INITIAL_FORMS": "0",
4344 "form-MAX_NUM_FORMS": "0",
4345 "form-0-title": "The News",
4346 "form-0-id": "",
4347 "_save": "Save",
4348 }
4349 # This model admin allows no add permissions.
4350 changelist_url = reverse("admin7:admin_views_parentwithuuidpk_changelist")
4351 response = self.client.post(changelist_url, data)
4352 self.assertEqual(response.status_code, HTTPStatus.BAD_REQUEST)
4353 self.assertEqual(ParentWithUUIDPK.objects.count(), before_count)
4354
4355 def test_non_field_errors(self):
4356 """
4357 Non-field errors are displayed for each of the forms in the
4358 changelist's formset.
4359 """
4360 fd1 = FoodDelivery.objects.create(
4361 reference="123", driver="bill", restaurant="thai"
4362 )
4363 fd2 = FoodDelivery.objects.create(
4364 reference="456", driver="bill", restaurant="india"
4365 )
4366 fd3 = FoodDelivery.objects.create(
4367 reference="789", driver="bill", restaurant="pizza"
4368 )
4369
4370 data = {
4371 "form-TOTAL_FORMS": "3",
4372 "form-INITIAL_FORMS": "3",
4373 "form-MAX_NUM_FORMS": "0",
4374 "form-0-id": str(fd1.id),
4375 "form-0-reference": "123",
4376 "form-0-driver": "bill",
4377 "form-0-restaurant": "thai",
4378 # Same data as above: Forbidden because of unique_together!
4379 "form-1-id": str(fd2.id),
4380 "form-1-reference": "456",
4381 "form-1-driver": "bill",
4382 "form-1-restaurant": "thai",
4383 "form-2-id": str(fd3.id),
4384 "form-2-reference": "789",
4385 "form-2-driver": "bill",
4386 "form-2-restaurant": "pizza",
4387 "_save": "Save",
4388 }
4389 response = self.client.post(
4390 reverse("admin:admin_views_fooddelivery_changelist"), data
4391 )
4392 self.assertContains(
4393 response,
4394 '<tr><td colspan="4"><ul class="errorlist nonfield"><li>Food delivery '
4395 "with this Driver and Restaurant already exists.</li></ul></td></tr>",
4396 1,
4397 html=True,
4398 )
4399
4400 data = {
4401 "form-TOTAL_FORMS": "3",
4402 "form-INITIAL_FORMS": "3",
4403 "form-MAX_NUM_FORMS": "0",
4404 "form-0-id": str(fd1.id),
4405 "form-0-reference": "123",
4406 "form-0-driver": "bill",
4407 "form-0-restaurant": "thai",
4408 # Same data as above: Forbidden because of unique_together!
4409 "form-1-id": str(fd2.id),
4410 "form-1-reference": "456",
4411 "form-1-driver": "bill",
4412 "form-1-restaurant": "thai",
4413 # Same data also.
4414 "form-2-id": str(fd3.id),
4415 "form-2-reference": "789",
4416 "form-2-driver": "bill",
4417 "form-2-restaurant": "thai",
4418 "_save": "Save",
4419 }
4420 response = self.client.post(
4421 reverse("admin:admin_views_fooddelivery_changelist"), data
4422 )
4423 self.assertContains(
4424 response,
4425 '<tr><td colspan="4"><ul class="errorlist nonfield"><li>Food delivery '
4426 "with this Driver and Restaurant already exists.</li></ul></td></tr>",
4427 2,
4428 html=True,
4429 )
4430
4431 def test_non_form_errors(self):
4432 # test if non-form errors are handled; ticket #12716
4433 data = {
4434 "form-TOTAL_FORMS": "1",
4435 "form-INITIAL_FORMS": "1",
4436 "form-MAX_NUM_FORMS": "0",
4437 "form-0-id": str(self.per2.pk),
4438 "form-0-alive": "1",
4439 "form-0-gender": "2",
4440 # The form processing understands this as a list_editable "Save"
4441 # and not an action "Go".
4442 "_save": "Save",
4443 }
4444 response = self.client.post(
4445 reverse("admin:admin_views_person_changelist"), data
4446 )
4447 self.assertContains(response, "Grace is not a Zombie")
4448
4449 def test_non_form_errors_is_errorlist(self):
4450 # test if non-form errors are correctly handled; ticket #12878
4451 data = {
4452 "form-TOTAL_FORMS": "1",
4453 "form-INITIAL_FORMS": "1",
4454 "form-MAX_NUM_FORMS": "0",
4455 "form-0-id": str(self.per2.pk),
4456 "form-0-alive": "1",
4457 "form-0-gender": "2",
4458 "_save": "Save",
4459 }
4460 response = self.client.post(
4461 reverse("admin:admin_views_person_changelist"), data
4462 )
4463 non_form_errors = response.context["cl"].formset.non_form_errors()
4464 self.assertIsInstance(non_form_errors, ErrorList)
4465 self.assertEqual(
4466 str(non_form_errors),
4467 str(ErrorList(["Grace is not a Zombie"], error_class="nonform")),
4468 )
4469
4470 def test_list_editable_ordering(self):
4471 collector = Collector.objects.create(id=1, name="Frederick Clegg")
4472
4473 Category.objects.create(id=1, order=1, collector=collector)
4474 Category.objects.create(id=2, order=2, collector=collector)
4475 Category.objects.create(id=3, order=0, collector=collector)
4476 Category.objects.create(id=4, order=0, collector=collector)
4477
4478 # NB: The order values must be changed so that the items are reordered.
4479 data = {
4480 "form-TOTAL_FORMS": "4",
4481 "form-INITIAL_FORMS": "4",
4482 "form-MAX_NUM_FORMS": "0",
4483 "form-0-order": "14",
4484 "form-0-id": "1",
4485 "form-0-collector": "1",
4486 "form-1-order": "13",
4487 "form-1-id": "2",
4488 "form-1-collector": "1",
4489 "form-2-order": "1",
4490 "form-2-id": "3",
4491 "form-2-collector": "1",
4492 "form-3-order": "0",
4493 "form-3-id": "4",
4494 "form-3-collector": "1",
4495 # The form processing understands this as a list_editable "Save"
4496 # and not an action "Go".
4497 "_save": "Save",
4498 }
4499 response = self.client.post(
4500 reverse("admin:admin_views_category_changelist"), data
4501 )
4502 # Successful post will redirect
4503 self.assertEqual(response.status_code, 302)
4504
4505 # The order values have been applied to the right objects
4506 self.assertEqual(Category.objects.get(id=1).order, 14)
4507 self.assertEqual(Category.objects.get(id=2).order, 13)
4508 self.assertEqual(Category.objects.get(id=3).order, 1)
4509 self.assertEqual(Category.objects.get(id=4).order, 0)
4510
4511 def test_list_editable_pagination(self):
4512 """
4513 Pagination works for list_editable items.
4514 """
4515 UnorderedObject.objects.create(id=1, name="Unordered object #1")
4516 UnorderedObject.objects.create(id=2, name="Unordered object #2")
4517 UnorderedObject.objects.create(id=3, name="Unordered object #3")
4518 response = self.client.get(
4519 reverse("admin:admin_views_unorderedobject_changelist")
4520 )
4521 self.assertContains(response, "Unordered object #3")
4522 self.assertContains(response, "Unordered object #2")
4523 self.assertNotContains(response, "Unordered object #1")
4524 response = self.client.get(
4525 reverse("admin:admin_views_unorderedobject_changelist") + "?p=2"
4526 )
4527 self.assertNotContains(response, "Unordered object #3")
4528 self.assertNotContains(response, "Unordered object #2")
4529 self.assertContains(response, "Unordered object #1")
4530
4531 def test_list_editable_action_submit(self):
4532 # List editable changes should not be executed if the action "Go" button is
4533 # used to submit the form.
4534 data = {
4535 "form-TOTAL_FORMS": "3",
4536 "form-INITIAL_FORMS": "3",
4537 "form-MAX_NUM_FORMS": "0",
4538 "form-0-gender": "1",
4539 "form-0-id": "1",
4540 "form-1-gender": "2",
4541 "form-1-id": "2",
4542 "form-2-alive": "checked",
4543 "form-2-gender": "1",
4544 "form-2-id": "3",
4545 "index": "0",
4546 "_selected_action": ["3"],
4547 "action": ["", "delete_selected"],
4548 }
4549 self.client.post(reverse("admin:admin_views_person_changelist"), data)
4550
4551 self.assertIs(Person.objects.get(name="John Mauchly").alive, True)
4552 self.assertEqual(Person.objects.get(name="Grace Hopper").gender, 1)
4553
4554 def test_list_editable_action_choices(self):
4555 # List editable changes should be executed if the "Save" button is
4556 # used to submit the form - any action choices should be ignored.
4557 data = {
4558 "form-TOTAL_FORMS": "3",
4559 "form-INITIAL_FORMS": "3",
4560 "form-MAX_NUM_FORMS": "0",
4561 "form-0-gender": "1",
4562 "form-0-id": str(self.per1.pk),
4563 "form-1-gender": "2",
4564 "form-1-id": str(self.per2.pk),
4565 "form-2-alive": "checked",
4566 "form-2-gender": "1",
4567 "form-2-id": str(self.per3.pk),
4568 "_save": "Save",
4569 "_selected_action": ["1"],
4570 "action": ["", "delete_selected"],
4571 }
4572 self.client.post(reverse("admin:admin_views_person_changelist"), data)
4573
4574 self.assertIs(Person.objects.get(name="John Mauchly").alive, False)
4575 self.assertEqual(Person.objects.get(name="Grace Hopper").gender, 2)
4576
4577 def test_list_editable_popup(self):
4578 """
4579 Fields should not be list-editable in popups.
4580 """
4581 response = self.client.get(reverse("admin:admin_views_person_changelist"))
4582 self.assertNotEqual(response.context["cl"].list_editable, ())
4583 response = self.client.get(
4584 reverse("admin:admin_views_person_changelist") + "?%s" % IS_POPUP_VAR
4585 )
4586 self.assertEqual(response.context["cl"].list_editable, ())
4587
4588 def test_pk_hidden_fields(self):
4589 """
4590 hidden pk fields aren't displayed in the table body and their
4591 corresponding human-readable value is displayed instead. The hidden pk
4592 fields are displayed but separately (not in the table) and only once.
4593 """
4594 story1 = Story.objects.create(
4595 title="The adventures of Guido", content="Once upon a time in Djangoland..."
4596 )
4597 story2 = Story.objects.create(
4598 title="Crouching Tiger, Hidden Python",
4599 content="The Python was sneaking into...",
4600 )
4601 response = self.client.get(reverse("admin:admin_views_story_changelist"))
4602 # Only one hidden field, in a separate place than the table.
4603 self.assertContains(response, 'id="id_form-0-id"', 1)
4604 self.assertContains(response, 'id="id_form-1-id"', 1)
4605 self.assertContains(
4606 response,
4607 '<div class="hiddenfields">\n'
4608 '<input type="hidden" name="form-0-id" value="%d" id="id_form-0-id">'
4609 '<input type="hidden" name="form-1-id" value="%d" id="id_form-1-id">\n'
4610 "</div>" % (story2.id, story1.id),
4611 html=True,
4612 )
4613 self.assertContains(response, '<td class="field-id">%d</td>' % story1.id, 1)
4614 self.assertContains(response, '<td class="field-id">%d</td>' % story2.id, 1)
4615
4616 def test_pk_hidden_fields_with_list_display_links(self):
4617 """Similarly as test_pk_hidden_fields, but when the hidden pk fields are
4618 referenced in list_display_links.
4619 Refs #12475.
4620 """
4621 story1 = OtherStory.objects.create(
4622 title="The adventures of Guido",
4623 content="Once upon a time in Djangoland...",
4624 )
4625 story2 = OtherStory.objects.create(
4626 title="Crouching Tiger, Hidden Python",
4627 content="The Python was sneaking into...",
4628 )
4629 link1 = reverse("admin:admin_views_otherstory_change", args=(story1.pk,))
4630 link2 = reverse("admin:admin_views_otherstory_change", args=(story2.pk,))
4631 response = self.client.get(reverse("admin:admin_views_otherstory_changelist"))
4632 # Only one hidden field, in a separate place than the table.
4633 self.assertContains(response, 'id="id_form-0-id"', 1)
4634 self.assertContains(response, 'id="id_form-1-id"', 1)
4635 self.assertContains(
4636 response,
4637 '<div class="hiddenfields">\n'
4638 '<input type="hidden" name="form-0-id" value="%d" id="id_form-0-id">'
4639 '<input type="hidden" name="form-1-id" value="%d" id="id_form-1-id">\n'
4640 "</div>" % (story2.id, story1.id),
4641 html=True,
4642 )
4643 self.assertContains(
4644 response,
4645 '<th class="field-id"><a href="%s">%d</a></th>' % (link1, story1.id),
4646 1,
4647 )
4648 self.assertContains(
4649 response,
4650 '<th class="field-id"><a href="%s">%d</a></th>' % (link2, story2.id),
4651 1,
4652 )
4653
4654
4655 @override_settings(ROOT_URLCONF="admin_views.urls")
4656 class AdminSearchTest(TestCase):
4657 @classmethod
4658 def setUpTestData(cls):
4659 cls.superuser = User.objects.create_superuser(
4660 username="super", password="secret", email="[email protected]"
4661 )
4662 cls.joepublicuser = User.objects.create_user(
4663 username="joepublic", password="secret"
4664 )
4665 cls.s1 = Section.objects.create(name="Test section")
4666 cls.a1 = Article.objects.create(
4667 content="<p>Middle content</p>",
4668 date=datetime.datetime(2008, 3, 18, 11, 54, 58),
4669 section=cls.s1,
4670 )
4671 cls.a2 = Article.objects.create(
4672 content="<p>Oldest content</p>",
4673 date=datetime.datetime(2000, 3, 18, 11, 54, 58),
4674 section=cls.s1,
4675 )
4676 cls.a3 = Article.objects.create(
4677 content="<p>Newest content</p>",
4678 date=datetime.datetime(2009, 3, 18, 11, 54, 58),
4679 section=cls.s1,
4680 )
4681 cls.p1 = PrePopulatedPost.objects.create(
4682 title="A Long Title", published=True, slug="a-long-title"
4683 )
4684
4685 cls.per1 = Person.objects.create(name="John Mauchly", gender=1, alive=True)
4686 cls.per2 = Person.objects.create(name="Grace Hopper", gender=1, alive=False)
4687 cls.per3 = Person.objects.create(name="Guido van Rossum", gender=1, alive=True)
4688 Person.objects.create(name="John Doe", gender=1)
4689 Person.objects.create(name='John O"Hara', gender=1)
4690 Person.objects.create(name="John O'Hara", gender=1)
4691
4692 cls.t1 = Recommender.objects.create()
4693 cls.t2 = Recommendation.objects.create(the_recommender=cls.t1)
4694 cls.t3 = Recommender.objects.create()
4695 cls.t4 = Recommendation.objects.create(the_recommender=cls.t3)
4696
4697 cls.tt1 = TitleTranslation.objects.create(title=cls.t1, text="Bar")
4698 cls.tt2 = TitleTranslation.objects.create(title=cls.t2, text="Foo")
4699 cls.tt3 = TitleTranslation.objects.create(title=cls.t3, text="Few")
4700 cls.tt4 = TitleTranslation.objects.create(title=cls.t4, text="Bas")
4701
4702 def setUp(self):
4703 self.client.force_login(self.superuser)
4704
4705 def test_search_on_sibling_models(self):
4706 "A search that mentions sibling models"
4707 response = self.client.get(
4708 reverse("admin:admin_views_recommendation_changelist") + "?q=bar"
4709 )
4710 # confirm the search returned 1 object
4711 self.assertContains(response, "\n1 recommendation\n")
4712
4713 def test_with_fk_to_field(self):
4714 """
4715 The to_field GET parameter is preserved when a search is performed.
4716 Refs #10918.
4717 """
4718 response = self.client.get(
4719 reverse("admin:auth_user_changelist") + "?q=joe&%s=id" % TO_FIELD_VAR
4720 )
4721 self.assertContains(response, "\n1 user\n")
4722 self.assertContains(
4723 response,
4724 '<input type="hidden" name="%s" value="id">' % TO_FIELD_VAR,
4725 html=True,
4726 )
4727
4728 def test_exact_matches(self):
4729 response = self.client.get(
4730 reverse("admin:admin_views_recommendation_changelist") + "?q=bar"
4731 )
4732 # confirm the search returned one object
4733 self.assertContains(response, "\n1 recommendation\n")
4734
4735 response = self.client.get(
4736 reverse("admin:admin_views_recommendation_changelist") + "?q=ba"
4737 )
4738 # confirm the search returned zero objects
4739 self.assertContains(response, "\n0 recommendations\n")
4740
4741 def test_beginning_matches(self):
4742 response = self.client.get(
4743 reverse("admin:admin_views_person_changelist") + "?q=Gui"
4744 )
4745 # confirm the search returned one object
4746 self.assertContains(response, "\n1 person\n")
4747 self.assertContains(response, "Guido")
4748
4749 response = self.client.get(
4750 reverse("admin:admin_views_person_changelist") + "?q=uido"
4751 )
4752 # confirm the search returned zero objects
4753 self.assertContains(response, "\n0 persons\n")
4754 self.assertNotContains(response, "Guido")
4755
4756 def test_pluggable_search(self):
4757 PluggableSearchPerson.objects.create(name="Bob", age=10)
4758 PluggableSearchPerson.objects.create(name="Amy", age=20)
4759
4760 response = self.client.get(
4761 reverse("admin:admin_views_pluggablesearchperson_changelist") + "?q=Bob"
4762 )
4763 # confirm the search returned one object
4764 self.assertContains(response, "\n1 pluggable search person\n")
4765 self.assertContains(response, "Bob")
4766
4767 response = self.client.get(
4768 reverse("admin:admin_views_pluggablesearchperson_changelist") + "?q=20"
4769 )
4770 # confirm the search returned one object
4771 self.assertContains(response, "\n1 pluggable search person\n")
4772 self.assertContains(response, "Amy")
4773
4774 def test_reset_link(self):
4775 """
4776 Test presence of reset link in search bar ("1 result (_x total_)").
4777 """
4778 # 1 query for session + 1 for fetching user
4779 # + 1 for filtered result + 1 for filtered count
4780 # + 1 for total count
4781 with self.assertNumQueries(5):
4782 response = self.client.get(
4783 reverse("admin:admin_views_person_changelist") + "?q=Gui"
4784 )
4785 self.assertContains(
4786 response,
4787 """<span class="small quiet">1 result (<a href="?">6 total</a>)</span>""",
4788 html=True,
4789 )
4790
4791 def test_no_total_count(self):
4792 """
4793 #8408 -- "Show all" should be displayed instead of the total count if
4794 ModelAdmin.show_full_result_count is False.
4795 """
4796 # 1 query for session + 1 for fetching user
4797 # + 1 for filtered result + 1 for filtered count
4798 with self.assertNumQueries(4):
4799 response = self.client.get(
4800 reverse("admin:admin_views_recommendation_changelist") + "?q=bar"
4801 )
4802 self.assertContains(
4803 response,
4804 """<span class="small quiet">1 result (<a href="?">Show all</a>)</span>""",
4805 html=True,
4806 )
4807 self.assertTrue(response.context["cl"].show_admin_actions)
4808
4809 def test_search_with_spaces(self):
4810 url = reverse("admin:admin_views_person_changelist") + "?q=%s"
4811 tests = [
4812 ('"John Doe"', 1),
4813 ("'John Doe'", 1),
4814 ("John Doe", 0),
4815 ('"John Doe" John', 1),
4816 ("'John Doe' John", 1),
4817 ("John Doe John", 0),
4818 ('"John Do"', 1),
4819 ("'John Do'", 1),
4820 ("'John O'Hara'", 0),
4821 ("'John O\\'Hara'", 1),
4822 ('"John O"Hara"', 0),
4823 ('"John O\\"Hara"', 1),
4824 ]
4825 for search, hits in tests:
4826 with self.subTest(search=search):
4827 response = self.client.get(url % search)
4828 self.assertContains(response, "\n%s person" % hits)
4829
4830
4831 @override_settings(ROOT_URLCONF="admin_views.urls")
4832 class AdminInheritedInlinesTest(TestCase):
4833 @classmethod
4834 def setUpTestData(cls):
4835 cls.superuser = User.objects.create_superuser(
4836 username="super", password="secret", email="[email protected]"
4837 )
4838
4839 def setUp(self):
4840 self.client.force_login(self.superuser)
4841
4842 def test_inline(self):
4843 """
4844 Inline models which inherit from a common parent are correctly handled.
4845 """
4846 foo_user = "foo username"
4847 bar_user = "bar username"
4848
4849 name_re = re.compile(b'name="(.*?)"')
4850
4851 # test the add case
4852 response = self.client.get(reverse("admin:admin_views_persona_add"))
4853 names = name_re.findall(response.content)
4854 names.remove(b"csrfmiddlewaretoken")
4855 # make sure we have no duplicate HTML names
4856 self.assertEqual(len(names), len(set(names)))
4857
4858 # test the add case
4859 post_data = {
4860 "name": "Test Name",
4861 # inline data
4862 "accounts-TOTAL_FORMS": "1",
4863 "accounts-INITIAL_FORMS": "0",
4864 "accounts-MAX_NUM_FORMS": "0",
4865 "accounts-0-username": foo_user,
4866 "accounts-2-TOTAL_FORMS": "1",
4867 "accounts-2-INITIAL_FORMS": "0",
4868 "accounts-2-MAX_NUM_FORMS": "0",
4869 "accounts-2-0-username": bar_user,
4870 }
4871
4872 response = self.client.post(reverse("admin:admin_views_persona_add"), post_data)
4873 self.assertEqual(response.status_code, 302) # redirect somewhere
4874 self.assertEqual(Persona.objects.count(), 1)
4875 self.assertEqual(FooAccount.objects.count(), 1)
4876 self.assertEqual(BarAccount.objects.count(), 1)
4877 self.assertEqual(FooAccount.objects.all()[0].username, foo_user)
4878 self.assertEqual(BarAccount.objects.all()[0].username, bar_user)
4879 self.assertEqual(Persona.objects.all()[0].accounts.count(), 2)
4880
4881 persona_id = Persona.objects.all()[0].id
4882 foo_id = FooAccount.objects.all()[0].id
4883 bar_id = BarAccount.objects.all()[0].id
4884
4885 # test the edit case
4886
4887 response = self.client.get(
4888 reverse("admin:admin_views_persona_change", args=(persona_id,))
4889 )
4890 names = name_re.findall(response.content)
4891 names.remove(b"csrfmiddlewaretoken")
4892 # make sure we have no duplicate HTML names
4893 self.assertEqual(len(names), len(set(names)))
4894
4895 post_data = {
4896 "name": "Test Name",
4897 "accounts-TOTAL_FORMS": "2",
4898 "accounts-INITIAL_FORMS": "1",
4899 "accounts-MAX_NUM_FORMS": "0",
4900 "accounts-0-username": "%s-1" % foo_user,
4901 "accounts-0-account_ptr": str(foo_id),
4902 "accounts-0-persona": str(persona_id),
4903 "accounts-2-TOTAL_FORMS": "2",
4904 "accounts-2-INITIAL_FORMS": "1",
4905 "accounts-2-MAX_NUM_FORMS": "0",
4906 "accounts-2-0-username": "%s-1" % bar_user,
4907 "accounts-2-0-account_ptr": str(bar_id),
4908 "accounts-2-0-persona": str(persona_id),
4909 }
4910 response = self.client.post(
4911 reverse("admin:admin_views_persona_change", args=(persona_id,)), post_data
4912 )
4913 self.assertEqual(response.status_code, 302)
4914 self.assertEqual(Persona.objects.count(), 1)
4915 self.assertEqual(FooAccount.objects.count(), 1)
4916 self.assertEqual(BarAccount.objects.count(), 1)
4917 self.assertEqual(FooAccount.objects.all()[0].username, "%s-1" % foo_user)
4918 self.assertEqual(BarAccount.objects.all()[0].username, "%s-1" % bar_user)
4919 self.assertEqual(Persona.objects.all()[0].accounts.count(), 2)
4920
4921
4922 @override_settings(ROOT_URLCONF="admin_views.urls")
4923 class TestCustomChangeList(TestCase):
4924 @classmethod
4925 def setUpTestData(cls):
4926 cls.superuser = User.objects.create_superuser(
4927 username="super", password="secret", email="[email protected]"
4928 )
4929
4930 def setUp(self):
4931 self.client.force_login(self.superuser)
4932
4933 def test_custom_changelist(self):
4934 """
4935 Validate that a custom ChangeList class can be used (#9749)
4936 """
4937 # Insert some data
4938 post_data = {"name": "First Gadget"}
4939 response = self.client.post(reverse("admin:admin_views_gadget_add"), post_data)
4940 self.assertEqual(response.status_code, 302) # redirect somewhere
4941 # Hit the page once to get messages out of the queue message list
4942 response = self.client.get(reverse("admin:admin_views_gadget_changelist"))
4943 # Data is still not visible on the page
4944 response = self.client.get(reverse("admin:admin_views_gadget_changelist"))
4945 self.assertNotContains(response, "First Gadget")
4946
4947
4948 @override_settings(ROOT_URLCONF="admin_views.urls")
4949 class TestInlineNotEditable(TestCase):
4950 @classmethod
4951 def setUpTestData(cls):
4952 cls.superuser = User.objects.create_superuser(
4953 username="super", password="secret", email="[email protected]"
4954 )
4955
4956 def setUp(self):
4957 self.client.force_login(self.superuser)
4958
4959 def test_GET_parent_add(self):
4960 """
4961 InlineModelAdmin broken?
4962 """
4963 response = self.client.get(reverse("admin:admin_views_parent_add"))
4964 self.assertEqual(response.status_code, 200)
4965
4966
4967 @override_settings(ROOT_URLCONF="admin_views.urls")
4968 class AdminCustomQuerysetTest(TestCase):
4969 @classmethod
4970 def setUpTestData(cls):
4971 cls.superuser = User.objects.create_superuser(
4972 username="super", password="secret", email="[email protected]"
4973 )
4974 cls.pks = [EmptyModel.objects.create().id for i in range(3)]
4975
4976 def setUp(self):
4977 self.client.force_login(self.superuser)
4978 self.super_login = {
4979 REDIRECT_FIELD_NAME: reverse("admin:index"),
4980 "username": "super",
4981 "password": "secret",
4982 }
4983
4984 def test_changelist_view(self):
4985 response = self.client.get(reverse("admin:admin_views_emptymodel_changelist"))
4986 for i in self.pks:
4987 if i > 1:
4988 self.assertContains(response, "Primary key = %s" % i)
4989 else:
4990 self.assertNotContains(response, "Primary key = %s" % i)
4991
4992 def test_changelist_view_count_queries(self):
4993 # create 2 Person objects
4994 Person.objects.create(name="person1", gender=1)
4995 Person.objects.create(name="person2", gender=2)
4996 changelist_url = reverse("admin:admin_views_person_changelist")
4997
4998 # 5 queries are expected: 1 for the session, 1 for the user,
4999 # 2 for the counts and 1 for the objects on the page
5000 with self.assertNumQueries(5):
5001 resp = self.client.get(changelist_url)
5002 self.assertEqual(resp.context["selection_note"], "0 of 2 selected")
5003 self.assertEqual(resp.context["selection_note_all"], "All 2 selected")
5004 with self.assertNumQueries(5):
5005 extra = {"q": "not_in_name"}
5006 resp = self.client.get(changelist_url, extra)
5007 self.assertEqual(resp.context["selection_note"], "0 of 0 selected")
5008 self.assertEqual(resp.context["selection_note_all"], "All 0 selected")
5009 with self.assertNumQueries(5):
5010 extra = {"q": "person"}
5011 resp = self.client.get(changelist_url, extra)
5012 self.assertEqual(resp.context["selection_note"], "0 of 2 selected")
5013 self.assertEqual(resp.context["selection_note_all"], "All 2 selected")
5014 with self.assertNumQueries(5):
5015 extra = {"gender__exact": "1"}
5016 resp = self.client.get(changelist_url, extra)
5017 self.assertEqual(resp.context["selection_note"], "0 of 1 selected")
5018 self.assertEqual(resp.context["selection_note_all"], "1 selected")
5019
5020 def test_change_view(self):
5021 for i in self.pks:
5022 url = reverse("admin:admin_views_emptymodel_change", args=(i,))
5023 response = self.client.get(url, follow=True)
5024 if i > 1:
5025 self.assertEqual(response.status_code, 200)
5026 else:
5027 self.assertRedirects(response, reverse("admin:index"))
5028 self.assertEqual(
5029 [m.message for m in response.context["messages"]],
5030 ["empty model with ID “1” doesn’t exist. Perhaps it was deleted?"],
5031 )
5032
5033 def test_add_model_modeladmin_defer_qs(self):
5034 # Test for #14529. defer() is used in ModelAdmin.get_queryset()
5035
5036 # model has __str__ method
5037 self.assertEqual(CoverLetter.objects.count(), 0)
5038 # Emulate model instance creation via the admin
5039 post_data = {
5040 "author": "Candidate, Best",
5041 "_save": "Save",
5042 }
5043 response = self.client.post(
5044 reverse("admin:admin_views_coverletter_add"), post_data, follow=True
5045 )
5046 self.assertEqual(response.status_code, 200)
5047 self.assertEqual(CoverLetter.objects.count(), 1)
5048 # Message should contain non-ugly model verbose name
5049 pk = CoverLetter.objects.all()[0].pk
5050 self.assertContains(
5051 response,
5052 '<li class="success">The cover letter “<a href="%s">'
5053 "Candidate, Best</a>” was added successfully.</li>"
5054 % reverse("admin:admin_views_coverletter_change", args=(pk,)),
5055 html=True,
5056 )
5057
5058 # model has no __str__ method
5059 self.assertEqual(ShortMessage.objects.count(), 0)
5060 # Emulate model instance creation via the admin
5061 post_data = {
5062 "content": "What's this SMS thing?",
5063 "_save": "Save",
5064 }
5065 response = self.client.post(
5066 reverse("admin:admin_views_shortmessage_add"), post_data, follow=True
5067 )
5068 self.assertEqual(response.status_code, 200)
5069 self.assertEqual(ShortMessage.objects.count(), 1)
5070 # Message should contain non-ugly model verbose name
5071 sm = ShortMessage.objects.all()[0]
5072 self.assertContains(
5073 response,
5074 '<li class="success">The short message “<a href="%s">'
5075 "%s</a>” was added successfully.</li>"
5076 % (reverse("admin:admin_views_shortmessage_change", args=(sm.pk,)), sm),
5077 html=True,
5078 )
5079
5080 def test_add_model_modeladmin_only_qs(self):
5081 # Test for #14529. only() is used in ModelAdmin.get_queryset()
5082
5083 # model has __str__ method
5084 self.assertEqual(Telegram.objects.count(), 0)
5085 # Emulate model instance creation via the admin
5086 post_data = {
5087 "title": "Urgent telegram",
5088 "_save": "Save",
5089 }
5090 response = self.client.post(
5091 reverse("admin:admin_views_telegram_add"), post_data, follow=True
5092 )
5093 self.assertEqual(response.status_code, 200)
5094 self.assertEqual(Telegram.objects.count(), 1)
5095 # Message should contain non-ugly model verbose name
5096 pk = Telegram.objects.all()[0].pk
5097 self.assertContains(
5098 response,
5099 '<li class="success">The telegram “<a href="%s">'
5100 "Urgent telegram</a>” was added successfully.</li>"
5101 % reverse("admin:admin_views_telegram_change", args=(pk,)),
5102 html=True,
5103 )
5104
5105 # model has no __str__ method
5106 self.assertEqual(Paper.objects.count(), 0)
5107 # Emulate model instance creation via the admin
5108 post_data = {
5109 "title": "My Modified Paper Title",
5110 "_save": "Save",
5111 }
5112 response = self.client.post(
5113 reverse("admin:admin_views_paper_add"), post_data, follow=True
5114 )
5115 self.assertEqual(response.status_code, 200)
5116 self.assertEqual(Paper.objects.count(), 1)
5117 # Message should contain non-ugly model verbose name
5118 p = Paper.objects.all()[0]
5119 self.assertContains(
5120 response,
5121 '<li class="success">The paper “<a href="%s">'
5122 "%s</a>” was added successfully.</li>"
5123 % (reverse("admin:admin_views_paper_change", args=(p.pk,)), p),
5124 html=True,
5125 )
5126
5127 def test_edit_model_modeladmin_defer_qs(self):
5128 # Test for #14529. defer() is used in ModelAdmin.get_queryset()
5129
5130 # model has __str__ method
5131 cl = CoverLetter.objects.create(author="John Doe")
5132 self.assertEqual(CoverLetter.objects.count(), 1)
5133 response = self.client.get(
5134 reverse("admin:admin_views_coverletter_change", args=(cl.pk,))
5135 )
5136 self.assertEqual(response.status_code, 200)
5137 # Emulate model instance edit via the admin
5138 post_data = {
5139 "author": "John Doe II",
5140 "_save": "Save",
5141 }
5142 url = reverse("admin:admin_views_coverletter_change", args=(cl.pk,))
5143 response = self.client.post(url, post_data, follow=True)
5144 self.assertEqual(response.status_code, 200)
5145 self.assertEqual(CoverLetter.objects.count(), 1)
5146 # Message should contain non-ugly model verbose name. Instance
5147 # representation is set by model's __str__()
5148 self.assertContains(
5149 response,
5150 '<li class="success">The cover letter “<a href="%s">'
5151 "John Doe II</a>” was changed successfully.</li>"
5152 % reverse("admin:admin_views_coverletter_change", args=(cl.pk,)),
5153 html=True,
5154 )
5155
5156 # model has no __str__ method
5157 sm = ShortMessage.objects.create(content="This is expensive")
5158 self.assertEqual(ShortMessage.objects.count(), 1)
5159 response = self.client.get(
5160 reverse("admin:admin_views_shortmessage_change", args=(sm.pk,))
5161 )
5162 self.assertEqual(response.status_code, 200)
5163 # Emulate model instance edit via the admin
5164 post_data = {
5165 "content": "Too expensive",
5166 "_save": "Save",
5167 }
5168 url = reverse("admin:admin_views_shortmessage_change", args=(sm.pk,))
5169 response = self.client.post(url, post_data, follow=True)
5170 self.assertEqual(response.status_code, 200)
5171 self.assertEqual(ShortMessage.objects.count(), 1)
5172 # Message should contain non-ugly model verbose name. The ugly(!)
5173 # instance representation is set by __str__().
5174 self.assertContains(
5175 response,
5176 '<li class="success">The short message “<a href="%s">'
5177 "%s</a>” was changed successfully.</li>"
5178 % (reverse("admin:admin_views_shortmessage_change", args=(sm.pk,)), sm),
5179 html=True,
5180 )
5181
5182 def test_edit_model_modeladmin_only_qs(self):
5183 # Test for #14529. only() is used in ModelAdmin.get_queryset()
5184
5185 # model has __str__ method
5186 t = Telegram.objects.create(title="First Telegram")
5187 self.assertEqual(Telegram.objects.count(), 1)
5188 response = self.client.get(
5189 reverse("admin:admin_views_telegram_change", args=(t.pk,))
5190 )
5191 self.assertEqual(response.status_code, 200)
5192 # Emulate model instance edit via the admin
5193 post_data = {
5194 "title": "Telegram without typo",
5195 "_save": "Save",
5196 }
5197 response = self.client.post(
5198 reverse("admin:admin_views_telegram_change", args=(t.pk,)),
5199 post_data,
5200 follow=True,
5201 )
5202 self.assertEqual(response.status_code, 200)
5203 self.assertEqual(Telegram.objects.count(), 1)
5204 # Message should contain non-ugly model verbose name. The instance
5205 # representation is set by model's __str__()
5206 self.assertContains(
5207 response,
5208 '<li class="success">The telegram “<a href="%s">'
5209 "Telegram without typo</a>” was changed successfully.</li>"
5210 % reverse("admin:admin_views_telegram_change", args=(t.pk,)),
5211 html=True,
5212 )
5213
5214 # model has no __str__ method
5215 p = Paper.objects.create(title="My Paper Title")
5216 self.assertEqual(Paper.objects.count(), 1)
5217 response = self.client.get(
5218 reverse("admin:admin_views_paper_change", args=(p.pk,))
5219 )
5220 self.assertEqual(response.status_code, 200)
5221 # Emulate model instance edit via the admin
5222 post_data = {
5223 "title": "My Modified Paper Title",
5224 "_save": "Save",
5225 }
5226 response = self.client.post(
5227 reverse("admin:admin_views_paper_change", args=(p.pk,)),
5228 post_data,
5229 follow=True,
5230 )
5231 self.assertEqual(response.status_code, 200)
5232 self.assertEqual(Paper.objects.count(), 1)
5233 # Message should contain non-ugly model verbose name. The ugly(!)
5234 # instance representation is set by __str__().
5235 self.assertContains(
5236 response,
5237 '<li class="success">The paper “<a href="%s">'
5238 "%s</a>” was changed successfully.</li>"
5239 % (reverse("admin:admin_views_paper_change", args=(p.pk,)), p),
5240 html=True,
5241 )
5242
5243 def test_history_view_custom_qs(self):
5244 """
5245 Custom querysets are considered for the admin history view.
5246 """
5247 self.client.post(reverse("admin:login"), self.super_login)
5248 FilteredManager.objects.create(pk=1)
5249 FilteredManager.objects.create(pk=2)
5250 response = self.client.get(
5251 reverse("admin:admin_views_filteredmanager_changelist")
5252 )
5253 self.assertContains(response, "PK=1")
5254 self.assertContains(response, "PK=2")
5255 self.assertEqual(
5256 self.client.get(
5257 reverse("admin:admin_views_filteredmanager_history", args=(1,))
5258 ).status_code,
5259 200,
5260 )
5261 self.assertEqual(
5262 self.client.get(
5263 reverse("admin:admin_views_filteredmanager_history", args=(2,))
5264 ).status_code,
5265 200,
5266 )
5267
5268
5269 @override_settings(ROOT_URLCONF="admin_views.urls")
5270 class AdminInlineFileUploadTest(TestCase):
5271 @classmethod
5272 def setUpTestData(cls):
5273 cls.superuser = User.objects.create_superuser(
5274 username="super", password="secret", email="[email protected]"
5275 )
5276 file1 = tempfile.NamedTemporaryFile(suffix=".file1")
5277 file1.write(b"a" * (2**21))
5278 filename = file1.name
5279 file1.close()
5280 cls.gallery = Gallery.objects.create(name="Test Gallery")
5281 cls.picture = Picture.objects.create(
5282 name="Test Picture",
5283 image=filename,
5284 gallery=cls.gallery,
5285 )
5286
5287 def setUp(self):
5288 self.client.force_login(self.superuser)
5289
5290 def test_form_has_multipart_enctype(self):
5291 response = self.client.get(
5292 reverse("admin:admin_views_gallery_change", args=(self.gallery.id,))
5293 )
5294 self.assertIs(response.context["has_file_field"], True)
5295 self.assertContains(response, MULTIPART_ENCTYPE)
5296
5297 def test_inline_file_upload_edit_validation_error_post(self):
5298 """
5299 Inline file uploads correctly display prior data (#10002).
5300 """
5301 post_data = {
5302 "name": "Test Gallery",
5303 "pictures-TOTAL_FORMS": "2",
5304 "pictures-INITIAL_FORMS": "1",
5305 "pictures-MAX_NUM_FORMS": "0",
5306 "pictures-0-id": str(self.picture.id),
5307 "pictures-0-gallery": str(self.gallery.id),
5308 "pictures-0-name": "Test Picture",
5309 "pictures-0-image": "",
5310 "pictures-1-id": "",
5311 "pictures-1-gallery": str(self.gallery.id),
5312 "pictures-1-name": "Test Picture 2",
5313 "pictures-1-image": "",
5314 }
5315 response = self.client.post(
5316 reverse("admin:admin_views_gallery_change", args=(self.gallery.id,)),
5317 post_data,
5318 )
5319 self.assertContains(response, b"Currently")
5320
5321
5322 @override_settings(ROOT_URLCONF="admin_views.urls")
5323 class AdminInlineTests(TestCase):
5324 @classmethod
5325 def setUpTestData(cls):
5326 cls.superuser = User.objects.create_superuser(
5327 username="super", password="secret", email="[email protected]"
5328 )
5329 cls.collector = Collector.objects.create(pk=1, name="John Fowles")
5330
5331 def setUp(self):
5332 self.post_data = {
5333 "name": "Test Name",
5334 "widget_set-TOTAL_FORMS": "3",
5335 "widget_set-INITIAL_FORMS": "0",
5336 "widget_set-MAX_NUM_FORMS": "0",
5337 "widget_set-0-id": "",
5338 "widget_set-0-owner": "1",
5339 "widget_set-0-name": "",
5340 "widget_set-1-id": "",
5341 "widget_set-1-owner": "1",
5342 "widget_set-1-name": "",
5343 "widget_set-2-id": "",
5344 "widget_set-2-owner": "1",
5345 "widget_set-2-name": "",
5346 "doohickey_set-TOTAL_FORMS": "3",
5347 "doohickey_set-INITIAL_FORMS": "0",
5348 "doohickey_set-MAX_NUM_FORMS": "0",
5349 "doohickey_set-0-owner": "1",
5350 "doohickey_set-0-code": "",
5351 "doohickey_set-0-name": "",
5352 "doohickey_set-1-owner": "1",
5353 "doohickey_set-1-code": "",
5354 "doohickey_set-1-name": "",
5355 "doohickey_set-2-owner": "1",
5356 "doohickey_set-2-code": "",
5357 "doohickey_set-2-name": "",
5358 "grommet_set-TOTAL_FORMS": "3",
5359 "grommet_set-INITIAL_FORMS": "0",
5360 "grommet_set-MAX_NUM_FORMS": "0",
5361 "grommet_set-0-code": "",
5362 "grommet_set-0-owner": "1",
5363 "grommet_set-0-name": "",
5364 "grommet_set-1-code": "",
5365 "grommet_set-1-owner": "1",
5366 "grommet_set-1-name": "",
5367 "grommet_set-2-code": "",
5368 "grommet_set-2-owner": "1",
5369 "grommet_set-2-name": "",
5370 "whatsit_set-TOTAL_FORMS": "3",
5371 "whatsit_set-INITIAL_FORMS": "0",
5372 "whatsit_set-MAX_NUM_FORMS": "0",
5373 "whatsit_set-0-owner": "1",
5374 "whatsit_set-0-index": "",
5375 "whatsit_set-0-name": "",
5376 "whatsit_set-1-owner": "1",
5377 "whatsit_set-1-index": "",
5378 "whatsit_set-1-name": "",
5379 "whatsit_set-2-owner": "1",
5380 "whatsit_set-2-index": "",
5381 "whatsit_set-2-name": "",
5382 "fancydoodad_set-TOTAL_FORMS": "3",
5383 "fancydoodad_set-INITIAL_FORMS": "0",
5384 "fancydoodad_set-MAX_NUM_FORMS": "0",
5385 "fancydoodad_set-0-doodad_ptr": "",
5386 "fancydoodad_set-0-owner": "1",
5387 "fancydoodad_set-0-name": "",
5388 "fancydoodad_set-0-expensive": "on",
5389 "fancydoodad_set-1-doodad_ptr": "",
5390 "fancydoodad_set-1-owner": "1",
5391 "fancydoodad_set-1-name": "",
5392 "fancydoodad_set-1-expensive": "on",
5393 "fancydoodad_set-2-doodad_ptr": "",
5394 "fancydoodad_set-2-owner": "1",
5395 "fancydoodad_set-2-name": "",
5396 "fancydoodad_set-2-expensive": "on",
5397 "category_set-TOTAL_FORMS": "3",
5398 "category_set-INITIAL_FORMS": "0",
5399 "category_set-MAX_NUM_FORMS": "0",
5400 "category_set-0-order": "",
5401 "category_set-0-id": "",
5402 "category_set-0-collector": "1",
5403 "category_set-1-order": "",
5404 "category_set-1-id": "",
5405 "category_set-1-collector": "1",
5406 "category_set-2-order": "",
5407 "category_set-2-id": "",
5408 "category_set-2-collector": "1",
5409 }
5410
5411 self.client.force_login(self.superuser)
5412
5413 def test_simple_inline(self):
5414 "A simple model can be saved as inlines"
5415 # First add a new inline
5416 self.post_data["widget_set-0-name"] = "Widget 1"
5417 collector_url = reverse(
5418 "admin:admin_views_collector_change", args=(self.collector.pk,)
5419 )
5420 response = self.client.post(collector_url, self.post_data)
5421 self.assertEqual(response.status_code, 302)
5422 self.assertEqual(Widget.objects.count(), 1)
5423 self.assertEqual(Widget.objects.all()[0].name, "Widget 1")
5424 widget_id = Widget.objects.all()[0].id
5425
5426 # The PK link exists on the rendered form
5427 response = self.client.get(collector_url)
5428 self.assertContains(response, 'name="widget_set-0-id"')
5429
5430 # No file or image fields, no enctype on the forms
5431 self.assertIs(response.context["has_file_field"], False)
5432 self.assertNotContains(response, MULTIPART_ENCTYPE)
5433
5434 # Now resave that inline
5435 self.post_data["widget_set-INITIAL_FORMS"] = "1"
5436 self.post_data["widget_set-0-id"] = str(widget_id)
5437 self.post_data["widget_set-0-name"] = "Widget 1"
5438 response = self.client.post(collector_url, self.post_data)
5439 self.assertEqual(response.status_code, 302)
5440 self.assertEqual(Widget.objects.count(), 1)
5441 self.assertEqual(Widget.objects.all()[0].name, "Widget 1")
5442
5443 # Now modify that inline
5444 self.post_data["widget_set-INITIAL_FORMS"] = "1"
5445 self.post_data["widget_set-0-id"] = str(widget_id)
5446 self.post_data["widget_set-0-name"] = "Widget 1 Updated"
5447 response = self.client.post(collector_url, self.post_data)
5448 self.assertEqual(response.status_code, 302)
5449 self.assertEqual(Widget.objects.count(), 1)
5450 self.assertEqual(Widget.objects.all()[0].name, "Widget 1 Updated")
5451
5452 def test_explicit_autofield_inline(self):
5453 """
5454 A model with an explicit autofield primary key can be saved as inlines.
5455 """
5456 # First add a new inline
5457 self.post_data["grommet_set-0-name"] = "Grommet 1"
5458 collector_url = reverse(
5459 "admin:admin_views_collector_change", args=(self.collector.pk,)
5460 )
5461 response = self.client.post(collector_url, self.post_data)
5462 self.assertEqual(response.status_code, 302)
5463 self.assertEqual(Grommet.objects.count(), 1)
5464 self.assertEqual(Grommet.objects.all()[0].name, "Grommet 1")
5465
5466 # The PK link exists on the rendered form
5467 response = self.client.get(collector_url)
5468 self.assertContains(response, 'name="grommet_set-0-code"')
5469
5470 # Now resave that inline
5471 self.post_data["grommet_set-INITIAL_FORMS"] = "1"
5472 self.post_data["grommet_set-0-code"] = str(Grommet.objects.all()[0].code)
5473 self.post_data["grommet_set-0-name"] = "Grommet 1"
5474 response = self.client.post(collector_url, self.post_data)
5475 self.assertEqual(response.status_code, 302)
5476 self.assertEqual(Grommet.objects.count(), 1)
5477 self.assertEqual(Grommet.objects.all()[0].name, "Grommet 1")
5478
5479 # Now modify that inline
5480 self.post_data["grommet_set-INITIAL_FORMS"] = "1"
5481 self.post_data["grommet_set-0-code"] = str(Grommet.objects.all()[0].code)
5482 self.post_data["grommet_set-0-name"] = "Grommet 1 Updated"
5483 response = self.client.post(collector_url, self.post_data)
5484 self.assertEqual(response.status_code, 302)
5485 self.assertEqual(Grommet.objects.count(), 1)
5486 self.assertEqual(Grommet.objects.all()[0].name, "Grommet 1 Updated")
5487
5488 def test_char_pk_inline(self):
5489 "A model with a character PK can be saved as inlines. Regression for #10992"
5490 # First add a new inline
5491 self.post_data["doohickey_set-0-code"] = "DH1"
5492 self.post_data["doohickey_set-0-name"] = "Doohickey 1"
5493 collector_url = reverse(
5494 "admin:admin_views_collector_change", args=(self.collector.pk,)
5495 )
5496 response = self.client.post(collector_url, self.post_data)
5497 self.assertEqual(response.status_code, 302)
5498 self.assertEqual(DooHickey.objects.count(), 1)
5499 self.assertEqual(DooHickey.objects.all()[0].name, "Doohickey 1")
5500
5501 # The PK link exists on the rendered form
5502 response = self.client.get(collector_url)
5503 self.assertContains(response, 'name="doohickey_set-0-code"')
5504
5505 # Now resave that inline
5506 self.post_data["doohickey_set-INITIAL_FORMS"] = "1"
5507 self.post_data["doohickey_set-0-code"] = "DH1"
5508 self.post_data["doohickey_set-0-name"] = "Doohickey 1"
5509 response = self.client.post(collector_url, self.post_data)
5510 self.assertEqual(response.status_code, 302)
5511 self.assertEqual(DooHickey.objects.count(), 1)
5512 self.assertEqual(DooHickey.objects.all()[0].name, "Doohickey 1")
5513
5514 # Now modify that inline
5515 self.post_data["doohickey_set-INITIAL_FORMS"] = "1"
5516 self.post_data["doohickey_set-0-code"] = "DH1"
5517 self.post_data["doohickey_set-0-name"] = "Doohickey 1 Updated"
5518 response = self.client.post(collector_url, self.post_data)
5519 self.assertEqual(response.status_code, 302)
5520 self.assertEqual(DooHickey.objects.count(), 1)
5521 self.assertEqual(DooHickey.objects.all()[0].name, "Doohickey 1 Updated")
5522
5523 def test_integer_pk_inline(self):
5524 "A model with an integer PK can be saved as inlines. Regression for #10992"
5525 # First add a new inline
5526 self.post_data["whatsit_set-0-index"] = "42"
5527 self.post_data["whatsit_set-0-name"] = "Whatsit 1"
5528 collector_url = reverse(
5529 "admin:admin_views_collector_change", args=(self.collector.pk,)
5530 )
5531 response = self.client.post(collector_url, self.post_data)
5532 self.assertEqual(response.status_code, 302)
5533 self.assertEqual(Whatsit.objects.count(), 1)
5534 self.assertEqual(Whatsit.objects.all()[0].name, "Whatsit 1")
5535
5536 # The PK link exists on the rendered form
5537 response = self.client.get(collector_url)
5538 self.assertContains(response, 'name="whatsit_set-0-index"')
5539
5540 # Now resave that inline
5541 self.post_data["whatsit_set-INITIAL_FORMS"] = "1"
5542 self.post_data["whatsit_set-0-index"] = "42"
5543 self.post_data["whatsit_set-0-name"] = "Whatsit 1"
5544 response = self.client.post(collector_url, self.post_data)
5545 self.assertEqual(response.status_code, 302)
5546 self.assertEqual(Whatsit.objects.count(), 1)
5547 self.assertEqual(Whatsit.objects.all()[0].name, "Whatsit 1")
5548
5549 # Now modify that inline
5550 self.post_data["whatsit_set-INITIAL_FORMS"] = "1"
5551 self.post_data["whatsit_set-0-index"] = "42"
5552 self.post_data["whatsit_set-0-name"] = "Whatsit 1 Updated"
5553 response = self.client.post(collector_url, self.post_data)
5554 self.assertEqual(response.status_code, 302)
5555 self.assertEqual(Whatsit.objects.count(), 1)
5556 self.assertEqual(Whatsit.objects.all()[0].name, "Whatsit 1 Updated")
5557
5558 def test_inherited_inline(self):
5559 "An inherited model can be saved as inlines. Regression for #11042"
5560 # First add a new inline
5561 self.post_data["fancydoodad_set-0-name"] = "Fancy Doodad 1"
5562 collector_url = reverse(
5563 "admin:admin_views_collector_change", args=(self.collector.pk,)
5564 )
5565 response = self.client.post(collector_url, self.post_data)
5566 self.assertEqual(response.status_code, 302)
5567 self.assertEqual(FancyDoodad.objects.count(), 1)
5568 self.assertEqual(FancyDoodad.objects.all()[0].name, "Fancy Doodad 1")
5569 doodad_pk = FancyDoodad.objects.all()[0].pk
5570
5571 # The PK link exists on the rendered form
5572 response = self.client.get(collector_url)
5573 self.assertContains(response, 'name="fancydoodad_set-0-doodad_ptr"')
5574
5575 # Now resave that inline
5576 self.post_data["fancydoodad_set-INITIAL_FORMS"] = "1"
5577 self.post_data["fancydoodad_set-0-doodad_ptr"] = str(doodad_pk)
5578 self.post_data["fancydoodad_set-0-name"] = "Fancy Doodad 1"
5579 response = self.client.post(collector_url, self.post_data)
5580 self.assertEqual(response.status_code, 302)
5581 self.assertEqual(FancyDoodad.objects.count(), 1)
5582 self.assertEqual(FancyDoodad.objects.all()[0].name, "Fancy Doodad 1")
5583
5584 # Now modify that inline
5585 self.post_data["fancydoodad_set-INITIAL_FORMS"] = "1"
5586 self.post_data["fancydoodad_set-0-doodad_ptr"] = str(doodad_pk)
5587 self.post_data["fancydoodad_set-0-name"] = "Fancy Doodad 1 Updated"
5588 response = self.client.post(collector_url, self.post_data)
5589 self.assertEqual(response.status_code, 302)
5590 self.assertEqual(FancyDoodad.objects.count(), 1)
5591 self.assertEqual(FancyDoodad.objects.all()[0].name, "Fancy Doodad 1 Updated")
5592
5593 def test_ordered_inline(self):
5594 """
5595 An inline with an editable ordering fields is updated correctly.
5596 """
5597 # Create some objects with an initial ordering
5598 Category.objects.create(id=1, order=1, collector=self.collector)
5599 Category.objects.create(id=2, order=2, collector=self.collector)
5600 Category.objects.create(id=3, order=0, collector=self.collector)
5601 Category.objects.create(id=4, order=0, collector=self.collector)
5602
5603 # NB: The order values must be changed so that the items are reordered.
5604 self.post_data.update(
5605 {
5606 "name": "Frederick Clegg",
5607 "category_set-TOTAL_FORMS": "7",
5608 "category_set-INITIAL_FORMS": "4",
5609 "category_set-MAX_NUM_FORMS": "0",
5610 "category_set-0-order": "14",
5611 "category_set-0-id": "1",
5612 "category_set-0-collector": "1",
5613 "category_set-1-order": "13",
5614 "category_set-1-id": "2",
5615 "category_set-1-collector": "1",
5616 "category_set-2-order": "1",
5617 "category_set-2-id": "3",
5618 "category_set-2-collector": "1",
5619 "category_set-3-order": "0",
5620 "category_set-3-id": "4",
5621 "category_set-3-collector": "1",
5622 "category_set-4-order": "",
5623 "category_set-4-id": "",
5624 "category_set-4-collector": "1",
5625 "category_set-5-order": "",
5626 "category_set-5-id": "",
5627 "category_set-5-collector": "1",
5628 "category_set-6-order": "",
5629 "category_set-6-id": "",
5630 "category_set-6-collector": "1",
5631 }
5632 )
5633 collector_url = reverse(
5634 "admin:admin_views_collector_change", args=(self.collector.pk,)
5635 )
5636 response = self.client.post(collector_url, self.post_data)
5637 # Successful post will redirect
5638 self.assertEqual(response.status_code, 302)
5639
5640 # The order values have been applied to the right objects
5641 self.assertEqual(self.collector.category_set.count(), 4)
5642 self.assertEqual(Category.objects.get(id=1).order, 14)
5643 self.assertEqual(Category.objects.get(id=2).order, 13)
5644 self.assertEqual(Category.objects.get(id=3).order, 1)
5645 self.assertEqual(Category.objects.get(id=4).order, 0)
5646
5647
5648 @override_settings(ROOT_URLCONF="admin_views.urls")
5649 class NeverCacheTests(TestCase):
5650 @classmethod
5651 def setUpTestData(cls):
5652 cls.superuser = User.objects.create_superuser(
5653 username="super", password="secret", email="[email protected]"
5654 )
5655 cls.s1 = Section.objects.create(name="Test section")
5656
5657 def setUp(self):
5658 self.client.force_login(self.superuser)
5659
5660 def test_admin_index(self):
5661 "Check the never-cache status of the main index"
5662 response = self.client.get(reverse("admin:index"))
5663 self.assertEqual(get_max_age(response), 0)
5664
5665 def test_app_index(self):
5666 "Check the never-cache status of an application index"
5667 response = self.client.get(reverse("admin:app_list", args=("admin_views",)))
5668 self.assertEqual(get_max_age(response), 0)
5669
5670 def test_model_index(self):
5671 "Check the never-cache status of a model index"
5672 response = self.client.get(reverse("admin:admin_views_fabric_changelist"))
5673 self.assertEqual(get_max_age(response), 0)
5674
5675 def test_model_add(self):
5676 "Check the never-cache status of a model add page"
5677 response = self.client.get(reverse("admin:admin_views_fabric_add"))
5678 self.assertEqual(get_max_age(response), 0)
5679
5680 def test_model_view(self):
5681 "Check the never-cache status of a model edit page"
5682 response = self.client.get(
5683 reverse("admin:admin_views_section_change", args=(self.s1.pk,))
5684 )
5685 self.assertEqual(get_max_age(response), 0)
5686
5687 def test_model_history(self):
5688 "Check the never-cache status of a model history page"
5689 response = self.client.get(
5690 reverse("admin:admin_views_section_history", args=(self.s1.pk,))
5691 )
5692 self.assertEqual(get_max_age(response), 0)
5693
5694 def test_model_delete(self):
5695 "Check the never-cache status of a model delete page"
5696 response = self.client.get(
5697 reverse("admin:admin_views_section_delete", args=(self.s1.pk,))
5698 )
5699 self.assertEqual(get_max_age(response), 0)
5700
5701 def test_login(self):
5702 "Check the never-cache status of login views"
5703 self.client.logout()
5704 response = self.client.get(reverse("admin:index"))
5705 self.assertEqual(get_max_age(response), 0)
5706
5707 def test_logout(self):
5708 "Check the never-cache status of logout view"
5709 response = self.client.post(reverse("admin:logout"))
5710 self.assertEqual(get_max_age(response), 0)
5711
5712 def test_password_change(self):
5713 "Check the never-cache status of the password change view"
5714 self.client.logout()
5715 response = self.client.get(reverse("admin:password_change"))
5716 self.assertIsNone(get_max_age(response))
5717
5718 def test_password_change_done(self):
5719 "Check the never-cache status of the password change done view"
5720 response = self.client.get(reverse("admin:password_change_done"))
5721 self.assertIsNone(get_max_age(response))
5722
5723 def test_JS_i18n(self):
5724 "Check the never-cache status of the JavaScript i18n view"
5725 response = self.client.get(reverse("admin:jsi18n"))
5726 self.assertIsNone(get_max_age(response))
5727
5728
5729 @override_settings(ROOT_URLCONF="admin_views.urls")
5730 class PrePopulatedTest(TestCase):
5731 @classmethod
5732 def setUpTestData(cls):
5733 cls.superuser = User.objects.create_superuser(
5734 username="super", password="secret", email="[email protected]"
5735 )
5736 cls.p1 = PrePopulatedPost.objects.create(
5737 title="A Long Title", published=True, slug="a-long-title"
5738 )
5739
5740 def setUp(self):
5741 self.client.force_login(self.superuser)
5742
5743 def test_prepopulated_on(self):
5744 response = self.client.get(reverse("admin:admin_views_prepopulatedpost_add"))
5745 self.assertContains(response, "&quot;id&quot;: &quot;#id_slug&quot;")
5746 self.assertContains(
5747 response, "&quot;dependency_ids&quot;: [&quot;#id_title&quot;]"
5748 )
5749 self.assertContains(
5750 response,
5751 "&quot;id&quot;: &quot;#id_prepopulatedsubpost_set-0-subslug&quot;",
5752 )
5753
5754 def test_prepopulated_off(self):
5755 response = self.client.get(
5756 reverse("admin:admin_views_prepopulatedpost_change", args=(self.p1.pk,))
5757 )
5758 self.assertContains(response, "A Long Title")
5759 self.assertNotContains(response, "&quot;id&quot;: &quot;#id_slug&quot;")
5760 self.assertNotContains(
5761 response, "&quot;dependency_ids&quot;: [&quot;#id_title&quot;]"
5762 )
5763 self.assertNotContains(
5764 response,
5765 "&quot;id&quot;: &quot;#id_prepopulatedsubpost_set-0-subslug&quot;",
5766 )
5767
5768 @override_settings(USE_THOUSAND_SEPARATOR=True)
5769 def test_prepopulated_maxlength_localized(self):
5770 """
5771 Regression test for #15938: if USE_THOUSAND_SEPARATOR is set, make sure
5772 that maxLength (in the JavaScript) is rendered without separators.
5773 """
5774 response = self.client.get(
5775 reverse("admin:admin_views_prepopulatedpostlargeslug_add")
5776 )
5777 self.assertContains(response, "&quot;maxLength&quot;: 1000") # instead of 1,000
5778
5779 def test_view_only_add_form(self):
5780 """
5781 PrePopulatedPostReadOnlyAdmin.prepopulated_fields includes 'slug'
5782 which is present in the add view, even if the
5783 ModelAdmin.has_change_permission() returns False.
5784 """
5785 response = self.client.get(reverse("admin7:admin_views_prepopulatedpost_add"))
5786 self.assertContains(response, "data-prepopulated-fields=")
5787 self.assertContains(response, "&quot;id&quot;: &quot;#id_slug&quot;")
5788
5789 def test_view_only_change_form(self):
5790 """
5791 PrePopulatedPostReadOnlyAdmin.prepopulated_fields includes 'slug'. That
5792 doesn't break a view-only change view.
5793 """
5794 response = self.client.get(
5795 reverse("admin7:admin_views_prepopulatedpost_change", args=(self.p1.pk,))
5796 )
5797 self.assertContains(response, 'data-prepopulated-fields="[]"')
5798 self.assertContains(response, '<div class="readonly">%s</div>' % self.p1.slug)
5799
5800
5801 def _clean_sidebar_state(driver):
5802 driver.execute_script("localStorage.removeItem('django.admin.navSidebarIsOpen')")
5803
5804
5805 @override_settings(ROOT_URLCONF="admin_views.urls")
5806 class SeleniumTests(AdminSeleniumTestCase):
5807 available_apps = ["admin_views"] + AdminSeleniumTestCase.available_apps
5808
5809 def setUp(self):
5810 self.superuser = User.objects.create_superuser(
5811 username="super", password="secret", email="[email protected]"
5812 )
5813 self.p1 = PrePopulatedPost.objects.create(
5814 title="A Long Title", published=True, slug="a-long-title"
5815 )
5816
5817 @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
5818 def test_login_button_centered(self):
5819 from selenium.webdriver.common.by import By
5820
5821 self.selenium.get(self.live_server_url + reverse("admin:login"))
5822 button = self.selenium.find_element(By.CSS_SELECTOR, ".submit-row input")
5823 offset_left = button.get_property("offsetLeft")
5824 offset_right = button.get_property("offsetParent").get_property(
5825 "offsetWidth"
5826 ) - (offset_left + button.get_property("offsetWidth"))
5827 # Use assertAlmostEqual to avoid pixel rounding errors.
5828 self.assertAlmostEqual(offset_left, offset_right, delta=3)
5829 self.take_screenshot("login")
5830
5831 def test_prepopulated_fields(self):
5832 """
5833 The JavaScript-automated prepopulated fields work with the main form
5834 and with stacked and tabular inlines.
5835 Refs #13068, #9264, #9983, #9784.
5836 """
5837 from selenium.webdriver import ActionChains
5838 from selenium.webdriver.common.by import By
5839
5840 self.admin_login(
5841 username="super", password="secret", login_url=reverse("admin:index")
5842 )
5843 self.selenium.get(
5844 self.live_server_url + reverse("admin:admin_views_mainprepopulated_add")
5845 )
5846 self.wait_for(".select2")
5847
5848 # Main form ----------------------------------------------------------
5849 self.selenium.find_element(By.ID, "id_pubdate").send_keys("2012-02-18")
5850 status = self.selenium.find_element(By.ID, "id_status")
5851 ActionChains(self.selenium).move_to_element(status).click(status).perform()
5852 self.select_option("#id_status", "option two")
5853 self.selenium.find_element(By.ID, "id_name").send_keys(
5854 " the mAin nÀMë and it's awεšomeıııİ"
5855 )
5856 slug1 = self.selenium.find_element(By.ID, "id_slug1").get_attribute("value")
5857 slug2 = self.selenium.find_element(By.ID, "id_slug2").get_attribute("value")
5858 slug3 = self.selenium.find_element(By.ID, "id_slug3").get_attribute("value")
5859 self.assertEqual(slug1, "the-main-name-and-its-awesomeiiii-2012-02-18")
5860 self.assertEqual(slug2, "option-two-the-main-name-and-its-awesomeiiii")
5861 self.assertEqual(
5862 slug3, "the-main-n\xe0m\xeb-and-its-aw\u03b5\u0161ome\u0131\u0131\u0131i"
5863 )
5864
5865 # Stacked inlines with fieldsets -------------------------------------
5866 # Initial inline
5867 self.selenium.find_element(
5868 By.ID, "id_relatedprepopulated_set-0-pubdate"
5869 ).send_keys("2011-12-17")
5870 status = self.selenium.find_element(
5871 By.ID, "id_relatedprepopulated_set-0-status"
5872 )
5873 ActionChains(self.selenium).move_to_element(status).click(status).perform()
5874 self.select_option("#id_relatedprepopulated_set-0-status", "option one")
5875 self.selenium.find_element(
5876 By.ID, "id_relatedprepopulated_set-0-name"
5877 ).send_keys(" here is a sŤāÇkeð inline ! ")
5878 slug1 = self.selenium.find_element(
5879 By.ID, "id_relatedprepopulated_set-0-slug1"
5880 ).get_attribute("value")
5881 slug2 = self.selenium.find_element(
5882 By.ID, "id_relatedprepopulated_set-0-slug2"
5883 ).get_attribute("value")
5884 self.assertEqual(slug1, "here-is-a-stacked-inline-2011-12-17")
5885 self.assertEqual(slug2, "option-one-here-is-a-stacked-inline")
5886 initial_select2_inputs = self.selenium.find_elements(
5887 By.CLASS_NAME, "select2-selection"
5888 )
5889 # Inline formsets have empty/invisible forms.
5890 # Only the 4 visible select2 inputs are initialized.
5891 num_initial_select2_inputs = len(initial_select2_inputs)
5892 self.assertEqual(num_initial_select2_inputs, 4)
5893
5894 # Add an inline
5895 self.selenium.find_elements(By.LINK_TEXT, "Add another Related prepopulated")[
5896 0
5897 ].click()
5898 self.assertEqual(
5899 len(self.selenium.find_elements(By.CLASS_NAME, "select2-selection")),
5900 num_initial_select2_inputs + 2,
5901 )
5902 self.selenium.find_element(
5903 By.ID, "id_relatedprepopulated_set-1-pubdate"
5904 ).send_keys("1999-01-25")
5905 status = self.selenium.find_element(
5906 By.ID, "id_relatedprepopulated_set-1-status"
5907 )
5908 ActionChains(self.selenium).move_to_element(status).click(status).perform()
5909 self.select_option("#id_relatedprepopulated_set-1-status", "option two")
5910 self.selenium.find_element(
5911 By.ID, "id_relatedprepopulated_set-1-name"
5912 ).send_keys(
5913 " now you haVe anöther sŤāÇkeð inline with a very ... "
5914 "loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooog "
5915 "text... "
5916 )
5917 slug1 = self.selenium.find_element(
5918 By.ID, "id_relatedprepopulated_set-1-slug1"
5919 ).get_attribute("value")
5920 slug2 = self.selenium.find_element(
5921 By.ID, "id_relatedprepopulated_set-1-slug2"
5922 ).get_attribute("value")
5923 # 50 characters maximum for slug1 field
5924 self.assertEqual(slug1, "now-you-have-another-stacked-inline-with-a-very-lo")
5925 # 60 characters maximum for slug2 field
5926 self.assertEqual(
5927 slug2, "option-two-now-you-have-another-stacked-inline-with-a-very-l"
5928 )
5929
5930 # Tabular inlines ----------------------------------------------------
5931 # Initial inline
5932 status = self.selenium.find_element(
5933 By.ID, "id_relatedprepopulated_set-2-0-status"
5934 )
5935 ActionChains(self.selenium).move_to_element(status).click(status).perform()
5936 self.selenium.find_element(
5937 By.ID, "id_relatedprepopulated_set-2-0-pubdate"
5938 ).send_keys("1234-12-07")
5939 self.select_option("#id_relatedprepopulated_set-2-0-status", "option two")
5940 self.selenium.find_element(
5941 By.ID, "id_relatedprepopulated_set-2-0-name"
5942 ).send_keys("And now, with a tÃbűlaŘ inline !!!")
5943 slug1 = self.selenium.find_element(
5944 By.ID, "id_relatedprepopulated_set-2-0-slug1"
5945 ).get_attribute("value")
5946 slug2 = self.selenium.find_element(
5947 By.ID, "id_relatedprepopulated_set-2-0-slug2"
5948 ).get_attribute("value")
5949 self.assertEqual(slug1, "and-now-with-a-tabular-inline-1234-12-07")
5950 self.assertEqual(slug2, "option-two-and-now-with-a-tabular-inline")
5951
5952 # Add an inline
5953 # Button may be outside the browser frame.
5954 element = self.selenium.find_elements(
5955 By.LINK_TEXT, "Add another Related prepopulated"
5956 )[1]
5957 self.selenium.execute_script("window.scrollTo(0, %s);" % element.location["y"])
5958 element.click()
5959 self.assertEqual(
5960 len(self.selenium.find_elements(By.CLASS_NAME, "select2-selection")),
5961 num_initial_select2_inputs + 4,
5962 )
5963 self.selenium.find_element(
5964 By.ID, "id_relatedprepopulated_set-2-1-pubdate"
5965 ).send_keys("1981-08-22")
5966 status = self.selenium.find_element(
5967 By.ID, "id_relatedprepopulated_set-2-1-status"
5968 )
5969 ActionChains(self.selenium).move_to_element(status).click(status).perform()
5970 self.select_option("#id_relatedprepopulated_set-2-1-status", "option one")
5971 self.selenium.find_element(
5972 By.ID, "id_relatedprepopulated_set-2-1-name"
5973 ).send_keys(r'tÃbűlaŘ inline with ignored ;"&*^\%$#@-/`~ characters')
5974 slug1 = self.selenium.find_element(
5975 By.ID, "id_relatedprepopulated_set-2-1-slug1"
5976 ).get_attribute("value")
5977 slug2 = self.selenium.find_element(
5978 By.ID, "id_relatedprepopulated_set-2-1-slug2"
5979 ).get_attribute("value")
5980 self.assertEqual(slug1, "tabular-inline-with-ignored-characters-1981-08-22")
5981 self.assertEqual(slug2, "option-one-tabular-inline-with-ignored-characters")
5982 # Add an inline without an initial inline.
5983 # The button is outside of the browser frame.
5984 self.selenium.execute_script("window.scrollTo(0, document.body.scrollHeight);")
5985 self.selenium.find_elements(By.LINK_TEXT, "Add another Related prepopulated")[
5986 2
5987 ].click()
5988 self.assertEqual(
5989 len(self.selenium.find_elements(By.CLASS_NAME, "select2-selection")),
5990 num_initial_select2_inputs + 6,
5991 )
5992 # Stacked Inlines without fieldsets ----------------------------------
5993 # Initial inline.
5994 row_id = "id_relatedprepopulated_set-4-0-"
5995 self.selenium.find_element(By.ID, f"{row_id}pubdate").send_keys("2011-12-12")
5996 status = self.selenium.find_element(By.ID, f"{row_id}status")
5997 ActionChains(self.selenium).move_to_element(status).click(status).perform()
5998 self.select_option(f"#{row_id}status", "option one")
5999 self.selenium.find_element(By.ID, f"{row_id}name").send_keys(
6000 " sŤāÇkeð inline ! "
6001 )
6002 slug1 = self.selenium.find_element(By.ID, f"{row_id}slug1").get_attribute(
6003 "value"
6004 )
6005 slug2 = self.selenium.find_element(By.ID, f"{row_id}slug2").get_attribute(
6006 "value"
6007 )
6008 self.assertEqual(slug1, "stacked-inline-2011-12-12")
6009 self.assertEqual(slug2, "option-one")
6010 # Add inline.
6011 self.selenium.find_elements(
6012 By.LINK_TEXT,
6013 "Add another Related prepopulated",
6014 )[3].click()
6015 row_id = "id_relatedprepopulated_set-4-1-"
6016 self.selenium.find_element(By.ID, f"{row_id}pubdate").send_keys("1999-01-20")
6017 status = self.selenium.find_element(By.ID, f"{row_id}status")
6018 ActionChains(self.selenium).move_to_element(status).click(status).perform()
6019 self.select_option(f"#{row_id}status", "option two")
6020 self.selenium.find_element(By.ID, f"{row_id}name").send_keys(
6021 " now you haVe anöther sŤāÇkeð inline with a very loooong "
6022 )
6023 slug1 = self.selenium.find_element(By.ID, f"{row_id}slug1").get_attribute(
6024 "value"
6025 )
6026 slug2 = self.selenium.find_element(By.ID, f"{row_id}slug2").get_attribute(
6027 "value"
6028 )
6029 self.assertEqual(slug1, "now-you-have-another-stacked-inline-with-a-very-lo")
6030 self.assertEqual(slug2, "option-two")
6031
6032 # Save and check that everything is properly stored in the database
6033 with self.wait_page_loaded():
6034 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6035 self.assertEqual(MainPrepopulated.objects.count(), 1)
6036 MainPrepopulated.objects.get(
6037 name=" the mAin nÀMë and it's awεšomeıııİ",
6038 pubdate="2012-02-18",
6039 status="option two",
6040 slug1="the-main-name-and-its-awesomeiiii-2012-02-18",
6041 slug2="option-two-the-main-name-and-its-awesomeiiii",
6042 slug3="the-main-nàmë-and-its-awεšomeıııi",
6043 )
6044 self.assertEqual(RelatedPrepopulated.objects.count(), 6)
6045 RelatedPrepopulated.objects.get(
6046 name=" here is a sŤāÇkeð inline ! ",
6047 pubdate="2011-12-17",
6048 status="option one",
6049 slug1="here-is-a-stacked-inline-2011-12-17",
6050 slug2="option-one-here-is-a-stacked-inline",
6051 )
6052 RelatedPrepopulated.objects.get(
6053 # 75 characters in name field
6054 name=(
6055 " now you haVe anöther sŤāÇkeð inline with a very ... "
6056 "loooooooooooooooooo"
6057 ),
6058 pubdate="1999-01-25",
6059 status="option two",
6060 slug1="now-you-have-another-stacked-inline-with-a-very-lo",
6061 slug2="option-two-now-you-have-another-stacked-inline-with-a-very-l",
6062 )
6063 RelatedPrepopulated.objects.get(
6064 name="And now, with a tÃbűlaŘ inline !!!",
6065 pubdate="1234-12-07",
6066 status="option two",
6067 slug1="and-now-with-a-tabular-inline-1234-12-07",
6068 slug2="option-two-and-now-with-a-tabular-inline",
6069 )
6070 RelatedPrepopulated.objects.get(
6071 name=r'tÃbűlaŘ inline with ignored ;"&*^\%$#@-/`~ characters',
6072 pubdate="1981-08-22",
6073 status="option one",
6074 slug1="tabular-inline-with-ignored-characters-1981-08-22",
6075 slug2="option-one-tabular-inline-with-ignored-characters",
6076 )
6077
6078 def test_populate_existing_object(self):
6079 """
6080 The prepopulation works for existing objects too, as long as
6081 the original field is empty (#19082).
6082 """
6083 from selenium.webdriver.common.by import By
6084
6085 # Slugs are empty to start with.
6086 item = MainPrepopulated.objects.create(
6087 name=" this is the mAin nÀMë",
6088 pubdate="2012-02-18",
6089 status="option two",
6090 slug1="",
6091 slug2="",
6092 )
6093 self.admin_login(
6094 username="super", password="secret", login_url=reverse("admin:index")
6095 )
6096
6097 object_url = self.live_server_url + reverse(
6098 "admin:admin_views_mainprepopulated_change", args=(item.id,)
6099 )
6100
6101 self.selenium.get(object_url)
6102 self.selenium.find_element(By.ID, "id_name").send_keys(" the best")
6103
6104 # The slugs got prepopulated since they were originally empty
6105 slug1 = self.selenium.find_element(By.ID, "id_slug1").get_attribute("value")
6106 slug2 = self.selenium.find_element(By.ID, "id_slug2").get_attribute("value")
6107 self.assertEqual(slug1, "this-is-the-main-name-the-best-2012-02-18")
6108 self.assertEqual(slug2, "option-two-this-is-the-main-name-the-best")
6109
6110 # Save the object
6111 with self.wait_page_loaded():
6112 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6113
6114 self.selenium.get(object_url)
6115 self.selenium.find_element(By.ID, "id_name").send_keys(" hello")
6116
6117 # The slugs got prepopulated didn't change since they were originally not empty
6118 slug1 = self.selenium.find_element(By.ID, "id_slug1").get_attribute("value")
6119 slug2 = self.selenium.find_element(By.ID, "id_slug2").get_attribute("value")
6120 self.assertEqual(slug1, "this-is-the-main-name-the-best-2012-02-18")
6121 self.assertEqual(slug2, "option-two-this-is-the-main-name-the-best")
6122
6123 @screenshot_cases(["desktop_size", "mobile_size", "dark", "high_contrast"])
6124 def test_collapsible_fieldset(self):
6125 """
6126 The 'collapse' class in fieldsets definition allows to
6127 show/hide the appropriate field section.
6128 """
6129 from selenium.webdriver.common.by import By
6130
6131 self.admin_login(
6132 username="super", password="secret", login_url=reverse("admin:index")
6133 )
6134 self.selenium.get(
6135 self.live_server_url + reverse("admin:admin_views_article_add")
6136 )
6137 self.assertFalse(self.selenium.find_element(By.ID, "id_title").is_displayed())
6138 self.take_screenshot("collapsed")
6139 self.selenium.find_elements(By.TAG_NAME, "summary")[0].click()
6140 self.assertTrue(self.selenium.find_element(By.ID, "id_title").is_displayed())
6141 self.take_screenshot("expanded")
6142
6143 @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
6144 def test_selectbox_height_collapsible_fieldset(self):
6145 from selenium.webdriver.common.by import By
6146
6147 self.admin_login(
6148 username="super",
6149 password="secret",
6150 login_url=reverse("admin7:index"),
6151 )
6152 url = self.live_server_url + reverse("admin7:admin_views_pizza_add")
6153 self.selenium.get(url)
6154 self.selenium.find_elements(By.TAG_NAME, "summary")[0].click()
6155 from_filter_box = self.selenium.find_element(By.ID, "id_toppings_filter")
6156 from_box = self.selenium.find_element(By.ID, "id_toppings_from")
6157 to_filter_box = self.selenium.find_element(By.ID, "id_toppings_filter_selected")
6158 to_box = self.selenium.find_element(By.ID, "id_toppings_to")
6159 self.assertEqual(
6160 (
6161 to_filter_box.get_property("offsetHeight")
6162 + to_box.get_property("offsetHeight")
6163 ),
6164 (
6165 from_filter_box.get_property("offsetHeight")
6166 + from_box.get_property("offsetHeight")
6167 ),
6168 )
6169 self.take_screenshot("selectbox-collapsible")
6170
6171 @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
6172 def test_selectbox_height_not_collapsible_fieldset(self):
6173 from selenium.webdriver.common.by import By
6174
6175 self.admin_login(
6176 username="super",
6177 password="secret",
6178 login_url=reverse("admin7:index"),
6179 )
6180 url = self.live_server_url + reverse("admin7:admin_views_question_add")
6181 self.selenium.get(url)
6182 from_filter_box = self.selenium.find_element(
6183 By.ID, "id_related_questions_filter"
6184 )
6185 from_box = self.selenium.find_element(By.ID, "id_related_questions_from")
6186 to_filter_box = self.selenium.find_element(
6187 By.ID, "id_related_questions_filter_selected"
6188 )
6189 to_box = self.selenium.find_element(By.ID, "id_related_questions_to")
6190 self.assertEqual(
6191 (
6192 to_filter_box.get_property("offsetHeight")
6193 + to_box.get_property("offsetHeight")
6194 ),
6195 (
6196 from_filter_box.get_property("offsetHeight")
6197 + from_box.get_property("offsetHeight")
6198 ),
6199 )
6200 self.take_screenshot("selectbox-non-collapsible")
6201
6202 @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
6203 def test_selectbox_selected_rows(self):
6204 from selenium.webdriver import ActionChains
6205 from selenium.webdriver.common.by import By
6206 from selenium.webdriver.common.keys import Keys
6207
6208 self.admin_login(
6209 username="super", password="secret", login_url=reverse("admin:index")
6210 )
6211 # Create a new user to ensure that no extra permissions have been set.
6212 user = User.objects.create_user(username="new", password="newuser")
6213 url = self.live_server_url + reverse("admin:auth_user_change", args=[user.id])
6214 self.selenium.get(url)
6215
6216 # Scroll to the User permissions section.
6217 user_permissions = self.selenium.find_element(
6218 By.CSS_SELECTOR, "#id_user_permissions_from"
6219 )
6220 ActionChains(self.selenium).move_to_element(user_permissions).perform()
6221 self.take_screenshot("selectbox-available-perms-none-selected")
6222
6223 # Select multiple permissions from the "Available" list.
6224 ct = ContentType.objects.get_for_model(Permission)
6225 perms = list(Permission.objects.filter(content_type=ct))
6226 for perm in perms:
6227 elem = self.selenium.find_element(
6228 By.CSS_SELECTOR, f"#id_user_permissions_from option[value='{perm.id}']"
6229 )
6230 ActionChains(self.selenium).key_down(Keys.CONTROL).click(elem).key_up(
6231 Keys.CONTROL
6232 ).perform()
6233
6234 # Move focus to other element.
6235 self.selenium.find_element(
6236 By.CSS_SELECTOR, "#id_user_permissions_input"
6237 ).click()
6238 self.take_screenshot("selectbox-available-perms-some-selected")
6239
6240 # Move permissions to the "Chosen" list, but none is selected yet.
6241 self.selenium.find_element(By.CSS_SELECTOR, "#id_user_permissions_add").click()
6242 self.take_screenshot("selectbox-chosen-perms-none-selected")
6243
6244 # Select some permissions from the "Chosen" list.
6245 for perm in [perms[0], perms[-1]]:
6246 elem = self.selenium.find_element(
6247 By.CSS_SELECTOR, f"#id_user_permissions_to option[value='{perm.id}']"
6248 )
6249 ActionChains(self.selenium).key_down(Keys.CONTROL).click(elem).key_up(
6250 Keys.CONTROL
6251 ).perform()
6252
6253 # Move focus to other element.
6254 self.selenium.find_element(
6255 By.CSS_SELECTOR, "#id_user_permissions_selected_input"
6256 ).click()
6257 self.take_screenshot("selectbox-chosen-perms-some-selected")
6258
6259 @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
6260 def test_first_field_focus(self):
6261 """JavaScript-assisted auto-focus on first usable form field."""
6262 from selenium.webdriver.common.by import By
6263
6264 # First form field has a single widget
6265 self.admin_login(
6266 username="super", password="secret", login_url=reverse("admin:index")
6267 )
6268 with self.wait_page_loaded():
6269 self.selenium.get(
6270 self.live_server_url + reverse("admin:admin_views_picture_add")
6271 )
6272 self.assertEqual(
6273 self.selenium.switch_to.active_element,
6274 self.selenium.find_element(By.ID, "id_name"),
6275 )
6276 self.take_screenshot("focus-single-widget")
6277
6278 # First form field has a MultiWidget
6279 with self.wait_page_loaded():
6280 self.selenium.get(
6281 self.live_server_url + reverse("admin:admin_views_reservation_add")
6282 )
6283 self.assertEqual(
6284 self.selenium.switch_to.active_element,
6285 self.selenium.find_element(By.ID, "id_start_date_0"),
6286 )
6287 self.take_screenshot("focus-multi-widget")
6288
6289 def test_cancel_delete_confirmation(self):
6290 "Cancelling the deletion of an object takes the user back one page."
6291 from selenium.webdriver.common.by import By
6292
6293 pizza = Pizza.objects.create(name="Double Cheese")
6294 url = reverse("admin:admin_views_pizza_change", args=(pizza.id,))
6295 full_url = self.live_server_url + url
6296 self.admin_login(
6297 username="super", password="secret", login_url=reverse("admin:index")
6298 )
6299 self.selenium.get(full_url)
6300 self.selenium.find_element(By.CLASS_NAME, "deletelink").click()
6301 # Click 'cancel' on the delete page.
6302 self.selenium.find_element(By.CLASS_NAME, "cancel-link").click()
6303 # Wait until we're back on the change page.
6304 self.wait_for_text("#content h1", "Change pizza")
6305 self.assertEqual(self.selenium.current_url, full_url)
6306 self.assertEqual(Pizza.objects.count(), 1)
6307
6308 def test_cancel_delete_related_confirmation(self):
6309 """
6310 Cancelling the deletion of an object with relations takes the user back
6311 one page.
6312 """
6313 from selenium.webdriver.common.by import By
6314
6315 pizza = Pizza.objects.create(name="Double Cheese")
6316 topping1 = Topping.objects.create(name="Cheddar")
6317 topping2 = Topping.objects.create(name="Mozzarella")
6318 pizza.toppings.add(topping1, topping2)
6319 url = reverse("admin:admin_views_pizza_change", args=(pizza.id,))
6320 full_url = self.live_server_url + url
6321 self.admin_login(
6322 username="super", password="secret", login_url=reverse("admin:index")
6323 )
6324 self.selenium.get(full_url)
6325 self.selenium.find_element(By.CLASS_NAME, "deletelink").click()
6326 # Click 'cancel' on the delete page.
6327 self.selenium.find_element(By.CLASS_NAME, "cancel-link").click()
6328 # Wait until we're back on the change page.
6329 self.wait_for_text("#content h1", "Change pizza")
6330 self.assertEqual(self.selenium.current_url, full_url)
6331 self.assertEqual(Pizza.objects.count(), 1)
6332 self.assertEqual(Topping.objects.count(), 2)
6333
6334 def test_list_editable_popups(self):
6335 """
6336 list_editable foreign keys have add/change popups.
6337 """
6338 from selenium.webdriver.common.by import By
6339 from selenium.webdriver.support.ui import Select
6340
6341 s1 = Section.objects.create(name="Test section")
6342 Article.objects.create(
6343 title="foo",
6344 content="<p>Middle content</p>",
6345 date=datetime.datetime(2008, 3, 18, 11, 54, 58),
6346 section=s1,
6347 )
6348 self.admin_login(
6349 username="super", password="secret", login_url=reverse("admin:index")
6350 )
6351 self.selenium.get(
6352 self.live_server_url + reverse("admin:admin_views_article_changelist")
6353 )
6354 # Change popup
6355 self.selenium.find_element(By.ID, "change_id_form-0-section").click()
6356 self.wait_for_and_switch_to_popup()
6357 self.wait_for_text("#content h1", "Change section")
6358 name_input = self.selenium.find_element(By.ID, "id_name")
6359 name_input.clear()
6360 name_input.send_keys("<i>edited section</i>")
6361 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6362 self.wait_until(lambda d: len(d.window_handles) == 1, 1)
6363 self.selenium.switch_to.window(self.selenium.window_handles[0])
6364 # Hide sidebar.
6365 toggle_button = self.selenium.find_element(
6366 By.CSS_SELECTOR, "#toggle-nav-sidebar"
6367 )
6368 toggle_button.click()
6369 self.addCleanup(_clean_sidebar_state, self.selenium)
6370 select = Select(self.selenium.find_element(By.ID, "id_form-0-section"))
6371 self.assertEqual(select.first_selected_option.text, "<i>edited section</i>")
6372 # Rendered select2 input.
6373 select2_display = self.selenium.find_element(
6374 By.CLASS_NAME, "select2-selection__rendered"
6375 )
6376 # Clear button (×\n) is included in text.
6377 self.assertEqual(select2_display.text, "×\n<i>edited section</i>")
6378
6379 # Add popup
6380 self.selenium.find_element(By.ID, "add_id_form-0-section").click()
6381 self.wait_for_and_switch_to_popup()
6382 self.wait_for_text("#content h1", "Add section")
6383 self.selenium.find_element(By.ID, "id_name").send_keys("new section")
6384 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6385 self.wait_until(lambda d: len(d.window_handles) == 1, 1)
6386 self.selenium.switch_to.window(self.selenium.window_handles[0])
6387 select = Select(self.selenium.find_element(By.ID, "id_form-0-section"))
6388 self.assertEqual(select.first_selected_option.text, "new section")
6389 select2_display = self.selenium.find_element(
6390 By.CLASS_NAME, "select2-selection__rendered"
6391 )
6392 # Clear button (×\n) is included in text.
6393 self.assertEqual(select2_display.text, "×\nnew section")
6394
6395 def test_inline_uuid_pk_edit_with_popup(self):
6396 from selenium.webdriver import ActionChains
6397 from selenium.webdriver.common.by import By
6398 from selenium.webdriver.support.ui import Select
6399
6400 parent = ParentWithUUIDPK.objects.create(title="test")
6401 related_with_parent = RelatedWithUUIDPKModel.objects.create(parent=parent)
6402 self.admin_login(
6403 username="super", password="secret", login_url=reverse("admin:index")
6404 )
6405 change_url = reverse(
6406 "admin:admin_views_relatedwithuuidpkmodel_change",
6407 args=(related_with_parent.id,),
6408 )
6409 with self.wait_page_loaded():
6410 self.selenium.get(self.live_server_url + change_url)
6411 change_parent = self.selenium.find_element(By.ID, "change_id_parent")
6412 ActionChains(self.selenium).move_to_element(change_parent).click().perform()
6413 self.wait_for_and_switch_to_popup()
6414 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6415 self.selenium.switch_to.window(self.selenium.window_handles[0])
6416 select = Select(self.selenium.find_element(By.ID, "id_parent"))
6417 self.assertEqual(select.first_selected_option.text, str(parent.id))
6418 self.assertEqual(
6419 select.first_selected_option.get_attribute("value"), str(parent.id)
6420 )
6421
6422 def test_inline_uuid_pk_add_with_popup(self):
6423 from selenium.webdriver.common.by import By
6424 from selenium.webdriver.support.ui import Select
6425
6426 self.admin_login(
6427 username="super", password="secret", login_url=reverse("admin:index")
6428 )
6429 self.selenium.get(
6430 self.live_server_url
6431 + reverse("admin:admin_views_relatedwithuuidpkmodel_add")
6432 )
6433 self.selenium.find_element(By.ID, "add_id_parent").click()
6434 self.wait_for_and_switch_to_popup()
6435 self.selenium.find_element(By.ID, "id_title").send_keys("test")
6436 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6437 self.wait_until(lambda d: len(d.window_handles) == 1, 1)
6438 self.selenium.switch_to.window(self.selenium.window_handles[0])
6439 select = Select(self.selenium.find_element(By.ID, "id_parent"))
6440 uuid_id = str(ParentWithUUIDPK.objects.first().id)
6441 self.assertEqual(select.first_selected_option.text, uuid_id)
6442 self.assertEqual(select.first_selected_option.get_attribute("value"), uuid_id)
6443
6444 def test_inline_uuid_pk_delete_with_popup(self):
6445 from selenium.webdriver import ActionChains
6446 from selenium.webdriver.common.by import By
6447 from selenium.webdriver.support.ui import Select
6448
6449 parent = ParentWithUUIDPK.objects.create(title="test")
6450 related_with_parent = RelatedWithUUIDPKModel.objects.create(parent=parent)
6451 self.admin_login(
6452 username="super", password="secret", login_url=reverse("admin:index")
6453 )
6454 change_url = reverse(
6455 "admin:admin_views_relatedwithuuidpkmodel_change",
6456 args=(related_with_parent.id,),
6457 )
6458 with self.wait_page_loaded():
6459 self.selenium.get(self.live_server_url + change_url)
6460 delete_parent = self.selenium.find_element(By.ID, "delete_id_parent")
6461 ActionChains(self.selenium).move_to_element(delete_parent).click().perform()
6462 self.wait_for_and_switch_to_popup()
6463 self.selenium.find_element(By.XPATH, '//input[@value="Yes, I’m sure"]').click()
6464 self.selenium.switch_to.window(self.selenium.window_handles[0])
6465 select = Select(self.selenium.find_element(By.ID, "id_parent"))
6466 self.assertEqual(ParentWithUUIDPK.objects.count(), 0)
6467 self.assertEqual(select.first_selected_option.text, "---------")
6468 self.assertEqual(select.first_selected_option.get_attribute("value"), "")
6469
6470 def test_inline_with_popup_cancel_delete(self):
6471 """Clicking ""No, take me back" on a delete popup closes the window."""
6472 from selenium.webdriver import ActionChains
6473 from selenium.webdriver.common.by import By
6474
6475 parent = ParentWithUUIDPK.objects.create(title="test")
6476 related_with_parent = RelatedWithUUIDPKModel.objects.create(parent=parent)
6477 self.admin_login(
6478 username="super", password="secret", login_url=reverse("admin:index")
6479 )
6480 change_url = reverse(
6481 "admin:admin_views_relatedwithuuidpkmodel_change",
6482 args=(related_with_parent.id,),
6483 )
6484 with self.wait_page_loaded():
6485 self.selenium.get(self.live_server_url + change_url)
6486 delete_parent = self.selenium.find_element(By.ID, "delete_id_parent")
6487 ActionChains(self.selenium).move_to_element(delete_parent).click().perform()
6488 self.wait_for_and_switch_to_popup()
6489 self.selenium.find_element(By.XPATH, '//a[text()="No, take me back"]').click()
6490 self.selenium.switch_to.window(self.selenium.window_handles[0])
6491 self.assertEqual(len(self.selenium.window_handles), 1)
6492
6493 def test_list_editable_raw_id_fields(self):
6494 from selenium.webdriver.common.by import By
6495
6496 parent = ParentWithUUIDPK.objects.create(title="test")
6497 parent2 = ParentWithUUIDPK.objects.create(title="test2")
6498 RelatedWithUUIDPKModel.objects.create(parent=parent)
6499 self.admin_login(
6500 username="super", password="secret", login_url=reverse("admin:index")
6501 )
6502 change_url = reverse(
6503 "admin:admin_views_relatedwithuuidpkmodel_changelist",
6504 current_app=site2.name,
6505 )
6506 self.selenium.get(self.live_server_url + change_url)
6507 self.selenium.find_element(By.ID, "lookup_id_form-0-parent").click()
6508 self.wait_for_and_switch_to_popup()
6509 # Select "parent2" in the popup.
6510 self.selenium.find_element(By.LINK_TEXT, str(parent2.pk)).click()
6511 self.selenium.switch_to.window(self.selenium.window_handles[0])
6512 # The newly selected pk should appear in the raw id input.
6513 value = self.selenium.find_element(By.ID, "id_form-0-parent").get_attribute(
6514 "value"
6515 )
6516 self.assertEqual(value, str(parent2.pk))
6517
6518 def test_input_element_font(self):
6519 """
6520 Browsers' default stylesheets override the font of inputs. The admin
6521 adds additional CSS to handle this.
6522 """
6523 from selenium.webdriver.common.by import By
6524
6525 self.selenium.get(self.live_server_url + reverse("admin:login"))
6526 element = self.selenium.find_element(By.ID, "id_username")
6527 # Some browsers quotes the fonts, some don't.
6528 fonts = [
6529 font.strip().strip('"')
6530 for font in element.value_of_css_property("font-family").split(",")
6531 ]
6532 self.assertEqual(
6533 fonts,
6534 [
6535 "Segoe UI",
6536 "system-ui",
6537 "Roboto",
6538 "Helvetica Neue",
6539 "Arial",
6540 "sans-serif",
6541 "Apple Color Emoji",
6542 "Segoe UI Emoji",
6543 "Segoe UI Symbol",
6544 "Noto Color Emoji",
6545 ],
6546 )
6547
6548 def test_search_input_filtered_page(self):
6549 from selenium.webdriver.common.by import By
6550
6551 Person.objects.create(name="Guido van Rossum", gender=1, alive=True)
6552 Person.objects.create(name="Grace Hopper", gender=1, alive=False)
6553 self.admin_login(
6554 username="super", password="secret", login_url=reverse("admin:index")
6555 )
6556 person_url = reverse("admin:admin_views_person_changelist") + "?q=Gui"
6557 self.selenium.get(self.live_server_url + person_url)
6558 # Hide sidebar.
6559 toggle_button = self.selenium.find_element(
6560 By.CSS_SELECTOR, "#toggle-nav-sidebar"
6561 )
6562 toggle_button.click()
6563 self.addCleanup(_clean_sidebar_state, self.selenium)
6564 self.assertGreater(
6565 self.selenium.find_element(By.ID, "searchbar").rect["width"],
6566 50,
6567 )
6568
6569 def test_related_popup_index(self):
6570 """
6571 Create a chain of 'self' related objects via popups.
6572 """
6573 from selenium.webdriver.common.by import By
6574 from selenium.webdriver.support.ui import Select
6575
6576 self.admin_login(
6577 username="super", password="secret", login_url=reverse("admin:index")
6578 )
6579 add_url = reverse("admin:admin_views_box_add", current_app=site.name)
6580 self.selenium.get(self.live_server_url + add_url)
6581
6582 base_window = self.selenium.current_window_handle
6583 self.selenium.find_element(By.ID, "add_id_next_box").click()
6584 self.wait_for_and_switch_to_popup()
6585
6586 popup_window_test = self.selenium.current_window_handle
6587 self.selenium.find_element(By.ID, "id_title").send_keys("test")
6588 self.selenium.find_element(By.ID, "add_id_next_box").click()
6589 self.wait_for_and_switch_to_popup(num_windows=3)
6590
6591 popup_window_test2 = self.selenium.current_window_handle
6592 self.selenium.find_element(By.ID, "id_title").send_keys("test2")
6593 self.selenium.find_element(By.ID, "add_id_next_box").click()
6594 self.wait_for_and_switch_to_popup(num_windows=4)
6595
6596 self.selenium.find_element(By.ID, "id_title").send_keys("test3")
6597 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6598 self.selenium.switch_to.window(popup_window_test2)
6599 select = Select(self.selenium.find_element(By.ID, "id_next_box"))
6600 next_box_id = str(Box.objects.get(title="test3").id)
6601 self.assertEqual(
6602 select.first_selected_option.get_attribute("value"), next_box_id
6603 )
6604
6605 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6606 self.selenium.switch_to.window(popup_window_test)
6607 select = Select(self.selenium.find_element(By.ID, "id_next_box"))
6608 next_box_id = str(Box.objects.get(title="test2").id)
6609 self.assertEqual(
6610 select.first_selected_option.get_attribute("value"), next_box_id
6611 )
6612
6613 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6614 self.selenium.switch_to.window(base_window)
6615 select = Select(self.selenium.find_element(By.ID, "id_next_box"))
6616 next_box_id = str(Box.objects.get(title="test").id)
6617 self.assertEqual(
6618 select.first_selected_option.get_attribute("value"), next_box_id
6619 )
6620
6621 def test_related_popup_incorrect_close(self):
6622 """
6623 Cleanup child popups when closing a parent popup.
6624 """
6625 from selenium.webdriver.common.by import By
6626
6627 self.admin_login(
6628 username="super", password="secret", login_url=reverse("admin:index")
6629 )
6630 add_url = reverse("admin:admin_views_box_add", current_app=site.name)
6631 self.selenium.get(self.live_server_url + add_url)
6632
6633 self.selenium.find_element(By.ID, "add_id_next_box").click()
6634 self.wait_for_and_switch_to_popup()
6635
6636 test_window = self.selenium.current_window_handle
6637 self.selenium.find_element(By.ID, "id_title").send_keys("test")
6638 self.selenium.find_element(By.ID, "add_id_next_box").click()
6639 self.wait_for_and_switch_to_popup(num_windows=3)
6640
6641 test2_window = self.selenium.current_window_handle
6642 self.selenium.find_element(By.ID, "id_title").send_keys("test2")
6643 self.selenium.find_element(By.ID, "add_id_next_box").click()
6644 self.wait_for_and_switch_to_popup(num_windows=4)
6645 self.assertEqual(len(self.selenium.window_handles), 4)
6646
6647 self.selenium.switch_to.window(test2_window)
6648 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6649 self.wait_until(lambda d: len(d.window_handles) == 2, 1)
6650 self.assertEqual(len(self.selenium.window_handles), 2)
6651
6652 # Close final popup to clean up test.
6653 self.selenium.switch_to.window(test_window)
6654 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
6655 self.wait_until(lambda d: len(d.window_handles) == 1, 1)
6656 self.selenium.switch_to.window(self.selenium.window_handles[-1])
6657
6658 def test_hidden_fields_small_window(self):
6659 from selenium.webdriver.common.by import By
6660
6661 self.admin_login(
6662 username="super",
6663 password="secret",
6664 login_url=reverse("admin:index"),
6665 )
6666 self.selenium.get(self.live_server_url + reverse("admin:admin_views_story_add"))
6667 field_title = self.selenium.find_element(By.CLASS_NAME, "field-title")
6668 with self.small_screen_size():
6669 self.assertIs(field_title.is_displayed(), False)
6670 with self.mobile_size():
6671 self.assertIs(field_title.is_displayed(), False)
6672
6673 def test_updating_related_objects_updates_fk_selects_except_autocompletes(self):
6674 from selenium.webdriver import ActionChains
6675 from selenium.webdriver.common.by import By
6676 from selenium.webdriver.support.ui import Select
6677
6678 born_country_select_id = "id_born_country"
6679 living_country_select_id = "id_living_country"
6680 living_country_select2_textbox_id = "select2-id_living_country-container"
6681 favorite_country_to_vacation_select_id = "id_favorite_country_to_vacation"
6682 continent_select_id = "id_continent"
6683
6684 def _get_HTML_inside_element_by_id(id_):
6685 return self.selenium.find_element(By.ID, id_).get_attribute("innerHTML")
6686
6687 def _get_text_inside_element_by_selector(selector):
6688 return self.selenium.find_element(By.CSS_SELECTOR, selector).get_attribute(
6689 "innerText"
6690 )
6691
6692 self.admin_login(
6693 username="super", password="secret", login_url=reverse("admin:index")
6694 )
6695 add_url = reverse("admin:admin_views_traveler_add")
6696 self.selenium.get(self.live_server_url + add_url)
6697
6698 # Add new Country from the born_country select.
6699 self.selenium.find_element(By.ID, f"add_{born_country_select_id}").click()
6700 self.wait_for_and_switch_to_popup()
6701 self.selenium.find_element(By.ID, "id_name").send_keys("Argentina")
6702 continent_select = Select(
6703 self.selenium.find_element(By.ID, continent_select_id)
6704 )
6705 continent_select.select_by_visible_text("South America")
6706 self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
6707 self.wait_until(lambda d: len(d.window_handles) == 1, 1)
6708 self.selenium.switch_to.window(self.selenium.window_handles[0])
6709
6710 self.assertHTMLEqual(
6711 _get_HTML_inside_element_by_id(born_country_select_id),
6712 """
6713 <option value="" selected="">---------</option>
6714 <option value="1" selected="">Argentina</option>
6715 """,
6716 )
6717 # Argentina isn't added to the living_country select nor selected by
6718 # the select2 widget.
6719 self.assertEqual(
6720 _get_text_inside_element_by_selector(f"#{living_country_select_id}"), ""
6721 )
6722 self.assertEqual(
6723 _get_text_inside_element_by_selector(
6724 f"#{living_country_select2_textbox_id}"
6725 ),
6726 "",
6727 )
6728 # Argentina won't appear because favorite_country_to_vacation field has
6729 # limit_choices_to.
6730 self.assertHTMLEqual(
6731 _get_HTML_inside_element_by_id(favorite_country_to_vacation_select_id),
6732 '<option value="" selected="">---------</option>',
6733 )
6734
6735 # Add new Country from the living_country select.
6736 element = self.selenium.find_element(By.ID, f"add_{living_country_select_id}")
6737 ActionChains(self.selenium).move_to_element(element).click(element).perform()
6738 self.wait_for_and_switch_to_popup()
6739 self.selenium.find_element(By.ID, "id_name").send_keys("Spain")
6740 continent_select = Select(
6741 self.selenium.find_element(By.ID, continent_select_id)
6742 )
6743 continent_select.select_by_visible_text("Europe")
6744 self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
6745 self.wait_until(lambda d: len(d.window_handles) == 1, 1)
6746 self.selenium.switch_to.window(self.selenium.window_handles[0])
6747
6748 self.assertHTMLEqual(
6749 _get_HTML_inside_element_by_id(born_country_select_id),
6750 """
6751 <option value="" selected="">---------</option>
6752 <option value="1" selected="">Argentina</option>
6753 <option value="2">Spain</option>
6754 """,
6755 )
6756
6757 # Spain is added to the living_country select and it's also selected by
6758 # the select2 widget.
6759 self.assertEqual(
6760 _get_text_inside_element_by_selector(f"#{living_country_select_id} option"),
6761 "Spain",
6762 )
6763 self.assertEqual(
6764 _get_text_inside_element_by_selector(
6765 f"#{living_country_select2_textbox_id}"
6766 ),
6767 "Spain",
6768 )
6769 # Spain won't appear because favorite_country_to_vacation field has
6770 # limit_choices_to.
6771 self.assertHTMLEqual(
6772 _get_HTML_inside_element_by_id(favorite_country_to_vacation_select_id),
6773 '<option value="" selected="">---------</option>',
6774 )
6775
6776 # Edit second Country created from living_country select.
6777 favorite_select = Select(
6778 self.selenium.find_element(By.ID, living_country_select_id)
6779 )
6780 favorite_select.select_by_visible_text("Spain")
6781 self.selenium.find_element(By.ID, f"change_{living_country_select_id}").click()
6782 self.wait_for_and_switch_to_popup()
6783 favorite_name_input = self.selenium.find_element(By.ID, "id_name")
6784 favorite_name_input.clear()
6785 favorite_name_input.send_keys("Italy")
6786 self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
6787 self.wait_until(lambda d: len(d.window_handles) == 1, 1)
6788 self.selenium.switch_to.window(self.selenium.window_handles[0])
6789
6790 self.assertHTMLEqual(
6791 _get_HTML_inside_element_by_id(born_country_select_id),
6792 """
6793 <option value="" selected="">---------</option>
6794 <option value="1" selected="">Argentina</option>
6795 <option value="2">Italy</option>
6796 """,
6797 )
6798 # Italy is added to the living_country select and it's also selected by
6799 # the select2 widget.
6800 self.assertEqual(
6801 _get_text_inside_element_by_selector(f"#{living_country_select_id} option"),
6802 "Italy",
6803 )
6804 self.assertEqual(
6805 _get_text_inside_element_by_selector(
6806 f"#{living_country_select2_textbox_id}"
6807 ),
6808 "Italy",
6809 )
6810 # favorite_country_to_vacation field has no options.
6811 self.assertHTMLEqual(
6812 _get_HTML_inside_element_by_id(favorite_country_to_vacation_select_id),
6813 '<option value="" selected="">---------</option>',
6814 )
6815
6816 # Add a new Asian country.
6817 self.selenium.find_element(
6818 By.ID, f"add_{favorite_country_to_vacation_select_id}"
6819 ).click()
6820 self.wait_for_and_switch_to_popup()
6821 favorite_name_input = self.selenium.find_element(By.ID, "id_name")
6822 favorite_name_input.send_keys("Qatar")
6823 continent_select = Select(
6824 self.selenium.find_element(By.ID, continent_select_id)
6825 )
6826 continent_select.select_by_visible_text("Asia")
6827 self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
6828 self.wait_until(lambda d: len(d.window_handles) == 1, 1)
6829 self.selenium.switch_to.window(self.selenium.window_handles[0])
6830
6831 # Submit the new Traveler.
6832 with self.wait_page_loaded():
6833 self.selenium.find_element(By.CSS_SELECTOR, '[name="_save"]').click()
6834 traveler = Traveler.objects.get()
6835 self.assertEqual(traveler.born_country.name, "Argentina")
6836 self.assertEqual(traveler.living_country.name, "Italy")
6837 self.assertEqual(traveler.favorite_country_to_vacation.name, "Qatar")
6838
6839 def test_redirect_on_add_view_add_another_button(self):
6840 from selenium.webdriver.common.by import By
6841
6842 self.admin_login(
6843 username="super", password="secret", login_url=reverse("admin:index")
6844 )
6845 add_url = reverse("admin7:admin_views_section_add")
6846 self.selenium.get(self.live_server_url + add_url)
6847 name_input = self.selenium.find_element(By.ID, "id_name")
6848 name_input.send_keys("Test section 1")
6849 self.selenium.find_element(
6850 By.XPATH, '//input[@value="Save and add another"]'
6851 ).click()
6852 self.assertEqual(Section.objects.count(), 1)
6853 name_input = self.selenium.find_element(By.ID, "id_name")
6854 name_input.send_keys("Test section 2")
6855 self.selenium.find_element(
6856 By.XPATH, '//input[@value="Save and add another"]'
6857 ).click()
6858 self.assertEqual(Section.objects.count(), 2)
6859
6860 def test_redirect_on_add_view_continue_button(self):
6861 from selenium.webdriver.common.by import By
6862
6863 self.admin_login(
6864 username="super", password="secret", login_url=reverse("admin:index")
6865 )
6866 add_url = reverse("admin7:admin_views_section_add")
6867 self.selenium.get(self.live_server_url + add_url)
6868 name_input = self.selenium.find_element(By.ID, "id_name")
6869 name_input.send_keys("Test section 1")
6870 self.selenium.find_element(
6871 By.XPATH, '//input[@value="Save and continue editing"]'
6872 ).click()
6873 self.assertEqual(Section.objects.count(), 1)
6874 name_input = self.selenium.find_element(By.ID, "id_name")
6875 name_input_value = name_input.get_attribute("value")
6876 self.assertEqual(name_input_value, "Test section 1")
6877
6878
6879 @override_settings(ROOT_URLCONF="admin_views.urls")
6880 class ReadonlyTest(AdminFieldExtractionMixin, TestCase):
6881 @classmethod
6882 def setUpTestData(cls):
6883 cls.superuser = User.objects.create_superuser(
6884 username="super", password="secret", email="[email protected]"
6885 )
6886
6887 def setUp(self):
6888 self.client.force_login(self.superuser)
6889
6890 @ignore_warnings(category=RemovedInDjango60Warning)
6891 def test_readonly_get(self):
6892 response = self.client.get(reverse("admin:admin_views_post_add"))
6893 self.assertNotContains(response, 'name="posted"')
6894 # 3 fields + 2 submit buttons + 5 inline management form fields, + 2
6895 # hidden fields for inlines + 1 field for the inline + 2 empty form
6896 # + 1 logout form.
6897 self.assertContains(response, "<input", count=17)
6898 self.assertContains(response, formats.localize(datetime.date.today()))
6899 self.assertContains(response, "<label>Awesomeness level:</label>")
6900 self.assertContains(response, "Very awesome.")
6901 self.assertContains(response, "Unknown coolness.")
6902 self.assertContains(response, "foo")
6903
6904 # Multiline text in a readonly field gets <br> tags
6905 self.assertContains(response, "Multiline<br>test<br>string")
6906 self.assertContains(
6907 response,
6908 '<div class="readonly">Multiline<br>html<br>content</div>',
6909 html=True,
6910 )
6911 self.assertContains(response, "InlineMultiline<br>test<br>string")
6912
6913 self.assertContains(
6914 response,
6915 formats.localize(datetime.date.today() - datetime.timedelta(days=7)),
6916 )
6917
6918 self.assertContains(response, '<div class="form-row field-coolness">')
6919 self.assertContains(response, '<div class="form-row field-awesomeness_level">')
6920 self.assertContains(response, '<div class="form-row field-posted">')
6921 self.assertContains(response, '<div class="form-row field-value">')
6922 self.assertContains(response, '<div class="form-row">')
6923 self.assertContains(response, '<div class="help"', 3)
6924 self.assertContains(
6925 response,
6926 '<div class="help" id="id_title_helptext"><div>Some help text for the '
6927 "title (with Unicode ŠĐĆŽćžšđ)</div></div>",
6928 html=True,
6929 )
6930 self.assertContains(
6931 response,
6932 '<div class="help" id="id_content_helptext"><div>Some help text for the '
6933 "content (with Unicode ŠĐĆŽćžšđ)</div></div>",
6934 html=True,
6935 )
6936 self.assertContains(
6937 response,
6938 '<div class="help"><div>Some help text for the date (with Unicode ŠĐĆŽćžšđ)'
6939 "</div></div>",
6940 html=True,
6941 )
6942
6943 p = Post.objects.create(
6944 title="I worked on readonly_fields", content="Its good stuff"
6945 )
6946 response = self.client.get(
6947 reverse("admin:admin_views_post_change", args=(p.pk,))
6948 )
6949 self.assertContains(response, "%d amount of cool" % p.pk)
6950
6951 @ignore_warnings(category=RemovedInDjango60Warning)
6952 def test_readonly_text_field(self):
6953 p = Post.objects.create(
6954 title="Readonly test",
6955 content="test",
6956 readonly_content="test\r\n\r\ntest\r\n\r\ntest\r\n\r\ntest",
6957 )
6958 Link.objects.create(
6959 url="http://www.djangoproject.com",
6960 post=p,
6961 readonly_link_content="test\r\nlink",
6962 )
6963 response = self.client.get(
6964 reverse("admin:admin_views_post_change", args=(p.pk,))
6965 )
6966 # Checking readonly field.
6967 self.assertContains(response, "test<br><br>test<br><br>test<br><br>test")
6968 # Checking readonly field in inline.
6969 self.assertContains(response, "test<br>link")
6970
6971 @ignore_warnings(category=RemovedInDjango60Warning)
6972 def test_readonly_post(self):
6973 data = {
6974 "title": "Django Got Readonly Fields",
6975 "content": "This is an incredible development.",
6976 "link_set-TOTAL_FORMS": "1",
6977 "link_set-INITIAL_FORMS": "0",
6978 "link_set-MAX_NUM_FORMS": "0",
6979 }
6980 response = self.client.post(reverse("admin:admin_views_post_add"), data)
6981 self.assertEqual(response.status_code, 302)
6982 self.assertEqual(Post.objects.count(), 1)
6983 p = Post.objects.get()
6984 self.assertEqual(p.posted, datetime.date.today())
6985
6986 data["posted"] = "10-8-1990" # some date that's not today
6987 response = self.client.post(reverse("admin:admin_views_post_add"), data)
6988 self.assertEqual(response.status_code, 302)
6989 self.assertEqual(Post.objects.count(), 2)
6990 p = Post.objects.order_by("-id")[0]
6991 self.assertEqual(p.posted, datetime.date.today())
6992
6993 def test_readonly_manytomany(self):
6994 "Regression test for #13004"
6995 response = self.client.get(reverse("admin:admin_views_pizza_add"))
6996 self.assertEqual(response.status_code, 200)
6997
6998 def test_user_password_change_limited_queryset(self):
6999 su = User.objects.filter(is_superuser=True)[0]
7000 response = self.client.get(
7001 reverse("admin2:auth_user_password_change", args=(su.pk,))
7002 )
7003 self.assertEqual(response.status_code, 404)
7004
7005 def test_change_form_renders_correct_null_choice_value(self):
7006 """
7007 Regression test for #17911.
7008 """
7009 choice = Choice.objects.create(choice=None)
7010 response = self.client.get(
7011 reverse("admin:admin_views_choice_change", args=(choice.pk,))
7012 )
7013 self.assertContains(
7014 response, '<div class="readonly">No opinion</div>', html=True
7015 )
7016
7017 def _test_readonly_foreignkey_links(self, admin_site):
7018 """
7019 ForeignKey readonly fields render as links if the target model is
7020 registered in admin.
7021 """
7022 chapter = Chapter.objects.create(
7023 title="Chapter 1",
7024 content="content",
7025 book=Book.objects.create(name="Book 1"),
7026 )
7027 language = Language.objects.create(iso="_40", name="Test")
7028 obj = ReadOnlyRelatedField.objects.create(
7029 chapter=chapter,
7030 language=language,
7031 user=self.superuser,
7032 )
7033 response = self.client.get(
7034 reverse(
7035 f"{admin_site}:admin_views_readonlyrelatedfield_change", args=(obj.pk,)
7036 ),
7037 )
7038 # Related ForeignKey object registered in admin.
7039 user_url = reverse(f"{admin_site}:auth_user_change", args=(self.superuser.pk,))
7040 self.assertContains(
7041 response,
7042 '<div class="readonly"><a href="%s">super</a></div>' % user_url,
7043 html=True,
7044 )
7045 # Related ForeignKey with the string primary key registered in admin.
7046 language_url = reverse(
7047 f"{admin_site}:admin_views_language_change",
7048 args=(quote(language.pk),),
7049 )
7050 self.assertContains(
7051 response,
7052 '<div class="readonly"><a href="%s">_40</a></div>' % language_url,
7053 html=True,
7054 )
7055 # Related ForeignKey object not registered in admin.
7056 self.assertContains(
7057 response, '<div class="readonly">Chapter 1</div>', html=True
7058 )
7059
7060 def test_readonly_foreignkey_links_default_admin_site(self):
7061 self._test_readonly_foreignkey_links("admin")
7062
7063 def test_readonly_foreignkey_links_custom_admin_site(self):
7064 self._test_readonly_foreignkey_links("namespaced_admin")
7065
7066 def test_readonly_manytomany_backwards_ref(self):
7067 """
7068 Regression test for #16433 - backwards references for related objects
7069 broke if the related field is read-only due to the help_text attribute
7070 """
7071 topping = Topping.objects.create(name="Salami")
7072 pizza = Pizza.objects.create(name="Americano")
7073 pizza.toppings.add(topping)
7074 response = self.client.get(reverse("admin:admin_views_topping_add"))
7075 self.assertEqual(response.status_code, 200)
7076
7077 def test_readonly_manytomany_forwards_ref(self):
7078 topping = Topping.objects.create(name="Salami")
7079 pizza = Pizza.objects.create(name="Americano")
7080 pizza.toppings.add(topping)
7081 response = self.client.get(
7082 reverse("admin:admin_views_pizza_change", args=(pizza.pk,))
7083 )
7084 self.assertContains(response, "<label>Toppings:</label>", html=True)
7085 self.assertContains(response, '<div class="readonly">Salami</div>', html=True)
7086
7087 def test_readonly_onetoone_backwards_ref(self):
7088 """
7089 Can reference a reverse OneToOneField in ModelAdmin.readonly_fields.
7090 """
7091 v1 = Villain.objects.create(name="Adam")
7092 pl = Plot.objects.create(name="Test Plot", team_leader=v1, contact=v1)
7093 pd = PlotDetails.objects.create(details="Brand New Plot", plot=pl)
7094
7095 response = self.client.get(
7096 reverse("admin:admin_views_plotproxy_change", args=(pl.pk,))
7097 )
7098 field = self.get_admin_readonly_field(response, "plotdetails")
7099 pd_url = reverse("admin:admin_views_plotdetails_change", args=(pd.pk,))
7100 self.assertEqual(field.contents(), '<a href="%s">Brand New Plot</a>' % pd_url)
7101
7102 # The reverse relation also works if the OneToOneField is null.
7103 pd.plot = None
7104 pd.save()
7105
7106 response = self.client.get(
7107 reverse("admin:admin_views_plotproxy_change", args=(pl.pk,))
7108 )
7109 field = self.get_admin_readonly_field(response, "plotdetails")
7110 self.assertEqual(field.contents(), "-") # default empty value
7111
7112 @skipUnlessDBFeature("supports_stored_generated_columns")
7113 def test_readonly_unsaved_generated_field(self):
7114 response = self.client.get(reverse("admin:admin_views_square_add"))
7115 self.assertContains(response, '<div class="readonly">-</div>')
7116
7117 @ignore_warnings(category=RemovedInDjango60Warning)
7118 def test_readonly_field_overrides(self):
7119 """
7120 Regression test for #22087 - ModelForm Meta overrides are ignored by
7121 AdminReadonlyField
7122 """
7123 p = FieldOverridePost.objects.create(title="Test Post", content="Test Content")
7124 response = self.client.get(
7125 reverse("admin:admin_views_fieldoverridepost_change", args=(p.pk,))
7126 )
7127 self.assertContains(
7128 response,
7129 '<div class="help"><div>Overridden help text for the date</div></div>',
7130 html=True,
7131 )
7132 self.assertContains(
7133 response,
7134 '<label for="id_public">Overridden public label:</label>',
7135 html=True,
7136 )
7137 self.assertNotContains(
7138 response, "Some help text for the date (with Unicode ŠĐĆŽćžšđ)"
7139 )
7140
7141 def test_correct_autoescaping(self):
7142 """
7143 Make sure that non-field readonly elements are properly autoescaped (#24461)
7144 """
7145 section = Section.objects.create(name="<a>evil</a>")
7146 response = self.client.get(
7147 reverse("admin:admin_views_section_change", args=(section.pk,))
7148 )
7149 self.assertNotContains(response, "<a>evil</a>", status_code=200)
7150 self.assertContains(response, "&lt;a&gt;evil&lt;/a&gt;", status_code=200)
7151
7152 def test_label_suffix_translated(self):
7153 pizza = Pizza.objects.create(name="Americano")
7154 url = reverse("admin:admin_views_pizza_change", args=(pizza.pk,))
7155 with self.settings(LANGUAGE_CODE="fr"):
7156 response = self.client.get(url)
7157 self.assertContains(response, "<label>Toppings\u00a0:</label>", html=True)
7158
7159
7160 @override_settings(ROOT_URLCONF="admin_views.urls")
7161 class LimitChoicesToInAdminTest(TestCase):
7162 @classmethod
7163 def setUpTestData(cls):
7164 cls.superuser = User.objects.create_superuser(
7165 username="super", password="secret", email="[email protected]"
7166 )
7167
7168 def setUp(self):
7169 self.client.force_login(self.superuser)
7170
7171 def test_limit_choices_to_as_callable(self):
7172 """Test for ticket 2445 changes to admin."""
7173 threepwood = Character.objects.create(
7174 username="threepwood",
7175 last_action=datetime.datetime.today() + datetime.timedelta(days=1),
7176 )
7177 marley = Character.objects.create(
7178 username="marley",
7179 last_action=datetime.datetime.today() - datetime.timedelta(days=1),
7180 )
7181 response = self.client.get(reverse("admin:admin_views_stumpjoke_add"))
7182 # The allowed option should appear twice; the limited option should not appear.
7183 self.assertContains(response, threepwood.username, count=2)
7184 self.assertNotContains(response, marley.username)
7185
7186
7187 @override_settings(ROOT_URLCONF="admin_views.urls")
7188 class RawIdFieldsTest(TestCase):
7189 @classmethod
7190 def setUpTestData(cls):
7191 cls.superuser = User.objects.create_superuser(
7192 username="super", password="secret", email="[email protected]"
7193 )
7194
7195 def setUp(self):
7196 self.client.force_login(self.superuser)
7197
7198 def test_limit_choices_to(self):
7199 """Regression test for 14880"""
7200 actor = Actor.objects.create(name="Palin", age=27)
7201 Inquisition.objects.create(expected=True, leader=actor, country="England")
7202 Inquisition.objects.create(expected=False, leader=actor, country="Spain")
7203 response = self.client.get(reverse("admin:admin_views_sketch_add"))
7204 # Find the link
7205 m = re.search(
7206 rb'<a href="([^"]*)"[^>]* id="lookup_id_inquisition"', response.content
7207 )
7208 self.assertTrue(m) # Got a match
7209 popup_url = m[1].decode().replace("&amp;", "&")
7210
7211 # Handle relative links
7212 popup_url = urljoin(response.request["PATH_INFO"], popup_url)
7213 # Get the popup and verify the correct objects show up in the resulting
7214 # page. This step also tests integers, strings and booleans in the
7215 # lookup query string; in model we define inquisition field to have a
7216 # limit_choices_to option that includes a filter on a string field
7217 # (inquisition__actor__name), a filter on an integer field
7218 # (inquisition__actor__age), and a filter on a boolean field
7219 # (inquisition__expected).
7220 response2 = self.client.get(popup_url)
7221 self.assertContains(response2, "Spain")
7222 self.assertNotContains(response2, "England")
7223
7224 def test_limit_choices_to_isnull_false(self):
7225 """Regression test for 20182"""
7226 Actor.objects.create(name="Palin", age=27)
7227 Actor.objects.create(name="Kilbraken", age=50, title="Judge")
7228 response = self.client.get(reverse("admin:admin_views_sketch_add"))
7229 # Find the link
7230 m = re.search(
7231 rb'<a href="([^"]*)"[^>]* id="lookup_id_defendant0"', response.content
7232 )
7233 self.assertTrue(m) # Got a match
7234 popup_url = m[1].decode().replace("&amp;", "&")
7235
7236 # Handle relative links
7237 popup_url = urljoin(response.request["PATH_INFO"], popup_url)
7238 # Get the popup and verify the correct objects show up in the resulting
7239 # page. This step tests field__isnull=0 gets parsed correctly from the
7240 # lookup query string; in model we define defendant0 field to have a
7241 # limit_choices_to option that includes "actor__title__isnull=False".
7242 response2 = self.client.get(popup_url)
7243 self.assertContains(response2, "Kilbraken")
7244 self.assertNotContains(response2, "Palin")
7245
7246 def test_limit_choices_to_isnull_true(self):
7247 """Regression test for 20182"""
7248 Actor.objects.create(name="Palin", age=27)
7249 Actor.objects.create(name="Kilbraken", age=50, title="Judge")
7250 response = self.client.get(reverse("admin:admin_views_sketch_add"))
7251 # Find the link
7252 m = re.search(
7253 rb'<a href="([^"]*)"[^>]* id="lookup_id_defendant1"', response.content
7254 )
7255 self.assertTrue(m) # Got a match
7256 popup_url = m[1].decode().replace("&amp;", "&")
7257
7258 # Handle relative links
7259 popup_url = urljoin(response.request["PATH_INFO"], popup_url)
7260 # Get the popup and verify the correct objects show up in the resulting
7261 # page. This step tests field__isnull=1 gets parsed correctly from the
7262 # lookup query string; in model we define defendant1 field to have a
7263 # limit_choices_to option that includes "actor__title__isnull=True".
7264 response2 = self.client.get(popup_url)
7265 self.assertNotContains(response2, "Kilbraken")
7266 self.assertContains(response2, "Palin")
7267
7268 def test_list_display_method_same_name_as_reverse_accessor(self):
7269 """
7270 Should be able to use a ModelAdmin method in list_display that has the
7271 same name as a reverse model field ("sketch" in this case).
7272 """
7273 actor = Actor.objects.create(name="Palin", age=27)
7274 Inquisition.objects.create(expected=True, leader=actor, country="England")
7275 response = self.client.get(reverse("admin:admin_views_inquisition_changelist"))
7276 self.assertContains(response, "list-display-sketch")
7277
7278
7279 @override_settings(ROOT_URLCONF="admin_views.urls")
7280 class UserAdminTest(TestCase):
7281 """
7282 Tests user CRUD functionality.
7283 """
7284
7285 @classmethod
7286 def setUpTestData(cls):
7287 cls.superuser = User.objects.create_superuser(
7288 username="super", password="secret", email="[email protected]"
7289 )
7290 cls.adduser = User.objects.create_user(
7291 username="adduser", password="secret", is_staff=True
7292 )
7293 cls.changeuser = User.objects.create_user(
7294 username="changeuser", password="secret", is_staff=True
7295 )
7296 cls.s1 = Section.objects.create(name="Test section")
7297 cls.a1 = Article.objects.create(
7298 content="<p>Middle content</p>",
7299 date=datetime.datetime(2008, 3, 18, 11, 54, 58),
7300 section=cls.s1,
7301 )
7302 cls.a2 = Article.objects.create(
7303 content="<p>Oldest content</p>",
7304 date=datetime.datetime(2000, 3, 18, 11, 54, 58),
7305 section=cls.s1,
7306 )
7307 cls.a3 = Article.objects.create(
7308 content="<p>Newest content</p>",
7309 date=datetime.datetime(2009, 3, 18, 11, 54, 58),
7310 section=cls.s1,
7311 )
7312 cls.p1 = PrePopulatedPost.objects.create(
7313 title="A Long Title", published=True, slug="a-long-title"
7314 )
7315
7316 cls.per1 = Person.objects.create(name="John Mauchly", gender=1, alive=True)
7317 cls.per2 = Person.objects.create(name="Grace Hopper", gender=1, alive=False)
7318 cls.per3 = Person.objects.create(name="Guido van Rossum", gender=1, alive=True)
7319
7320 def setUp(self):
7321 self.client.force_login(self.superuser)
7322
7323 def test_save_button(self):
7324 user_count = User.objects.count()
7325 response = self.client.post(
7326 reverse("admin:auth_user_add"),
7327 {
7328 "username": "newuser",
7329 "password1": "newpassword",
7330 "password2": "newpassword",
7331 },
7332 )
7333 new_user = User.objects.get(username="newuser")
7334 self.assertRedirects(
7335 response, reverse("admin:auth_user_change", args=(new_user.pk,))
7336 )
7337 self.assertEqual(User.objects.count(), user_count + 1)
7338 self.assertTrue(new_user.has_usable_password())
7339
7340 def test_save_continue_editing_button(self):
7341 user_count = User.objects.count()
7342 response = self.client.post(
7343 reverse("admin:auth_user_add"),
7344 {
7345 "username": "newuser",
7346 "password1": "newpassword",
7347 "password2": "newpassword",
7348 "_continue": "1",
7349 },
7350 )
7351 new_user = User.objects.get(username="newuser")
7352 new_user_url = reverse("admin:auth_user_change", args=(new_user.pk,))
7353 self.assertRedirects(response, new_user_url, fetch_redirect_response=False)
7354 self.assertEqual(User.objects.count(), user_count + 1)
7355 self.assertTrue(new_user.has_usable_password())
7356 response = self.client.get(new_user_url)
7357 self.assertContains(
7358 response,
7359 '<li class="success">The user “<a href="%s">'
7360 "%s</a>” was added successfully. You may edit it again below.</li>"
7361 % (new_user_url, new_user),
7362 html=True,
7363 )
7364
7365 def test_password_mismatch(self):
7366 response = self.client.post(
7367 reverse("admin:auth_user_add"),
7368 {
7369 "username": "newuser",
7370 "password1": "newpassword",
7371 "password2": "mismatch",
7372 },
7373 )
7374 self.assertEqual(response.status_code, 200)
7375 self.assertFormError(response.context["adminform"], "password1", [])
7376 self.assertFormError(
7377 response.context["adminform"],
7378 "password2",
7379 ["The two password fields didn’t match."],
7380 )
7381
7382 def test_user_fk_add_popup(self):
7383 """
7384 User addition through a FK popup should return the appropriate
7385 JavaScript response.
7386 """
7387 response = self.client.get(reverse("admin:admin_views_album_add"))
7388 self.assertContains(response, reverse("admin:auth_user_add"))
7389 self.assertContains(
7390 response,
7391 'class="related-widget-wrapper-link add-related" id="add_id_owner"',
7392 )
7393 response = self.client.get(
7394 reverse("admin:auth_user_add") + "?%s=1" % IS_POPUP_VAR
7395 )
7396 self.assertNotContains(response, 'name="_continue"')
7397 self.assertNotContains(response, 'name="_addanother"')
7398 data = {
7399 "username": "newuser",
7400 "password1": "newpassword",
7401 "password2": "newpassword",
7402 IS_POPUP_VAR: "1",
7403 "_save": "1",
7404 }
7405 response = self.client.post(
7406 reverse("admin:auth_user_add") + "?%s=1" % IS_POPUP_VAR, data, follow=True
7407 )
7408 self.assertContains(response, "&quot;obj&quot;: &quot;newuser&quot;")
7409
7410 def test_user_fk_change_popup(self):
7411 """
7412 User change through a FK popup should return the appropriate JavaScript
7413 response.
7414 """
7415 response = self.client.get(reverse("admin:admin_views_album_add"))
7416 self.assertContains(
7417 response, reverse("admin:auth_user_change", args=("__fk__",))
7418 )
7419 self.assertContains(
7420 response,
7421 'class="related-widget-wrapper-link change-related" id="change_id_owner"',
7422 )
7423 user = User.objects.get(username="changeuser")
7424 url = (
7425 reverse("admin:auth_user_change", args=(user.pk,)) + "?%s=1" % IS_POPUP_VAR
7426 )
7427 response = self.client.get(url)
7428 self.assertNotContains(response, 'name="_continue"')
7429 self.assertNotContains(response, 'name="_addanother"')
7430 data = {
7431 "username": "newuser",
7432 "password1": "newpassword",
7433 "password2": "newpassword",
7434 "last_login_0": "2007-05-30",
7435 "last_login_1": "13:20:10",
7436 "date_joined_0": "2007-05-30",
7437 "date_joined_1": "13:20:10",
7438 IS_POPUP_VAR: "1",
7439 "_save": "1",
7440 }
7441 response = self.client.post(url, data, follow=True)
7442 self.assertContains(response, "&quot;obj&quot;: &quot;newuser&quot;")
7443 self.assertContains(response, "&quot;action&quot;: &quot;change&quot;")
7444
7445 def test_user_fk_delete_popup(self):
7446 """
7447 User deletion through a FK popup should return the appropriate
7448 JavaScript response.
7449 """
7450 response = self.client.get(reverse("admin:admin_views_album_add"))
7451 self.assertContains(
7452 response, reverse("admin:auth_user_delete", args=("__fk__",))
7453 )
7454 self.assertContains(
7455 response,
7456 'class="related-widget-wrapper-link change-related" id="change_id_owner"',
7457 )
7458 user = User.objects.get(username="changeuser")
7459 url = (
7460 reverse("admin:auth_user_delete", args=(user.pk,)) + "?%s=1" % IS_POPUP_VAR
7461 )
7462 response = self.client.get(url)
7463 self.assertEqual(response.status_code, 200)
7464 data = {
7465 "post": "yes",
7466 IS_POPUP_VAR: "1",
7467 }
7468 response = self.client.post(url, data, follow=True)
7469 self.assertContains(response, "&quot;action&quot;: &quot;delete&quot;")
7470
7471 def test_save_add_another_button(self):
7472 user_count = User.objects.count()
7473 response = self.client.post(
7474 reverse("admin:auth_user_add"),
7475 {
7476 "username": "newuser",
7477 "password1": "newpassword",
7478 "password2": "newpassword",
7479 "_addanother": "1",
7480 },
7481 )
7482 new_user = User.objects.order_by("-id")[0]
7483 self.assertRedirects(response, reverse("admin:auth_user_add"))
7484 self.assertEqual(User.objects.count(), user_count + 1)
7485 self.assertTrue(new_user.has_usable_password())
7486
7487 def test_user_permission_performance(self):
7488 u = User.objects.all()[0]
7489
7490 # Don't depend on a warm cache, see #17377.
7491 ContentType.objects.clear_cache()
7492
7493 with self.assertNumQueries(8):
7494 response = self.client.get(reverse("admin:auth_user_change", args=(u.pk,)))
7495 self.assertEqual(response.status_code, 200)
7496
7497 def test_form_url_present_in_context(self):
7498 u = User.objects.all()[0]
7499 response = self.client.get(
7500 reverse("admin3:auth_user_password_change", args=(u.pk,))
7501 )
7502 self.assertEqual(response.status_code, 200)
7503 self.assertEqual(response.context["form_url"], "pony")
7504
7505
7506 @override_settings(ROOT_URLCONF="admin_views.urls")
7507 class GroupAdminTest(TestCase):
7508 """
7509 Tests group CRUD functionality.
7510 """
7511
7512 @classmethod
7513 def setUpTestData(cls):
7514 cls.superuser = User.objects.create_superuser(
7515 username="super", password="secret", email="[email protected]"
7516 )
7517
7518 def setUp(self):
7519 self.client.force_login(self.superuser)
7520
7521 def test_save_button(self):
7522 group_count = Group.objects.count()
7523 response = self.client.post(
7524 reverse("admin:auth_group_add"),
7525 {
7526 "name": "newgroup",
7527 },
7528 )
7529
7530 Group.objects.order_by("-id")[0]
7531 self.assertRedirects(response, reverse("admin:auth_group_changelist"))
7532 self.assertEqual(Group.objects.count(), group_count + 1)
7533
7534 def test_group_permission_performance(self):
7535 g = Group.objects.create(name="test_group")
7536
7537 # Ensure no queries are skipped due to cached content type for Group.
7538 ContentType.objects.clear_cache()
7539
7540 with self.assertNumQueries(6):
7541 response = self.client.get(reverse("admin:auth_group_change", args=(g.pk,)))
7542 self.assertEqual(response.status_code, 200)
7543
7544
7545 @override_settings(ROOT_URLCONF="admin_views.urls")
7546 class CSSTest(TestCase):
7547 @classmethod
7548 def setUpTestData(cls):
7549 cls.superuser = User.objects.create_superuser(
7550 username="super", password="secret", email="[email protected]"
7551 )
7552 cls.s1 = Section.objects.create(name="Test section")
7553 cls.a1 = Article.objects.create(
7554 content="<p>Middle content</p>",
7555 date=datetime.datetime(2008, 3, 18, 11, 54, 58),
7556 section=cls.s1,
7557 )
7558 cls.a2 = Article.objects.create(
7559 content="<p>Oldest content</p>",
7560 date=datetime.datetime(2000, 3, 18, 11, 54, 58),
7561 section=cls.s1,
7562 )
7563 cls.a3 = Article.objects.create(
7564 content="<p>Newest content</p>",
7565 date=datetime.datetime(2009, 3, 18, 11, 54, 58),
7566 section=cls.s1,
7567 )
7568 cls.p1 = PrePopulatedPost.objects.create(
7569 title="A Long Title", published=True, slug="a-long-title"
7570 )
7571
7572 def setUp(self):
7573 self.client.force_login(self.superuser)
7574
7575 @ignore_warnings(category=RemovedInDjango60Warning)
7576 def test_field_prefix_css_classes(self):
7577 """
7578 Fields have a CSS class name with a 'field-' prefix.
7579 """
7580 response = self.client.get(reverse("admin:admin_views_post_add"))
7581
7582 # The main form
7583 self.assertContains(response, 'class="form-row field-title"')
7584 self.assertContains(response, 'class="form-row field-content"')
7585 self.assertContains(response, 'class="form-row field-public"')
7586 self.assertContains(response, 'class="form-row field-awesomeness_level"')
7587 self.assertContains(response, 'class="form-row field-coolness"')
7588 self.assertContains(response, 'class="form-row field-value"')
7589 self.assertContains(response, 'class="form-row"') # The lambda function
7590
7591 # The tabular inline
7592 self.assertContains(response, '<td class="field-url">')
7593 self.assertContains(response, '<td class="field-posted">')
7594
7595 def test_index_css_classes(self):
7596 """
7597 CSS class names are used for each app and model on the admin index
7598 pages (#17050).
7599 """
7600 # General index page
7601 response = self.client.get(reverse("admin:index"))
7602 self.assertContains(response, '<div class="app-admin_views module')
7603 self.assertContains(
7604 response,
7605 '<thead class="visually-hidden"><tr><th scope="col">Model name</th>'
7606 '<th scope="col">Add link</th><th scope="col">Change or view list link</th>'
7607 "</tr></thead>",
7608 html=True,
7609 )
7610 self.assertContains(response, '<tr class="model-actor">')
7611 self.assertContains(response, '<tr class="model-album">')
7612
7613 # App index page
7614 response = self.client.get(reverse("admin:app_list", args=("admin_views",)))
7615 self.assertContains(response, '<div class="app-admin_views module')
7616 self.assertContains(
7617 response,
7618 '<thead class="visually-hidden"><tr><th scope="col">Model name</th>'
7619 '<th scope="col">Add link</th><th scope="col">Change or view list link</th>'
7620 "</tr></thead>",
7621 html=True,
7622 )
7623 self.assertContains(response, '<tr class="model-actor">')
7624 self.assertContains(response, '<tr class="model-album">')
7625
7626 def test_app_model_in_form_body_class(self):
7627 """
7628 Ensure app and model tag are correctly read by change_form template
7629 """
7630 response = self.client.get(reverse("admin:admin_views_section_add"))
7631 self.assertContains(response, '<body class=" app-admin_views model-section ')
7632
7633 def test_app_model_in_list_body_class(self):
7634 """
7635 Ensure app and model tag are correctly read by change_list template
7636 """
7637 response = self.client.get(reverse("admin:admin_views_section_changelist"))
7638 self.assertContains(response, '<body class=" app-admin_views model-section ')
7639
7640 def test_app_model_in_delete_confirmation_body_class(self):
7641 """
7642 Ensure app and model tag are correctly read by delete_confirmation
7643 template
7644 """
7645 response = self.client.get(
7646 reverse("admin:admin_views_section_delete", args=(self.s1.pk,))
7647 )
7648 self.assertContains(response, '<body class=" app-admin_views model-section ')
7649
7650 def test_app_model_in_app_index_body_class(self):
7651 """
7652 Ensure app and model tag are correctly read by app_index template
7653 """
7654 response = self.client.get(reverse("admin:app_list", args=("admin_views",)))
7655 self.assertContains(response, '<body class=" dashboard app-admin_views')
7656
7657 def test_app_model_in_delete_selected_confirmation_body_class(self):
7658 """
7659 Ensure app and model tag are correctly read by
7660 delete_selected_confirmation template
7661 """
7662 action_data = {
7663 ACTION_CHECKBOX_NAME: [self.s1.pk],
7664 "action": "delete_selected",
7665 "index": 0,
7666 }
7667 response = self.client.post(
7668 reverse("admin:admin_views_section_changelist"), action_data
7669 )
7670 self.assertContains(response, '<body class=" app-admin_views model-section ')
7671
7672 def test_changelist_field_classes(self):
7673 """
7674 Cells of the change list table should contain the field name in their
7675 class attribute.
7676 """
7677 Podcast.objects.create(name="Django Dose", release_date=datetime.date.today())
7678 response = self.client.get(reverse("admin:admin_views_podcast_changelist"))
7679 self.assertContains(response, '<th class="field-name">')
7680 self.assertContains(response, '<td class="field-release_date nowrap">')
7681 self.assertContains(response, '<td class="action-checkbox">')
7682
7683
7684 try:
7685 import docutils
7686 except ImportError:
7687 docutils = None
7688
7689
7690 @unittest.skipUnless(docutils, "no docutils installed.")
7691 @override_settings(ROOT_URLCONF="admin_views.urls")
7692 @modify_settings(
7693 INSTALLED_APPS={"append": ["django.contrib.admindocs", "django.contrib.flatpages"]}
7694 )
7695 class AdminDocsTest(TestCase):
7696 @classmethod
7697 def setUpTestData(cls):
7698 cls.superuser = User.objects.create_superuser(
7699 username="super", password="secret", email="[email protected]"
7700 )
7701
7702 def setUp(self):
7703 self.client.force_login(self.superuser)
7704
7705 def test_tags(self):
7706 response = self.client.get(reverse("django-admindocs-tags"))
7707
7708 # The builtin tag group exists
7709 self.assertContains(response, "<h2>Built-in tags</h2>", count=2, html=True)
7710
7711 # A builtin tag exists in both the index and detail
7712 self.assertContains(
7713 response, '<h3 id="built_in-autoescape">autoescape</h3>', html=True
7714 )
7715 self.assertContains(
7716 response,
7717 '<li><a href="#built_in-autoescape">autoescape</a></li>',
7718 html=True,
7719 )
7720
7721 # An app tag exists in both the index and detail
7722 self.assertContains(
7723 response, '<h3 id="flatpages-get_flatpages">get_flatpages</h3>', html=True
7724 )
7725 self.assertContains(
7726 response,
7727 '<li><a href="#flatpages-get_flatpages">get_flatpages</a></li>',
7728 html=True,
7729 )
7730
7731 # The admin list tag group exists
7732 self.assertContains(response, "<h2>admin_list</h2>", count=2, html=True)
7733
7734 # An admin list tag exists in both the index and detail
7735 self.assertContains(
7736 response, '<h3 id="admin_list-admin_actions">admin_actions</h3>', html=True
7737 )
7738 self.assertContains(
7739 response,
7740 '<li><a href="#admin_list-admin_actions">admin_actions</a></li>',
7741 html=True,
7742 )
7743
7744 def test_filters(self):
7745 response = self.client.get(reverse("django-admindocs-filters"))
7746
7747 # The builtin filter group exists
7748 self.assertContains(response, "<h2>Built-in filters</h2>", count=2, html=True)
7749
7750 # A builtin filter exists in both the index and detail
7751 self.assertContains(response, '<h3 id="built_in-add">add</h3>', html=True)
7752 self.assertContains(
7753 response, '<li><a href="#built_in-add">add</a></li>', html=True
7754 )
7755
7756 def test_index_headers(self):
7757 response = self.client.get(reverse("django-admindocs-docroot"))
7758 self.assertContains(response, "<h1>Documentation</h1>")
7759 self.assertContains(response, '<h2><a href="tags/">Tags</a></h2>')
7760 self.assertContains(response, '<h2><a href="filters/">Filters</a></h2>')
7761 self.assertContains(response, '<h2><a href="models/">Models</a></h2>')
7762 self.assertContains(response, '<h2><a href="views/">Views</a></h2>')
7763 self.assertContains(
7764 response, '<h2><a href="bookmarklets/">Bookmarklets</a></h2>'
7765 )
7766
7767
7768 @override_settings(
7769 ROOT_URLCONF="admin_views.urls",
7770 TEMPLATES=[
7771 {
7772 "BACKEND": "django.template.backends.django.DjangoTemplates",
7773 "APP_DIRS": True,
7774 "OPTIONS": {
7775 "context_processors": [
7776 "django.template.context_processors.request",
7777 "django.contrib.auth.context_processors.auth",
7778 "django.contrib.messages.context_processors.messages",
7779 ],
7780 },
7781 }
7782 ],
7783 )
7784 class ValidXHTMLTests(TestCase):
7785 @classmethod
7786 def setUpTestData(cls):
7787 cls.superuser = User.objects.create_superuser(
7788 username="super", password="secret", email="[email protected]"
7789 )
7790
7791 def setUp(self):
7792 self.client.force_login(self.superuser)
7793
7794 def test_lang_name_present(self):
7795 with translation.override(None):
7796 response = self.client.get(reverse("admin:app_list", args=("admin_views",)))
7797 self.assertNotContains(response, ' lang=""')
7798 self.assertNotContains(response, ' xml:lang=""')
7799
7800
7801 @override_settings(ROOT_URLCONF="admin_views.urls", USE_THOUSAND_SEPARATOR=True)
7802 class DateHierarchyTests(TestCase):
7803 @classmethod
7804 def setUpTestData(cls):
7805 cls.superuser = User.objects.create_superuser(
7806 username="super", password="secret", email="[email protected]"
7807 )
7808
7809 def setUp(self):
7810 self.client.force_login(self.superuser)
7811
7812 def assert_non_localized_year(self, response, year):
7813 """
7814 The year is not localized with USE_THOUSAND_SEPARATOR (#15234).
7815 """
7816 self.assertNotContains(response, formats.number_format(year))
7817
7818 def assert_contains_year_link(self, response, date):
7819 self.assertContains(response, '?release_date__year=%d"' % date.year)
7820
7821 def assert_contains_month_link(self, response, date):
7822 self.assertContains(
7823 response,
7824 '?release_date__month=%d&amp;release_date__year=%d"'
7825 % (date.month, date.year),
7826 )
7827
7828 def assert_contains_day_link(self, response, date):
7829 self.assertContains(
7830 response,
7831 "?release_date__day=%d&amp;"
7832 'release_date__month=%d&amp;release_date__year=%d"'
7833 % (date.day, date.month, date.year),
7834 )
7835
7836 def test_empty(self):
7837 """
7838 No date hierarchy links display with empty changelist.
7839 """
7840 response = self.client.get(reverse("admin:admin_views_podcast_changelist"))
7841 self.assertNotContains(response, "release_date__year=")
7842 self.assertNotContains(response, "release_date__month=")
7843 self.assertNotContains(response, "release_date__day=")
7844
7845 def test_single(self):
7846 """
7847 Single day-level date hierarchy appears for single object.
7848 """
7849 DATE = datetime.date(2000, 6, 30)
7850 Podcast.objects.create(release_date=DATE)
7851 url = reverse("admin:admin_views_podcast_changelist")
7852 response = self.client.get(url)
7853 self.assert_contains_day_link(response, DATE)
7854 self.assert_non_localized_year(response, 2000)
7855
7856 def test_within_month(self):
7857 """
7858 day-level links appear for changelist within single month.
7859 """
7860 DATES = (
7861 datetime.date(2000, 6, 30),
7862 datetime.date(2000, 6, 15),
7863 datetime.date(2000, 6, 3),
7864 )
7865 for date in DATES:
7866 Podcast.objects.create(release_date=date)
7867 url = reverse("admin:admin_views_podcast_changelist")
7868 response = self.client.get(url)
7869 for date in DATES:
7870 self.assert_contains_day_link(response, date)
7871 self.assert_non_localized_year(response, 2000)
7872
7873 def test_within_year(self):
7874 """
7875 month-level links appear for changelist within single year.
7876 """
7877 DATES = (
7878 datetime.date(2000, 1, 30),
7879 datetime.date(2000, 3, 15),
7880 datetime.date(2000, 5, 3),
7881 )
7882 for date in DATES:
7883 Podcast.objects.create(release_date=date)
7884 url = reverse("admin:admin_views_podcast_changelist")
7885 response = self.client.get(url)
7886 # no day-level links
7887 self.assertNotContains(response, "release_date__day=")
7888 for date in DATES:
7889 self.assert_contains_month_link(response, date)
7890 self.assert_non_localized_year(response, 2000)
7891
7892 def test_multiple_years(self):
7893 """
7894 year-level links appear for year-spanning changelist.
7895 """
7896 DATES = (
7897 datetime.date(2001, 1, 30),
7898 datetime.date(2003, 3, 15),
7899 datetime.date(2005, 5, 3),
7900 )
7901 for date in DATES:
7902 Podcast.objects.create(release_date=date)
7903 response = self.client.get(reverse("admin:admin_views_podcast_changelist"))
7904 # no day/month-level links
7905 self.assertNotContains(response, "release_date__day=")
7906 self.assertNotContains(response, "release_date__month=")
7907 for date in DATES:
7908 self.assert_contains_year_link(response, date)
7909
7910 # and make sure GET parameters still behave correctly
7911 for date in DATES:
7912 url = "%s?release_date__year=%d" % (
7913 reverse("admin:admin_views_podcast_changelist"),
7914 date.year,
7915 )
7916 response = self.client.get(url)
7917 self.assert_contains_month_link(response, date)
7918 self.assert_non_localized_year(response, 2000)
7919 self.assert_non_localized_year(response, 2003)
7920 self.assert_non_localized_year(response, 2005)
7921
7922 url = "%s?release_date__year=%d&release_date__month=%d" % (
7923 reverse("admin:admin_views_podcast_changelist"),
7924 date.year,
7925 date.month,
7926 )
7927 response = self.client.get(url)
7928 self.assert_contains_day_link(response, date)
7929 self.assert_non_localized_year(response, 2000)
7930 self.assert_non_localized_year(response, 2003)
7931 self.assert_non_localized_year(response, 2005)
7932
7933 def test_related_field(self):
7934 questions_data = (
7935 # (posted data, number of answers),
7936 (datetime.date(2001, 1, 30), 0),
7937 (datetime.date(2003, 3, 15), 1),
7938 (datetime.date(2005, 5, 3), 2),
7939 )
7940 for date, answer_count in questions_data:
7941 question = Question.objects.create(posted=date)
7942 for i in range(answer_count):
7943 question.answer_set.create()
7944
7945 response = self.client.get(reverse("admin:admin_views_answer_changelist"))
7946 for date, answer_count in questions_data:
7947 link = '?question__posted__year=%d"' % date.year
7948 if answer_count > 0:
7949 self.assertContains(response, link)
7950 else:
7951 self.assertNotContains(response, link)
7952
7953
7954 @override_settings(ROOT_URLCONF="admin_views.urls")
7955 class AdminCustomSaveRelatedTests(TestCase):
7956 """
7957 One can easily customize the way related objects are saved.
7958 Refs #16115.
7959 """
7960
7961 @classmethod
7962 def setUpTestData(cls):
7963 cls.superuser = User.objects.create_superuser(
7964 username="super", password="secret", email="[email protected]"
7965 )
7966
7967 def setUp(self):
7968 self.client.force_login(self.superuser)
7969
7970 def test_should_be_able_to_edit_related_objects_on_add_view(self):
7971 post = {
7972 "child_set-TOTAL_FORMS": "3",
7973 "child_set-INITIAL_FORMS": "0",
7974 "name": "Josh Stone",
7975 "child_set-0-name": "Paul",
7976 "child_set-1-name": "Catherine",
7977 }
7978 self.client.post(reverse("admin:admin_views_parent_add"), post)
7979 self.assertEqual(1, Parent.objects.count())
7980 self.assertEqual(2, Child.objects.count())
7981
7982 children_names = list(
7983 Child.objects.order_by("name").values_list("name", flat=True)
7984 )
7985
7986 self.assertEqual("Josh Stone", Parent.objects.latest("id").name)
7987 self.assertEqual(["Catherine Stone", "Paul Stone"], children_names)
7988
7989 def test_should_be_able_to_edit_related_objects_on_change_view(self):
7990 parent = Parent.objects.create(name="Josh Stone")
7991 paul = Child.objects.create(parent=parent, name="Paul")
7992 catherine = Child.objects.create(parent=parent, name="Catherine")
7993 post = {
7994 "child_set-TOTAL_FORMS": "5",
7995 "child_set-INITIAL_FORMS": "2",
7996 "name": "Josh Stone",
7997 "child_set-0-name": "Paul",
7998 "child_set-0-id": paul.id,
7999 "child_set-1-name": "Catherine",
8000 "child_set-1-id": catherine.id,
8001 }
8002 self.client.post(
8003 reverse("admin:admin_views_parent_change", args=(parent.id,)), post
8004 )
8005
8006 children_names = list(
8007 Child.objects.order_by("name").values_list("name", flat=True)
8008 )
8009
8010 self.assertEqual("Josh Stone", Parent.objects.latest("id").name)
8011 self.assertEqual(["Catherine Stone", "Paul Stone"], children_names)
8012
8013 def test_should_be_able_to_edit_related_objects_on_changelist_view(self):
8014 parent = Parent.objects.create(name="Josh Rock")
8015 Child.objects.create(parent=parent, name="Paul")
8016 Child.objects.create(parent=parent, name="Catherine")
8017 post = {
8018 "form-TOTAL_FORMS": "1",
8019 "form-INITIAL_FORMS": "1",
8020 "form-MAX_NUM_FORMS": "0",
8021 "form-0-id": parent.id,
8022 "form-0-name": "Josh Stone",
8023 "_save": "Save",
8024 }
8025
8026 self.client.post(reverse("admin:admin_views_parent_changelist"), post)
8027 children_names = list(
8028 Child.objects.order_by("name").values_list("name", flat=True)
8029 )
8030
8031 self.assertEqual("Josh Stone", Parent.objects.latest("id").name)
8032 self.assertEqual(["Catherine Stone", "Paul Stone"], children_names)
8033
8034
8035 @override_settings(ROOT_URLCONF="admin_views.urls")
8036 class AdminViewLogoutTests(TestCase):
8037 @classmethod
8038 def setUpTestData(cls):
8039 cls.superuser = User.objects.create_superuser(
8040 username="super", password="secret", email="[email protected]"
8041 )
8042
8043 def test_logout(self):
8044 self.client.force_login(self.superuser)
8045 response = self.client.post(reverse("admin:logout"))
8046 self.assertEqual(response.status_code, 200)
8047 self.assertTemplateUsed(response, "registration/logged_out.html")
8048 self.assertEqual(response.request["PATH_INFO"], reverse("admin:logout"))
8049 self.assertFalse(response.context["has_permission"])
8050 self.assertNotContains(
8051 response, "user-tools"
8052 ) # user-tools div shouldn't visible.
8053
8054 def test_client_logout_url_can_be_used_to_login(self):
8055 response = self.client.post(reverse("admin:logout"))
8056 self.assertEqual(
8057 response.status_code, 302
8058 ) # we should be redirected to the login page.
8059
8060 # follow the redirect and test results.
8061 response = self.client.post(reverse("admin:logout"), follow=True)
8062 self.assertContains(
8063 response,
8064 '<input type="hidden" name="next" value="%s">' % reverse("admin:index"),
8065 )
8066 self.assertTemplateUsed(response, "admin/login.html")
8067 self.assertEqual(response.request["PATH_INFO"], reverse("admin:login"))
8068
8069
8070 @override_settings(ROOT_URLCONF="admin_views.urls")
8071 class AdminUserMessageTest(TestCase):
8072 @classmethod
8073 def setUpTestData(cls):
8074 cls.superuser = User.objects.create_superuser(
8075 username="super", password="secret", email="[email protected]"
8076 )
8077
8078 def setUp(self):
8079 self.client.force_login(self.superuser)
8080
8081 def send_message(self, level):
8082 """
8083 Helper that sends a post to the dummy test methods and asserts that a
8084 message with the level has appeared in the response.
8085 """
8086 action_data = {
8087 ACTION_CHECKBOX_NAME: [1],
8088 "action": "message_%s" % level,
8089 "index": 0,
8090 }
8091
8092 response = self.client.post(
8093 reverse("admin:admin_views_usermessenger_changelist"),
8094 action_data,
8095 follow=True,
8096 )
8097 self.assertContains(
8098 response, '<li class="%s">Test %s</li>' % (level, level), html=True
8099 )
8100
8101 @override_settings(MESSAGE_LEVEL=10) # Set to DEBUG for this request
8102 def test_message_debug(self):
8103 self.send_message("debug")
8104
8105 def test_message_info(self):
8106 self.send_message("info")
8107
8108 def test_message_success(self):
8109 self.send_message("success")
8110
8111 def test_message_warning(self):
8112 self.send_message("warning")
8113
8114 def test_message_error(self):
8115 self.send_message("error")
8116
8117 def test_message_extra_tags(self):
8118 action_data = {
8119 ACTION_CHECKBOX_NAME: [1],
8120 "action": "message_extra_tags",
8121 "index": 0,
8122 }
8123
8124 response = self.client.post(
8125 reverse("admin:admin_views_usermessenger_changelist"),
8126 action_data,
8127 follow=True,
8128 )
8129 self.assertContains(
8130 response, '<li class="extra_tag info">Test tags</li>', html=True
8131 )
8132
8133
8134 @override_settings(ROOT_URLCONF="admin_views.urls")
8135 class AdminKeepChangeListFiltersTests(TestCase):
8136 admin_site = site
8137
8138 @classmethod
8139 def setUpTestData(cls):
8140 cls.superuser = User.objects.create_superuser(
8141 username="super", password="secret", email="[email protected]"
8142 )
8143 cls.joepublicuser = User.objects.create_user(
8144 username="joepublic", password="secret"
8145 )
8146
8147 def setUp(self):
8148 self.client.force_login(self.superuser)
8149
8150 def assertURLEqual(self, url1, url2, msg_prefix=""):
8151 """
8152 Assert that two URLs are equal despite the ordering
8153 of their querystring. Refs #22360.
8154 """
8155 parsed_url1 = urlsplit(url1)
8156 path1 = parsed_url1.path
8157 parsed_qs1 = dict(parse_qsl(parsed_url1.query))
8158
8159 parsed_url2 = urlsplit(url2)
8160 path2 = parsed_url2.path
8161 parsed_qs2 = dict(parse_qsl(parsed_url2.query))
8162
8163 for parsed_qs in [parsed_qs1, parsed_qs2]:
8164 if "_changelist_filters" in parsed_qs:
8165 changelist_filters = parsed_qs["_changelist_filters"]
8166 parsed_filters = dict(parse_qsl(changelist_filters))
8167 parsed_qs["_changelist_filters"] = parsed_filters
8168
8169 self.assertEqual(path1, path2)
8170 self.assertEqual(parsed_qs1, parsed_qs2)
8171
8172 def test_assert_url_equal(self):
8173 # Test equality.
8174 change_user_url = reverse(
8175 "admin:auth_user_change", args=(self.joepublicuser.pk,)
8176 )
8177 self.assertURLEqual(
8178 "http://testserver{}?_changelist_filters="
8179 "is_staff__exact%3D0%26is_superuser__exact%3D0".format(change_user_url),
8180 "http://testserver{}?_changelist_filters="
8181 "is_staff__exact%3D0%26is_superuser__exact%3D0".format(change_user_url),
8182 )
8183
8184 # Test inequality.
8185 with self.assertRaises(AssertionError):
8186 self.assertURLEqual(
8187 "http://testserver{}?_changelist_filters="
8188 "is_staff__exact%3D0%26is_superuser__exact%3D0".format(change_user_url),
8189 "http://testserver{}?_changelist_filters="
8190 "is_staff__exact%3D1%26is_superuser__exact%3D1".format(change_user_url),
8191 )
8192
8193 # Ignore scheme and host.
8194 self.assertURLEqual(
8195 "http://testserver{}?_changelist_filters="
8196 "is_staff__exact%3D0%26is_superuser__exact%3D0".format(change_user_url),
8197 "{}?_changelist_filters="
8198 "is_staff__exact%3D0%26is_superuser__exact%3D0".format(change_user_url),
8199 )
8200
8201 # Ignore ordering of querystring.
8202 self.assertURLEqual(
8203 "{}?is_staff__exact=0&is_superuser__exact=0".format(
8204 reverse("admin:auth_user_changelist")
8205 ),
8206 "{}?is_superuser__exact=0&is_staff__exact=0".format(
8207 reverse("admin:auth_user_changelist")
8208 ),
8209 )
8210
8211 # Ignore ordering of _changelist_filters.
8212 self.assertURLEqual(
8213 "{}?_changelist_filters="
8214 "is_staff__exact%3D0%26is_superuser__exact%3D0".format(change_user_url),
8215 "{}?_changelist_filters="
8216 "is_superuser__exact%3D0%26is_staff__exact%3D0".format(change_user_url),
8217 )
8218
8219 def get_changelist_filters(self):
8220 return {
8221 "is_superuser__exact": 0,
8222 "is_staff__exact": 0,
8223 }
8224
8225 def get_changelist_filters_querystring(self):
8226 return urlencode(self.get_changelist_filters())
8227
8228 def get_preserved_filters_querystring(self):
8229 return urlencode(
8230 {"_changelist_filters": self.get_changelist_filters_querystring()}
8231 )
8232
8233 def get_sample_user_id(self):
8234 return self.joepublicuser.pk
8235
8236 def get_changelist_url(self):
8237 return "%s?%s" % (
8238 reverse("admin:auth_user_changelist", current_app=self.admin_site.name),
8239 self.get_changelist_filters_querystring(),
8240 )
8241
8242 def get_add_url(self, add_preserved_filters=True):
8243 url = reverse("admin:auth_user_add", current_app=self.admin_site.name)
8244 if add_preserved_filters:
8245 url = "%s?%s" % (url, self.get_preserved_filters_querystring())
8246 return url
8247
8248 def get_change_url(self, user_id=None, add_preserved_filters=True):
8249 if user_id is None:
8250 user_id = self.get_sample_user_id()
8251 url = reverse(
8252 "admin:auth_user_change", args=(user_id,), current_app=self.admin_site.name
8253 )
8254 if add_preserved_filters:
8255 url = "%s?%s" % (url, self.get_preserved_filters_querystring())
8256 return url
8257
8258 def get_history_url(self, user_id=None):
8259 if user_id is None:
8260 user_id = self.get_sample_user_id()
8261 return "%s?%s" % (
8262 reverse(
8263 "admin:auth_user_history",
8264 args=(user_id,),
8265 current_app=self.admin_site.name,
8266 ),
8267 self.get_preserved_filters_querystring(),
8268 )
8269
8270 def get_delete_url(self, user_id=None):
8271 if user_id is None:
8272 user_id = self.get_sample_user_id()
8273 return "%s?%s" % (
8274 reverse(
8275 "admin:auth_user_delete",
8276 args=(user_id,),
8277 current_app=self.admin_site.name,
8278 ),
8279 self.get_preserved_filters_querystring(),
8280 )
8281
8282 def test_changelist_view(self):
8283 response = self.client.get(self.get_changelist_url())
8284 self.assertEqual(response.status_code, 200)
8285
8286 # Check the `change_view` link has the correct querystring.
8287 detail_link = re.search(
8288 '<a href="(.*?)">{}</a>'.format(self.joepublicuser.username),
8289 response.text,
8290 )
8291 self.assertURLEqual(detail_link[1], self.get_change_url())
8292
8293 def test_change_view(self):
8294 # Get the `change_view`.
8295 response = self.client.get(self.get_change_url())
8296 self.assertEqual(response.status_code, 200)
8297
8298 # Check the form action.
8299 form_action = re.search(
8300 '<form action="(.*?)" method="post" id="user_form" novalidate>',
8301 response.text,
8302 )
8303 self.assertURLEqual(
8304 form_action[1], "?%s" % self.get_preserved_filters_querystring()
8305 )
8306
8307 # Check the history link.
8308 history_link = re.search(
8309 '<a href="(.*?)" class="historylink">History</a>', response.text
8310 )
8311 self.assertURLEqual(history_link[1], self.get_history_url())
8312
8313 # Check the delete link.
8314 delete_link = re.search(
8315 '<a href="(.*?)" class="deletelink">Delete</a>', response.text
8316 )
8317 self.assertURLEqual(delete_link[1], self.get_delete_url())
8318
8319 # Test redirect on "Save".
8320 post_data = {
8321 "username": "joepublic",
8322 "last_login_0": "2007-05-30",
8323 "last_login_1": "13:20:10",
8324 "date_joined_0": "2007-05-30",
8325 "date_joined_1": "13:20:10",
8326 }
8327
8328 post_data["_save"] = 1
8329 response = self.client.post(self.get_change_url(), data=post_data)
8330 self.assertRedirects(response, self.get_changelist_url())
8331 post_data.pop("_save")
8332
8333 # Test redirect on "Save and continue".
8334 post_data["_continue"] = 1
8335 response = self.client.post(self.get_change_url(), data=post_data)
8336 self.assertRedirects(response, self.get_change_url())
8337 post_data.pop("_continue")
8338
8339 # Test redirect on "Save and add new".
8340 post_data["_addanother"] = 1
8341 response = self.client.post(self.get_change_url(), data=post_data)
8342 self.assertRedirects(response, self.get_add_url())
8343 post_data.pop("_addanother")
8344
8345 def test_change_view_close_link(self):
8346 viewuser = User.objects.create_user(
8347 username="view", password="secret", is_staff=True
8348 )
8349 viewuser.user_permissions.add(
8350 get_perm(User, get_permission_codename("view", User._meta))
8351 )
8352 self.client.force_login(viewuser)
8353 response = self.client.get(self.get_change_url())
8354 close_link = re.search(
8355 '<a href="(.*?)" class="closelink">Close</a>', response.text
8356 )
8357 close_link = close_link[1].replace("&amp;", "&")
8358 self.assertURLEqual(close_link, self.get_changelist_url())
8359
8360 def test_change_view_without_preserved_filters(self):
8361 response = self.client.get(self.get_change_url(add_preserved_filters=False))
8362 # The action attribute is omitted.
8363 self.assertContains(response, '<form method="post" id="user_form" novalidate>')
8364
8365 def test_add_view(self):
8366 # Get the `add_view`.
8367 response = self.client.get(self.get_add_url())
8368 self.assertEqual(response.status_code, 200)
8369
8370 # Check the form action.
8371 form_action = re.search(
8372 '<form action="(.*?)" method="post" id="user_form" novalidate>',
8373 response.text,
8374 )
8375 self.assertURLEqual(
8376 form_action[1], "?%s" % self.get_preserved_filters_querystring()
8377 )
8378
8379 post_data = {
8380 "username": "dummy",
8381 "password1": "test",
8382 "password2": "test",
8383 }
8384
8385 # Test redirect on "Save".
8386 post_data["_save"] = 1
8387 response = self.client.post(self.get_add_url(), data=post_data)
8388 self.assertRedirects(
8389 response, self.get_change_url(User.objects.get(username="dummy").pk)
8390 )
8391 post_data.pop("_save")
8392
8393 # Test redirect on "Save and continue".
8394 post_data["username"] = "dummy2"
8395 post_data["_continue"] = 1
8396 response = self.client.post(self.get_add_url(), data=post_data)
8397 self.assertRedirects(
8398 response, self.get_change_url(User.objects.get(username="dummy2").pk)
8399 )
8400 post_data.pop("_continue")
8401
8402 # Test redirect on "Save and add new".
8403 post_data["username"] = "dummy3"
8404 post_data["_addanother"] = 1
8405 response = self.client.post(self.get_add_url(), data=post_data)
8406 self.assertRedirects(response, self.get_add_url())
8407 post_data.pop("_addanother")
8408
8409 def test_add_view_without_preserved_filters(self):
8410 response = self.client.get(self.get_add_url(add_preserved_filters=False))
8411 # The action attribute is omitted.
8412 self.assertContains(response, '<form method="post" id="user_form" novalidate>')
8413
8414 def test_delete_view(self):
8415 # Test redirect on "Delete".
8416 response = self.client.post(self.get_delete_url(), {"post": "yes"})
8417 self.assertRedirects(response, self.get_changelist_url())
8418
8419 def test_url_prefix(self):
8420 context = {
8421 "preserved_filters": self.get_preserved_filters_querystring(),
8422 "opts": User._meta,
8423 }
8424 prefixes = ("", "/prefix/", "/後台/")
8425 for prefix in prefixes:
8426 with self.subTest(prefix=prefix), override_script_prefix(prefix):
8427 url = reverse(
8428 "admin:auth_user_changelist", current_app=self.admin_site.name
8429 )
8430 self.assertURLEqual(
8431 self.get_changelist_url(),
8432 add_preserved_filters(context, url),
8433 )
8434
8435
8436 class NamespacedAdminKeepChangeListFiltersTests(AdminKeepChangeListFiltersTests):
8437 admin_site = site2
8438
8439
8440 @override_settings(ROOT_URLCONF="admin_views.urls")
8441 class TestLabelVisibility(TestCase):
8442 """#11277 -Labels of hidden fields in admin were not hidden."""
8443
8444 @classmethod
8445 def setUpTestData(cls):
8446 cls.superuser = User.objects.create_superuser(
8447 username="super", password="secret", email="[email protected]"
8448 )
8449
8450 def setUp(self):
8451 self.client.force_login(self.superuser)
8452
8453 def test_all_fields_visible(self):
8454 response = self.client.get(reverse("admin:admin_views_emptymodelvisible_add"))
8455 self.assert_fieldline_visible(response)
8456 self.assert_field_visible(response, "first")
8457 self.assert_field_visible(response, "second")
8458
8459 def test_all_fields_hidden(self):
8460 response = self.client.get(reverse("admin:admin_views_emptymodelhidden_add"))
8461 self.assert_fieldline_hidden(response)
8462 self.assert_field_hidden(response, "first")
8463 self.assert_field_hidden(response, "second")
8464
8465 def test_mixin(self):
8466 response = self.client.get(reverse("admin:admin_views_emptymodelmixin_add"))
8467 self.assert_fieldline_visible(response)
8468 self.assert_field_hidden(response, "first")
8469 self.assert_field_visible(response, "second")
8470
8471 def assert_field_visible(self, response, field_name):
8472 self.assertContains(
8473 response, f'<div class="flex-container fieldBox field-{field_name}">'
8474 )
8475
8476 def assert_field_hidden(self, response, field_name):
8477 self.assertContains(
8478 response, f'<div class="flex-container fieldBox field-{field_name} hidden">'
8479 )
8480
8481 def assert_fieldline_visible(self, response):
8482 self.assertContains(response, '<div class="form-row field-first field-second">')
8483
8484 def assert_fieldline_hidden(self, response):
8485 self.assertContains(response, '<div class="form-row hidden')
8486
8487
8488 @override_settings(ROOT_URLCONF="admin_views.urls")
8489 class AdminViewOnSiteTests(TestCase):
8490 @classmethod
8491 def setUpTestData(cls):
8492 cls.superuser = User.objects.create_superuser(
8493 username="super", password="secret", email="[email protected]"
8494 )
8495
8496 cls.s1 = State.objects.create(name="New York")
8497 cls.s2 = State.objects.create(name="Illinois")
8498 cls.s3 = State.objects.create(name="California")
8499 cls.c1 = City.objects.create(state=cls.s1, name="New York")
8500 cls.c2 = City.objects.create(state=cls.s2, name="Chicago")
8501 cls.c3 = City.objects.create(state=cls.s3, name="San Francisco")
8502 cls.r1 = Restaurant.objects.create(city=cls.c1, name="Italian Pizza")
8503 cls.r2 = Restaurant.objects.create(city=cls.c1, name="Boulevard")
8504 cls.r3 = Restaurant.objects.create(city=cls.c2, name="Chinese Dinner")
8505 cls.r4 = Restaurant.objects.create(city=cls.c2, name="Angels")
8506 cls.r5 = Restaurant.objects.create(city=cls.c2, name="Take Away")
8507 cls.r6 = Restaurant.objects.create(city=cls.c3, name="The Unknown Restaurant")
8508 cls.w1 = Worker.objects.create(work_at=cls.r1, name="Mario", surname="Rossi")
8509 cls.w2 = Worker.objects.create(
8510 work_at=cls.r1, name="Antonio", surname="Bianchi"
8511 )
8512 cls.w3 = Worker.objects.create(work_at=cls.r1, name="John", surname="Doe")
8513
8514 def setUp(self):
8515 self.client.force_login(self.superuser)
8516
8517 def test_add_view_form_and_formsets_run_validation(self):
8518 """
8519 Issue #20522
8520 Verifying that if the parent form fails validation, the inlines also
8521 run validation even if validation is contingent on parent form data.
8522 Also, assertFormError() and assertFormSetError() is usable for admin
8523 forms and formsets.
8524 """
8525 # The form validation should fail because 'some_required_info' is
8526 # not included on the parent form, and the family_name of the parent
8527 # does not match that of the child
8528 post_data = {
8529 "family_name": "Test1",
8530 "dependentchild_set-TOTAL_FORMS": "1",
8531 "dependentchild_set-INITIAL_FORMS": "0",
8532 "dependentchild_set-MAX_NUM_FORMS": "1",
8533 "dependentchild_set-0-id": "",
8534 "dependentchild_set-0-parent": "",
8535 "dependentchild_set-0-family_name": "Test2",
8536 }
8537 response = self.client.post(
8538 reverse("admin:admin_views_parentwithdependentchildren_add"), post_data
8539 )
8540 self.assertFormError(
8541 response.context["adminform"],
8542 "some_required_info",
8543 ["This field is required."],
8544 )
8545 self.assertFormError(response.context["adminform"], None, [])
8546 self.assertFormSetError(
8547 response.context["inline_admin_formset"],
8548 0,
8549 None,
8550 [
8551 "Children must share a family name with their parents in this "
8552 "contrived test case"
8553 ],
8554 )
8555 self.assertFormSetError(
8556 response.context["inline_admin_formset"], None, None, []
8557 )
8558
8559 def test_change_view_form_and_formsets_run_validation(self):
8560 """
8561 Issue #20522
8562 Verifying that if the parent form fails validation, the inlines also
8563 run validation even if validation is contingent on parent form data
8564 """
8565 pwdc = ParentWithDependentChildren.objects.create(
8566 some_required_info=6, family_name="Test1"
8567 )
8568 # The form validation should fail because 'some_required_info' is
8569 # not included on the parent form, and the family_name of the parent
8570 # does not match that of the child
8571 post_data = {
8572 "family_name": "Test2",
8573 "dependentchild_set-TOTAL_FORMS": "1",
8574 "dependentchild_set-INITIAL_FORMS": "0",
8575 "dependentchild_set-MAX_NUM_FORMS": "1",
8576 "dependentchild_set-0-id": "",
8577 "dependentchild_set-0-parent": str(pwdc.id),
8578 "dependentchild_set-0-family_name": "Test1",
8579 }
8580 response = self.client.post(
8581 reverse(
8582 "admin:admin_views_parentwithdependentchildren_change", args=(pwdc.id,)
8583 ),
8584 post_data,
8585 )
8586 self.assertFormError(
8587 response.context["adminform"],
8588 "some_required_info",
8589 ["This field is required."],
8590 )
8591 self.assertFormSetError(
8592 response.context["inline_admin_formset"],
8593 0,
8594 None,
8595 [
8596 "Children must share a family name with their parents in this "
8597 "contrived test case"
8598 ],
8599 )
8600
8601 def test_check(self):
8602 "The view_on_site value is either a boolean or a callable"
8603 try:
8604 admin = CityAdmin(City, AdminSite())
8605 CityAdmin.view_on_site = True
8606 self.assertEqual(admin.check(), [])
8607 CityAdmin.view_on_site = False
8608 self.assertEqual(admin.check(), [])
8609 CityAdmin.view_on_site = lambda obj: obj.get_absolute_url()
8610 self.assertEqual(admin.check(), [])
8611 CityAdmin.view_on_site = []
8612 self.assertEqual(
8613 admin.check(),
8614 [
8615 Error(
8616 "The value of 'view_on_site' must be a callable or a boolean "
8617 "value.",
8618 obj=CityAdmin,
8619 id="admin.E025",
8620 ),
8621 ],
8622 )
8623 finally:
8624 # Restore the original values for the benefit of other tests.
8625 CityAdmin.view_on_site = True
8626
8627 def test_false(self):
8628 "The 'View on site' button is not displayed if view_on_site is False"
8629 response = self.client.get(
8630 reverse("admin:admin_views_restaurant_change", args=(self.r1.pk,))
8631 )
8632 content_type_pk = ContentType.objects.get_for_model(Restaurant).pk
8633 self.assertNotContains(
8634 response, reverse("admin:view_on_site", args=(content_type_pk, 1))
8635 )
8636
8637 def test_true(self):
8638 "The default behavior is followed if view_on_site is True"
8639 response = self.client.get(
8640 reverse("admin:admin_views_city_change", args=(self.c1.pk,))
8641 )
8642 content_type_pk = ContentType.objects.get_for_model(City).pk
8643 self.assertContains(
8644 response, reverse("admin:view_on_site", args=(content_type_pk, self.c1.pk))
8645 )
8646
8647 def test_callable(self):
8648 "The right link is displayed if view_on_site is a callable"
8649 response = self.client.get(
8650 reverse("admin:admin_views_worker_change", args=(self.w1.pk,))
8651 )
8652 self.assertContains(
8653 response, '"/worker/%s/%s/"' % (self.w1.surname, self.w1.name)
8654 )
8655
8656 def test_missing_get_absolute_url(self):
8657 "None is returned if model doesn't have get_absolute_url"
8658 model_admin = ModelAdmin(Worker, None)
8659 self.assertIsNone(model_admin.get_view_on_site_url(Worker()))
8660
8661 def test_custom_admin_site(self):
8662 model_admin = ModelAdmin(City, customadmin.site)
8663 content_type_pk = ContentType.objects.get_for_model(City).pk
8664 redirect_url = model_admin.get_view_on_site_url(self.c1)
8665 self.assertEqual(
8666 redirect_url,
8667 reverse(
8668 f"{customadmin.site.name}:view_on_site",
8669 kwargs={
8670 "content_type_id": content_type_pk,
8671 "object_id": self.c1.pk,
8672 },
8673 ),
8674 )
8675
8676 def test_view_on_site_url_non_integer_ids(self):
8677 """The view_on_site URL accepts non-integer ids."""
8678 self.assertEqual(
8679 reverse(
8680 "admin:view_on_site",
8681 kwargs={
8682 "content_type_id": "37156b6a-8a82",
8683 "object_id": "37156b6a-8a83",
8684 },
8685 ),
8686 "/test_admin/admin/r/37156b6a-8a82/37156b6a-8a83/",
8687 )
8688
8689
8690 @override_settings(ROOT_URLCONF="admin_views.urls")
8691 class InlineAdminViewOnSiteTest(TestCase):
8692 @classmethod
8693 def setUpTestData(cls):
8694 cls.superuser = User.objects.create_superuser(
8695 username="super", password="secret", email="[email protected]"
8696 )
8697
8698 cls.s1 = State.objects.create(name="New York")
8699 cls.s2 = State.objects.create(name="Illinois")
8700 cls.s3 = State.objects.create(name="California")
8701 cls.c1 = City.objects.create(state=cls.s1, name="New York")
8702 cls.c2 = City.objects.create(state=cls.s2, name="Chicago")
8703 cls.c3 = City.objects.create(state=cls.s3, name="San Francisco")
8704 cls.r1 = Restaurant.objects.create(city=cls.c1, name="Italian Pizza")
8705 cls.r2 = Restaurant.objects.create(city=cls.c1, name="Boulevard")
8706 cls.r3 = Restaurant.objects.create(city=cls.c2, name="Chinese Dinner")
8707 cls.r4 = Restaurant.objects.create(city=cls.c2, name="Angels")
8708 cls.r5 = Restaurant.objects.create(city=cls.c2, name="Take Away")
8709 cls.r6 = Restaurant.objects.create(city=cls.c3, name="The Unknown Restaurant")
8710 cls.w1 = Worker.objects.create(work_at=cls.r1, name="Mario", surname="Rossi")
8711 cls.w2 = Worker.objects.create(
8712 work_at=cls.r1, name="Antonio", surname="Bianchi"
8713 )
8714 cls.w3 = Worker.objects.create(work_at=cls.r1, name="John", surname="Doe")
8715
8716 def setUp(self):
8717 self.client.force_login(self.superuser)
8718
8719 def test_false(self):
8720 "The 'View on site' button is not displayed if view_on_site is False"
8721 response = self.client.get(
8722 reverse("admin:admin_views_state_change", args=(self.s1.pk,))
8723 )
8724 content_type_pk = ContentType.objects.get_for_model(City).pk
8725 self.assertNotContains(
8726 response, reverse("admin:view_on_site", args=(content_type_pk, self.c1.pk))
8727 )
8728
8729 def test_true(self):
8730 "The 'View on site' button is displayed if view_on_site is True"
8731 response = self.client.get(
8732 reverse("admin:admin_views_city_change", args=(self.c1.pk,))
8733 )
8734 content_type_pk = ContentType.objects.get_for_model(Restaurant).pk
8735 self.assertContains(
8736 response, reverse("admin:view_on_site", args=(content_type_pk, self.r1.pk))
8737 )
8738
8739 def test_callable(self):
8740 "The right link is displayed if view_on_site is a callable"
8741 response = self.client.get(
8742 reverse("admin:admin_views_restaurant_change", args=(self.r1.pk,))
8743 )
8744 self.assertContains(
8745 response, '"/worker_inline/%s/%s/"' % (self.w1.surname, self.w1.name)
8746 )
8747
8748
8749 @override_settings(ROOT_URLCONF="admin_views.urls")
8750 class GetFormsetsWithInlinesArgumentTest(TestCase):
8751 """
8752 #23934 - When adding a new model instance in the admin, the 'obj' argument
8753 of get_formsets_with_inlines() should be None. When changing, it should be
8754 equal to the existing model instance.
8755 The GetFormsetsArgumentCheckingAdmin ModelAdmin throws an exception
8756 if obj is not None during add_view or obj is None during change_view.
8757 """
8758
8759 @classmethod
8760 def setUpTestData(cls):
8761 cls.superuser = User.objects.create_superuser(
8762 username="super", password="secret", email="[email protected]"
8763 )
8764
8765 def setUp(self):
8766 self.client.force_login(self.superuser)
8767
8768 def test_explicitly_provided_pk(self):
8769 post_data = {"name": "1"}
8770 response = self.client.post(
8771 reverse("admin:admin_views_explicitlyprovidedpk_add"), post_data
8772 )
8773 self.assertEqual(response.status_code, 302)
8774
8775 post_data = {"name": "2"}
8776 response = self.client.post(
8777 reverse("admin:admin_views_explicitlyprovidedpk_change", args=(1,)),
8778 post_data,
8779 )
8780 self.assertEqual(response.status_code, 302)
8781
8782 def test_implicitly_generated_pk(self):
8783 post_data = {"name": "1"}
8784 response = self.client.post(
8785 reverse("admin:admin_views_implicitlygeneratedpk_add"), post_data
8786 )
8787 self.assertEqual(response.status_code, 302)
8788
8789 post_data = {"name": "2"}
8790 response = self.client.post(
8791 reverse("admin:admin_views_implicitlygeneratedpk_change", args=(1,)),
8792 post_data,
8793 )
8794 self.assertEqual(response.status_code, 302)
8795
8796
8797 @override_settings(ROOT_URLCONF="admin_views.urls")
8798 class AdminSiteFinalCatchAllPatternTests(TestCase):
8799 """
8800 Verifies the behaviour of the admin catch-all view.
8801
8802 * Anonynous/non-staff users are redirected to login for all URLs, whether
8803 otherwise valid or not.
8804 * APPEND_SLASH is applied for staff if needed.
8805 * Otherwise Http404.
8806 * Catch-all view disabled via AdminSite.final_catch_all_view.
8807 """
8808
8809 @classmethod
8810 def setUpTestData(cls):
8811 cls.staff_user = User.objects.create_user(
8812 username="staff",
8813 password="secret",
8814 email="[email protected]",
8815 is_staff=True,
8816 )
8817 cls.non_staff_user = User.objects.create_user(
8818 username="user",
8819 password="secret",
8820 email="[email protected]",
8821 is_staff=False,
8822 )
8823
8824 def test_unknown_url_redirects_login_if_not_authenticated(self):
8825 unknown_url = "/test_admin/admin/unknown/"
8826 response = self.client.get(unknown_url)
8827 self.assertRedirects(
8828 response, "%s?next=%s" % (reverse("admin:login"), unknown_url)
8829 )
8830
8831 def test_unknown_url_404_if_authenticated(self):
8832 self.client.force_login(self.staff_user)
8833 unknown_url = "/test_admin/admin/unknown/"
8834 response = self.client.get(unknown_url)
8835 self.assertEqual(response.status_code, 404)
8836
8837 def test_known_url_redirects_login_if_not_authenticated(self):
8838 known_url = reverse("admin:admin_views_article_changelist")
8839 response = self.client.get(known_url)
8840 self.assertRedirects(
8841 response, "%s?next=%s" % (reverse("admin:login"), known_url)
8842 )
8843
8844 def test_known_url_missing_slash_redirects_login_if_not_authenticated(self):
8845 known_url = reverse("admin:admin_views_article_changelist")[:-1]
8846 response = self.client.get(known_url)
8847 # Redirects with the next URL also missing the slash.
8848 self.assertRedirects(
8849 response, "%s?next=%s" % (reverse("admin:login"), known_url)
8850 )
8851
8852 def test_non_admin_url_shares_url_prefix(self):
8853 url = reverse("non_admin")[:-1]
8854 response = self.client.get(url)
8855 # Redirects with the next URL also missing the slash.
8856 self.assertRedirects(response, "%s?next=%s" % (reverse("admin:login"), url))
8857
8858 def test_url_without_trailing_slash_if_not_authenticated(self):
8859 url = reverse("admin:article_extra_json")
8860 response = self.client.get(url)
8861 self.assertRedirects(response, "%s?next=%s" % (reverse("admin:login"), url))
8862
8863 def test_unkown_url_without_trailing_slash_if_not_authenticated(self):
8864 url = reverse("admin:article_extra_json")[:-1]
8865 response = self.client.get(url)
8866 self.assertRedirects(response, "%s?next=%s" % (reverse("admin:login"), url))
8867
8868 @override_settings(APPEND_SLASH=True)
8869 def test_missing_slash_append_slash_true_unknown_url(self):
8870 self.client.force_login(self.staff_user)
8871 unknown_url = "/test_admin/admin/unknown/"
8872 response = self.client.get(unknown_url[:-1])
8873 self.assertEqual(response.status_code, 404)
8874
8875 @override_settings(APPEND_SLASH=True)
8876 def test_missing_slash_append_slash_true(self):
8877 self.client.force_login(self.staff_user)
8878 known_url = reverse("admin:admin_views_article_changelist")
8879 response = self.client.get(known_url[:-1])
8880 self.assertRedirects(
8881 response, known_url, status_code=301, target_status_code=403
8882 )
8883
8884 @override_settings(APPEND_SLASH=True)
8885 def test_missing_slash_append_slash_true_query_string(self):
8886 self.client.force_login(self.staff_user)
8887 known_url = reverse("admin:admin_views_article_changelist")
8888 response = self.client.get("%s?id=1" % known_url[:-1])
8889 self.assertRedirects(
8890 response,
8891 f"{known_url}?id=1",
8892 status_code=301,
8893 fetch_redirect_response=False,
8894 )
8895
8896 @override_settings(APPEND_SLASH=True)
8897 def test_missing_slash_append_slash_true_script_name(self):
8898 self.client.force_login(self.staff_user)
8899 known_url = reverse("admin:admin_views_article_changelist")
8900 response = self.client.get(known_url[:-1], SCRIPT_NAME="/prefix/")
8901 self.assertRedirects(
8902 response,
8903 "/prefix" + known_url,
8904 status_code=301,
8905 fetch_redirect_response=False,
8906 )
8907
8908 @override_settings(APPEND_SLASH=True)
8909 def test_missing_slash_append_slash_true_script_name_query_string(self):
8910 self.client.force_login(self.staff_user)
8911 known_url = reverse("admin:admin_views_article_changelist")
8912 response = self.client.get("%s?id=1" % known_url[:-1], SCRIPT_NAME="/prefix/")
8913 self.assertRedirects(
8914 response,
8915 f"/prefix{known_url}?id=1",
8916 status_code=301,
8917 fetch_redirect_response=False,
8918 )
8919
8920 @override_settings(APPEND_SLASH=True, FORCE_SCRIPT_NAME="/prefix/")
8921 def test_missing_slash_append_slash_true_force_script_name(self):
8922 self.client.force_login(self.staff_user)
8923 known_url = reverse("admin:admin_views_article_changelist")
8924 response = self.client.get(known_url[:-1])
8925 self.assertRedirects(
8926 response,
8927 "/prefix" + known_url,
8928 status_code=301,
8929 fetch_redirect_response=False,
8930 )
8931
8932 @override_settings(APPEND_SLASH=True)
8933 def test_missing_slash_append_slash_true_non_staff_user(self):
8934 self.client.force_login(self.non_staff_user)
8935 known_url = reverse("admin:admin_views_article_changelist")
8936 response = self.client.get(known_url[:-1])
8937 self.assertRedirects(
8938 response,
8939 "/test_admin/admin/login/?next=/test_admin/admin/admin_views/article",
8940 )
8941
8942 @override_settings(APPEND_SLASH=True)
8943 def test_missing_slash_append_slash_true_non_staff_user_query_string(self):
8944 self.client.force_login(self.non_staff_user)
8945 known_url = reverse("admin:admin_views_article_changelist")
8946 response = self.client.get("%s?id=1" % known_url[:-1])
8947 self.assertRedirects(
8948 response,
8949 "/test_admin/admin/login/?next=/test_admin/admin/admin_views/article"
8950 "%3Fid%3D1",
8951 )
8952
8953 @override_settings(APPEND_SLASH=False)
8954 def test_missing_slash_append_slash_false(self):
8955 self.client.force_login(self.staff_user)
8956 known_url = reverse("admin:admin_views_article_changelist")
8957 response = self.client.get(known_url[:-1])
8958 self.assertEqual(response.status_code, 404)
8959
8960 @override_settings(APPEND_SLASH=True)
8961 def test_single_model_no_append_slash(self):
8962 self.client.force_login(self.staff_user)
8963 known_url = reverse("admin9:admin_views_actor_changelist")
8964 response = self.client.get(known_url[:-1])
8965 self.assertEqual(response.status_code, 404)
8966
8967 # Same tests above with final_catch_all_view=False.
8968
8969 def test_unknown_url_404_if_not_authenticated_without_final_catch_all_view(self):
8970 unknown_url = "/test_admin/admin10/unknown/"
8971 response = self.client.get(unknown_url)
8972 self.assertEqual(response.status_code, 404)
8973
8974 def test_unknown_url_404_if_authenticated_without_final_catch_all_view(self):
8975 self.client.force_login(self.staff_user)
8976 unknown_url = "/test_admin/admin10/unknown/"
8977 response = self.client.get(unknown_url)
8978 self.assertEqual(response.status_code, 404)
8979
8980 def test_known_url_redirects_login_if_not_auth_without_final_catch_all_view(
8981 self,
8982 ):
8983 known_url = reverse("admin10:admin_views_article_changelist")
8984 response = self.client.get(known_url)
8985 self.assertRedirects(
8986 response, "%s?next=%s" % (reverse("admin10:login"), known_url)
8987 )
8988
8989 def test_known_url_missing_slash_redirects_with_slash_if_not_auth_no_catch_all_view(
8990 self,
8991 ):
8992 known_url = reverse("admin10:admin_views_article_changelist")
8993 response = self.client.get(known_url[:-1])
8994 self.assertRedirects(
8995 response, known_url, status_code=301, fetch_redirect_response=False
8996 )
8997
8998 def test_non_admin_url_shares_url_prefix_without_final_catch_all_view(self):
8999 url = reverse("non_admin10")
9000 response = self.client.get(url[:-1])
9001 self.assertRedirects(response, url, status_code=301)
9002
9003 def test_url_no_trailing_slash_if_not_auth_without_final_catch_all_view(
9004 self,
9005 ):
9006 url = reverse("admin10:article_extra_json")
9007 response = self.client.get(url)
9008 self.assertRedirects(response, "%s?next=%s" % (reverse("admin10:login"), url))
9009
9010 def test_unknown_url_no_trailing_slash_if_not_auth_without_final_catch_all_view(
9011 self,
9012 ):
9013 url = reverse("admin10:article_extra_json")[:-1]
9014 response = self.client.get(url)
9015 # Matches test_admin/admin10/admin_views/article/<path:object_id>/
9016 self.assertRedirects(
9017 response, url + "/", status_code=301, fetch_redirect_response=False
9018 )
9019
9020 @override_settings(APPEND_SLASH=True)
9021 def test_missing_slash_append_slash_true_unknown_url_without_final_catch_all_view(
9022 self,
9023 ):
9024 self.client.force_login(self.staff_user)
9025 unknown_url = "/test_admin/admin10/unknown/"
9026 response = self.client.get(unknown_url[:-1])
9027 self.assertEqual(response.status_code, 404)
9028
9029 @override_settings(APPEND_SLASH=True)
9030 def test_missing_slash_append_slash_true_without_final_catch_all_view(self):
9031 self.client.force_login(self.staff_user)
9032 known_url = reverse("admin10:admin_views_article_changelist")
9033 response = self.client.get(known_url[:-1])
9034 self.assertRedirects(
9035 response, known_url, status_code=301, target_status_code=403
9036 )
9037
9038 @override_settings(APPEND_SLASH=True)
9039 def test_missing_slash_append_slash_true_query_without_final_catch_all_view(self):
9040 self.client.force_login(self.staff_user)
9041 known_url = reverse("admin10:admin_views_article_changelist")
9042 response = self.client.get("%s?id=1" % known_url[:-1])
9043 self.assertRedirects(
9044 response,
9045 f"{known_url}?id=1",
9046 status_code=301,
9047 fetch_redirect_response=False,
9048 )
9049
9050 @override_settings(APPEND_SLASH=False)
9051 def test_missing_slash_append_slash_false_without_final_catch_all_view(self):
9052 self.client.force_login(self.staff_user)
9053 known_url = reverse("admin10:admin_views_article_changelist")
9054 response = self.client.get(known_url[:-1])
9055 self.assertEqual(response.status_code, 404)
9056
9057 # Outside admin.
9058
9059 def test_non_admin_url_404_if_not_authenticated(self):
9060 unknown_url = "/unknown/"
9061 response = self.client.get(unknown_url)
9062 # Does not redirect to the admin login.
9063 self.assertEqual(response.status_code, 404)