Debian Codegraph @

tests/generic_inline_admin/tests.py

raw
1 from django.contrib import admin
2 from django.contrib.admin.sites import AdminSite
3 from django.contrib.auth.models import Permission, User
4 from django.contrib.contenttypes.admin import GenericTabularInline
5 from django.contrib.contenttypes.models import ContentType
6 from django.forms.formsets import DEFAULT_MAX_NUM
7 from django.forms.models import ModelForm
8 from django.test import (
9 RequestFactory,
10 SimpleTestCase,
11 TestCase,
12 ignore_warnings,
13 override_settings,
14 )
15 from django.urls import reverse
16 from django.utils.deprecation import RemovedInDjango60Warning
17
18 from .admin import MediaInline, MediaPermanentInline, PhoneNumberInline
19 from .admin import site as admin_site
20 from .models import Category, Contact, Episode, EpisodePermanent, Media, PhoneNumber
21
22
23 class TestDataMixin:
24 @classmethod
25 def setUpTestData(cls):
26 cls.superuser = User.objects.create_superuser(
27 username="super", password="secret", email="[email protected]"
28 )
29
30
31 @ignore_warnings(category=RemovedInDjango60Warning)
32 @override_settings(ROOT_URLCONF="generic_inline_admin.urls")
33 class GenericAdminViewTest(TestDataMixin, TestCase):
34 def setUp(self):
35 self.client.force_login(self.superuser)
36
37 e = Episode.objects.create(name="This Week in Django")
38 self.episode_pk = e.pk
39 m = Media(content_object=e, url="http://example.com/podcast.mp3")
40 m.save()
41 self.mp3_media_pk = m.pk
42
43 m = Media(content_object=e, url="http://example.com/logo.png")
44 m.save()
45 self.png_media_pk = m.pk
46
47 def test_basic_add_GET(self):
48 """
49 A smoke test to ensure GET on the add_view works.
50 """
51 response = self.client.get(reverse("admin:generic_inline_admin_episode_add"))
52 self.assertEqual(response.status_code, 200)
53
54 def test_basic_edit_GET(self):
55 """
56 A smoke test to ensure GET on the change_view works.
57 """
58 response = self.client.get(
59 reverse(
60 "admin:generic_inline_admin_episode_change", args=(self.episode_pk,)
61 )
62 )
63 self.assertEqual(response.status_code, 200)
64
65 def test_basic_add_POST(self):
66 """
67 A smoke test to ensure POST on add_view works.
68 """
69 post_data = {
70 "name": "This Week in Django",
71 # inline data
72 "generic_inline_admin-media-content_type-object_id-TOTAL_FORMS": "1",
73 "generic_inline_admin-media-content_type-object_id-INITIAL_FORMS": "0",
74 "generic_inline_admin-media-content_type-object_id-MAX_NUM_FORMS": "0",
75 }
76 response = self.client.post(
77 reverse("admin:generic_inline_admin_episode_add"), post_data
78 )
79 self.assertEqual(response.status_code, 302) # redirect somewhere
80
81 def test_basic_edit_POST(self):
82 """
83 A smoke test to ensure POST on edit_view works.
84 """
85 prefix = "generic_inline_admin-media-content_type-object_id"
86 post_data = {
87 "name": "This Week in Django",
88 # inline data
89 f"{prefix}-TOTAL_FORMS": "3",
90 f"{prefix}-INITIAL_FORMS": "2",
91 f"{prefix}-MAX_NUM_FORMS": "0",
92 f"{prefix}-0-id": str(self.mp3_media_pk),
93 f"{prefix}-0-url": "http://example.com/podcast.mp3",
94 f"{prefix}-1-id": str(self.png_media_pk),
95 f"{prefix}-1-url": "http://example.com/logo.png",
96 f"{prefix}-2-id": "",
97 f"{prefix}-2-url": "",
98 }
99 url = reverse(
100 "admin:generic_inline_admin_episode_change", args=(self.episode_pk,)
101 )
102 response = self.client.post(url, post_data)
103 self.assertEqual(response.status_code, 302) # redirect somewhere
104
105
106 @ignore_warnings(category=RemovedInDjango60Warning)
107 @override_settings(ROOT_URLCONF="generic_inline_admin.urls")
108 class GenericInlineAdminParametersTest(TestDataMixin, TestCase):
109 factory = RequestFactory()
110
111 def setUp(self):
112 self.client.force_login(self.superuser)
113
114 def _create_object(self, model):
115 """
116 Create a model with an attached Media object via GFK. We can't
117 load content via a fixture (since the GenericForeignKey relies on
118 content type IDs, which will vary depending on what other tests
119 have been run), thus we do it here.
120 """
121 e = model.objects.create(name="This Week in Django")
122 Media.objects.create(content_object=e, url="http://example.com/podcast.mp3")
123 return e
124
125 def test_no_param(self):
126 """
127 With one initial form, extra (default) at 3, there should be 4 forms.
128 """
129 e = self._create_object(Episode)
130 response = self.client.get(
131 reverse("admin:generic_inline_admin_episode_change", args=(e.pk,))
132 )
133 formset = response.context["inline_admin_formsets"][0].formset
134 self.assertEqual(formset.total_form_count(), 4)
135 self.assertEqual(formset.initial_form_count(), 1)
136
137 def test_extra_param(self):
138 """
139 With extra=0, there should be one form.
140 """
141
142 class ExtraInline(GenericTabularInline):
143 model = Media
144 extra = 0
145
146 modeladmin = admin.ModelAdmin(Episode, admin_site)
147 modeladmin.inlines = [ExtraInline]
148
149 e = self._create_object(Episode)
150 request = self.factory.get(
151 reverse("admin:generic_inline_admin_episode_change", args=(e.pk,))
152 )
153 request.user = User(username="super", is_superuser=True)
154 response = modeladmin.changeform_view(request, object_id=str(e.pk))
155 formset = response.context_data["inline_admin_formsets"][0].formset
156 self.assertEqual(formset.total_form_count(), 1)
157 self.assertEqual(formset.initial_form_count(), 1)
158
159 def test_max_num_param(self):
160 """
161 With extra=5 and max_num=2, there should be only 2 forms.
162 """
163
164 class MaxNumInline(GenericTabularInline):
165 model = Media
166 extra = 5
167 max_num = 2
168
169 modeladmin = admin.ModelAdmin(Episode, admin_site)
170 modeladmin.inlines = [MaxNumInline]
171
172 e = self._create_object(Episode)
173 request = self.factory.get(
174 reverse("admin:generic_inline_admin_episode_change", args=(e.pk,))
175 )
176 request.user = User(username="super", is_superuser=True)
177 response = modeladmin.changeform_view(request, object_id=str(e.pk))
178 formset = response.context_data["inline_admin_formsets"][0].formset
179 self.assertEqual(formset.total_form_count(), 2)
180 self.assertEqual(formset.initial_form_count(), 1)
181
182 def test_min_num_param(self):
183 """
184 With extra=3 and min_num=2, there should be five forms.
185 """
186
187 class MinNumInline(GenericTabularInline):
188 model = Media
189 extra = 3
190 min_num = 2
191
192 modeladmin = admin.ModelAdmin(Episode, admin_site)
193 modeladmin.inlines = [MinNumInline]
194
195 e = self._create_object(Episode)
196 request = self.factory.get(
197 reverse("admin:generic_inline_admin_episode_change", args=(e.pk,))
198 )
199 request.user = User(username="super", is_superuser=True)
200 response = modeladmin.changeform_view(request, object_id=str(e.pk))
201 formset = response.context_data["inline_admin_formsets"][0].formset
202 self.assertEqual(formset.total_form_count(), 5)
203 self.assertEqual(formset.initial_form_count(), 1)
204
205 def test_get_extra(self):
206 class GetExtraInline(GenericTabularInline):
207 model = Media
208 extra = 4
209
210 def get_extra(self, request, obj):
211 return 2
212
213 modeladmin = admin.ModelAdmin(Episode, admin_site)
214 modeladmin.inlines = [GetExtraInline]
215 e = self._create_object(Episode)
216 request = self.factory.get(
217 reverse("admin:generic_inline_admin_episode_change", args=(e.pk,))
218 )
219 request.user = User(username="super", is_superuser=True)
220 response = modeladmin.changeform_view(request, object_id=str(e.pk))
221 formset = response.context_data["inline_admin_formsets"][0].formset
222
223 self.assertEqual(formset.extra, 2)
224
225 def test_get_min_num(self):
226 class GetMinNumInline(GenericTabularInline):
227 model = Media
228 min_num = 5
229
230 def get_min_num(self, request, obj):
231 return 2
232
233 modeladmin = admin.ModelAdmin(Episode, admin_site)
234 modeladmin.inlines = [GetMinNumInline]
235 e = self._create_object(Episode)
236 request = self.factory.get(
237 reverse("admin:generic_inline_admin_episode_change", args=(e.pk,))
238 )
239 request.user = User(username="super", is_superuser=True)
240 response = modeladmin.changeform_view(request, object_id=str(e.pk))
241 formset = response.context_data["inline_admin_formsets"][0].formset
242
243 self.assertEqual(formset.min_num, 2)
244
245 def test_get_max_num(self):
246 class GetMaxNumInline(GenericTabularInline):
247 model = Media
248 extra = 5
249
250 def get_max_num(self, request, obj):
251 return 2
252
253 modeladmin = admin.ModelAdmin(Episode, admin_site)
254 modeladmin.inlines = [GetMaxNumInline]
255 e = self._create_object(Episode)
256 request = self.factory.get(
257 reverse("admin:generic_inline_admin_episode_change", args=(e.pk,))
258 )
259 request.user = User(username="super", is_superuser=True)
260 response = modeladmin.changeform_view(request, object_id=str(e.pk))
261 formset = response.context_data["inline_admin_formsets"][0].formset
262
263 self.assertEqual(formset.max_num, 2)
264
265
266 @override_settings(ROOT_URLCONF="generic_inline_admin.urls")
267 class GenericInlineAdminWithUniqueTogetherTest(TestDataMixin, TestCase):
268 def setUp(self):
269 self.client.force_login(self.superuser)
270
271 def test_add(self):
272 category_id = Category.objects.create(name="male").pk
273 prefix = "generic_inline_admin-phonenumber-content_type-object_id"
274 post_data = {
275 "name": "John Doe",
276 # inline data
277 f"{prefix}-TOTAL_FORMS": "1",
278 f"{prefix}-INITIAL_FORMS": "0",
279 f"{prefix}-MAX_NUM_FORMS": "0",
280 f"{prefix}-0-id": "",
281 f"{prefix}-0-phone_number": "555-555-5555",
282 f"{prefix}-0-category": str(category_id),
283 }
284 response = self.client.get(reverse("admin:generic_inline_admin_contact_add"))
285 self.assertEqual(response.status_code, 200)
286 response = self.client.post(
287 reverse("admin:generic_inline_admin_contact_add"), post_data
288 )
289 self.assertEqual(response.status_code, 302) # redirect somewhere
290
291 def test_delete(self):
292 from .models import Contact
293
294 c = Contact.objects.create(name="foo")
295 PhoneNumber.objects.create(
296 object_id=c.id,
297 content_type=ContentType.objects.get_for_model(Contact),
298 phone_number="555-555-5555",
299 )
300 response = self.client.post(
301 reverse("admin:generic_inline_admin_contact_delete", args=[c.pk])
302 )
303 self.assertContains(response, "Are you sure you want to delete")
304
305
306 @override_settings(ROOT_URLCONF="generic_inline_admin.urls")
307 class GenericInlineAdminPermissionsTest(TestCase):
308 factory = RequestFactory()
309
310 @classmethod
311 def setUpTestData(cls):
312 cls.user = User(username="admin", is_staff=True, is_active=True)
313 cls.user.set_password("secret")
314 cls.user.save()
315
316 # User always has all permissions on Contact (parent) model.
317 # Permissions on the inlines vary per test.
318 cls.contact_type = ContentType.objects.get_for_model(Contact)
319 cls.user.user_permissions.add(
320 *Permission.objects.filter(content_type=cls.contact_type)
321 )
322
323 def test_add_inline_without_add_permission(self):
324 self.client.force_login(self.user)
325 inline_view_perm = Permission.objects.get(codename="view_phonenumber")
326 self.user.user_permissions.add(inline_view_perm)
327
328 category_id = Category.objects.create(name="test").pk
329 prefix = "generic_inline_admin-phonenumber-content_type-object_id"
330 post_data = {
331 "name": "Barbara",
332 # inline data
333 f"{prefix}-TOTAL_FORMS": "1",
334 f"{prefix}-INITIAL_FORMS": "0",
335 f"{prefix}-MIN_NUM_FORMS": "0",
336 f"{prefix}-MAX_NUM_FORMS": "0",
337 f"{prefix}-0-id": "",
338 f"{prefix}-0-phone_number": "555-555-5555",
339 f"{prefix}-0-category": str(category_id),
340 }
341 request = self.factory.get(reverse("admin:generic_inline_admin_contact_add"))
342 request.user = self.user
343 inline = PhoneNumberInline(Contact, AdminSite())
344 FormSet = inline.get_formset(request)
345 formset = FormSet(
346 data=post_data, prefix=prefix, instance=Contact(name="Barbara")
347 )
348
349 self.assertIs(formset.is_valid(), True)
350 self.assertIs(formset.has_changed(), False)
351 self.assertEqual(formset.save(commit=False), [])
352
353 def test_add_inline_with_change_permission_only(self):
354 """
355 Forged new inline instances are ignored without add permissions, but
356 but edits still work with edit permissions.
357 """
358 self.client.force_login(self.user)
359 inline_perms = Permission.objects.filter(
360 codename__in=("view_phonenumber", "change_phonenumber")
361 )
362 self.user.user_permissions.add(*inline_perms)
363
364 category_id = Category.objects.create(name="test").pk
365 contact = Contact.objects.create(name="Barbara")
366 existing_number = PhoneNumber.objects.create(
367 category_id=category_id,
368 content_type=self.contact_type,
369 object_id=contact.pk,
370 phone_number="555-555-5555",
371 )
372 prefix = "generic_inline_admin-phonenumber-content_type-object_id"
373 post_data = {
374 "id": str(contact.pk),
375 "name": "Barbara",
376 # inline data
377 f"{prefix}-TOTAL_FORMS": "2",
378 f"{prefix}-INITIAL_FORMS": "1",
379 f"{prefix}-MIN_NUM_FORMS": "0",
380 f"{prefix}-MAX_NUM_FORMS": "0",
381 # Attempt to edit the existing phone number value.
382 f"{prefix}-0-id": str(existing_number.id),
383 f"{prefix}-0-phone_number": "111-111-1111",
384 f"{prefix}-0-category": str(category_id),
385 # Attempt to forge a new phone number.
386 f"{prefix}-1-id": "",
387 f"{prefix}-1-phone_number": "666-666-6666",
388 f"{prefix}-1-category": str(category_id),
389 "_save": "Save",
390 }
391 request = self.factory.get(
392 reverse("admin:generic_inline_admin_contact_change", args=[contact.pk])
393 )
394 request.user = self.user
395 inline = PhoneNumberInline(Contact, AdminSite())
396 FormSet = inline.get_formset(request)
397 formset = FormSet(data=post_data, prefix=prefix, instance=contact)
398
399 self.assertIs(formset.is_valid(), True)
400 self.assertIs(formset.has_changed(), True)
401 # The edit succeeds; the add is ignored.
402 self.assertEqual(formset.save(commit=False), [existing_number])
403
404
405 class MockRequest:
406 pass
407
408
409 class MockSuperUser:
410 def has_perm(self, perm, obj=None):
411 return True
412
413
414 request = MockRequest()
415 request.user = MockSuperUser()
416
417
418 @override_settings(ROOT_URLCONF="generic_inline_admin.urls")
419 class NoInlineDeletionTest(SimpleTestCase):
420 @ignore_warnings(category=RemovedInDjango60Warning)
421 def test_no_deletion(self):
422 inline = MediaPermanentInline(EpisodePermanent, admin_site)
423 formset = inline.get_formset(request)
424 self.assertFalse(formset.can_delete)
425
426
427 @override_settings(ROOT_URLCONF="generic_inline_admin.urls")
428 class GenericInlineModelAdminTest(SimpleTestCase):
429 def setUp(self):
430 self.site = AdminSite()
431
432 @ignore_warnings(category=RemovedInDjango60Warning)
433 def test_get_formset_kwargs(self):
434 media_inline = MediaInline(Media, AdminSite())
435
436 # Create a formset with default arguments
437 formset = media_inline.get_formset(request)
438 self.assertEqual(formset.max_num, DEFAULT_MAX_NUM)
439 self.assertIs(formset.can_order, False)
440
441 # Create a formset with custom keyword arguments
442 formset = media_inline.get_formset(request, max_num=100, can_order=True)
443 self.assertEqual(formset.max_num, 100)
444 self.assertIs(formset.can_order, True)
445
446 def test_custom_form_meta_exclude_with_readonly(self):
447 """
448 The custom ModelForm's `Meta.exclude` is respected when
449 used in conjunction with `GenericInlineModelAdmin.readonly_fields`
450 and when no `ModelAdmin.exclude` is defined.
451 """
452
453 class MediaForm(ModelForm):
454 class Meta:
455 model = Media
456 exclude = ["url"]
457
458 class MediaInline(GenericTabularInline):
459 readonly_fields = ["description"]
460 form = MediaForm
461 model = Media
462
463 class EpisodeAdmin(admin.ModelAdmin):
464 inlines = [MediaInline]
465
466 ma = EpisodeAdmin(Episode, self.site)
467 self.assertEqual(
468 list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields),
469 ["keywords", "id", "DELETE"],
470 )
471
472 @ignore_warnings(category=RemovedInDjango60Warning)
473 def test_custom_form_meta_exclude(self):
474 """
475 The custom ModelForm's `Meta.exclude` is respected by
476 `GenericInlineModelAdmin.get_formset`, and overridden if
477 `ModelAdmin.exclude` or `GenericInlineModelAdmin.exclude` are defined.
478 Refs #15907.
479 """
480 # First with `GenericInlineModelAdmin` -----------------
481
482 class MediaForm(ModelForm):
483 class Meta:
484 model = Media
485 exclude = ["url"]
486
487 class MediaInline(GenericTabularInline):
488 exclude = ["description"]
489 form = MediaForm
490 model = Media
491
492 class EpisodeAdmin(admin.ModelAdmin):
493 inlines = [MediaInline]
494
495 ma = EpisodeAdmin(Episode, self.site)
496 self.assertEqual(
497 list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields),
498 ["url", "keywords", "id", "DELETE"],
499 )
500
501 # Then, only with `ModelForm` -----------------
502
503 class MediaInline(GenericTabularInline):
504 form = MediaForm
505 model = Media
506
507 class EpisodeAdmin(admin.ModelAdmin):
508 inlines = [MediaInline]
509
510 ma = EpisodeAdmin(Episode, self.site)
511 self.assertEqual(
512 list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields),
513 ["description", "keywords", "id", "DELETE"],
514 )
515
516 @ignore_warnings(category=RemovedInDjango60Warning)
517 def test_get_fieldsets(self):
518 # get_fieldsets is called when figuring out form fields.
519 # Refs #18681.
520 class MediaForm(ModelForm):
521 class Meta:
522 model = Media
523 fields = "__all__"
524
525 class MediaInline(GenericTabularInline):
526 form = MediaForm
527 model = Media
528 can_delete = False
529
530 def get_fieldsets(self, request, obj=None):
531 return [(None, {"fields": ["url", "description"]})]
532
533 ma = MediaInline(Media, self.site)
534 form = ma.get_formset(None).form
535 self.assertEqual(form._meta.fields, ["url", "description"])
536
537 def test_get_formsets_with_inlines_returns_tuples(self):
538 """
539 get_formsets_with_inlines() returns the correct tuples.
540 """
541
542 class MediaForm(ModelForm):
543 class Meta:
544 model = Media
545 exclude = ["url"]
546
547 class MediaInline(GenericTabularInline):
548 form = MediaForm
549 model = Media
550
551 class AlternateInline(GenericTabularInline):
552 form = MediaForm
553 model = Media
554
555 class EpisodeAdmin(admin.ModelAdmin):
556 inlines = [AlternateInline, MediaInline]
557
558 ma = EpisodeAdmin(Episode, self.site)
559 inlines = ma.get_inline_instances(request)
560 for (formset, inline), other_inline in zip(
561 ma.get_formsets_with_inlines(request), inlines
562 ):
563 self.assertIsInstance(formset, other_inline.get_formset(request).__class__)
564
565 def test_get_inline_instances_override_get_inlines(self):
566 class MediaInline(GenericTabularInline):
567 model = Media
568
569 class AlternateInline(GenericTabularInline):
570 model = Media
571
572 class EpisodeAdmin(admin.ModelAdmin):
573 inlines = (AlternateInline, MediaInline)
574
575 def get_inlines(self, request, obj):
576 if hasattr(request, "name"):
577 if request.name == "alternate":
578 return self.inlines[:1]
579 elif request.name == "media":
580 return self.inlines[1:2]
581 return []
582
583 ma = EpisodeAdmin(Episode, self.site)
584 self.assertEqual(ma.get_inlines(request, None), [])
585 self.assertEqual(ma.get_inline_instances(request), [])
586 for name, inline_class in (
587 ("alternate", AlternateInline),
588 ("media", MediaInline),
589 ):
590 request.name = name
591 self.assertEqual(ma.get_inlines(request, None), (inline_class,))
592 self.assertEqual(type(ma.get_inline_instances(request)[0]), inline_class)