Debian Codegraph @

tests/admin_ordering/tests.py

raw
1 from django.contrib import admin
2 from django.contrib.admin.options import ModelAdmin
3 from django.contrib.auth.models import User
4 from django.db.models import F
5 from django.test import RequestFactory, TestCase
6
7 from .models import (
8 Band,
9 DynOrderingBandAdmin,
10 Song,
11 SongInlineDefaultOrdering,
12 SongInlineNewOrdering,
13 )
14
15
16 class MockRequest:
17 pass
18
19
20 class MockSuperUser:
21 def has_perm(self, perm, obj=None):
22 return True
23
24 def has_module_perms(self, module):
25 return True
26
27
28 request = MockRequest()
29 request.user = MockSuperUser()
30
31 site = admin.AdminSite()
32
33
34 class TestAdminOrdering(TestCase):
35 """
36 Let's make sure that ModelAdmin.get_queryset uses the ordering we define
37 in ModelAdmin rather that ordering defined in the model's inner Meta
38 class.
39 """
40
41 request_factory = RequestFactory()
42
43 @classmethod
44 def setUpTestData(cls):
45 Band.objects.bulk_create(
46 [
47 Band(name="Aerosmith", bio="", rank=3),
48 Band(name="Radiohead", bio="", rank=1),
49 Band(name="Van Halen", bio="", rank=2),
50 ]
51 )
52
53 def test_default_ordering(self):
54 """
55 The default ordering should be by name, as specified in the inner Meta
56 class.
57 """
58 ma = ModelAdmin(Band, site)
59 names = [b.name for b in ma.get_queryset(request)]
60 self.assertEqual(["Aerosmith", "Radiohead", "Van Halen"], names)
61
62 def test_specified_ordering(self):
63 """
64 Let's use a custom ModelAdmin that changes the ordering, and make sure
65 it actually changes.
66 """
67
68 class BandAdmin(ModelAdmin):
69 ordering = ("rank",) # default ordering is ('name',)
70
71 ma = BandAdmin(Band, site)
72 names = [b.name for b in ma.get_queryset(request)]
73 self.assertEqual(["Radiohead", "Van Halen", "Aerosmith"], names)
74
75 def test_specified_ordering_by_f_expression(self):
76 class BandAdmin(ModelAdmin):
77 ordering = (F("rank").desc(nulls_last=True),)
78
79 band_admin = BandAdmin(Band, site)
80 names = [b.name for b in band_admin.get_queryset(request)]
81 self.assertEqual(["Aerosmith", "Van Halen", "Radiohead"], names)
82
83 def test_dynamic_ordering(self):
84 """
85 Let's use a custom ModelAdmin that changes the ordering dynamically.
86 """
87 super_user = User.objects.create(username="admin", is_superuser=True)
88 other_user = User.objects.create(username="other")
89 request = self.request_factory.get("/")
90 request.user = super_user
91 ma = DynOrderingBandAdmin(Band, site)
92 names = [b.name for b in ma.get_queryset(request)]
93 self.assertEqual(["Radiohead", "Van Halen", "Aerosmith"], names)
94 request.user = other_user
95 names = [b.name for b in ma.get_queryset(request)]
96 self.assertEqual(["Aerosmith", "Radiohead", "Van Halen"], names)
97
98
99 class TestInlineModelAdminOrdering(TestCase):
100 """
101 Let's make sure that InlineModelAdmin.get_queryset uses the ordering we
102 define in InlineModelAdmin.
103 """
104
105 @classmethod
106 def setUpTestData(cls):
107 cls.band = Band.objects.create(name="Aerosmith", bio="", rank=3)
108 Song.objects.bulk_create(
109 [
110 Song(band=cls.band, name="Pink", duration=235),
111 Song(band=cls.band, name="Dude (Looks Like a Lady)", duration=264),
112 Song(band=cls.band, name="Jaded", duration=214),
113 ]
114 )
115
116 def test_default_ordering(self):
117 """
118 The default ordering should be by name, as specified in the inner Meta
119 class.
120 """
121 inline = SongInlineDefaultOrdering(self.band, site)
122 names = [s.name for s in inline.get_queryset(request)]
123 self.assertEqual(["Dude (Looks Like a Lady)", "Jaded", "Pink"], names)
124
125 def test_specified_ordering(self):
126 """
127 Let's check with ordering set to something different than the default.
128 """
129 inline = SongInlineNewOrdering(self.band, site)
130 names = [s.name for s in inline.get_queryset(request)]
131 self.assertEqual(["Jaded", "Pink", "Dude (Looks Like a Lady)"], names)
132
133
134 class TestRelatedFieldsAdminOrdering(TestCase):
135 @classmethod
136 def setUpTestData(cls):
137 cls.b1 = Band.objects.create(name="Pink Floyd", bio="", rank=1)
138 cls.b2 = Band.objects.create(name="Foo Fighters", bio="", rank=5)
139
140 def setUp(self):
141 # we need to register a custom ModelAdmin (instead of just using
142 # ModelAdmin) because the field creator tries to find the ModelAdmin
143 # for the related model
144 class SongAdmin(admin.ModelAdmin):
145 pass
146
147 site.register(Song, SongAdmin)
148
149 def tearDown(self):
150 site.unregister(Song)
151 if site.is_registered(Band):
152 site.unregister(Band)
153
154 def check_ordering_of_field_choices(self, correct_ordering):
155 fk_field = site.get_model_admin(Song).formfield_for_foreignkey(
156 Song.band.field, request=None
157 )
158 m2m_field = site.get_model_admin(Song).formfield_for_manytomany(
159 Song.other_interpreters.field, request=None
160 )
161 self.assertEqual(list(fk_field.queryset), correct_ordering)
162 self.assertEqual(list(m2m_field.queryset), correct_ordering)
163
164 def test_no_admin_fallback_to_model_ordering(self):
165 # should be ordered by name (as defined by the model)
166 self.check_ordering_of_field_choices([self.b2, self.b1])
167
168 def test_admin_with_no_ordering_fallback_to_model_ordering(self):
169 class NoOrderingBandAdmin(admin.ModelAdmin):
170 pass
171
172 site.register(Band, NoOrderingBandAdmin)
173
174 # should be ordered by name (as defined by the model)
175 self.check_ordering_of_field_choices([self.b2, self.b1])
176
177 def test_admin_ordering_beats_model_ordering(self):
178 class StaticOrderingBandAdmin(admin.ModelAdmin):
179 ordering = ("rank",)
180
181 site.register(Band, StaticOrderingBandAdmin)
182
183 # should be ordered by rank (defined by the ModelAdmin)
184 self.check_ordering_of_field_choices([self.b1, self.b2])
185
186 def test_custom_queryset_still_wins(self):
187 """Custom queryset has still precedence (#21405)"""
188
189 class SongAdmin(admin.ModelAdmin):
190 # Exclude one of the two Bands from the querysets
191 def formfield_for_foreignkey(self, db_field, request, **kwargs):
192 if db_field.name == "band":
193 kwargs["queryset"] = Band.objects.filter(rank__gt=2)
194 return super().formfield_for_foreignkey(db_field, request, **kwargs)
195
196 def formfield_for_manytomany(self, db_field, request, **kwargs):
197 if db_field.name == "other_interpreters":
198 kwargs["queryset"] = Band.objects.filter(rank__gt=2)
199 return super().formfield_for_foreignkey(db_field, request, **kwargs)
200
201 class StaticOrderingBandAdmin(admin.ModelAdmin):
202 ordering = ("rank",)
203
204 site.unregister(Song)
205 site.register(Song, SongAdmin)
206 site.register(Band, StaticOrderingBandAdmin)
207
208 self.check_ordering_of_field_choices([self.b2])