Debian Codegraph @

tests/modeladmin/tests.py

raw
1 from datetime import date
2
3 from django import forms
4 from django.contrib.admin.models import ADDITION, CHANGE, DELETION, LogEntry
5 from django.contrib.admin.options import (
6 HORIZONTAL,
7 VERTICAL,
8 ModelAdmin,
9 TabularInline,
10 get_content_type_for_model,
11 )
12 from django.contrib.admin.sites import AdminSite
13 from django.contrib.admin.widgets import (
14 AdminDateWidget,
15 AdminRadioSelect,
16 AutocompleteSelect,
17 AutocompleteSelectMultiple,
18 )
19 from django.contrib.auth.models import User
20 from django.db import models
21 from django.forms.widgets import Select
22 from django.test import RequestFactory, SimpleTestCase, TestCase
23 from django.test.utils import isolate_apps
24 from django.utils.deprecation import RemovedInDjango60Warning
25
26 from .models import Band, Concert, Song
27
28
29 class MockRequest:
30 pass
31
32
33 class MockSuperUser:
34 def has_perm(self, perm, obj=None):
35 return True
36
37
38 request = MockRequest()
39 request.user = MockSuperUser()
40
41
42 class ModelAdminTests(TestCase):
43 @classmethod
44 def setUpTestData(cls):
45 cls.band = Band.objects.create(
46 name="The Doors",
47 bio="",
48 sign_date=date(1965, 1, 1),
49 )
50
51 def setUp(self):
52 self.site = AdminSite()
53
54 def test_modeladmin_str(self):
55 ma = ModelAdmin(Band, self.site)
56 self.assertEqual(str(ma), "modeladmin.ModelAdmin")
57
58 def test_default_attributes(self):
59 ma = ModelAdmin(Band, self.site)
60 self.assertEqual(ma.actions, ())
61 self.assertEqual(ma.inlines, ())
62
63 # form/fields/fieldsets interaction ##############################
64
65 def test_default_fields(self):
66 ma = ModelAdmin(Band, self.site)
67 self.assertEqual(
68 list(ma.get_form(request).base_fields), ["name", "bio", "sign_date"]
69 )
70 self.assertEqual(list(ma.get_fields(request)), ["name", "bio", "sign_date"])
71 self.assertEqual(
72 list(ma.get_fields(request, self.band)), ["name", "bio", "sign_date"]
73 )
74 self.assertIsNone(ma.get_exclude(request, self.band))
75
76 def test_default_fieldsets(self):
77 # fieldsets_add and fieldsets_change should return a special data structure that
78 # is used in the templates. They should generate the "right thing" whether we
79 # have specified a custom form, the fields argument, or nothing at all.
80 #
81 # Here's the default case. There are no custom form_add/form_change methods,
82 # no fields argument, and no fieldsets argument.
83 ma = ModelAdmin(Band, self.site)
84 self.assertEqual(
85 ma.get_fieldsets(request),
86 [(None, {"fields": ["name", "bio", "sign_date"]})],
87 )
88 self.assertEqual(
89 ma.get_fieldsets(request, self.band),
90 [(None, {"fields": ["name", "bio", "sign_date"]})],
91 )
92
93 def test_get_fieldsets(self):
94 # get_fieldsets() is called when figuring out form fields (#18681).
95 class BandAdmin(ModelAdmin):
96 def get_fieldsets(self, request, obj=None):
97 return [(None, {"fields": ["name", "bio"]})]
98
99 ma = BandAdmin(Band, self.site)
100 form = ma.get_form(None)
101 self.assertEqual(form._meta.fields, ["name", "bio"])
102
103 class InlineBandAdmin(TabularInline):
104 model = Concert
105 fk_name = "main_band"
106 can_delete = False
107
108 def get_fieldsets(self, request, obj=None):
109 return [(None, {"fields": ["day", "transport"]})]
110
111 ma = InlineBandAdmin(Band, self.site)
112 form = ma.get_formset(None).form
113 self.assertEqual(form._meta.fields, ["day", "transport"])
114
115 def test_lookup_allowed_allows_nonexistent_lookup(self):
116 """
117 A lookup_allowed allows a parameter whose field lookup doesn't exist.
118 (#21129).
119 """
120
121 class BandAdmin(ModelAdmin):
122 fields = ["name"]
123
124 ma = BandAdmin(Band, self.site)
125 self.assertIs(
126 ma.lookup_allowed("name__nonexistent", "test_value", request),
127 True,
128 )
129
130 @isolate_apps("modeladmin")
131 def test_lookup_allowed_onetoone(self):
132 class Department(models.Model):
133 code = models.CharField(max_length=4, unique=True)
134
135 class Employee(models.Model):
136 department = models.ForeignKey(Department, models.CASCADE, to_field="code")
137
138 class EmployeeProfile(models.Model):
139 employee = models.OneToOneField(Employee, models.CASCADE)
140
141 class EmployeeInfo(models.Model):
142 employee = models.OneToOneField(Employee, models.CASCADE)
143 description = models.CharField(max_length=100)
144
145 class EmployeeProfileAdmin(ModelAdmin):
146 list_filter = [
147 "employee__employeeinfo__description",
148 "employee__department__code",
149 ]
150
151 ma = EmployeeProfileAdmin(EmployeeProfile, self.site)
152 # Reverse OneToOneField
153 self.assertIs(
154 ma.lookup_allowed(
155 "employee__employeeinfo__description", "test_value", request
156 ),
157 True,
158 )
159 # OneToOneField and ForeignKey
160 self.assertIs(
161 ma.lookup_allowed("employee__department__code", "test_value", request),
162 True,
163 )
164
165 @isolate_apps("modeladmin")
166 def test_lookup_allowed_for_local_fk_fields(self):
167 class Country(models.Model):
168 pass
169
170 class Place(models.Model):
171 country = models.ForeignKey(Country, models.CASCADE)
172
173 class PlaceAdmin(ModelAdmin):
174 pass
175
176 ma = PlaceAdmin(Place, self.site)
177
178 cases = [
179 ("country", "1"),
180 ("country__exact", "1"),
181 ("country__id", "1"),
182 ("country__id__exact", "1"),
183 ("country__isnull", True),
184 ("country__isnull", False),
185 ("country__id__isnull", False),
186 ]
187 for lookup, lookup_value in cases:
188 with self.subTest(lookup=lookup):
189 self.assertIs(ma.lookup_allowed(lookup, lookup_value, request), True)
190
191 @isolate_apps("modeladmin")
192 def test_lookup_allowed_non_autofield_primary_key(self):
193 class Country(models.Model):
194 id = models.CharField(max_length=2, primary_key=True)
195
196 class Place(models.Model):
197 country = models.ForeignKey(Country, models.CASCADE)
198
199 class PlaceAdmin(ModelAdmin):
200 list_filter = ["country"]
201
202 ma = PlaceAdmin(Place, self.site)
203 self.assertIs(ma.lookup_allowed("country__id__exact", "DE", request), True)
204
205 @isolate_apps("modeladmin")
206 def test_lookup_allowed_foreign_primary(self):
207 class Country(models.Model):
208 name = models.CharField(max_length=256)
209
210 class Place(models.Model):
211 country = models.ForeignKey(Country, models.CASCADE)
212
213 class Restaurant(models.Model):
214 place = models.OneToOneField(Place, models.CASCADE, primary_key=True)
215
216 class Waiter(models.Model):
217 restaurant = models.ForeignKey(Restaurant, models.CASCADE)
218
219 class WaiterAdmin(ModelAdmin):
220 list_filter = [
221 "restaurant__place__country",
222 "restaurant__place__country__name",
223 ]
224
225 ma = WaiterAdmin(Waiter, self.site)
226 self.assertIs(
227 ma.lookup_allowed("restaurant__place__country", "1", request),
228 True,
229 )
230 self.assertIs(
231 ma.lookup_allowed("restaurant__place__country__id__exact", "1", request),
232 True,
233 )
234 self.assertIs(
235 ma.lookup_allowed(
236 "restaurant__place__country__name", "test_value", request
237 ),
238 True,
239 )
240
241 def test_lookup_allowed_considers_dynamic_list_filter(self):
242 class ConcertAdmin(ModelAdmin):
243 list_filter = ["main_band__sign_date"]
244
245 def get_list_filter(self, request):
246 if getattr(request, "user", None):
247 return self.list_filter + ["main_band__name"]
248 return self.list_filter
249
250 model_admin = ConcertAdmin(Concert, self.site)
251 request_band_name_filter = RequestFactory().get(
252 "/", {"main_band__name": "test"}
253 )
254 self.assertIs(
255 model_admin.lookup_allowed(
256 "main_band__sign_date", "?", request_band_name_filter
257 ),
258 True,
259 )
260 self.assertIs(
261 model_admin.lookup_allowed(
262 "main_band__name", "?", request_band_name_filter
263 ),
264 False,
265 )
266 request_with_superuser = request
267 self.assertIs(
268 model_admin.lookup_allowed(
269 "main_band__sign_date", "?", request_with_superuser
270 ),
271 True,
272 )
273 self.assertIs(
274 model_admin.lookup_allowed("main_band__name", "?", request_with_superuser),
275 True,
276 )
277
278 def test_lookup_allowed_without_request_deprecation(self):
279 class ConcertAdmin(ModelAdmin):
280 list_filter = ["main_band__sign_date"]
281
282 def get_list_filter(self, request):
283 return self.list_filter + ["main_band__name"]
284
285 def lookup_allowed(self, lookup, value):
286 return True
287
288 model_admin = ConcertAdmin(Concert, self.site)
289 msg = (
290 "`request` must be added to the signature of ModelAdminTests."
291 "test_lookup_allowed_without_request_deprecation.<locals>."
292 "ConcertAdmin.lookup_allowed()."
293 )
294 request_band_name_filter = RequestFactory().get(
295 "/", {"main_band__name": "test"}
296 )
297 request_band_name_filter.user = User.objects.create_superuser(
298 username="bob", email="[email protected]", password="test"
299 )
300 with self.assertWarnsMessage(RemovedInDjango60Warning, msg):
301 changelist = model_admin.get_changelist_instance(request_band_name_filter)
302 filterspec = changelist.get_filters(request_band_name_filter)[0][0]
303 self.assertEqual(filterspec.title, "sign date")
304 filterspec = changelist.get_filters(request_band_name_filter)[0][1]
305 self.assertEqual(filterspec.title, "name")
306 self.assertSequenceEqual(filterspec.lookup_choices, [self.band.name])
307
308 def test_field_arguments(self):
309 # If fields is specified, fieldsets_add and fieldsets_change should
310 # just stick the fields into a formsets structure and return it.
311 class BandAdmin(ModelAdmin):
312 fields = ["name"]
313
314 ma = BandAdmin(Band, self.site)
315
316 self.assertEqual(list(ma.get_fields(request)), ["name"])
317 self.assertEqual(list(ma.get_fields(request, self.band)), ["name"])
318 self.assertEqual(ma.get_fieldsets(request), [(None, {"fields": ["name"]})])
319 self.assertEqual(
320 ma.get_fieldsets(request, self.band), [(None, {"fields": ["name"]})]
321 )
322
323 def test_field_arguments_restricted_on_form(self):
324 # If fields or fieldsets is specified, it should exclude fields on the
325 # Form class to the fields specified. This may cause errors to be
326 # raised in the db layer if required model fields aren't in fields/
327 # fieldsets, but that's preferable to ghost errors where a field in the
328 # Form class isn't being displayed because it's not in fields/fieldsets.
329
330 # Using `fields`.
331 class BandAdmin(ModelAdmin):
332 fields = ["name"]
333
334 ma = BandAdmin(Band, self.site)
335 self.assertEqual(list(ma.get_form(request).base_fields), ["name"])
336 self.assertEqual(list(ma.get_form(request, self.band).base_fields), ["name"])
337
338 # Using `fieldsets`.
339 class BandAdmin(ModelAdmin):
340 fieldsets = [(None, {"fields": ["name"]})]
341
342 ma = BandAdmin(Band, self.site)
343 self.assertEqual(list(ma.get_form(request).base_fields), ["name"])
344 self.assertEqual(list(ma.get_form(request, self.band).base_fields), ["name"])
345
346 # Using `exclude`.
347 class BandAdmin(ModelAdmin):
348 exclude = ["bio"]
349
350 ma = BandAdmin(Band, self.site)
351 self.assertEqual(list(ma.get_form(request).base_fields), ["name", "sign_date"])
352
353 # You can also pass a tuple to `exclude`.
354 class BandAdmin(ModelAdmin):
355 exclude = ("bio",)
356
357 ma = BandAdmin(Band, self.site)
358 self.assertEqual(list(ma.get_form(request).base_fields), ["name", "sign_date"])
359
360 # Using `fields` and `exclude`.
361 class BandAdmin(ModelAdmin):
362 fields = ["name", "bio"]
363 exclude = ["bio"]
364
365 ma = BandAdmin(Band, self.site)
366 self.assertEqual(list(ma.get_form(request).base_fields), ["name"])
367
368 def test_custom_form_meta_exclude_with_readonly(self):
369 """
370 The custom ModelForm's `Meta.exclude` is respected when used in
371 conjunction with `ModelAdmin.readonly_fields` and when no
372 `ModelAdmin.exclude` is defined (#14496).
373 """
374
375 # With ModelAdmin
376 class AdminBandForm(forms.ModelForm):
377 class Meta:
378 model = Band
379 exclude = ["bio"]
380
381 class BandAdmin(ModelAdmin):
382 readonly_fields = ["name"]
383 form = AdminBandForm
384
385 ma = BandAdmin(Band, self.site)
386 self.assertEqual(list(ma.get_form(request).base_fields), ["sign_date"])
387
388 # With InlineModelAdmin
389 class AdminConcertForm(forms.ModelForm):
390 class Meta:
391 model = Concert
392 exclude = ["day"]
393
394 class ConcertInline(TabularInline):
395 readonly_fields = ["transport"]
396 form = AdminConcertForm
397 fk_name = "main_band"
398 model = Concert
399
400 class BandAdmin(ModelAdmin):
401 inlines = [ConcertInline]
402
403 ma = BandAdmin(Band, self.site)
404 self.assertEqual(
405 list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields),
406 ["main_band", "opening_band", "id", "DELETE"],
407 )
408
409 def test_custom_formfield_override_readonly(self):
410 class AdminBandForm(forms.ModelForm):
411 name = forms.CharField()
412
413 class Meta:
414 exclude = ()
415 model = Band
416
417 class BandAdmin(ModelAdmin):
418 form = AdminBandForm
419 readonly_fields = ["name"]
420
421 ma = BandAdmin(Band, self.site)
422
423 # `name` shouldn't appear in base_fields because it's part of
424 # readonly_fields.
425 self.assertEqual(list(ma.get_form(request).base_fields), ["bio", "sign_date"])
426 # But it should appear in get_fields()/fieldsets() so it can be
427 # displayed as read-only.
428 self.assertEqual(list(ma.get_fields(request)), ["bio", "sign_date", "name"])
429 self.assertEqual(
430 list(ma.get_fieldsets(request)),
431 [(None, {"fields": ["bio", "sign_date", "name"]})],
432 )
433
434 def test_custom_form_meta_exclude(self):
435 """
436 The custom ModelForm's `Meta.exclude` is overridden if
437 `ModelAdmin.exclude` or `InlineModelAdmin.exclude` are defined (#14496).
438 """
439
440 # With ModelAdmin
441 class AdminBandForm(forms.ModelForm):
442 class Meta:
443 model = Band
444 exclude = ["bio"]
445
446 class BandAdmin(ModelAdmin):
447 exclude = ["name"]
448 form = AdminBandForm
449
450 ma = BandAdmin(Band, self.site)
451 self.assertEqual(list(ma.get_form(request).base_fields), ["bio", "sign_date"])
452
453 # With InlineModelAdmin
454 class AdminConcertForm(forms.ModelForm):
455 class Meta:
456 model = Concert
457 exclude = ["day"]
458
459 class ConcertInline(TabularInline):
460 exclude = ["transport"]
461 form = AdminConcertForm
462 fk_name = "main_band"
463 model = Concert
464
465 class BandAdmin(ModelAdmin):
466 inlines = [ConcertInline]
467
468 ma = BandAdmin(Band, self.site)
469 self.assertEqual(
470 list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields),
471 ["main_band", "opening_band", "day", "id", "DELETE"],
472 )
473
474 def test_overriding_get_exclude(self):
475 class BandAdmin(ModelAdmin):
476 def get_exclude(self, request, obj=None):
477 return ["name"]
478
479 self.assertEqual(
480 list(BandAdmin(Band, self.site).get_form(request).base_fields),
481 ["bio", "sign_date"],
482 )
483
484 def test_get_exclude_overrides_exclude(self):
485 class BandAdmin(ModelAdmin):
486 exclude = ["bio"]
487
488 def get_exclude(self, request, obj=None):
489 return ["name"]
490
491 self.assertEqual(
492 list(BandAdmin(Band, self.site).get_form(request).base_fields),
493 ["bio", "sign_date"],
494 )
495
496 def test_get_exclude_takes_obj(self):
497 class BandAdmin(ModelAdmin):
498 def get_exclude(self, request, obj=None):
499 if obj:
500 return ["sign_date"]
501 return ["name"]
502
503 self.assertEqual(
504 list(BandAdmin(Band, self.site).get_form(request, self.band).base_fields),
505 ["name", "bio"],
506 )
507
508 def test_custom_form_validation(self):
509 # If a form is specified, it should use it allowing custom validation
510 # to work properly. This won't break any of the admin widgets or media.
511 class AdminBandForm(forms.ModelForm):
512 delete = forms.BooleanField()
513
514 class BandAdmin(ModelAdmin):
515 form = AdminBandForm
516
517 ma = BandAdmin(Band, self.site)
518 self.assertEqual(
519 list(ma.get_form(request).base_fields),
520 ["name", "bio", "sign_date", "delete"],
521 )
522 self.assertEqual(
523 type(ma.get_form(request).base_fields["sign_date"].widget), AdminDateWidget
524 )
525
526 def test_form_exclude_kwarg_override(self):
527 """
528 The `exclude` kwarg passed to `ModelAdmin.get_form()` overrides all
529 other declarations (#8999).
530 """
531
532 class AdminBandForm(forms.ModelForm):
533 class Meta:
534 model = Band
535 exclude = ["name"]
536
537 class BandAdmin(ModelAdmin):
538 exclude = ["sign_date"]
539 form = AdminBandForm
540
541 def get_form(self, request, obj=None, **kwargs):
542 kwargs["exclude"] = ["bio"]
543 return super().get_form(request, obj, **kwargs)
544
545 ma = BandAdmin(Band, self.site)
546 self.assertEqual(list(ma.get_form(request).base_fields), ["name", "sign_date"])
547
548 def test_formset_exclude_kwarg_override(self):
549 """
550 The `exclude` kwarg passed to `InlineModelAdmin.get_formset()`
551 overrides all other declarations (#8999).
552 """
553
554 class AdminConcertForm(forms.ModelForm):
555 class Meta:
556 model = Concert
557 exclude = ["day"]
558
559 class ConcertInline(TabularInline):
560 exclude = ["transport"]
561 form = AdminConcertForm
562 fk_name = "main_band"
563 model = Concert
564
565 def get_formset(self, request, obj=None, **kwargs):
566 kwargs["exclude"] = ["opening_band"]
567 return super().get_formset(request, obj, **kwargs)
568
569 class BandAdmin(ModelAdmin):
570 inlines = [ConcertInline]
571
572 ma = BandAdmin(Band, self.site)
573 self.assertEqual(
574 list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields),
575 ["main_band", "day", "transport", "id", "DELETE"],
576 )
577
578 def test_formset_overriding_get_exclude_with_form_fields(self):
579 class AdminConcertForm(forms.ModelForm):
580 class Meta:
581 model = Concert
582 fields = ["main_band", "opening_band", "day", "transport"]
583
584 class ConcertInline(TabularInline):
585 form = AdminConcertForm
586 fk_name = "main_band"
587 model = Concert
588
589 def get_exclude(self, request, obj=None):
590 return ["opening_band"]
591
592 class BandAdmin(ModelAdmin):
593 inlines = [ConcertInline]
594
595 ma = BandAdmin(Band, self.site)
596 self.assertEqual(
597 list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields),
598 ["main_band", "day", "transport", "id", "DELETE"],
599 )
600
601 def test_formset_overriding_get_exclude_with_form_exclude(self):
602 class AdminConcertForm(forms.ModelForm):
603 class Meta:
604 model = Concert
605 exclude = ["day"]
606
607 class ConcertInline(TabularInline):
608 form = AdminConcertForm
609 fk_name = "main_band"
610 model = Concert
611
612 def get_exclude(self, request, obj=None):
613 return ["opening_band"]
614
615 class BandAdmin(ModelAdmin):
616 inlines = [ConcertInline]
617
618 ma = BandAdmin(Band, self.site)
619 self.assertEqual(
620 list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields),
621 ["main_band", "day", "transport", "id", "DELETE"],
622 )
623
624 def test_raw_id_fields_widget_override(self):
625 """
626 The autocomplete_fields, raw_id_fields, and radio_fields widgets may
627 overridden by specifying a widget in get_formset().
628 """
629
630 class ConcertInline(TabularInline):
631 model = Concert
632 fk_name = "main_band"
633 raw_id_fields = ("opening_band",)
634
635 def get_formset(self, request, obj=None, **kwargs):
636 kwargs["widgets"] = {"opening_band": Select}
637 return super().get_formset(request, obj, **kwargs)
638
639 class BandAdmin(ModelAdmin):
640 inlines = [ConcertInline]
641
642 ma = BandAdmin(Band, self.site)
643 band_widget = (
644 list(ma.get_formsets_with_inlines(request))[0][0]()
645 .forms[0]
646 .fields["opening_band"]
647 .widget
648 )
649 # Without the override this would be ForeignKeyRawIdWidget.
650 self.assertIsInstance(band_widget, Select)
651
652 def test_queryset_override(self):
653 # If the queryset of a ModelChoiceField in a custom form is overridden,
654 # RelatedFieldWidgetWrapper doesn't mess that up.
655 band2 = Band.objects.create(
656 name="The Beatles", bio="", sign_date=date(1962, 1, 1)
657 )
658
659 ma = ModelAdmin(Concert, self.site)
660 form = ma.get_form(request)()
661
662 self.assertHTMLEqual(
663 str(form["main_band"]),
664 '<div class="related-widget-wrapper" data-model-ref="band">'
665 '<select data-context="available-source" '
666 'name="main_band" id="id_main_band" required>'
667 '<option value="" selected>---------</option>'
668 '<option value="%d">The Beatles</option>'
669 '<option value="%d">The Doors</option>'
670 "</select></div>" % (band2.id, self.band.id),
671 )
672
673 class AdminConcertForm(forms.ModelForm):
674 def __init__(self, *args, **kwargs):
675 super().__init__(*args, **kwargs)
676 self.fields["main_band"].queryset = Band.objects.filter(
677 name="The Doors"
678 )
679
680 class ConcertAdminWithForm(ModelAdmin):
681 form = AdminConcertForm
682
683 ma = ConcertAdminWithForm(Concert, self.site)
684 form = ma.get_form(request)()
685
686 self.assertHTMLEqual(
687 str(form["main_band"]),
688 '<div class="related-widget-wrapper" data-model-ref="band">'
689 '<select data-context="available-source" '
690 'name="main_band" id="id_main_band" required>'
691 '<option value="" selected>---------</option>'
692 '<option value="%d">The Doors</option>'
693 "</select></div>" % self.band.id,
694 )
695
696 def test_regression_for_ticket_15820(self):
697 """
698 `obj` is passed from `InlineModelAdmin.get_fieldsets()` to
699 `InlineModelAdmin.get_formset()`.
700 """
701
702 class CustomConcertForm(forms.ModelForm):
703 class Meta:
704 model = Concert
705 fields = ["day"]
706
707 class ConcertInline(TabularInline):
708 model = Concert
709 fk_name = "main_band"
710
711 def get_formset(self, request, obj=None, **kwargs):
712 if obj:
713 kwargs["form"] = CustomConcertForm
714 return super().get_formset(request, obj, **kwargs)
715
716 class BandAdmin(ModelAdmin):
717 inlines = [ConcertInline]
718
719 Concert.objects.create(main_band=self.band, opening_band=self.band, day=1)
720 ma = BandAdmin(Band, self.site)
721 inline_instances = ma.get_inline_instances(request)
722 fieldsets = list(inline_instances[0].get_fieldsets(request))
723 self.assertEqual(
724 fieldsets[0][1]["fields"], ["main_band", "opening_band", "day", "transport"]
725 )
726 fieldsets = list(
727 inline_instances[0].get_fieldsets(request, inline_instances[0].model)
728 )
729 self.assertEqual(fieldsets[0][1]["fields"], ["day"])
730
731 # radio_fields behavior ###########################################
732
733 def test_default_foreign_key_widget(self):
734 # First, without any radio_fields specified, the widgets for ForeignKey
735 # and fields with choices specified ought to be a basic Select widget.
736 # ForeignKey widgets in the admin are wrapped with RelatedFieldWidgetWrapper so
737 # they need to be handled properly when type checking. For Select fields, all of
738 # the choices lists have a first entry of dashes.
739 cma = ModelAdmin(Concert, self.site)
740 cmafa = cma.get_form(request)
741
742 self.assertEqual(type(cmafa.base_fields["main_band"].widget.widget), Select)
743 self.assertEqual(
744 list(cmafa.base_fields["main_band"].widget.choices),
745 [("", "---------"), (self.band.id, "The Doors")],
746 )
747
748 self.assertEqual(type(cmafa.base_fields["opening_band"].widget.widget), Select)
749 self.assertEqual(
750 list(cmafa.base_fields["opening_band"].widget.choices),
751 [("", "---------"), (self.band.id, "The Doors")],
752 )
753 self.assertEqual(type(cmafa.base_fields["day"].widget), Select)
754 self.assertEqual(
755 list(cmafa.base_fields["day"].widget.choices),
756 [("", "---------"), (1, "Fri"), (2, "Sat")],
757 )
758 self.assertEqual(type(cmafa.base_fields["transport"].widget), Select)
759 self.assertEqual(
760 list(cmafa.base_fields["transport"].widget.choices),
761 [("", "---------"), (1, "Plane"), (2, "Train"), (3, "Bus")],
762 )
763
764 def test_foreign_key_as_radio_field(self):
765 # Now specify all the fields as radio_fields. Widgets should now be
766 # RadioSelect, and the choices list should have a first entry of 'None' if
767 # blank=True for the model field. Finally, the widget should have the
768 # 'radiolist' attr, and 'inline' as well if the field is specified HORIZONTAL.
769 class ConcertAdmin(ModelAdmin):
770 radio_fields = {
771 "main_band": HORIZONTAL,
772 "opening_band": VERTICAL,
773 "day": VERTICAL,
774 "transport": HORIZONTAL,
775 }
776
777 cma = ConcertAdmin(Concert, self.site)
778 cmafa = cma.get_form(request)
779
780 self.assertEqual(
781 type(cmafa.base_fields["main_band"].widget.widget), AdminRadioSelect
782 )
783 self.assertEqual(
784 cmafa.base_fields["main_band"].widget.attrs,
785 {"class": "radiolist inline", "data-context": "available-source"},
786 )
787 self.assertEqual(
788 list(cmafa.base_fields["main_band"].widget.choices),
789 [(self.band.id, "The Doors")],
790 )
791
792 self.assertEqual(
793 type(cmafa.base_fields["opening_band"].widget.widget), AdminRadioSelect
794 )
795 self.assertEqual(
796 cmafa.base_fields["opening_band"].widget.attrs,
797 {"class": "radiolist", "data-context": "available-source"},
798 )
799 self.assertEqual(
800 list(cmafa.base_fields["opening_band"].widget.choices),
801 [("", "None"), (self.band.id, "The Doors")],
802 )
803 self.assertEqual(type(cmafa.base_fields["day"].widget), AdminRadioSelect)
804 self.assertEqual(cmafa.base_fields["day"].widget.attrs, {"class": "radiolist"})
805 self.assertEqual(
806 list(cmafa.base_fields["day"].widget.choices), [(1, "Fri"), (2, "Sat")]
807 )
808
809 self.assertEqual(type(cmafa.base_fields["transport"].widget), AdminRadioSelect)
810 self.assertEqual(
811 cmafa.base_fields["transport"].widget.attrs, {"class": "radiolist inline"}
812 )
813 self.assertEqual(
814 list(cmafa.base_fields["transport"].widget.choices),
815 [("", "None"), (1, "Plane"), (2, "Train"), (3, "Bus")],
816 )
817
818 class AdminConcertForm(forms.ModelForm):
819 class Meta:
820 model = Concert
821 exclude = ("transport",)
822
823 class ConcertAdmin(ModelAdmin):
824 form = AdminConcertForm
825
826 ma = ConcertAdmin(Concert, self.site)
827 self.assertEqual(
828 list(ma.get_form(request).base_fields), ["main_band", "opening_band", "day"]
829 )
830
831 class AdminConcertForm(forms.ModelForm):
832 extra = forms.CharField()
833
834 class Meta:
835 model = Concert
836 fields = ["extra", "transport"]
837
838 class ConcertAdmin(ModelAdmin):
839 form = AdminConcertForm
840
841 ma = ConcertAdmin(Concert, self.site)
842 self.assertEqual(list(ma.get_form(request).base_fields), ["extra", "transport"])
843
844 class ConcertInline(TabularInline):
845 form = AdminConcertForm
846 model = Concert
847 fk_name = "main_band"
848 can_delete = True
849
850 class BandAdmin(ModelAdmin):
851 inlines = [ConcertInline]
852
853 ma = BandAdmin(Band, self.site)
854 self.assertEqual(
855 list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields),
856 ["extra", "transport", "id", "DELETE", "main_band"],
857 )
858
859 def test_log_actions(self):
860 ma = ModelAdmin(Band, self.site)
861 mock_request = MockRequest()
862 mock_request.user = User.objects.create(username="bill")
863 content_type = get_content_type_for_model(self.band)
864 tests = (
865 (ma.log_addition, ADDITION, {"added": {}}),
866 (ma.log_change, CHANGE, {"changed": {"fields": ["name", "bio"]}}),
867 )
868 for method, flag, message in tests:
869 with self.subTest(name=method.__name__):
870 created = method(mock_request, self.band, message)
871 fetched = LogEntry.objects.filter(action_flag=flag).latest("id")
872 self.assertEqual(created, fetched)
873 self.assertEqual(fetched.action_flag, flag)
874 self.assertEqual(fetched.content_type, content_type)
875 self.assertEqual(fetched.object_id, str(self.band.pk))
876 self.assertEqual(fetched.user, mock_request.user)
877 self.assertEqual(fetched.change_message, str(message))
878 self.assertEqual(fetched.object_repr, str(self.band))
879
880 def test_log_deletions(self):
881 ma = ModelAdmin(Band, self.site)
882 mock_request = MockRequest()
883 mock_request.user = User.objects.create(username="akash")
884 content_type = get_content_type_for_model(self.band)
885 Band.objects.create(
886 name="The Beatles",
887 bio="A legendary rock band from Liverpool.",
888 sign_date=date(1962, 1, 1),
889 )
890 Band.objects.create(
891 name="Mohiner Ghoraguli",
892 bio="A progressive rock band from Calcutta.",
893 sign_date=date(1975, 1, 1),
894 )
895 queryset = Band.objects.all().order_by("-id")[:3]
896 self.assertEqual(len(queryset), 3)
897 with self.assertNumQueries(1):
898 ma.log_deletions(mock_request, queryset)
899 logs = (
900 LogEntry.objects.filter(action_flag=DELETION)
901 .order_by("id")
902 .values_list(
903 "user_id",
904 "content_type",
905 "object_id",
906 "object_repr",
907 "action_flag",
908 "change_message",
909 )
910 )
911 expected_log_values = [
912 (
913 mock_request.user.id,
914 content_type.id,
915 str(obj.pk),
916 str(obj),
917 DELETION,
918 "",
919 )
920 for obj in queryset
921 ]
922 self.assertSequenceEqual(logs, expected_log_values)
923
924 # RemovedInDjango60Warning.
925 def test_log_deletion(self):
926 ma = ModelAdmin(Band, self.site)
927 mock_request = MockRequest()
928 mock_request.user = User.objects.create(username="bill")
929 content_type = get_content_type_for_model(self.band)
930 msg = "ModelAdmin.log_deletion() is deprecated. Use log_deletions() instead."
931 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
932 created = ma.log_deletion(mock_request, self.band, str(self.band))
933 self.assertEqual(ctx.filename, __file__)
934 fetched = LogEntry.objects.filter(action_flag=DELETION).latest("id")
935 self.assertEqual(created, fetched)
936 self.assertEqual(fetched.action_flag, DELETION)
937 self.assertEqual(fetched.content_type, content_type)
938 self.assertEqual(fetched.object_id, str(self.band.pk))
939 self.assertEqual(fetched.user, mock_request.user)
940 self.assertEqual(fetched.change_message, "")
941 self.assertEqual(fetched.object_repr, str(self.band))
942
943 # RemovedInDjango60Warning.
944 def test_log_deletion_fallback(self):
945 class InheritedModelAdmin(ModelAdmin):
946 def log_deletion(self, request, obj, object_repr):
947 return super().log_deletion(request, obj, object_repr)
948
949 ima = InheritedModelAdmin(Band, self.site)
950 mock_request = MockRequest()
951 mock_request.user = User.objects.create(username="akash")
952 content_type = get_content_type_for_model(self.band)
953 Band.objects.create(
954 name="The Beatles",
955 bio="A legendary rock band from Liverpool.",
956 sign_date=date(1962, 1, 1),
957 )
958 Band.objects.create(
959 name="Mohiner Ghoraguli",
960 bio="A progressive rock band from Calcutta.",
961 sign_date=date(1975, 1, 1),
962 )
963 queryset = Band.objects.all().order_by("-id")[:3]
964 self.assertEqual(len(queryset), 3)
965 msg = (
966 "The usage of log_deletion() is deprecated. Implement log_deletions() "
967 "instead."
968 )
969 with self.assertNumQueries(3):
970 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
971 ima.log_deletions(mock_request, queryset)
972 self.assertEqual(ctx.filename, __file__)
973 logs = (
974 LogEntry.objects.filter(action_flag=DELETION)
975 .order_by("id")
976 .values_list(
977 "user_id",
978 "content_type",
979 "object_id",
980 "object_repr",
981 "action_flag",
982 "change_message",
983 )
984 )
985 expected_log_values = [
986 (
987 mock_request.user.id,
988 content_type.id,
989 str(obj.pk),
990 str(obj),
991 DELETION,
992 "",
993 )
994 for obj in queryset
995 ]
996 self.assertSequenceEqual(logs, expected_log_values)
997
998 def test_get_autocomplete_fields(self):
999 class NameAdmin(ModelAdmin):
1000 search_fields = ["name"]
1001
1002 class SongAdmin(ModelAdmin):
1003 autocomplete_fields = ["featuring"]
1004 fields = ["featuring", "band"]
1005
1006 class OtherSongAdmin(SongAdmin):
1007 def get_autocomplete_fields(self, request):
1008 return ["band"]
1009
1010 self.site.register(Band, NameAdmin)
1011 try:
1012 # Uses autocomplete_fields if not overridden.
1013 model_admin = SongAdmin(Song, self.site)
1014 form = model_admin.get_form(request)()
1015 self.assertIsInstance(
1016 form.fields["featuring"].widget.widget, AutocompleteSelectMultiple
1017 )
1018 # Uses overridden get_autocomplete_fields
1019 model_admin = OtherSongAdmin(Song, self.site)
1020 form = model_admin.get_form(request)()
1021 self.assertIsInstance(form.fields["band"].widget.widget, AutocompleteSelect)
1022 finally:
1023 self.site.unregister(Band)
1024
1025 def test_get_deleted_objects(self):
1026 mock_request = MockRequest()
1027 mock_request.user = User.objects.create_superuser(
1028 username="bob", email="[email protected]", password="test"
1029 )
1030 self.site.register(Band, ModelAdmin)
1031 ma = self.site.get_model_admin(Band)
1032 (
1033 deletable_objects,
1034 model_count,
1035 perms_needed,
1036 protected,
1037 ) = ma.get_deleted_objects([self.band], request)
1038 self.assertEqual(deletable_objects, ["Band: The Doors"])
1039 self.assertEqual(model_count, {"bands": 1})
1040 self.assertEqual(perms_needed, set())
1041 self.assertEqual(protected, [])
1042
1043 def test_get_deleted_objects_with_custom_has_delete_permission(self):
1044 """
1045 ModelAdmin.get_deleted_objects() uses ModelAdmin.has_delete_permission()
1046 for permissions checking.
1047 """
1048 mock_request = MockRequest()
1049 mock_request.user = User.objects.create_superuser(
1050 username="bob", email="[email protected]", password="test"
1051 )
1052
1053 class TestModelAdmin(ModelAdmin):
1054 def has_delete_permission(self, request, obj=None):
1055 return False
1056
1057 self.site.register(Band, TestModelAdmin)
1058 ma = self.site.get_model_admin(Band)
1059 (
1060 deletable_objects,
1061 model_count,
1062 perms_needed,
1063 protected,
1064 ) = ma.get_deleted_objects([self.band], request)
1065 self.assertEqual(deletable_objects, ["Band: The Doors"])
1066 self.assertEqual(model_count, {"bands": 1})
1067 self.assertEqual(perms_needed, {"band"})
1068 self.assertEqual(protected, [])
1069
1070 def test_modeladmin_repr(self):
1071 ma = ModelAdmin(Band, self.site)
1072 self.assertEqual(
1073 repr(ma),
1074 "<ModelAdmin: model=Band site=AdminSite(name='admin')>",
1075 )
1076
1077
1078 class ModelAdminPermissionTests(SimpleTestCase):
1079 class MockUser:
1080 def has_module_perms(self, app_label):
1081 return app_label == "modeladmin"
1082
1083 class MockViewUser(MockUser):
1084 def has_perm(self, perm, obj=None):
1085 return perm == "modeladmin.view_band"
1086
1087 class MockAddUser(MockUser):
1088 def has_perm(self, perm, obj=None):
1089 return perm == "modeladmin.add_band"
1090
1091 class MockChangeUser(MockUser):
1092 def has_perm(self, perm, obj=None):
1093 return perm == "modeladmin.change_band"
1094
1095 class MockDeleteUser(MockUser):
1096 def has_perm(self, perm, obj=None):
1097 return perm == "modeladmin.delete_band"
1098
1099 def test_has_view_permission(self):
1100 """
1101 has_view_permission() returns True for users who can view objects and
1102 False for users who can't.
1103 """
1104 ma = ModelAdmin(Band, AdminSite())
1105 request = MockRequest()
1106 request.user = self.MockViewUser()
1107 self.assertIs(ma.has_view_permission(request), True)
1108 request.user = self.MockAddUser()
1109 self.assertIs(ma.has_view_permission(request), False)
1110 request.user = self.MockChangeUser()
1111 self.assertIs(ma.has_view_permission(request), True)
1112 request.user = self.MockDeleteUser()
1113 self.assertIs(ma.has_view_permission(request), False)
1114
1115 def test_has_add_permission(self):
1116 """
1117 has_add_permission returns True for users who can add objects and
1118 False for users who can't.
1119 """
1120 ma = ModelAdmin(Band, AdminSite())
1121 request = MockRequest()
1122 request.user = self.MockViewUser()
1123 self.assertFalse(ma.has_add_permission(request))
1124 request.user = self.MockAddUser()
1125 self.assertTrue(ma.has_add_permission(request))
1126 request.user = self.MockChangeUser()
1127 self.assertFalse(ma.has_add_permission(request))
1128 request.user = self.MockDeleteUser()
1129 self.assertFalse(ma.has_add_permission(request))
1130
1131 def test_inline_has_add_permission_uses_obj(self):
1132 class ConcertInline(TabularInline):
1133 model = Concert
1134
1135 def has_add_permission(self, request, obj):
1136 return bool(obj)
1137
1138 class BandAdmin(ModelAdmin):
1139 inlines = [ConcertInline]
1140
1141 ma = BandAdmin(Band, AdminSite())
1142 request = MockRequest()
1143 request.user = self.MockAddUser()
1144 self.assertEqual(ma.get_inline_instances(request), [])
1145 band = Band(name="The Doors", bio="", sign_date=date(1965, 1, 1))
1146 inline_instances = ma.get_inline_instances(request, band)
1147 self.assertEqual(len(inline_instances), 1)
1148 self.assertIsInstance(inline_instances[0], ConcertInline)
1149
1150 def test_has_change_permission(self):
1151 """
1152 has_change_permission returns True for users who can edit objects and
1153 False for users who can't.
1154 """
1155 ma = ModelAdmin(Band, AdminSite())
1156 request = MockRequest()
1157 request.user = self.MockViewUser()
1158 self.assertIs(ma.has_change_permission(request), False)
1159 request.user = self.MockAddUser()
1160 self.assertFalse(ma.has_change_permission(request))
1161 request.user = self.MockChangeUser()
1162 self.assertTrue(ma.has_change_permission(request))
1163 request.user = self.MockDeleteUser()
1164 self.assertFalse(ma.has_change_permission(request))
1165
1166 def test_has_delete_permission(self):
1167 """
1168 has_delete_permission returns True for users who can delete objects and
1169 False for users who can't.
1170 """
1171 ma = ModelAdmin(Band, AdminSite())
1172 request = MockRequest()
1173 request.user = self.MockViewUser()
1174 self.assertIs(ma.has_delete_permission(request), False)
1175 request.user = self.MockAddUser()
1176 self.assertFalse(ma.has_delete_permission(request))
1177 request.user = self.MockChangeUser()
1178 self.assertFalse(ma.has_delete_permission(request))
1179 request.user = self.MockDeleteUser()
1180 self.assertTrue(ma.has_delete_permission(request))
1181
1182 def test_has_module_permission(self):
1183 """
1184 as_module_permission returns True for users who have any permission
1185 for the module and False for users who don't.
1186 """
1187 ma = ModelAdmin(Band, AdminSite())
1188 request = MockRequest()
1189 request.user = self.MockViewUser()
1190 self.assertIs(ma.has_module_permission(request), True)
1191 request.user = self.MockAddUser()
1192 self.assertTrue(ma.has_module_permission(request))
1193 request.user = self.MockChangeUser()
1194 self.assertTrue(ma.has_module_permission(request))
1195 request.user = self.MockDeleteUser()
1196 self.assertTrue(ma.has_module_permission(request))
1197
1198 original_app_label = ma.opts.app_label
1199 ma.opts.app_label = "anotherapp"
1200 try:
1201 request.user = self.MockViewUser()
1202 self.assertIs(ma.has_module_permission(request), False)
1203 request.user = self.MockAddUser()
1204 self.assertFalse(ma.has_module_permission(request))
1205 request.user = self.MockChangeUser()
1206 self.assertFalse(ma.has_module_permission(request))
1207 request.user = self.MockDeleteUser()
1208 self.assertFalse(ma.has_module_permission(request))
1209 finally:
1210 ma.opts.app_label = original_app_label