| 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">&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">&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 |
) |