Debian Codegraph @

tests/admin_widgets/tests.py

raw
1 import gettext
2 import os
3 import re
4 import zoneinfo
5 from datetime import datetime, timedelta
6 from importlib import import_module
7 from unittest import skipUnless
8
9 from django import forms
10 from django.conf import settings
11 from django.contrib import admin
12 from django.contrib.admin import widgets
13 from django.contrib.admin.tests import AdminSeleniumTestCase
14 from django.contrib.auth.models import User
15 from django.core.files.storage import default_storage
16 from django.core.files.uploadedfile import SimpleUploadedFile
17 from django.db.models import (
18 CharField,
19 DateField,
20 DateTimeField,
21 ForeignKey,
22 ManyToManyField,
23 UUIDField,
24 )
25 from django.test import SimpleTestCase, TestCase, ignore_warnings, override_settings
26 from django.test.selenium import screenshot_cases
27 from django.test.utils import requires_tz_support
28 from django.urls import reverse
29 from django.utils import translation
30 from django.utils.deprecation import RemovedInDjango60Warning
31
32 from .models import (
33 Advisor,
34 Album,
35 Band,
36 Bee,
37 Car,
38 Company,
39 Event,
40 Honeycomb,
41 Image,
42 Individual,
43 Inventory,
44 Member,
45 MyFileField,
46 Profile,
47 ReleaseEvent,
48 School,
49 Student,
50 UnsafeLimitChoicesTo,
51 VideoStream,
52 )
53 from .widgetadmin import site as widget_admin_site
54
55
56 class TestDataMixin:
57 @classmethod
58 def setUpTestData(cls):
59 cls.superuser = User.objects.create_superuser(
60 username="super", password="secret", email=None
61 )
62 cls.u2 = User.objects.create_user(username="testser", password="secret")
63 Car.objects.create(owner=cls.superuser, make="Volkswagen", model="Passat")
64 Car.objects.create(owner=cls.u2, make="BMW", model="M3")
65
66
67 class AdminFormfieldForDBFieldTests(SimpleTestCase):
68 """
69 Tests for correct behavior of ModelAdmin.formfield_for_dbfield
70 """
71
72 def assertFormfield(self, model, fieldname, widgetclass, **admin_overrides):
73 """
74 Helper to call formfield_for_dbfield for a given model and field name
75 and verify that the returned formfield is appropriate.
76 """
77
78 # Override any settings on the model admin
79 class MyModelAdmin(admin.ModelAdmin):
80 pass
81
82 for k in admin_overrides:
83 setattr(MyModelAdmin, k, admin_overrides[k])
84
85 # Construct the admin, and ask it for a formfield
86 ma = MyModelAdmin(model, admin.site)
87 ff = ma.formfield_for_dbfield(model._meta.get_field(fieldname), request=None)
88
89 # "unwrap" the widget wrapper, if needed
90 if isinstance(ff.widget, widgets.RelatedFieldWidgetWrapper):
91 widget = ff.widget.widget
92 else:
93 widget = ff.widget
94
95 self.assertIsInstance(widget, widgetclass)
96
97 # Return the formfield so that other tests can continue
98 return ff
99
100 def test_DateField(self):
101 self.assertFormfield(Event, "start_date", widgets.AdminDateWidget)
102
103 def test_DateTimeField(self):
104 self.assertFormfield(Member, "birthdate", widgets.AdminSplitDateTime)
105
106 def test_TimeField(self):
107 self.assertFormfield(Event, "start_time", widgets.AdminTimeWidget)
108
109 def test_TextField(self):
110 self.assertFormfield(Event, "description", widgets.AdminTextareaWidget)
111
112 @ignore_warnings(category=RemovedInDjango60Warning)
113 def test_URLField(self):
114 self.assertFormfield(Event, "link", widgets.AdminURLFieldWidget)
115
116 def test_IntegerField(self):
117 self.assertFormfield(Event, "min_age", widgets.AdminIntegerFieldWidget)
118
119 def test_CharField(self):
120 self.assertFormfield(Member, "name", widgets.AdminTextInputWidget)
121
122 def test_EmailField(self):
123 self.assertFormfield(Member, "email", widgets.AdminEmailInputWidget)
124
125 def test_FileField(self):
126 self.assertFormfield(Album, "cover_art", widgets.AdminFileWidget)
127
128 def test_ForeignKey(self):
129 self.assertFormfield(Event, "main_band", forms.Select)
130
131 def test_raw_id_ForeignKey(self):
132 self.assertFormfield(
133 Event,
134 "main_band",
135 widgets.ForeignKeyRawIdWidget,
136 raw_id_fields=["main_band"],
137 )
138
139 def test_radio_fields_ForeignKey(self):
140 ff = self.assertFormfield(
141 Event,
142 "main_band",
143 widgets.AdminRadioSelect,
144 radio_fields={"main_band": admin.VERTICAL},
145 )
146 self.assertIsNone(ff.empty_label)
147
148 def test_radio_fields_foreignkey_formfield_overrides_empty_label(self):
149 class MyModelAdmin(admin.ModelAdmin):
150 radio_fields = {"parent": admin.VERTICAL}
151 formfield_overrides = {
152 ForeignKey: {"empty_label": "Custom empty label"},
153 }
154
155 ma = MyModelAdmin(Inventory, admin.site)
156 ff = ma.formfield_for_dbfield(Inventory._meta.get_field("parent"), request=None)
157 self.assertEqual(ff.empty_label, "Custom empty label")
158
159 def test_many_to_many(self):
160 self.assertFormfield(Band, "members", forms.SelectMultiple)
161
162 def test_raw_id_many_to_many(self):
163 self.assertFormfield(
164 Band, "members", widgets.ManyToManyRawIdWidget, raw_id_fields=["members"]
165 )
166
167 def test_filtered_many_to_many(self):
168 self.assertFormfield(
169 Band, "members", widgets.FilteredSelectMultiple, filter_vertical=["members"]
170 )
171
172 def test_formfield_overrides(self):
173 self.assertFormfield(
174 Event,
175 "start_date",
176 forms.TextInput,
177 formfield_overrides={DateField: {"widget": forms.TextInput}},
178 )
179
180 def test_formfield_overrides_widget_instances(self):
181 """
182 Widget instances in formfield_overrides are not shared between
183 different fields. (#19423)
184 """
185
186 class BandAdmin(admin.ModelAdmin):
187 formfield_overrides = {
188 CharField: {"widget": forms.TextInput(attrs={"size": "10"})}
189 }
190
191 ma = BandAdmin(Band, admin.site)
192 f1 = ma.formfield_for_dbfield(Band._meta.get_field("name"), request=None)
193 f2 = ma.formfield_for_dbfield(Band._meta.get_field("style"), request=None)
194 self.assertNotEqual(f1.widget, f2.widget)
195 self.assertEqual(f1.widget.attrs["maxlength"], "100")
196 self.assertEqual(f2.widget.attrs["maxlength"], "20")
197 self.assertEqual(f2.widget.attrs["size"], "10")
198
199 def test_formfield_overrides_m2m_filter_widget(self):
200 """
201 The autocomplete_fields, raw_id_fields, filter_vertical, and
202 filter_horizontal widgets for ManyToManyFields may be overridden by
203 specifying a widget in formfield_overrides.
204 """
205
206 class BandAdmin(admin.ModelAdmin):
207 filter_vertical = ["members"]
208 formfield_overrides = {
209 ManyToManyField: {"widget": forms.CheckboxSelectMultiple},
210 }
211
212 ma = BandAdmin(Band, admin.site)
213 field = ma.formfield_for_dbfield(Band._meta.get_field("members"), request=None)
214 self.assertIsInstance(field.widget.widget, forms.CheckboxSelectMultiple)
215
216 def test_formfield_overrides_for_datetime_field(self):
217 """
218 Overriding the widget for DateTimeField doesn't overrides the default
219 form_class for that field (#26449).
220 """
221
222 class MemberAdmin(admin.ModelAdmin):
223 formfield_overrides = {
224 DateTimeField: {"widget": widgets.AdminSplitDateTime}
225 }
226
227 ma = MemberAdmin(Member, admin.site)
228 f1 = ma.formfield_for_dbfield(Member._meta.get_field("birthdate"), request=None)
229 self.assertIsInstance(f1.widget, widgets.AdminSplitDateTime)
230 self.assertIsInstance(f1, forms.SplitDateTimeField)
231
232 def test_formfield_overrides_for_custom_field(self):
233 """
234 formfield_overrides works for a custom field class.
235 """
236
237 class AlbumAdmin(admin.ModelAdmin):
238 formfield_overrides = {MyFileField: {"widget": forms.TextInput()}}
239
240 ma = AlbumAdmin(Member, admin.site)
241 f1 = ma.formfield_for_dbfield(
242 Album._meta.get_field("backside_art"), request=None
243 )
244 self.assertIsInstance(f1.widget, forms.TextInput)
245
246 def test_field_with_choices(self):
247 self.assertFormfield(Member, "gender", forms.Select)
248
249 def test_choices_with_radio_fields(self):
250 self.assertFormfield(
251 Member,
252 "gender",
253 widgets.AdminRadioSelect,
254 radio_fields={"gender": admin.VERTICAL},
255 )
256
257 def test_inheritance(self):
258 self.assertFormfield(Album, "backside_art", widgets.AdminFileWidget)
259
260 def test_m2m_widgets(self):
261 """m2m fields help text as it applies to admin app (#9321)."""
262
263 class AdvisorAdmin(admin.ModelAdmin):
264 filter_vertical = ["companies"]
265
266 self.assertFormfield(
267 Advisor,
268 "companies",
269 widgets.FilteredSelectMultiple,
270 filter_vertical=["companies"],
271 )
272 ma = AdvisorAdmin(Advisor, admin.site)
273 f = ma.formfield_for_dbfield(Advisor._meta.get_field("companies"), request=None)
274 self.assertEqual(
275 f.help_text,
276 "Hold down “Control”, or “Command” on a Mac, to select more than one.",
277 )
278
279 def test_m2m_widgets_no_allow_multiple_selected(self):
280 class NoAllowMultipleSelectedWidget(forms.SelectMultiple):
281 allow_multiple_selected = False
282
283 class AdvisorAdmin(admin.ModelAdmin):
284 filter_vertical = ["companies"]
285 formfield_overrides = {
286 ManyToManyField: {"widget": NoAllowMultipleSelectedWidget},
287 }
288
289 self.assertFormfield(
290 Advisor,
291 "companies",
292 widgets.FilteredSelectMultiple,
293 filter_vertical=["companies"],
294 )
295 ma = AdvisorAdmin(Advisor, admin.site)
296 f = ma.formfield_for_dbfield(Advisor._meta.get_field("companies"), request=None)
297 self.assertEqual(f.help_text, "")
298
299
300 @override_settings(ROOT_URLCONF="admin_widgets.urls")
301 class AdminFormfieldForDBFieldWithRequestTests(TestDataMixin, TestCase):
302 def test_filter_choices_by_request_user(self):
303 """
304 Ensure the user can only see their own cars in the foreign key dropdown.
305 """
306 self.client.force_login(self.superuser)
307 response = self.client.get(reverse("admin:admin_widgets_cartire_add"))
308 self.assertNotContains(response, "BMW M3")
309 self.assertContains(response, "Volkswagen Passat")
310
311
312 @override_settings(ROOT_URLCONF="admin_widgets.urls")
313 class AdminForeignKeyWidgetChangeList(TestDataMixin, TestCase):
314 def setUp(self):
315 self.client.force_login(self.superuser)
316
317 def test_changelist_ForeignKey(self):
318 response = self.client.get(reverse("admin:admin_widgets_car_changelist"))
319 self.assertContains(response, "/auth/user/add/")
320
321
322 @override_settings(ROOT_URLCONF="admin_widgets.urls")
323 class AdminForeignKeyRawIdWidget(TestDataMixin, TestCase):
324 def setUp(self):
325 self.client.force_login(self.superuser)
326
327 @ignore_warnings(category=RemovedInDjango60Warning)
328 def test_nonexistent_target_id(self):
329 band = Band.objects.create(name="Bogey Blues")
330 pk = band.pk
331 band.delete()
332 post_data = {
333 "main_band": str(pk),
334 }
335 # Try posting with a nonexistent pk in a raw id field: this
336 # should result in an error message, not a server exception.
337 response = self.client.post(reverse("admin:admin_widgets_event_add"), post_data)
338 self.assertContains(
339 response,
340 "Select a valid choice. That choice is not one of the available choices.",
341 )
342
343 @ignore_warnings(category=RemovedInDjango60Warning)
344 def test_invalid_target_id(self):
345 for test_str in ("Iñtërnâtiônàlizætiøn", "1234'", -1234):
346 # This should result in an error message, not a server exception.
347 response = self.client.post(
348 reverse("admin:admin_widgets_event_add"), {"main_band": test_str}
349 )
350
351 self.assertContains(
352 response,
353 "Select a valid choice. That choice is not one of the available "
354 "choices.",
355 )
356
357 def test_url_params_from_lookup_dict_any_iterable(self):
358 lookup1 = widgets.url_params_from_lookup_dict({"color__in": ("red", "blue")})
359 lookup2 = widgets.url_params_from_lookup_dict({"color__in": ["red", "blue"]})
360 self.assertEqual(lookup1, {"color__in": "red,blue"})
361 self.assertEqual(lookup1, lookup2)
362
363 def test_url_params_from_lookup_dict_callable(self):
364 def my_callable():
365 return "works"
366
367 lookup1 = widgets.url_params_from_lookup_dict({"myfield": my_callable})
368 lookup2 = widgets.url_params_from_lookup_dict({"myfield": my_callable()})
369 self.assertEqual(lookup1, lookup2)
370
371 def test_label_and_url_for_value_invalid_uuid(self):
372 field = Bee._meta.get_field("honeycomb")
373 self.assertIsInstance(field.target_field, UUIDField)
374 widget = widgets.ForeignKeyRawIdWidget(field.remote_field, admin.site)
375 self.assertEqual(widget.label_and_url_for_value("invalid-uuid"), ("", ""))
376
377
378 class FilteredSelectMultipleWidgetTest(SimpleTestCase):
379 def test_render(self):
380 # Backslash in verbose_name to ensure it is JavaScript escaped.
381 w = widgets.FilteredSelectMultiple("test\\", False)
382 self.assertHTMLEqual(
383 w.render("test", "test"),
384 '<select multiple name="test" class="selectfilter" '
385 'data-field-name="test\\" data-is-stacked="0">\n</select>',
386 )
387
388 def test_stacked_render(self):
389 # Backslash in verbose_name to ensure it is JavaScript escaped.
390 w = widgets.FilteredSelectMultiple("test\\", True)
391 self.assertHTMLEqual(
392 w.render("test", "test"),
393 '<select multiple name="test" class="selectfilterstacked" '
394 'data-field-name="test\\" data-is-stacked="1">\n</select>',
395 )
396
397
398 class AdminDateWidgetTest(SimpleTestCase):
399 def test_attrs(self):
400 w = widgets.AdminDateWidget()
401 self.assertHTMLEqual(
402 w.render("test", datetime(2007, 12, 1, 9, 30)),
403 '<p class="date">'
404 '<input value="2007-12-01" type="text" class="vDateField" name="test" '
405 'size="10"></p>',
406 )
407 # pass attrs to widget
408 w = widgets.AdminDateWidget(attrs={"size": 20, "class": "myDateField"})
409 self.assertHTMLEqual(
410 w.render("test", datetime(2007, 12, 1, 9, 30)),
411 '<p class="date">'
412 '<input value="2007-12-01" type="text" class="myDateField" name="test" '
413 'size="20"></p>',
414 )
415
416
417 class AdminTimeWidgetTest(SimpleTestCase):
418 def test_attrs(self):
419 w = widgets.AdminTimeWidget()
420 self.assertHTMLEqual(
421 w.render("test", datetime(2007, 12, 1, 9, 30)),
422 '<p class="time">'
423 '<input value="09:30:00" type="text" class="vTimeField" name="test" '
424 'size="8"></p>',
425 )
426 # pass attrs to widget
427 w = widgets.AdminTimeWidget(attrs={"size": 20, "class": "myTimeField"})
428 self.assertHTMLEqual(
429 w.render("test", datetime(2007, 12, 1, 9, 30)),
430 '<p class="time">'
431 '<input value="09:30:00" type="text" class="myTimeField" name="test" '
432 'size="20"></p>',
433 )
434
435
436 class AdminSplitDateTimeWidgetTest(SimpleTestCase):
437 def test_render(self):
438 w = widgets.AdminSplitDateTime()
439 self.assertHTMLEqual(
440 w.render("test", datetime(2007, 12, 1, 9, 30)),
441 '<p class="datetime">'
442 'Date: <input value="2007-12-01" type="text" class="vDateField" '
443 'name="test_0" size="10"><br>'
444 'Time: <input value="09:30:00" type="text" class="vTimeField" '
445 'name="test_1" size="8"></p>',
446 )
447
448 def test_localization(self):
449 w = widgets.AdminSplitDateTime()
450
451 with translation.override("de-at"):
452 w.is_localized = True
453 self.assertHTMLEqual(
454 w.render("test", datetime(2007, 12, 1, 9, 30)),
455 '<p class="datetime">'
456 'Datum: <input value="01.12.2007" type="text" '
457 'class="vDateField" name="test_0"size="10"><br>'
458 'Zeit: <input value="09:30:00" type="text" class="vTimeField" '
459 'name="test_1" size="8"></p>',
460 )
461
462
463 class AdminURLWidgetTest(SimpleTestCase):
464 def test_get_context_validates_url(self):
465 w = widgets.AdminURLFieldWidget()
466 for invalid in [
467 "",
468 "/not/a/full/url/",
469 'javascript:alert("Danger XSS!")',
470 "http://" + "한.글." * 1_000_000 + "com",
471 ]:
472 with self.subTest(url=invalid):
473 self.assertFalse(w.get_context("name", invalid, {})["url_valid"])
474 self.assertTrue(w.get_context("name", "http://example.com", {})["url_valid"])
475
476 def test_render(self):
477 w = widgets.AdminURLFieldWidget()
478 self.assertHTMLEqual(
479 w.render("test", ""), '<input class="vURLField" name="test" type="url">'
480 )
481 self.assertHTMLEqual(
482 w.render("test", "http://example.com"),
483 '<p class="url">Currently:<a href="http://example.com">'
484 "http://example.com</a><br>"
485 'Change:<input class="vURLField" name="test" type="url" '
486 'value="http://example.com"></p>',
487 )
488
489 def test_render_idn(self):
490 w = widgets.AdminURLFieldWidget()
491 self.assertHTMLEqual(
492 w.render("test", "http://example-äüö.com"),
493 '<p class="url">Currently: <a href="http://example-%C3%A4%C3%BC%C3%B6.com">'
494 "http://example-äüö.com</a><br>"
495 'Change:<input class="vURLField" name="test" type="url" '
496 'value="http://example-äüö.com"></p>',
497 )
498 # Does not use obsolete IDNA-2003 encoding (#36013).
499 self.assertNotIn("fass.example.com", w.render("test", "http://faß.example.com"))
500
501 def test_render_quoting(self):
502 """
503 WARNING: This test doesn't use assertHTMLEqual since it will get rid
504 of some escapes which are tested here!
505 """
506 HREF_RE = re.compile('href="([^"]+)"')
507 VALUE_RE = re.compile('value="([^"]+)"')
508 TEXT_RE = re.compile("<a[^>]+>([^>]+)</a>")
509 w = widgets.AdminURLFieldWidget()
510 output = w.render("test", "http://example.com/<sometag>some-text</sometag>")
511 self.assertEqual(
512 HREF_RE.search(output)[1],
513 "http://example.com/%3Csometag%3Esome-text%3C/sometag%3E",
514 )
515 self.assertEqual(
516 TEXT_RE.search(output)[1],
517 "http://example.com/&lt;sometag&gt;some-text&lt;/sometag&gt;",
518 )
519 self.assertEqual(
520 VALUE_RE.search(output)[1],
521 "http://example.com/&lt;sometag&gt;some-text&lt;/sometag&gt;",
522 )
523 output = w.render("test", "http://example-äüö.com/<sometag>some-text</sometag>")
524 self.assertEqual(
525 HREF_RE.search(output)[1],
526 "http://example-%C3%A4%C3%BC%C3%B6.com/"
527 "%3Csometag%3Esome-text%3C/sometag%3E",
528 )
529 self.assertEqual(
530 TEXT_RE.search(output)[1],
531 "http://example-äüö.com/&lt;sometag&gt;some-text&lt;/sometag&gt;",
532 )
533 self.assertEqual(
534 VALUE_RE.search(output)[1],
535 "http://example-äüö.com/&lt;sometag&gt;some-text&lt;/sometag&gt;",
536 )
537 output = w.render(
538 "test", 'http://www.example.com/%C3%A4"><script>alert("XSS!")</script>"'
539 )
540 self.assertEqual(
541 HREF_RE.search(output)[1],
542 "http://www.example.com/%C3%A4%22%3E%3Cscript%3Ealert(%22XSS!%22)"
543 "%3C/script%3E%22",
544 )
545 self.assertEqual(
546 TEXT_RE.search(output)[1],
547 "http://www.example.com/%C3%A4&quot;&gt;&lt;script&gt;"
548 "alert(&quot;XSS!&quot;)&lt;/script&gt;&quot;",
549 )
550 self.assertEqual(
551 VALUE_RE.search(output)[1],
552 "http://www.example.com/%C3%A4&quot;&gt;&lt;script&gt;"
553 "alert(&quot;XSS!&quot;)&lt;/script&gt;&quot;",
554 )
555
556
557 class AdminUUIDWidgetTests(SimpleTestCase):
558 def test_attrs(self):
559 w = widgets.AdminUUIDInputWidget()
560 self.assertHTMLEqual(
561 w.render("test", "550e8400-e29b-41d4-a716-446655440000"),
562 '<input value="550e8400-e29b-41d4-a716-446655440000" type="text" '
563 'class="vUUIDField" name="test">',
564 )
565 w = widgets.AdminUUIDInputWidget(attrs={"class": "myUUIDInput"})
566 self.assertHTMLEqual(
567 w.render("test", "550e8400-e29b-41d4-a716-446655440000"),
568 '<input value="550e8400-e29b-41d4-a716-446655440000" type="text" '
569 'class="myUUIDInput" name="test">',
570 )
571
572
573 @override_settings(ROOT_URLCONF="admin_widgets.urls")
574 class AdminFileWidgetTests(TestDataMixin, TestCase):
575 @classmethod
576 def setUpTestData(cls):
577 super().setUpTestData()
578 band = Band.objects.create(name="Linkin Park")
579 cls.album = band.album_set.create(
580 name="Hybrid Theory", cover_art=r"albums\hybrid_theory.jpg"
581 )
582
583 def test_render(self):
584 w = widgets.AdminFileWidget()
585 self.assertHTMLEqual(
586 w.render("test", self.album.cover_art),
587 '<p class="file-upload">Currently: <a href="%(STORAGE_URL)salbums/'
588 r'hybrid_theory.jpg">albums\hybrid_theory.jpg</a> '
589 '<span class="clearable-file-input">'
590 '<input type="checkbox" name="test-clear" id="test-clear_id"> '
591 '<label for="test-clear_id">Clear</label></span><br>'
592 'Change: <input type="file" name="test"></p>'
593 % {
594 "STORAGE_URL": default_storage.url(""),
595 },
596 )
597 self.assertHTMLEqual(
598 w.render("test", SimpleUploadedFile("test", b"content")),
599 '<input type="file" name="test">',
600 )
601
602 def test_render_with_attrs_id(self):
603 storage_url = default_storage.url("")
604 w = widgets.AdminFileWidget()
605 self.assertHTMLEqual(
606 w.render("test", self.album.cover_art, attrs={"id": "test_id"}),
607 f'<p class="file-upload">Currently: <a href="{storage_url}albums/'
608 r'hybrid_theory.jpg">albums\hybrid_theory.jpg</a> '
609 '<span class="clearable-file-input">'
610 '<input type="checkbox" name="test-clear" id="test-clear_id"> '
611 '<label for="test-clear_id">Clear</label></span><br>'
612 'Change: <input type="file" name="test" id="test_id"></p>',
613 )
614
615 def test_render_required(self):
616 widget = widgets.AdminFileWidget()
617 widget.is_required = True
618 self.assertHTMLEqual(
619 widget.render("test", self.album.cover_art),
620 '<p class="file-upload">Currently: <a href="%(STORAGE_URL)salbums/'
621 r'hybrid_theory.jpg">albums\hybrid_theory.jpg</a><br>'
622 'Change: <input type="file" name="test"></p>'
623 % {
624 "STORAGE_URL": default_storage.url(""),
625 },
626 )
627
628 def test_render_disabled(self):
629 widget = widgets.AdminFileWidget(attrs={"disabled": True})
630 self.assertHTMLEqual(
631 widget.render("test", self.album.cover_art),
632 '<p class="file-upload">Currently: <a href="%(STORAGE_URL)salbums/'
633 r'hybrid_theory.jpg">albums\hybrid_theory.jpg</a> '
634 '<span class="clearable-file-input">'
635 '<input type="checkbox" name="test-clear" id="test-clear_id" disabled>'
636 '<label for="test-clear_id">Clear</label></span><br>'
637 'Change: <input type="file" name="test" disabled></p>'
638 % {
639 "STORAGE_URL": default_storage.url(""),
640 },
641 )
642
643 def test_render_checked(self):
644 storage_url = default_storage.url("")
645 widget = widgets.AdminFileWidget()
646 widget.checked = True
647 self.assertHTMLEqual(
648 widget.render("test", self.album.cover_art),
649 f'<p class="file-upload">Currently: <a href="{storage_url}albums/'
650 r'hybrid_theory.jpg">albums\hybrid_theory.jpg</a> '
651 '<span class="clearable-file-input">'
652 '<input type="checkbox" name="test-clear" id="test-clear_id" checked>'
653 '<label for="test-clear_id">Clear</label></span><br>'
654 'Change: <input type="file" name="test" checked></p>',
655 )
656
657 def test_readonly_fields(self):
658 """
659 File widgets should render as a link when they're marked "read only."
660 """
661 self.client.force_login(self.superuser)
662 response = self.client.get(
663 reverse("admin:admin_widgets_album_change", args=(self.album.id,))
664 )
665 self.assertContains(
666 response,
667 '<div class="readonly"><a href="%(STORAGE_URL)salbums/hybrid_theory.jpg">'
668 r"albums\hybrid_theory.jpg</a></div>"
669 % {"STORAGE_URL": default_storage.url("")},
670 html=True,
671 )
672 self.assertNotContains(
673 response,
674 '<input type="file" name="cover_art" id="id_cover_art">',
675 html=True,
676 )
677 response = self.client.get(reverse("admin:admin_widgets_album_add"))
678 self.assertContains(
679 response,
680 '<div class="readonly">-</div>',
681 html=True,
682 )
683
684
685 @override_settings(ROOT_URLCONF="admin_widgets.urls")
686 class ForeignKeyRawIdWidgetTest(TestCase):
687 def test_render(self):
688 band = Band.objects.create(name="Linkin Park")
689 band.album_set.create(
690 name="Hybrid Theory", cover_art=r"albums\hybrid_theory.jpg"
691 )
692 rel_uuid = Album._meta.get_field("band").remote_field
693 w = widgets.ForeignKeyRawIdWidget(rel_uuid, widget_admin_site)
694 self.assertHTMLEqual(
695 w.render("test", band.uuid, attrs={}),
696 '<div><input type="text" name="test" value="%(banduuid)s" '
697 'class="vForeignKeyRawIdAdminField vUUIDField">'
698 '<a href="/admin_widgets/band/?_to_field=uuid" class="related-lookup" '
699 'id="lookup_id_test" title="Lookup"></a>&nbsp;<strong>'
700 '<a href="/admin_widgets/band/%(bandpk)s/change/">Linkin Park</a>'
701 "</strong></div>" % {"banduuid": band.uuid, "bandpk": band.pk},
702 )
703
704 rel_id = ReleaseEvent._meta.get_field("album").remote_field
705 w = widgets.ForeignKeyRawIdWidget(rel_id, widget_admin_site)
706 self.assertHTMLEqual(
707 w.render("test", None, attrs={}),
708 '<div><input type="text" name="test" class="vForeignKeyRawIdAdminField">'
709 '<a href="/admin_widgets/album/?_to_field=id" class="related-lookup" '
710 'id="lookup_id_test" title="Lookup"></a></div>',
711 )
712
713 def test_relations_to_non_primary_key(self):
714 # ForeignKeyRawIdWidget works with fields which aren't related to
715 # the model's primary key.
716 apple = Inventory.objects.create(barcode=86, name="Apple")
717 Inventory.objects.create(barcode=22, name="Pear")
718 core = Inventory.objects.create(barcode=87, name="Core", parent=apple)
719 rel = Inventory._meta.get_field("parent").remote_field
720 w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
721 self.assertHTMLEqual(
722 w.render("test", core.parent_id, attrs={}),
723 '<div><input type="text" name="test" value="86" '
724 'class="vForeignKeyRawIdAdminField">'
725 '<a href="/admin_widgets/inventory/?_to_field=barcode" '
726 'class="related-lookup" id="lookup_id_test" title="Lookup"></a>'
727 '&nbsp;<strong><a href="/admin_widgets/inventory/%(pk)s/change/">'
728 "Apple</a></strong></div>" % {"pk": apple.pk},
729 )
730
731 def test_fk_related_model_not_in_admin(self):
732 # FK to a model not registered with admin site. Raw ID widget should
733 # have no magnifying glass link. See #16542
734 big_honeycomb = Honeycomb.objects.create(location="Old tree")
735 big_honeycomb.bee_set.create()
736 rel = Bee._meta.get_field("honeycomb").remote_field
737
738 w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
739 self.assertHTMLEqual(
740 w.render("honeycomb_widget", big_honeycomb.pk, attrs={}),
741 '<input type="text" name="honeycomb_widget" value="%(hcombpk)s">'
742 "&nbsp;<strong>%(hcomb)s</strong>"
743 % {"hcombpk": big_honeycomb.pk, "hcomb": big_honeycomb},
744 )
745
746 def test_fk_to_self_model_not_in_admin(self):
747 # FK to self, not registered with admin site. Raw ID widget should have
748 # no magnifying glass link. See #16542
749 subject1 = Individual.objects.create(name="Subject #1")
750 Individual.objects.create(name="Child", parent=subject1)
751 rel = Individual._meta.get_field("parent").remote_field
752
753 w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
754 self.assertHTMLEqual(
755 w.render("individual_widget", subject1.pk, attrs={}),
756 '<input type="text" name="individual_widget" value="%(subj1pk)s">'
757 "&nbsp;<strong>%(subj1)s</strong>"
758 % {"subj1pk": subject1.pk, "subj1": subject1},
759 )
760
761 def test_proper_manager_for_label_lookup(self):
762 # see #9258
763 rel = Inventory._meta.get_field("parent").remote_field
764 w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
765
766 hidden = Inventory.objects.create(barcode=93, name="Hidden", hidden=True)
767 child_of_hidden = Inventory.objects.create(
768 barcode=94, name="Child of hidden", parent=hidden
769 )
770 self.assertHTMLEqual(
771 w.render("test", child_of_hidden.parent_id, attrs={}),
772 '<div><input type="text" name="test" value="93" '
773 ' class="vForeignKeyRawIdAdminField">'
774 '<a href="/admin_widgets/inventory/?_to_field=barcode" '
775 'class="related-lookup" id="lookup_id_test" title="Lookup"></a>'
776 '&nbsp;<strong><a href="/admin_widgets/inventory/%(pk)s/change/">'
777 "Hidden</a></strong></div>" % {"pk": hidden.pk},
778 )
779
780 def test_render_unsafe_limit_choices_to(self):
781 rel = UnsafeLimitChoicesTo._meta.get_field("band").remote_field
782 w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
783 self.assertHTMLEqual(
784 w.render("test", None),
785 '<div><input type="text" name="test" class="vForeignKeyRawIdAdminField">'
786 '<a href="/admin_widgets/band/?name=%22%26%3E%3Cescapeme&amp;'
787 '_to_field=artist_ptr" class="related-lookup" id="lookup_id_test" '
788 'title="Lookup"></a></div>',
789 )
790
791 def test_render_fk_as_pk_model(self):
792 rel = VideoStream._meta.get_field("release_event").remote_field
793 w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
794 self.assertHTMLEqual(
795 w.render("test", None),
796 '<div><input type="text" name="test" class="vForeignKeyRawIdAdminField">'
797 '<a href="/admin_widgets/releaseevent/?_to_field=album" '
798 'class="related-lookup" id="lookup_id_test" title="Lookup"></a></div>',
799 )
800
801
802 @override_settings(ROOT_URLCONF="admin_widgets.urls")
803 class ManyToManyRawIdWidgetTest(TestCase):
804 def test_render(self):
805 band = Band.objects.create(name="Linkin Park")
806
807 m1 = Member.objects.create(name="Chester")
808 m2 = Member.objects.create(name="Mike")
809 band.members.add(m1, m2)
810 rel = Band._meta.get_field("members").remote_field
811
812 w = widgets.ManyToManyRawIdWidget(rel, widget_admin_site)
813 self.assertHTMLEqual(
814 w.render("test", [m1.pk, m2.pk], attrs={}),
815 (
816 '<div><input type="text" name="test" value="%(m1pk)s,%(m2pk)s" '
817 ' class="vManyToManyRawIdAdminField">'
818 '<a href="/admin_widgets/member/" class="related-lookup" '
819 ' id="lookup_id_test" title="Lookup"></a></div>'
820 )
821 % {"m1pk": m1.pk, "m2pk": m2.pk},
822 )
823
824 self.assertHTMLEqual(
825 w.render("test", [m1.pk]),
826 (
827 '<div><input type="text" name="test" value="%(m1pk)s" '
828 ' class="vManyToManyRawIdAdminField">'
829 '<a href="/admin_widgets/member/" class="related-lookup" '
830 ' id="lookup_id_test" title="Lookup"></a></div>'
831 )
832 % {"m1pk": m1.pk},
833 )
834
835 def test_m2m_related_model_not_in_admin(self):
836 # M2M relationship with model not registered with admin site. Raw ID
837 # widget should have no magnifying glass link. See #16542
838 consultor1 = Advisor.objects.create(name="Rockstar Techie")
839
840 c1 = Company.objects.create(name="Doodle")
841 c2 = Company.objects.create(name="Pear")
842 consultor1.companies.add(c1, c2)
843 rel = Advisor._meta.get_field("companies").remote_field
844
845 w = widgets.ManyToManyRawIdWidget(rel, widget_admin_site)
846 self.assertHTMLEqual(
847 w.render("company_widget1", [c1.pk, c2.pk], attrs={}),
848 '<input type="text" name="company_widget1" value="%(c1pk)s,%(c2pk)s">'
849 % {"c1pk": c1.pk, "c2pk": c2.pk},
850 )
851
852 self.assertHTMLEqual(
853 w.render("company_widget2", [c1.pk]),
854 '<input type="text" name="company_widget2" value="%(c1pk)s">'
855 % {"c1pk": c1.pk},
856 )
857
858
859 @override_settings(ROOT_URLCONF="admin_widgets.urls")
860 class RelatedFieldWidgetWrapperTests(SimpleTestCase):
861 def test_no_can_add_related(self):
862 rel = Individual._meta.get_field("parent").remote_field
863 w = widgets.AdminRadioSelect()
864 # Used to fail with a name error.
865 w = widgets.RelatedFieldWidgetWrapper(w, rel, widget_admin_site)
866 self.assertFalse(w.can_add_related)
867
868 def test_select_multiple_widget_cant_change_delete_related(self):
869 rel = Individual._meta.get_field("parent").remote_field
870 widget = forms.SelectMultiple()
871 wrapper = widgets.RelatedFieldWidgetWrapper(
872 widget,
873 rel,
874 widget_admin_site,
875 can_add_related=True,
876 can_change_related=True,
877 can_delete_related=True,
878 )
879 self.assertTrue(wrapper.can_add_related)
880 self.assertFalse(wrapper.can_change_related)
881 self.assertFalse(wrapper.can_delete_related)
882
883 def test_on_delete_cascade_rel_cant_delete_related(self):
884 rel = Individual._meta.get_field("soulmate").remote_field
885 widget = forms.Select()
886 wrapper = widgets.RelatedFieldWidgetWrapper(
887 widget,
888 rel,
889 widget_admin_site,
890 can_add_related=True,
891 can_change_related=True,
892 can_delete_related=True,
893 )
894 self.assertTrue(wrapper.can_add_related)
895 self.assertTrue(wrapper.can_change_related)
896 self.assertFalse(wrapper.can_delete_related)
897
898 def test_custom_widget_render(self):
899 class CustomWidget(forms.Select):
900 def render(self, *args, **kwargs):
901 return "custom render output"
902
903 rel = Album._meta.get_field("band").remote_field
904 widget = CustomWidget()
905 wrapper = widgets.RelatedFieldWidgetWrapper(
906 widget,
907 rel,
908 widget_admin_site,
909 can_add_related=True,
910 can_change_related=True,
911 can_delete_related=True,
912 )
913 output = wrapper.render("name", "value")
914 self.assertIn("custom render output", output)
915
916 def test_widget_delegates_value_omitted_from_data(self):
917 class CustomWidget(forms.Select):
918 def value_omitted_from_data(self, data, files, name):
919 return False
920
921 rel = Album._meta.get_field("band").remote_field
922 widget = CustomWidget()
923 wrapper = widgets.RelatedFieldWidgetWrapper(widget, rel, widget_admin_site)
924 self.assertIs(wrapper.value_omitted_from_data({}, {}, "band"), False)
925
926 def test_widget_is_hidden(self):
927 rel = Album._meta.get_field("band").remote_field
928 widget = forms.HiddenInput()
929 widget.choices = ()
930 wrapper = widgets.RelatedFieldWidgetWrapper(widget, rel, widget_admin_site)
931 self.assertIs(wrapper.is_hidden, True)
932 context = wrapper.get_context("band", None, {})
933 self.assertIs(context["is_hidden"], True)
934 output = wrapper.render("name", "value")
935 # Related item links are hidden.
936 self.assertNotIn("<a ", output)
937
938 def test_widget_is_not_hidden(self):
939 rel = Album._meta.get_field("band").remote_field
940 widget = forms.Select()
941 wrapper = widgets.RelatedFieldWidgetWrapper(widget, rel, widget_admin_site)
942 self.assertIs(wrapper.is_hidden, False)
943 context = wrapper.get_context("band", None, {})
944 self.assertIs(context["is_hidden"], False)
945 output = wrapper.render("name", "value")
946 # Related item links are present.
947 self.assertIn("<a ", output)
948
949 def test_data_model_ref_when_model_name_is_camel_case(self):
950 rel = VideoStream._meta.get_field("release_event").remote_field
951 widget = forms.Select()
952 wrapper = widgets.RelatedFieldWidgetWrapper(widget, rel, widget_admin_site)
953 self.assertIs(wrapper.is_hidden, False)
954 context = wrapper.get_context("release_event", None, {})
955 self.assertEqual(context["model"], "release event")
956 self.assertEqual(context["model_name"], "releaseevent")
957 output = wrapper.render("stream", "value")
958 expected = """
959 <div class="related-widget-wrapper" data-model-ref="releaseevent">
960 <select name="stream" data-context="available-source">
961 </select>
962 <a class="related-widget-wrapper-link add-related" id="add_id_stream"
963 data-popup="yes" title="Add another release event"
964 href="/admin_widgets/releaseevent/add/?_to_field=album&amp;_popup=1">
965 <img src="/static/admin/img/icon-addlink.svg" alt="" width="24" height="24">
966 </a>
967 </div>
968 """
969 self.assertHTMLEqual(output, expected)
970
971
972 @override_settings(ROOT_URLCONF="admin_widgets.urls")
973 class AdminWidgetSeleniumTestCase(AdminSeleniumTestCase):
974 available_apps = ["admin_widgets"] + AdminSeleniumTestCase.available_apps
975
976 def setUp(self):
977 self.u1 = User.objects.create_superuser(
978 username="super", password="secret", email="[email protected]"
979 )
980
981
982 class DateTimePickerSeleniumTests(AdminWidgetSeleniumTestCase):
983 def test_show_hide_date_time_picker_widgets(self):
984 """
985 Pressing the ESC key or clicking on a widget value closes the date and
986 time picker widgets.
987 """
988 from selenium.webdriver.common.by import By
989 from selenium.webdriver.common.keys import Keys
990
991 self.admin_login(username="super", password="secret", login_url="/")
992 # Open a page that has a date and time picker widgets
993 self.selenium.get(
994 self.live_server_url + reverse("admin:admin_widgets_member_add")
995 )
996
997 # First, with the date picker widget ---------------------------------
998 cal_icon = self.selenium.find_element(By.ID, "calendarlink0")
999 # The date picker is hidden
1000 self.assertFalse(
1001 self.selenium.find_element(By.ID, "calendarbox0").is_displayed()
1002 )
1003 # Click the calendar icon
1004 cal_icon.click()
1005 # The date picker is visible
1006 self.assertTrue(
1007 self.selenium.find_element(By.ID, "calendarbox0").is_displayed()
1008 )
1009 # Press the ESC key
1010 self.selenium.find_element(By.TAG_NAME, "body").send_keys([Keys.ESCAPE])
1011 # The date picker is hidden again
1012 self.assertFalse(
1013 self.selenium.find_element(By.ID, "calendarbox0").is_displayed()
1014 )
1015 # Click the calendar icon, then on the 15th of current month
1016 cal_icon.click()
1017 self.selenium.find_element(By.XPATH, "//a[contains(text(), '15')]").click()
1018 self.assertFalse(
1019 self.selenium.find_element(By.ID, "calendarbox0").is_displayed()
1020 )
1021 self.assertEqual(
1022 self.selenium.find_element(By.ID, "id_birthdate_0").get_attribute("value"),
1023 datetime.today().strftime("%Y-%m-") + "15",
1024 )
1025
1026 # Then, with the time picker widget ----------------------------------
1027 time_icon = self.selenium.find_element(By.ID, "clocklink0")
1028 # The time picker is hidden
1029 self.assertFalse(self.selenium.find_element(By.ID, "clockbox0").is_displayed())
1030 # Click the time icon
1031 time_icon.click()
1032 # The time picker is visible
1033 self.assertTrue(self.selenium.find_element(By.ID, "clockbox0").is_displayed())
1034 self.assertEqual(
1035 [
1036 x.text
1037 for x in self.selenium.find_elements(
1038 By.XPATH, "//ul[@class='timelist']/li/a"
1039 )
1040 ],
1041 ["Now", "Midnight", "6 a.m.", "Noon", "6 p.m."],
1042 )
1043 # Press the ESC key
1044 self.selenium.find_element(By.TAG_NAME, "body").send_keys([Keys.ESCAPE])
1045 # The time picker is hidden again
1046 self.assertFalse(self.selenium.find_element(By.ID, "clockbox0").is_displayed())
1047 # Click the time icon, then select the 'Noon' value
1048 time_icon.click()
1049 self.selenium.find_element(By.XPATH, "//a[contains(text(), 'Noon')]").click()
1050 self.assertFalse(self.selenium.find_element(By.ID, "clockbox0").is_displayed())
1051 self.assertEqual(
1052 self.selenium.find_element(By.ID, "id_birthdate_1").get_attribute("value"),
1053 "12:00:00",
1054 )
1055
1056 def test_calendar_nonday_class(self):
1057 """
1058 Ensure cells that are not days of the month have the `nonday` CSS class.
1059 Refs #4574.
1060 """
1061 from selenium.webdriver.common.by import By
1062
1063 self.admin_login(username="super", password="secret", login_url="/")
1064 # Open a page that has a date and time picker widgets
1065 self.selenium.get(
1066 self.live_server_url + reverse("admin:admin_widgets_member_add")
1067 )
1068
1069 # fill in the birth date.
1070 self.selenium.find_element(By.ID, "id_birthdate_0").send_keys("2013-06-01")
1071
1072 # Click the calendar icon
1073 self.selenium.find_element(By.ID, "calendarlink0").click()
1074
1075 # get all the tds within the calendar
1076 calendar0 = self.selenium.find_element(By.ID, "calendarin0")
1077 tds = calendar0.find_elements(By.TAG_NAME, "td")
1078
1079 # make sure the first and last 6 cells have class nonday
1080 for td in tds[:6] + tds[-6:]:
1081 self.assertEqual(td.get_attribute("class"), "nonday")
1082
1083 def test_calendar_selected_class(self):
1084 """
1085 Ensure cell for the day in the input has the `selected` CSS class.
1086 Refs #4574.
1087 """
1088 from selenium.webdriver.common.by import By
1089
1090 self.admin_login(username="super", password="secret", login_url="/")
1091 # Open a page that has a date and time picker widgets
1092 self.selenium.get(
1093 self.live_server_url + reverse("admin:admin_widgets_member_add")
1094 )
1095
1096 # fill in the birth date.
1097 self.selenium.find_element(By.ID, "id_birthdate_0").send_keys("2013-06-01")
1098
1099 # Click the calendar icon
1100 self.selenium.find_element(By.ID, "calendarlink0").click()
1101
1102 # get all the tds within the calendar
1103 calendar0 = self.selenium.find_element(By.ID, "calendarin0")
1104 tds = calendar0.find_elements(By.TAG_NAME, "td")
1105
1106 # verify the selected cell
1107 selected = tds[6]
1108 self.assertEqual(selected.get_attribute("class"), "selected")
1109
1110 self.assertEqual(selected.text, "1")
1111
1112 def test_calendar_no_selected_class(self):
1113 """
1114 Ensure no cells are given the selected class when the field is empty.
1115 Refs #4574.
1116 """
1117 from selenium.webdriver.common.by import By
1118
1119 self.admin_login(username="super", password="secret", login_url="/")
1120 # Open a page that has a date and time picker widgets
1121 self.selenium.get(
1122 self.live_server_url + reverse("admin:admin_widgets_member_add")
1123 )
1124
1125 # Click the calendar icon
1126 self.selenium.find_element(By.ID, "calendarlink0").click()
1127
1128 # get all the tds within the calendar
1129 calendar0 = self.selenium.find_element(By.ID, "calendarin0")
1130 tds = calendar0.find_elements(By.TAG_NAME, "td")
1131
1132 # verify there are no cells with the selected class
1133 selected = [td for td in tds if td.get_attribute("class") == "selected"]
1134
1135 self.assertEqual(len(selected), 0)
1136
1137 def test_calendar_show_date_from_input(self):
1138 """
1139 The calendar shows the date from the input field for every locale
1140 supported by Django.
1141 """
1142 from selenium.webdriver.common.by import By
1143
1144 self.admin_login(username="super", password="secret", login_url="/")
1145
1146 # Enter test data
1147 member = Member.objects.create(
1148 name="Bob", birthdate=datetime(1984, 5, 15), gender="M"
1149 )
1150
1151 # Get month name translations for every locale
1152 month_string = "May"
1153 path = os.path.join(
1154 os.path.dirname(import_module("django.contrib.admin").__file__), "locale"
1155 )
1156 url = reverse("admin:admin_widgets_member_change", args=(member.pk,))
1157 with self.small_screen_size():
1158 for language_code, language_name in settings.LANGUAGES:
1159 try:
1160 catalog = gettext.translation("djangojs", path, [language_code])
1161 except OSError:
1162 continue
1163 if month_string in catalog._catalog:
1164 month_name = catalog._catalog[month_string]
1165 else:
1166 month_name = month_string
1167
1168 # Get the expected caption.
1169 may_translation = month_name
1170 expected_caption = "{:s} {:d}".format(may_translation.upper(), 1984)
1171
1172 # Every locale.
1173 with override_settings(LANGUAGE_CODE=language_code):
1174 # Open a page that has a date picker widget.
1175 self.selenium.get(self.live_server_url + url)
1176 # Click on the calendar icon.
1177 self.selenium.find_element(By.ID, "calendarlink0").click()
1178 # The right month and year are displayed.
1179 self.wait_for_text("#calendarin0 caption", expected_caption)
1180
1181
1182 @requires_tz_support
1183 @override_settings(TIME_ZONE="Asia/Singapore")
1184 class DateTimePickerShortcutsSeleniumTests(AdminWidgetSeleniumTestCase):
1185 def test_date_time_picker_shortcuts(self):
1186 """
1187 date/time/datetime picker shortcuts work in the current time zone.
1188 Refs #20663.
1189
1190 This test case is fairly tricky, it relies on selenium still running the browser
1191 in the default time zone "America/Chicago" despite `override_settings` changing
1192 the time zone to "Asia/Singapore".
1193 """
1194 from selenium.webdriver.common.by import By
1195
1196 self.admin_login(username="super", password="secret", login_url="/")
1197
1198 error_margin = timedelta(seconds=10)
1199
1200 # If we are neighbouring a DST, we add an hour of error margin.
1201 tz = zoneinfo.ZoneInfo("America/Chicago")
1202 utc_now = datetime.now(zoneinfo.ZoneInfo("UTC"))
1203 tz_yesterday = (utc_now - timedelta(days=1)).astimezone(tz).tzname()
1204 tz_tomorrow = (utc_now + timedelta(days=1)).astimezone(tz).tzname()
1205 if tz_yesterday != tz_tomorrow:
1206 error_margin += timedelta(hours=1)
1207
1208 self.selenium.get(
1209 self.live_server_url + reverse("admin:admin_widgets_member_add")
1210 )
1211
1212 self.selenium.find_element(By.ID, "id_name").send_keys("test")
1213
1214 # Click on the "today" and "now" shortcuts.
1215 shortcuts = self.selenium.find_elements(
1216 By.CSS_SELECTOR, ".field-birthdate .datetimeshortcuts"
1217 )
1218
1219 now = datetime.now()
1220 for shortcut in shortcuts:
1221 shortcut.find_element(By.TAG_NAME, "a").click()
1222
1223 # There is a time zone mismatch warning.
1224 # Warning: This would effectively fail if the TIME_ZONE defined in the
1225 # settings has the same UTC offset as "Asia/Singapore" because the
1226 # mismatch warning would be rightfully missing from the page.
1227 self.assertCountSeleniumElements(".field-birthdate .timezonewarning", 1)
1228
1229 # Submit the form.
1230 with self.wait_page_loaded():
1231 self.selenium.find_element(By.NAME, "_save").click()
1232
1233 # Make sure that "now" in JavaScript is within 10 seconds
1234 # from "now" on the server side.
1235 member = Member.objects.get(name="test")
1236 self.assertGreater(member.birthdate, now - error_margin)
1237 self.assertLess(member.birthdate, now + error_margin)
1238
1239
1240 # The above tests run with Asia/Singapore which are on the positive side of
1241 # UTC. Here we test with a timezone on the negative side.
1242 @override_settings(TIME_ZONE="US/Eastern")
1243 class DateTimePickerAltTimezoneSeleniumTests(DateTimePickerShortcutsSeleniumTests):
1244 pass
1245
1246
1247 class HorizontalVerticalFilterSeleniumTests(AdminWidgetSeleniumTestCase):
1248 def setUp(self):
1249 super().setUp()
1250 self.lisa = Student.objects.create(name="Lisa")
1251 self.john = Student.objects.create(name="John")
1252 self.bob = Student.objects.create(name="Bob")
1253 self.peter = Student.objects.create(name="Peter")
1254 self.jenny = Student.objects.create(name="Jenny")
1255 self.jason = Student.objects.create(name="Jason")
1256 self.cliff = Student.objects.create(name="Cliff")
1257 self.arthur = Student.objects.create(name="Arthur")
1258 self.school = School.objects.create(name="School of Awesome")
1259
1260 def assertButtonsDisabled(
1261 self,
1262 mode,
1263 field_name,
1264 choose_btn_disabled=False,
1265 remove_btn_disabled=False,
1266 choose_all_btn_disabled=False,
1267 remove_all_btn_disabled=False,
1268 ):
1269 choose_button = "#id_%s_add" % field_name
1270 choose_all_button = "#id_%s_add_all" % field_name
1271 remove_button = "#id_%s_remove" % field_name
1272 remove_all_button = "#id_%s_remove_all" % field_name
1273 self.assertEqual(self.is_disabled(choose_button), choose_btn_disabled)
1274 self.assertEqual(self.is_disabled(remove_button), remove_btn_disabled)
1275 if mode == "horizontal":
1276 self.assertEqual(
1277 self.is_disabled(choose_all_button), choose_all_btn_disabled
1278 )
1279 self.assertEqual(
1280 self.is_disabled(remove_all_button), remove_all_btn_disabled
1281 )
1282
1283 def execute_basic_operations(self, mode, field_name):
1284 from selenium.webdriver.common.by import By
1285
1286 original_url = self.selenium.current_url
1287
1288 from_box = "#id_%s_from" % field_name
1289 to_box = "#id_%s_to" % field_name
1290 choose_button = "id_%s_add" % field_name
1291 choose_all_button = "id_%s_add_all" % field_name
1292 remove_button = "id_%s_remove" % field_name
1293 remove_all_button = "id_%s_remove_all" % field_name
1294
1295 # Initial positions ---------------------------------------------------
1296 self.assertSelectOptions(
1297 from_box,
1298 [
1299 str(self.arthur.id),
1300 str(self.bob.id),
1301 str(self.cliff.id),
1302 str(self.jason.id),
1303 str(self.jenny.id),
1304 str(self.john.id),
1305 ],
1306 )
1307 self.assertSelectOptions(to_box, [str(self.lisa.id), str(self.peter.id)])
1308 self.assertButtonsDisabled(
1309 mode,
1310 field_name,
1311 choose_btn_disabled=True,
1312 remove_btn_disabled=True,
1313 choose_all_btn_disabled=False,
1314 remove_all_btn_disabled=False,
1315 )
1316
1317 # Click 'Choose all' --------------------------------------------------
1318 if mode == "horizontal":
1319 self.selenium.find_element(By.ID, choose_all_button).click()
1320 elif mode == "vertical":
1321 # There 's no 'Choose all' button in vertical mode, so individually
1322 # select all options and click 'Choose'.
1323 for option in self.selenium.find_elements(
1324 By.CSS_SELECTOR, from_box + " > option"
1325 ):
1326 option.click()
1327 self.selenium.find_element(By.ID, choose_button).click()
1328 self.assertSelectOptions(from_box, [])
1329 self.assertSelectOptions(
1330 to_box,
1331 [
1332 str(self.lisa.id),
1333 str(self.peter.id),
1334 str(self.arthur.id),
1335 str(self.bob.id),
1336 str(self.cliff.id),
1337 str(self.jason.id),
1338 str(self.jenny.id),
1339 str(self.john.id),
1340 ],
1341 )
1342 self.assertButtonsDisabled(
1343 mode,
1344 field_name,
1345 choose_btn_disabled=True,
1346 remove_btn_disabled=True,
1347 choose_all_btn_disabled=True,
1348 remove_all_btn_disabled=False,
1349 )
1350
1351 # Click 'Remove all' --------------------------------------------------
1352 if mode == "horizontal":
1353 self.selenium.find_element(By.ID, remove_all_button).click()
1354 elif mode == "vertical":
1355 # There 's no 'Remove all' button in vertical mode, so individually
1356 # select all options and click 'Remove'.
1357 for option in self.selenium.find_elements(
1358 By.CSS_SELECTOR, to_box + " > option"
1359 ):
1360 option.click()
1361 self.selenium.find_element(By.ID, remove_button).click()
1362 self.assertSelectOptions(
1363 from_box,
1364 [
1365 str(self.lisa.id),
1366 str(self.peter.id),
1367 str(self.arthur.id),
1368 str(self.bob.id),
1369 str(self.cliff.id),
1370 str(self.jason.id),
1371 str(self.jenny.id),
1372 str(self.john.id),
1373 ],
1374 )
1375 self.assertSelectOptions(to_box, [])
1376 self.assertButtonsDisabled(
1377 mode,
1378 field_name,
1379 choose_btn_disabled=True,
1380 remove_btn_disabled=True,
1381 choose_all_btn_disabled=False,
1382 remove_all_btn_disabled=True,
1383 )
1384
1385 # Choose some options ------------------------------------------------
1386 from_lisa_select_option = self.selenium.find_element(
1387 By.CSS_SELECTOR, '{} > option[value="{}"]'.format(from_box, self.lisa.id)
1388 )
1389
1390 # Check the title attribute is there for tool tips: ticket #20821
1391 self.assertEqual(
1392 from_lisa_select_option.get_attribute("title"),
1393 from_lisa_select_option.get_attribute("text"),
1394 )
1395
1396 self.select_option(from_box, str(self.lisa.id))
1397 self.select_option(from_box, str(self.jason.id))
1398 self.select_option(from_box, str(self.bob.id))
1399 self.select_option(from_box, str(self.john.id))
1400 self.assertButtonsDisabled(
1401 mode,
1402 field_name,
1403 choose_btn_disabled=False,
1404 remove_btn_disabled=True,
1405 choose_all_btn_disabled=False,
1406 remove_all_btn_disabled=True,
1407 )
1408 self.selenium.find_element(By.ID, choose_button).click()
1409 self.assertButtonsDisabled(
1410 mode,
1411 field_name,
1412 choose_btn_disabled=True,
1413 remove_btn_disabled=True,
1414 choose_all_btn_disabled=False,
1415 remove_all_btn_disabled=False,
1416 )
1417
1418 self.assertSelectOptions(
1419 from_box,
1420 [
1421 str(self.peter.id),
1422 str(self.arthur.id),
1423 str(self.cliff.id),
1424 str(self.jenny.id),
1425 ],
1426 )
1427 self.assertSelectOptions(
1428 to_box,
1429 [
1430 str(self.lisa.id),
1431 str(self.bob.id),
1432 str(self.jason.id),
1433 str(self.john.id),
1434 ],
1435 )
1436
1437 # Check the tooltip is still there after moving: ticket #20821
1438 to_lisa_select_option = self.selenium.find_element(
1439 By.CSS_SELECTOR, '{} > option[value="{}"]'.format(to_box, self.lisa.id)
1440 )
1441 self.assertEqual(
1442 to_lisa_select_option.get_attribute("title"),
1443 to_lisa_select_option.get_attribute("text"),
1444 )
1445
1446 # Remove some options -------------------------------------------------
1447 self.select_option(to_box, str(self.lisa.id))
1448 self.select_option(to_box, str(self.bob.id))
1449 self.assertButtonsDisabled(
1450 mode,
1451 field_name,
1452 choose_btn_disabled=True,
1453 remove_btn_disabled=False,
1454 choose_all_btn_disabled=False,
1455 remove_all_btn_disabled=False,
1456 )
1457 self.selenium.find_element(By.ID, remove_button).click()
1458 self.assertButtonsDisabled(
1459 mode,
1460 field_name,
1461 choose_btn_disabled=True,
1462 remove_btn_disabled=True,
1463 choose_all_btn_disabled=False,
1464 remove_all_btn_disabled=False,
1465 )
1466
1467 self.assertSelectOptions(
1468 from_box,
1469 [
1470 str(self.peter.id),
1471 str(self.arthur.id),
1472 str(self.cliff.id),
1473 str(self.jenny.id),
1474 str(self.lisa.id),
1475 str(self.bob.id),
1476 ],
1477 )
1478 self.assertSelectOptions(to_box, [str(self.jason.id), str(self.john.id)])
1479
1480 # Choose some more options --------------------------------------------
1481 self.select_option(from_box, str(self.arthur.id))
1482 self.select_option(from_box, str(self.cliff.id))
1483 self.selenium.find_element(By.ID, choose_button).click()
1484
1485 self.assertSelectOptions(
1486 from_box,
1487 [
1488 str(self.peter.id),
1489 str(self.jenny.id),
1490 str(self.lisa.id),
1491 str(self.bob.id),
1492 ],
1493 )
1494 self.assertSelectOptions(
1495 to_box,
1496 [
1497 str(self.jason.id),
1498 str(self.john.id),
1499 str(self.arthur.id),
1500 str(self.cliff.id),
1501 ],
1502 )
1503
1504 # Choose some more options --------------------------------------------
1505 self.select_option(from_box, str(self.peter.id))
1506 self.select_option(from_box, str(self.lisa.id))
1507
1508 # Confirm they're selected after clicking inactive buttons: ticket #26575
1509 self.assertSelectedOptions(from_box, [str(self.peter.id), str(self.lisa.id)])
1510 self.selenium.find_element(By.ID, remove_button).click()
1511 self.assertSelectedOptions(from_box, [str(self.peter.id), str(self.lisa.id)])
1512
1513 # Unselect the options ------------------------------------------------
1514 self.deselect_option(from_box, str(self.peter.id))
1515 self.deselect_option(from_box, str(self.lisa.id))
1516
1517 # Choose some more options --------------------------------------------
1518 self.select_option(to_box, str(self.jason.id))
1519 self.select_option(to_box, str(self.john.id))
1520
1521 # Confirm they're selected after clicking inactive buttons: ticket #26575
1522 self.assertSelectedOptions(to_box, [str(self.jason.id), str(self.john.id)])
1523 self.selenium.find_element(By.ID, choose_button).click()
1524 self.assertSelectedOptions(to_box, [str(self.jason.id), str(self.john.id)])
1525
1526 # Unselect the options ------------------------------------------------
1527 self.deselect_option(to_box, str(self.jason.id))
1528 self.deselect_option(to_box, str(self.john.id))
1529
1530 # Pressing buttons shouldn't change the URL.
1531 self.assertEqual(self.selenium.current_url, original_url)
1532
1533 def test_basic(self):
1534 from selenium.webdriver.common.by import By
1535
1536 self.school.students.set([self.lisa, self.peter])
1537 self.school.alumni.set([self.lisa, self.peter])
1538
1539 with self.small_screen_size():
1540 self.admin_login(username="super", password="secret", login_url="/")
1541 self.selenium.get(
1542 self.live_server_url
1543 + reverse("admin:admin_widgets_school_change", args=(self.school.id,))
1544 )
1545
1546 self.wait_page_ready()
1547 self.execute_basic_operations("vertical", "students")
1548 self.execute_basic_operations("horizontal", "alumni")
1549
1550 # Save, everything should be stored properly stored in the
1551 # database.
1552 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
1553 self.wait_page_ready()
1554 self.school = School.objects.get(id=self.school.id) # Reload from database
1555 self.assertEqual(
1556 list(self.school.students.all()),
1557 [self.arthur, self.cliff, self.jason, self.john],
1558 )
1559 self.assertEqual(
1560 list(self.school.alumni.all()),
1561 [self.arthur, self.cliff, self.jason, self.john],
1562 )
1563
1564 def test_filter(self):
1565 """
1566 Typing in the search box filters out options displayed in the 'from'
1567 box.
1568 """
1569 from selenium.webdriver.common.by import By
1570 from selenium.webdriver.common.keys import Keys
1571
1572 self.school.students.set([self.lisa, self.peter])
1573 self.school.alumni.set([self.lisa, self.peter])
1574
1575 with self.small_screen_size():
1576 self.admin_login(username="super", password="secret", login_url="/")
1577 self.selenium.get(
1578 self.live_server_url
1579 + reverse("admin:admin_widgets_school_change", args=(self.school.id,))
1580 )
1581
1582 for field_name in ["students", "alumni"]:
1583 from_box = "#id_%s_from" % field_name
1584 to_box = "#id_%s_to" % field_name
1585 choose_link = "id_%s_add" % field_name
1586 remove_link = "id_%s_remove" % field_name
1587 input = self.selenium.find_element(By.ID, "id_%s_input" % field_name)
1588 # Initial values.
1589 self.assertSelectOptions(
1590 from_box,
1591 [
1592 str(self.arthur.id),
1593 str(self.bob.id),
1594 str(self.cliff.id),
1595 str(self.jason.id),
1596 str(self.jenny.id),
1597 str(self.john.id),
1598 ],
1599 )
1600 # Typing in some characters filters out non-matching options.
1601 input.send_keys("a")
1602 self.assertSelectOptions(
1603 from_box, [str(self.arthur.id), str(self.jason.id)]
1604 )
1605 input.send_keys("R")
1606 self.assertSelectOptions(from_box, [str(self.arthur.id)])
1607 # Clearing the text box makes the other options reappear.
1608 input.send_keys([Keys.BACK_SPACE])
1609 self.assertSelectOptions(
1610 from_box, [str(self.arthur.id), str(self.jason.id)]
1611 )
1612 input.send_keys([Keys.BACK_SPACE])
1613 self.assertSelectOptions(
1614 from_box,
1615 [
1616 str(self.arthur.id),
1617 str(self.bob.id),
1618 str(self.cliff.id),
1619 str(self.jason.id),
1620 str(self.jenny.id),
1621 str(self.john.id),
1622 ],
1623 )
1624
1625 # Choosing a filtered option sends it properly to the 'to' box.
1626 input.send_keys("a")
1627 self.assertSelectOptions(
1628 from_box, [str(self.arthur.id), str(self.jason.id)]
1629 )
1630 self.select_option(from_box, str(self.jason.id))
1631 self.selenium.find_element(By.ID, choose_link).click()
1632 self.assertSelectOptions(from_box, [str(self.arthur.id)])
1633 self.assertSelectOptions(
1634 to_box,
1635 [
1636 str(self.lisa.id),
1637 str(self.peter.id),
1638 str(self.jason.id),
1639 ],
1640 )
1641
1642 self.select_option(to_box, str(self.lisa.id))
1643 self.selenium.find_element(By.ID, remove_link).click()
1644 self.assertSelectOptions(
1645 from_box, [str(self.arthur.id), str(self.lisa.id)]
1646 )
1647 self.assertSelectOptions(
1648 to_box, [str(self.peter.id), str(self.jason.id)]
1649 )
1650
1651 input.send_keys([Keys.BACK_SPACE]) # Clear text box
1652 self.assertSelectOptions(
1653 from_box,
1654 [
1655 str(self.arthur.id),
1656 str(self.bob.id),
1657 str(self.cliff.id),
1658 str(self.jenny.id),
1659 str(self.john.id),
1660 str(self.lisa.id),
1661 ],
1662 )
1663 self.assertSelectOptions(
1664 to_box, [str(self.peter.id), str(self.jason.id)]
1665 )
1666
1667 # Pressing enter on a filtered option sends it properly to
1668 # the 'to' box.
1669 self.select_option(to_box, str(self.jason.id))
1670 self.selenium.find_element(By.ID, remove_link).click()
1671 input.send_keys("ja")
1672 self.assertSelectOptions(from_box, [str(self.jason.id)])
1673 input.send_keys([Keys.ENTER])
1674 self.assertSelectOptions(
1675 to_box, [str(self.peter.id), str(self.jason.id)]
1676 )
1677 input.send_keys([Keys.BACK_SPACE, Keys.BACK_SPACE])
1678
1679 # Save, everything should be stored properly in the database.
1680 with self.wait_page_loaded():
1681 self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
1682 self.school = School.objects.get(id=self.school.id) # Reload from database
1683 self.assertEqual(list(self.school.students.all()), [self.jason, self.peter])
1684 self.assertEqual(list(self.school.alumni.all()), [self.jason, self.peter])
1685
1686 def test_back_button_bug(self):
1687 """
1688 Some browsers had a bug where navigating away from the change page
1689 and then clicking the browser's back button would clear the
1690 filter_horizontal/filter_vertical widgets (#13614).
1691 """
1692 from selenium.webdriver.common.by import By
1693
1694 self.school.students.set([self.lisa, self.peter])
1695 self.school.alumni.set([self.lisa, self.peter])
1696 self.admin_login(username="super", password="secret", login_url="/")
1697 change_url = reverse(
1698 "admin:admin_widgets_school_change", args=(self.school.id,)
1699 )
1700 self.selenium.get(self.live_server_url + change_url)
1701 # Navigate away and go back to the change form page.
1702 self.selenium.find_element(By.LINK_TEXT, "Home").click()
1703 self.selenium.back()
1704 expected_unselected_values = [
1705 str(self.arthur.id),
1706 str(self.bob.id),
1707 str(self.cliff.id),
1708 str(self.jason.id),
1709 str(self.jenny.id),
1710 str(self.john.id),
1711 ]
1712 expected_selected_values = [str(self.lisa.id), str(self.peter.id)]
1713 # Everything is still in place
1714 self.assertSelectOptions("#id_students_from", expected_unselected_values)
1715 self.assertSelectOptions("#id_students_to", expected_selected_values)
1716 self.assertSelectOptions("#id_alumni_from", expected_unselected_values)
1717 self.assertSelectOptions("#id_alumni_to", expected_selected_values)
1718
1719 def test_refresh_page(self):
1720 """
1721 Horizontal and vertical filter widgets keep selected options on page
1722 reload (#22955).
1723 """
1724 self.school.students.add(self.arthur, self.jason)
1725 self.school.alumni.add(self.arthur, self.jason)
1726
1727 self.admin_login(username="super", password="secret", login_url="/")
1728 change_url = reverse(
1729 "admin:admin_widgets_school_change", args=(self.school.id,)
1730 )
1731 self.selenium.get(self.live_server_url + change_url)
1732
1733 self.assertCountSeleniumElements("#id_students_to > option", 2)
1734
1735 # self.selenium.refresh() or send_keys(Keys.F5) does hard reload and
1736 # doesn't replicate what happens when a user clicks the browser's
1737 # 'Refresh' button.
1738 with self.wait_page_loaded():
1739 self.selenium.execute_script("location.reload()")
1740
1741 self.assertCountSeleniumElements("#id_students_to > option", 2)
1742
1743 def test_form_submission_via_enter_key_with_filter_horizontal(self):
1744 """
1745 The main form can be submitted correctly by pressing the enter key.
1746 There is no shadowing from other buttons inside the form.
1747 """
1748 from selenium.webdriver.common.by import By
1749 from selenium.webdriver.common.keys import Keys
1750
1751 self.school.students.set([self.peter])
1752 self.school.alumni.set([self.lisa])
1753
1754 self.admin_login(username="super", password="secret", login_url="/")
1755 self.selenium.get(
1756 self.live_server_url
1757 + reverse("admin:admin_widgets_school_change", args=(self.school.id,))
1758 )
1759
1760 self.wait_page_ready()
1761 self.select_option("#id_students_from", str(self.lisa.id))
1762 self.selenium.find_element(By.ID, "id_students_add").click()
1763 self.select_option("#id_alumni_from", str(self.peter.id))
1764 self.selenium.find_element(By.ID, "id_alumni_add").click()
1765
1766 # Trigger form submission via Enter key on a text input field.
1767 name_input = self.selenium.find_element(By.ID, "id_name")
1768 name_input.click()
1769 name_input.send_keys(Keys.ENTER)
1770
1771 # Form was submitted, success message should be shown.
1772 self.wait_for_text(
1773 "li.success", "The school “School of Awesome” was changed successfully."
1774 )
1775
1776 # Changes should be stored properly in the database.
1777 school = School.objects.get(id=self.school.id)
1778 self.assertSequenceEqual(
1779 school.students.all().order_by("name"), [self.lisa, self.peter]
1780 )
1781 self.assertSequenceEqual(
1782 school.alumni.all().order_by("name"), [self.lisa, self.peter]
1783 )
1784
1785
1786 @ignore_warnings(category=RemovedInDjango60Warning)
1787 class AdminRawIdWidgetSeleniumTests(AdminWidgetSeleniumTestCase):
1788 def setUp(self):
1789 super().setUp()
1790 Band.objects.create(id=42, name="Bogey Blues")
1791 Band.objects.create(id=98, name="Green Potatoes")
1792
1793 @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
1794 def test_ForeignKey(self):
1795 from selenium.webdriver.common.by import By
1796
1797 self.admin_login(username="super", password="secret", login_url="/")
1798 self.selenium.get(
1799 self.live_server_url + reverse("admin:admin_widgets_event_add")
1800 )
1801 main_window = self.selenium.current_window_handle
1802 self.take_screenshot("raw_id_widget")
1803
1804 # No value has been selected yet
1805 self.assertEqual(
1806 self.selenium.find_element(By.ID, "id_main_band").get_attribute("value"), ""
1807 )
1808
1809 # Open the popup window and click on a band
1810 self.selenium.find_element(By.ID, "lookup_id_main_band").click()
1811 self.wait_for_and_switch_to_popup()
1812 link = self.selenium.find_element(By.LINK_TEXT, "Bogey Blues")
1813 self.assertIn("/band/42/", link.get_attribute("href"))
1814 link.click()
1815
1816 # The field now contains the selected band's id
1817 self.selenium.switch_to.window(main_window)
1818 self.wait_for_value("#id_main_band", "42")
1819
1820 # Reopen the popup window and click on another band
1821 self.selenium.find_element(By.ID, "lookup_id_main_band").click()
1822 self.wait_for_and_switch_to_popup()
1823 link = self.selenium.find_element(By.LINK_TEXT, "Green Potatoes")
1824 self.assertIn("/band/98/", link.get_attribute("href"))
1825 link.click()
1826
1827 # The field now contains the other selected band's id
1828 self.selenium.switch_to.window(main_window)
1829 self.wait_for_value("#id_main_band", "98")
1830
1831 def test_many_to_many(self):
1832 from selenium.webdriver.common.by import By
1833
1834 self.admin_login(username="super", password="secret", login_url="/")
1835 self.selenium.get(
1836 self.live_server_url + reverse("admin:admin_widgets_event_add")
1837 )
1838 main_window = self.selenium.current_window_handle
1839
1840 # No value has been selected yet
1841 self.assertEqual(
1842 self.selenium.find_element(By.ID, "id_supporting_bands").get_attribute(
1843 "value"
1844 ),
1845 "",
1846 )
1847
1848 # Help text for the field is displayed
1849 self.assertEqual(
1850 self.selenium.find_element(
1851 By.CSS_SELECTOR, ".field-supporting_bands div.help"
1852 ).text,
1853 "Supporting Bands.",
1854 )
1855
1856 # Open the popup window and click on a band
1857 self.selenium.find_element(By.ID, "lookup_id_supporting_bands").click()
1858 self.wait_for_and_switch_to_popup()
1859 link = self.selenium.find_element(By.LINK_TEXT, "Bogey Blues")
1860 self.assertIn("/band/42/", link.get_attribute("href"))
1861 link.click()
1862
1863 # The field now contains the selected band's id
1864 self.selenium.switch_to.window(main_window)
1865 self.wait_for_value("#id_supporting_bands", "42")
1866
1867 # Reopen the popup window and click on another band
1868 self.selenium.find_element(By.ID, "lookup_id_supporting_bands").click()
1869 self.wait_for_and_switch_to_popup()
1870 link = self.selenium.find_element(By.LINK_TEXT, "Green Potatoes")
1871 self.assertIn("/band/98/", link.get_attribute("href"))
1872 link.click()
1873
1874 # The field now contains the two selected bands' ids
1875 self.selenium.switch_to.window(main_window)
1876 self.wait_for_value("#id_supporting_bands", "42,98")
1877
1878
1879 class RelatedFieldWidgetSeleniumTests(AdminWidgetSeleniumTestCase):
1880 def test_ForeignKey_using_to_field(self):
1881 from selenium.webdriver import ActionChains
1882 from selenium.webdriver.common.by import By
1883 from selenium.webdriver.support.ui import Select
1884
1885 self.admin_login(username="super", password="secret", login_url="/")
1886 with self.wait_page_loaded():
1887 self.selenium.get(
1888 self.live_server_url + reverse("admin:admin_widgets_profile_add")
1889 )
1890
1891 main_window = self.selenium.current_window_handle
1892 # Click the Add User button to add new
1893 self.selenium.find_element(By.ID, "add_id_user").click()
1894 self.wait_for_and_switch_to_popup()
1895 password_field = self.selenium.find_element(By.ID, "id_password")
1896 password_field.send_keys("password")
1897
1898 username_field = self.selenium.find_element(By.ID, "id_username")
1899 username_value = "newuser"
1900 username_field.send_keys(username_value)
1901
1902 save_button_css_selector = ".submit-row > input[type=submit]"
1903 self.selenium.find_element(By.CSS_SELECTOR, save_button_css_selector).click()
1904 self.selenium.switch_to.window(main_window)
1905 # The field now contains the new user
1906 self.selenium.find_element(By.CSS_SELECTOR, "#id_user option[value=newuser]")
1907
1908 self.selenium.find_element(By.ID, "view_id_user").click()
1909 self.wait_for_value("#id_username", "newuser")
1910 self.selenium.back()
1911
1912 # Chrome and Safari don't update related object links when selecting
1913 # the same option as previously submitted. As a consequence, the
1914 # "pencil" and "eye" buttons remain disable, so select "---------"
1915 # first.
1916 select = Select(self.selenium.find_element(By.ID, "id_user"))
1917 select.select_by_index(0)
1918 select.select_by_value("newuser")
1919 # Click the Change User button to change it
1920 self.selenium.find_element(By.ID, "change_id_user").click()
1921 self.wait_for_and_switch_to_popup()
1922
1923 username_field = self.selenium.find_element(By.ID, "id_username")
1924 username_value = "changednewuser"
1925 username_field.clear()
1926 username_field.send_keys(username_value)
1927
1928 save_button_css_selector = ".submit-row > input[type=submit]"
1929 self.selenium.find_element(By.CSS_SELECTOR, save_button_css_selector).click()
1930 self.selenium.switch_to.window(main_window)
1931 self.selenium.find_element(
1932 By.CSS_SELECTOR, "#id_user option[value=changednewuser]"
1933 )
1934
1935 element = self.selenium.find_element(By.ID, "view_id_user")
1936 ActionChains(self.selenium).move_to_element(element).click(element).perform()
1937 self.wait_for_value("#id_username", "changednewuser")
1938 self.selenium.back()
1939
1940 select = Select(self.selenium.find_element(By.ID, "id_user"))
1941 select.select_by_value("changednewuser")
1942 # Go ahead and submit the form to make sure it works
1943 self.selenium.find_element(By.CSS_SELECTOR, save_button_css_selector).click()
1944 self.wait_for_text(
1945 "li.success", "The profile “changednewuser” was added successfully."
1946 )
1947 profiles = Profile.objects.all()
1948 self.assertEqual(len(profiles), 1)
1949 self.assertEqual(profiles[0].user.username, username_value)
1950
1951
1952 @skipUnless(Image, "Pillow not installed")
1953 class ImageFieldWidgetsSeleniumTests(AdminWidgetSeleniumTestCase):
1954 name_input_id = "id_name"
1955 photo_input_id = "id_photo"
1956 tests_files_folder = "%s/files" % os.getcwd()
1957 clear_checkbox_id = "photo-clear_id"
1958
1959 def _submit_and_wait(self):
1960 from selenium.webdriver.common.by import By
1961
1962 with self.wait_page_loaded():
1963 self.selenium.find_element(
1964 By.CSS_SELECTOR, "input[value='Save and continue editing']"
1965 ).click()
1966
1967 def _run_image_upload_path(self):
1968 from selenium.webdriver.common.by import By
1969
1970 self.admin_login(username="super", password="secret", login_url="/")
1971 self.selenium.get(
1972 self.live_server_url + reverse("admin:admin_widgets_student_add"),
1973 )
1974 # Add a student.
1975 name_input = self.selenium.find_element(By.ID, self.name_input_id)
1976 name_input.send_keys("Joe Doe")
1977 photo_input = self.selenium.find_element(By.ID, self.photo_input_id)
1978 photo_input.send_keys(f"{self.tests_files_folder}/test.png")
1979 self._submit_and_wait()
1980 student = Student.objects.last()
1981 self.assertEqual(student.name, "Joe Doe")
1982 self.assertRegex(student.photo.name, r"^photos\/(test|test_.+).png")
1983
1984 def test_clearablefileinput_widget(self):
1985 from selenium.webdriver.common.by import By
1986
1987 self._run_image_upload_path()
1988 self.selenium.find_element(By.ID, self.clear_checkbox_id).click()
1989 self._submit_and_wait()
1990 student = Student.objects.last()
1991 self.assertEqual(student.name, "Joe Doe")
1992 self.assertEqual(student.photo.name, "")
1993 # "Currently" with "Clear" checkbox and "Change" are not shown.
1994 photo_field_row = self.selenium.find_element(By.CSS_SELECTOR, ".field-photo")
1995 self.assertNotIn("Currently", photo_field_row.text)
1996 self.assertNotIn("Change", photo_field_row.text)
1997
1998 def test_clearablefileinput_widget_invalid_file(self):
1999 from selenium.webdriver.common.by import By
2000
2001 self._run_image_upload_path()
2002 # Uploading non-image files is not supported by Safari with Selenium,
2003 # so upload a broken one instead.
2004 photo_input = self.selenium.find_element(By.ID, self.photo_input_id)
2005 photo_input.send_keys(f"{self.tests_files_folder}/brokenimg.png")
2006 self._submit_and_wait()
2007 self.assertEqual(
2008 self.selenium.find_element(By.CSS_SELECTOR, ".errorlist li").text,
2009 (
2010 "Upload a valid image. The file you uploaded was either not an image "
2011 "or a corrupted image."
2012 ),
2013 )
2014 # "Currently" with "Clear" checkbox and "Change" still shown.
2015 photo_field_row = self.selenium.find_element(By.CSS_SELECTOR, ".field-photo")
2016 self.assertIn("Currently", photo_field_row.text)
2017 self.assertIn("Change", photo_field_row.text)
2018
2019 def test_clearablefileinput_widget_preserve_clear_checkbox(self):
2020 from selenium.webdriver.common.by import By
2021
2022 self._run_image_upload_path()
2023 # "Clear" is not checked by default.
2024 self.assertIs(
2025 self.selenium.find_element(By.ID, self.clear_checkbox_id).is_selected(),
2026 False,
2027 )
2028 # "Clear" was checked, but a validation error is raised.
2029 name_input = self.selenium.find_element(By.ID, self.name_input_id)
2030 name_input.clear()
2031 self.selenium.find_element(By.ID, self.clear_checkbox_id).click()
2032 self._submit_and_wait()
2033 self.assertEqual(
2034 self.selenium.find_element(By.CSS_SELECTOR, ".errorlist li").text,
2035 "This field is required.",
2036 )
2037 # "Clear" persists checked.
2038 self.assertIs(
2039 self.selenium.find_element(By.ID, self.clear_checkbox_id).is_selected(),
2040 True,
2041 )