Debian Codegraph @

tests/admin_utils/tests.py

raw
1 from datetime import datetime
2 from decimal import Decimal
3
4 from django import forms
5 from django.conf import settings
6 from django.contrib import admin
7 from django.contrib.admin import helpers
8 from django.contrib.admin.utils import (
9 NestedObjects,
10 build_q_object_from_lookup_parameters,
11 display_for_field,
12 display_for_value,
13 flatten,
14 flatten_fieldsets,
15 help_text_for_field,
16 label_for_field,
17 lookup_field,
18 quote,
19 )
20 from django.core.validators import EMPTY_VALUES
21 from django.db import DEFAULT_DB_ALIAS, models
22 from django.test import SimpleTestCase, TestCase, override_settings
23 from django.utils.formats import localize
24 from django.utils.safestring import mark_safe
25
26 from .models import Article, Car, Count, Event, EventGuide, Location, Site, Vehicle
27
28
29 class NestedObjectsTests(TestCase):
30 """
31 Tests for ``NestedObject`` utility collection.
32 """
33
34 @classmethod
35 def setUpTestData(cls):
36 cls.n = NestedObjects(using=DEFAULT_DB_ALIAS)
37 cls.objs = [Count.objects.create(num=i) for i in range(5)]
38
39 def _check(self, target):
40 self.assertEqual(self.n.nested(lambda obj: obj.num), target)
41
42 def _connect(self, i, j):
43 self.objs[i].parent = self.objs[j]
44 self.objs[i].save()
45
46 def _collect(self, *indices):
47 self.n.collect([self.objs[i] for i in indices])
48
49 def test_unrelated_roots(self):
50 self._connect(2, 1)
51 self._collect(0)
52 self._collect(1)
53 self._check([0, 1, [2]])
54
55 def test_siblings(self):
56 self._connect(1, 0)
57 self._connect(2, 0)
58 self._collect(0)
59 self._check([0, [1, 2]])
60
61 def test_non_added_parent(self):
62 self._connect(0, 1)
63 self._collect(0)
64 self._check([0])
65
66 def test_cyclic(self):
67 self._connect(0, 2)
68 self._connect(1, 0)
69 self._connect(2, 1)
70 self._collect(0)
71 self._check([0, [1, [2]]])
72
73 def test_queries(self):
74 self._connect(1, 0)
75 self._connect(2, 0)
76 # 1 query to fetch all children of 0 (1 and 2)
77 # 1 query to fetch all children of 1 and 2 (none)
78 # Should not require additional queries to populate the nested graph.
79 self.assertNumQueries(2, self._collect, 0)
80
81 def test_on_delete_do_nothing(self):
82 """
83 The nested collector doesn't query for DO_NOTHING objects.
84 """
85 n = NestedObjects(using=DEFAULT_DB_ALIAS)
86 objs = [Event.objects.create()]
87 EventGuide.objects.create(event=objs[0])
88 with self.assertNumQueries(2):
89 # One for Location, one for Guest, and no query for EventGuide
90 n.collect(objs)
91
92 def test_relation_on_abstract(self):
93 """
94 NestedObjects.collect() doesn't trip (AttributeError) on the special
95 notation for relations on abstract models (related_name that contains
96 %(app_label)s and/or %(class)s) (#21846).
97 """
98 n = NestedObjects(using=DEFAULT_DB_ALIAS)
99 Car.objects.create()
100 n.collect([Vehicle.objects.first()])
101
102
103 class UtilsTests(SimpleTestCase):
104 empty_value = "-empty-"
105
106 def test_values_from_lookup_field(self):
107 """
108 Regression test for #12654: lookup_field
109 """
110 SITE_NAME = "example.com"
111 TITLE_TEXT = "Some title"
112 CREATED_DATE = datetime.min
113 ADMIN_METHOD = "admin method"
114 SIMPLE_FUNCTION = "function"
115 INSTANCE_ATTRIBUTE = "attr"
116
117 class MockModelAdmin:
118 def get_admin_value(self, obj):
119 return ADMIN_METHOD
120
121 def simple_function(obj):
122 return SIMPLE_FUNCTION
123
124 site_obj = Site(domain=SITE_NAME)
125 article = Article(
126 site=site_obj,
127 title=TITLE_TEXT,
128 created=CREATED_DATE,
129 )
130 article.non_field = INSTANCE_ATTRIBUTE
131
132 verifications = (
133 ("site", SITE_NAME),
134 ("created", localize(CREATED_DATE)),
135 ("title", TITLE_TEXT),
136 ("get_admin_value", ADMIN_METHOD),
137 (simple_function, SIMPLE_FUNCTION),
138 ("test_from_model", article.test_from_model()),
139 ("non_field", INSTANCE_ATTRIBUTE),
140 ("site__domain", SITE_NAME),
141 )
142
143 mock_admin = MockModelAdmin()
144 for name, value in verifications:
145 field, attr, resolved_value = lookup_field(name, article, mock_admin)
146
147 if field is not None:
148 resolved_value = display_for_field(
149 resolved_value, field, self.empty_value
150 )
151
152 self.assertEqual(value, resolved_value)
153
154 def test_empty_value_display_for_field(self):
155 tests = [
156 models.CharField(),
157 models.DateField(),
158 models.DecimalField(),
159 models.FloatField(),
160 models.URLField(),
161 models.JSONField(),
162 models.TimeField(),
163 ]
164 for model_field in tests:
165 for value in model_field.empty_values:
166 with self.subTest(model_field=model_field, empty_value=value):
167 display_value = display_for_field(
168 value, model_field, self.empty_value
169 )
170 self.assertEqual(display_value, self.empty_value)
171
172 def test_empty_value_display_choices(self):
173 model_field = models.CharField(choices=((None, "test_none"),))
174 display_value = display_for_field(None, model_field, self.empty_value)
175 self.assertEqual(display_value, "test_none")
176
177 def test_empty_value_display_booleanfield(self):
178 model_field = models.BooleanField(null=True)
179 display_value = display_for_field(None, model_field, self.empty_value)
180 expected = (
181 f'<img src="{settings.STATIC_URL}admin/img/icon-unknown.svg" alt="None" />'
182 )
183 self.assertHTMLEqual(display_value, expected)
184
185 def test_json_display_for_field(self):
186 tests = [
187 ({"a": {"b": "c"}}, '{"a": {"b": "c"}}'),
188 (["a", "b"], '["a", "b"]'),
189 ("a", '"a"'),
190 ({"a": "你好 世界"}, '{"a": "你好 世界"}'),
191 ({("a", "b"): "c"}, "{('a', 'b'): 'c'}"), # Invalid JSON.
192 ]
193 for value, display_value in tests:
194 with self.subTest(value=value):
195 self.assertEqual(
196 display_for_field(value, models.JSONField(), self.empty_value),
197 display_value,
198 )
199
200 def test_url_display_for_field(self):
201 model_field = models.URLField()
202 display_value = display_for_field(
203 "http://example.com", model_field, self.empty_value
204 )
205 expected = '<a href="http://example.com">http://example.com</a>'
206 self.assertHTMLEqual(display_value, expected)
207
208 def test_number_formats_display_for_field(self):
209 display_value = display_for_field(
210 12345.6789, models.FloatField(), self.empty_value
211 )
212 self.assertEqual(display_value, "12345.6789")
213
214 display_value = display_for_field(
215 Decimal("12345.6789"), models.DecimalField(), self.empty_value
216 )
217 self.assertEqual(display_value, "12345.6789")
218
219 display_value = display_for_field(
220 12345, models.IntegerField(), self.empty_value
221 )
222 self.assertEqual(display_value, "12345")
223
224 @override_settings(USE_THOUSAND_SEPARATOR=True)
225 def test_number_formats_with_thousand_separator_display_for_field(self):
226 display_value = display_for_field(
227 12345.6789, models.FloatField(), self.empty_value
228 )
229 self.assertEqual(display_value, "12,345.6789")
230
231 display_value = display_for_field(
232 Decimal("12345.6789"), models.DecimalField(), self.empty_value
233 )
234 self.assertEqual(display_value, "12,345.6789")
235
236 display_value = display_for_field(
237 12345, models.IntegerField(), self.empty_value
238 )
239 self.assertEqual(display_value, "12,345")
240
241 def test_list_display_for_value(self):
242 display_value = display_for_value([1, 2, 3], self.empty_value)
243 self.assertEqual(display_value, "1, 2, 3")
244
245 display_value = display_for_value(
246 [1, 2, "buckle", "my", "shoe"], self.empty_value
247 )
248 self.assertEqual(display_value, "1, 2, buckle, my, shoe")
249
250 @override_settings(USE_THOUSAND_SEPARATOR=True)
251 def test_list_display_for_value_boolean(self):
252 self.assertEqual(
253 display_for_value(True, "", boolean=True),
254 '<img src="/static/admin/img/icon-yes.svg" alt="True">',
255 )
256 self.assertEqual(
257 display_for_value(False, "", boolean=True),
258 '<img src="/static/admin/img/icon-no.svg" alt="False">',
259 )
260 self.assertEqual(display_for_value(True, ""), "True")
261 self.assertEqual(display_for_value(False, ""), "False")
262
263 def test_list_display_for_value_empty(self):
264 for value in EMPTY_VALUES:
265 with self.subTest(empty_value=value):
266 display_value = display_for_value(value, self.empty_value)
267 self.assertEqual(display_value, self.empty_value)
268
269 def test_label_for_field(self):
270 """
271 Tests for label_for_field
272 """
273 self.assertEqual(label_for_field("title", Article), "title")
274 self.assertEqual(label_for_field("hist", Article), "History")
275 self.assertEqual(
276 label_for_field("hist", Article, return_attr=True), ("History", None)
277 )
278
279 self.assertEqual(label_for_field("__str__", Article), "article")
280
281 with self.assertRaisesMessage(
282 AttributeError, "Unable to lookup 'unknown' on Article"
283 ):
284 label_for_field("unknown", Article)
285
286 def test_callable(obj):
287 return "nothing"
288
289 self.assertEqual(label_for_field(test_callable, Article), "Test callable")
290 self.assertEqual(
291 label_for_field(test_callable, Article, return_attr=True),
292 ("Test callable", test_callable),
293 )
294
295 self.assertEqual(label_for_field("test_from_model", Article), "Test from model")
296 self.assertEqual(
297 label_for_field("test_from_model", Article, return_attr=True),
298 ("Test from model", Article.test_from_model),
299 )
300 self.assertEqual(
301 label_for_field("test_from_model_with_override", Article),
302 "not What you Expect",
303 )
304
305 self.assertEqual(label_for_field(lambda x: "nothing", Article), "--")
306 self.assertEqual(label_for_field("site_id", Article), "Site id")
307 # The correct name and attr are returned when `__` is in the field name.
308 self.assertEqual(label_for_field("site__domain", Article), "Site domain")
309 self.assertEqual(
310 label_for_field("site__domain", Article, return_attr=True),
311 ("Site domain", Site._meta.get_field("domain")),
312 )
313
314 def test_label_for_field_failed_lookup(self):
315 msg = "Unable to lookup 'site__unknown' on Article"
316 with self.assertRaisesMessage(AttributeError, msg):
317 label_for_field("site__unknown", Article)
318
319 class MockModelAdmin:
320 @admin.display(description="not Really the Model")
321 def test_from_model(self, obj):
322 return "nothing"
323
324 self.assertEqual(
325 label_for_field("test_from_model", Article, model_admin=MockModelAdmin),
326 "not Really the Model",
327 )
328 self.assertEqual(
329 label_for_field(
330 "test_from_model", Article, model_admin=MockModelAdmin, return_attr=True
331 ),
332 ("not Really the Model", MockModelAdmin.test_from_model),
333 )
334
335 def test_label_for_field_form_argument(self):
336 class ArticleForm(forms.ModelForm):
337 extra_form_field = forms.BooleanField()
338
339 class Meta:
340 fields = "__all__"
341 model = Article
342
343 self.assertEqual(
344 label_for_field("extra_form_field", Article, form=ArticleForm()),
345 "Extra form field",
346 )
347 msg = "Unable to lookup 'nonexistent' on Article or ArticleForm"
348 with self.assertRaisesMessage(AttributeError, msg):
349 label_for_field("nonexistent", Article, form=ArticleForm())
350
351 def test_label_for_property(self):
352 class MockModelAdmin:
353 @property
354 @admin.display(description="property short description")
355 def test_from_property(self):
356 return "this if from property"
357
358 self.assertEqual(
359 label_for_field("test_from_property", Article, model_admin=MockModelAdmin),
360 "property short description",
361 )
362
363 def test_help_text_for_field(self):
364 tests = [
365 ("article", ""),
366 ("unknown", ""),
367 ("hist", "History help text"),
368 ]
369 for name, help_text in tests:
370 with self.subTest(name=name):
371 self.assertEqual(help_text_for_field(name, Article), help_text)
372
373 def test_related_name(self):
374 """
375 Regression test for #13963
376 """
377 self.assertEqual(
378 label_for_field("location", Event, return_attr=True),
379 ("location", None),
380 )
381 self.assertEqual(
382 label_for_field("event", Location, return_attr=True),
383 ("awesome event", None),
384 )
385 self.assertEqual(
386 label_for_field("guest", Event, return_attr=True),
387 ("awesome guest", None),
388 )
389
390 def test_safestring_in_field_label(self):
391 # safestring should not be escaped
392 class MyForm(forms.Form):
393 text = forms.CharField(label=mark_safe("<i>text</i>"))
394 cb = forms.BooleanField(label=mark_safe("<i>cb</i>"))
395
396 form = MyForm()
397 self.assertHTMLEqual(
398 helpers.AdminField(form, "text", is_first=False).label_tag(),
399 '<label for="id_text" class="required inline"><i>text</i>:</label>',
400 )
401 self.assertHTMLEqual(
402 helpers.AdminField(form, "cb", is_first=False).label_tag(),
403 '<label for="id_cb" class="vCheckboxLabel required inline">'
404 "<i>cb</i></label>",
405 )
406
407 # normal strings needs to be escaped
408 class MyForm(forms.Form):
409 text = forms.CharField(label="&text")
410 cb = forms.BooleanField(label="&cb")
411
412 form = MyForm()
413 self.assertHTMLEqual(
414 helpers.AdminField(form, "text", is_first=False).label_tag(),
415 '<label for="id_text" class="required inline">&amp;text:</label>',
416 )
417 self.assertHTMLEqual(
418 helpers.AdminField(form, "cb", is_first=False).label_tag(),
419 '<label for="id_cb" class="vCheckboxLabel required inline">&amp;cb</label>',
420 )
421
422 def test_flatten(self):
423 flat_all = ["url", "title", "content", "sites"]
424 inputs = (
425 ((), []),
426 (("url", "title", ("content", "sites")), flat_all),
427 (("url", "title", "content", "sites"), flat_all),
428 ((("url", "title"), ("content", "sites")), flat_all),
429 )
430 for orig, expected in inputs:
431 self.assertEqual(flatten(orig), expected)
432
433 def test_flatten_fieldsets(self):
434 """
435 Regression test for #18051
436 """
437 fieldsets = ((None, {"fields": ("url", "title", ("content", "sites"))}),)
438 self.assertEqual(
439 flatten_fieldsets(fieldsets), ["url", "title", "content", "sites"]
440 )
441
442 fieldsets = ((None, {"fields": ("url", "title", ["content", "sites"])}),)
443 self.assertEqual(
444 flatten_fieldsets(fieldsets), ["url", "title", "content", "sites"]
445 )
446
447 def test_quote(self):
448 self.assertEqual(quote("something\nor\nother"), "something_0Aor_0Aother")
449
450 def test_build_q_object_from_lookup_parameters(self):
451 parameters = {
452 "title__in": [["Article 1", "Article 2"]],
453 "hist__iexact": ["history"],
454 "site__pk": [1, 2],
455 }
456 q_obj = build_q_object_from_lookup_parameters(parameters)
457 self.assertEqual(
458 q_obj,
459 models.Q(title__in=["Article 1", "Article 2"])
460 & models.Q(hist__iexact="history")
461 & (models.Q(site__pk=1) | models.Q(site__pk=2)),
462 )