Debian Codegraph @

tests/admin_utils/test_logentry.py

raw
1 import json
2 from datetime import datetime
3
4 from django.contrib.admin.models import ADDITION, CHANGE, DELETION, LogEntry
5 from django.contrib.admin.utils import quote
6 from django.contrib.auth.models import User
7 from django.contrib.contenttypes.models import ContentType
8 from django.db.models.signals import post_save, pre_save
9 from django.test import TestCase, override_settings
10 from django.urls import reverse
11 from django.utils import translation
12 from django.utils.deprecation import RemovedInDjango60Warning
13 from django.utils.html import escape
14
15 from .models import Article, ArticleProxy, Car, InheritedLogEntryManager, Site
16
17
18 @override_settings(ROOT_URLCONF="admin_utils.urls")
19 class LogEntryTests(TestCase):
20 @classmethod
21 def setUpTestData(cls):
22 cls.user = User.objects.create_superuser(
23 username="super", password="secret", email="[email protected]"
24 )
25 cls.site = Site.objects.create(domain="example.org")
26 cls.a1 = Article.objects.create(
27 site=cls.site,
28 title="Title",
29 created=datetime(2008, 3, 12, 11, 54),
30 )
31 cls.a2 = Article.objects.create(
32 site=cls.site,
33 title="Title 2",
34 created=datetime(2009, 3, 12, 11, 54),
35 )
36 cls.a3 = Article.objects.create(
37 site=cls.site,
38 title="Title 3",
39 created=datetime(2010, 3, 12, 11, 54),
40 )
41 LogEntry.objects.log_actions(
42 cls.user.pk,
43 [cls.a1],
44 CHANGE,
45 change_message="Changed something",
46 )
47
48 def setUp(self):
49 self.client.force_login(self.user)
50 self.signals = []
51
52 pre_save.connect(self.pre_save_listener, sender=LogEntry)
53 self.addCleanup(pre_save.disconnect, self.pre_save_listener, sender=LogEntry)
54
55 post_save.connect(self.post_save_listener, sender=LogEntry)
56 self.addCleanup(post_save.disconnect, self.post_save_listener, sender=LogEntry)
57
58 def pre_save_listener(self, instance, **kwargs):
59 self.signals.append(("pre_save", instance))
60
61 def post_save_listener(self, instance, created, **kwargs):
62 self.signals.append(("post_save", instance, created))
63
64 def test_logentry_save(self):
65 """
66 LogEntry.action_time is a timestamp of the date when the entry was
67 created. It shouldn't be updated on a subsequent save().
68 """
69 logentry = LogEntry.objects.get(content_type__model__iexact="article")
70 action_time = logentry.action_time
71 logentry.save()
72 self.assertEqual(logentry.action_time, action_time)
73
74 def test_logentry_change_message(self):
75 """
76 LogEntry.change_message is stored as a dumped JSON structure to be able
77 to get the message dynamically translated at display time.
78 """
79 post_data = {
80 "site": self.site.pk,
81 "title": "Changed",
82 "hist": "Some content",
83 "created_0": "2008-03-12",
84 "created_1": "11:54",
85 }
86 change_url = reverse(
87 "admin:admin_utils_article_change", args=[quote(self.a1.pk)]
88 )
89 response = self.client.post(change_url, post_data)
90 self.assertRedirects(response, reverse("admin:admin_utils_article_changelist"))
91 logentry = LogEntry.objects.filter(
92 content_type__model__iexact="article"
93 ).latest("id")
94 self.assertEqual(logentry.get_change_message(), "Changed Title and History.")
95 with translation.override("fr"):
96 self.assertEqual(
97 logentry.get_change_message(), "Modification de Title et Historique."
98 )
99
100 add_url = reverse("admin:admin_utils_article_add")
101 post_data["title"] = "New"
102 response = self.client.post(add_url, post_data)
103 self.assertRedirects(response, reverse("admin:admin_utils_article_changelist"))
104 logentry = LogEntry.objects.filter(
105 content_type__model__iexact="article"
106 ).latest("id")
107 self.assertEqual(logentry.get_change_message(), "Added.")
108 with translation.override("fr"):
109 self.assertEqual(logentry.get_change_message(), "Ajout.")
110
111 def test_logentry_change_message_not_json(self):
112 """LogEntry.change_message was a string before Django 1.10."""
113 logentry = LogEntry(change_message="non-JSON string")
114 self.assertEqual(logentry.get_change_message(), logentry.change_message)
115
116 def test_logentry_change_message_localized_datetime_input(self):
117 """
118 Localized date/time inputs shouldn't affect changed form data detection.
119 """
120 post_data = {
121 "site": self.site.pk,
122 "title": "Changed",
123 "hist": "Some content",
124 "created_0": "12/03/2008",
125 "created_1": "11:54",
126 }
127 with translation.override("fr"):
128 change_url = reverse(
129 "admin:admin_utils_article_change", args=[quote(self.a1.pk)]
130 )
131 response = self.client.post(change_url, post_data)
132 self.assertRedirects(
133 response, reverse("admin:admin_utils_article_changelist")
134 )
135 logentry = LogEntry.objects.filter(
136 content_type__model__iexact="article"
137 ).latest("id")
138 self.assertEqual(logentry.get_change_message(), "Changed Title and History.")
139
140 def test_logentry_change_message_formsets(self):
141 """
142 All messages for changed formsets are logged in a change message.
143 """
144 a2 = Article.objects.create(
145 site=self.site,
146 title="Title second article",
147 created=datetime(2012, 3, 18, 11, 54),
148 )
149 post_data = {
150 "domain": "example.com", # domain changed
151 "admin_articles-TOTAL_FORMS": "5",
152 "admin_articles-INITIAL_FORMS": "2",
153 "admin_articles-MIN_NUM_FORMS": "0",
154 "admin_articles-MAX_NUM_FORMS": "1000",
155 # Changed title for 1st article
156 "admin_articles-0-id": str(self.a1.pk),
157 "admin_articles-0-site": str(self.site.pk),
158 "admin_articles-0-title": "Changed Title",
159 # Second article is deleted
160 "admin_articles-1-id": str(a2.pk),
161 "admin_articles-1-site": str(self.site.pk),
162 "admin_articles-1-title": "Title second article",
163 "admin_articles-1-DELETE": "on",
164 # A new article is added
165 "admin_articles-2-site": str(self.site.pk),
166 "admin_articles-2-title": "Added article",
167 }
168 change_url = reverse(
169 "admin:admin_utils_site_change", args=[quote(self.site.pk)]
170 )
171 response = self.client.post(change_url, post_data)
172 self.assertRedirects(response, reverse("admin:admin_utils_site_changelist"))
173 self.assertSequenceEqual(Article.objects.filter(pk=a2.pk), [])
174 logentry = LogEntry.objects.filter(content_type__model__iexact="site").latest(
175 "action_time"
176 )
177 self.assertEqual(
178 json.loads(logentry.change_message),
179 [
180 {"changed": {"fields": ["Domain"]}},
181 {"added": {"object": "Added article", "name": "article"}},
182 {
183 "changed": {
184 "fields": ["Title", "not_a_form_field"],
185 "object": "Changed Title",
186 "name": "article",
187 }
188 },
189 {"deleted": {"object": "Title second article", "name": "article"}},
190 ],
191 )
192 self.assertEqual(
193 logentry.get_change_message(),
194 "Changed Domain. Added article “Added article”. "
195 "Changed Title and not_a_form_field for article “Changed Title”. "
196 "Deleted article “Title second article”.",
197 )
198
199 with translation.override("fr"):
200 self.assertEqual(
201 logentry.get_change_message(),
202 "Modification de Domain. Ajout de article « Added article ». "
203 "Modification de Title et not_a_form_field pour l'objet "
204 "article « Changed Title ». "
205 "Suppression de article « Title second article ».",
206 )
207
208 def test_logentry_get_edited_object(self):
209 """
210 LogEntry.get_edited_object() returns the edited object of a LogEntry
211 object.
212 """
213 logentry = LogEntry.objects.get(content_type__model__iexact="article")
214 edited_obj = logentry.get_edited_object()
215 self.assertEqual(logentry.object_id, str(edited_obj.pk))
216
217 def test_logentry_get_admin_url(self):
218 """
219 LogEntry.get_admin_url returns a URL to edit the entry's object or
220 None for nonexistent (possibly deleted) models.
221 """
222 logentry = LogEntry.objects.get(content_type__model__iexact="article")
223 expected_url = reverse(
224 "admin:admin_utils_article_change", args=(quote(self.a1.pk),)
225 )
226 self.assertEqual(logentry.get_admin_url(), expected_url)
227 self.assertIn("article/%d/change/" % self.a1.pk, logentry.get_admin_url())
228
229 logentry.content_type.model = "nonexistent"
230 self.assertIsNone(logentry.get_admin_url())
231
232 def test_logentry_unicode(self):
233 log_entry = LogEntry()
234
235 log_entry.action_flag = ADDITION
236 self.assertTrue(str(log_entry).startswith("Added "))
237
238 log_entry.action_flag = CHANGE
239 self.assertTrue(str(log_entry).startswith("Changed "))
240
241 log_entry.action_flag = DELETION
242 self.assertTrue(str(log_entry).startswith("Deleted "))
243
244 # Make sure custom action_flags works
245 log_entry.action_flag = 4
246 self.assertEqual(str(log_entry), "LogEntry Object")
247
248 def test_logentry_repr(self):
249 logentry = LogEntry.objects.first()
250 self.assertEqual(repr(logentry), str(logentry.action_time))
251
252 # RemovedInDjango60Warning.
253 def test_log_action(self):
254 msg = "LogEntryManager.log_action() is deprecated. Use log_actions() instead."
255 content_type_val = ContentType.objects.get_for_model(Article).pk
256 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
257 log_entry = LogEntry.objects.log_action(
258 self.user.pk,
259 content_type_val,
260 self.a1.pk,
261 repr(self.a1),
262 CHANGE,
263 change_message="Changed something else",
264 )
265 self.assertEqual(log_entry, LogEntry.objects.latest("id"))
266 self.assertEqual(ctx.filename, __file__)
267
268 def test_log_actions(self):
269 queryset = Article.objects.all().order_by("-id")
270 msg = "Deleted Something"
271 content_type = ContentType.objects.get_for_model(self.a1)
272 self.assertEqual(len(queryset), 3)
273 with self.assertNumQueries(1):
274 result = LogEntry.objects.log_actions(
275 self.user.pk,
276 queryset,
277 DELETION,
278 change_message=msg,
279 )
280 self.assertEqual(len(result), len(queryset))
281 logs = (
282 LogEntry.objects.filter(action_flag=DELETION)
283 .order_by("id")
284 .values_list(
285 "user",
286 "content_type",
287 "object_id",
288 "object_repr",
289 "action_flag",
290 "change_message",
291 )
292 )
293 expected_log_values = [
294 (
295 self.user.pk,
296 content_type.id,
297 str(obj.pk),
298 str(obj),
299 DELETION,
300 msg,
301 )
302 for obj in queryset
303 ]
304 result_logs = [
305 (
306 entry.user_id,
307 entry.content_type_id,
308 str(entry.object_id),
309 entry.object_repr,
310 entry.action_flag,
311 entry.change_message,
312 )
313 for entry in result
314 ]
315 self.assertSequenceEqual(logs, result_logs)
316 self.assertSequenceEqual(logs, expected_log_values)
317 self.assertEqual(self.signals, [])
318
319 # RemovedInDjango60Warning.
320 def test_log_action_fallback(self):
321 LogEntry.objects2 = InheritedLogEntryManager()
322 queryset = Article.objects.all().order_by("-id")
323 content_type = ContentType.objects.get_for_model(self.a1)
324 self.assertEqual(len(queryset), 3)
325 msg = (
326 "The usage of log_action() is deprecated. Implement log_actions() instead."
327 )
328 with (
329 self.assertNumQueries(3),
330 self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx,
331 ):
332 LogEntry.objects2.log_actions(self.user.pk, queryset, DELETION)
333 self.assertEqual(ctx.filename, __file__)
334 log_values = (
335 LogEntry.objects.filter(action_flag=DELETION)
336 .order_by("id")
337 .values_list(
338 "user",
339 "content_type",
340 "object_id",
341 "object_repr",
342 "action_flag",
343 "change_message",
344 )
345 )
346 expected_log_values = [
347 (
348 self.user.pk,
349 content_type.id,
350 str(obj.pk),
351 "Test Repr",
352 DELETION,
353 "",
354 )
355 for obj in queryset
356 ]
357 self.assertSequenceEqual(log_values, expected_log_values)
358
359 def test_log_actions_single_object_param(self):
360 queryset = Article.objects.filter(pk=self.a1.pk)
361 msg = "Deleted Something"
362 content_type = ContentType.objects.get_for_model(self.a1)
363 self.assertEqual(len(queryset), 1)
364 for single_object in (True, False):
365 self.signals = []
366 with self.subTest(single_object=single_object), self.assertNumQueries(1):
367 result = LogEntry.objects.log_actions(
368 self.user.pk,
369 queryset,
370 DELETION,
371 change_message=msg,
372 single_object=single_object,
373 )
374 if single_object:
375 self.assertIsInstance(result, LogEntry)
376 entry = result
377 else:
378 self.assertIsInstance(result, list)
379 self.assertEqual(len(result), 1)
380 entry = result[0]
381 self.assertEqual(entry.user_id, self.user.pk)
382 self.assertEqual(entry.content_type_id, content_type.id)
383 self.assertEqual(str(entry.object_id), str(self.a1.pk))
384 self.assertEqual(entry.object_repr, str(self.a1))
385 self.assertEqual(entry.action_flag, DELETION)
386 self.assertEqual(entry.change_message, msg)
387 expected_signals = [
388 ("pre_save", entry),
389 ("post_save", entry, True),
390 ]
391 self.assertEqual(self.signals, expected_signals)
392
393 def test_recentactions_without_content_type(self):
394 """
395 If a LogEntry is missing content_type it will not display it in span
396 tag under the hyperlink.
397 """
398 response = self.client.get(reverse("admin:index"))
399 link = reverse("admin:admin_utils_article_change", args=(quote(self.a1.pk),))
400 should_contain = """<a href="%s">%s</a>""" % (
401 escape(link),
402 escape(str(self.a1)),
403 )
404 self.assertContains(response, should_contain)
405 should_contain = "Article"
406 self.assertContains(response, should_contain)
407 logentry = LogEntry.objects.get(content_type__model__iexact="article")
408 # If the log entry doesn't have a content type it should still be
409 # possible to view the Recent Actions part (#10275).
410 logentry.content_type = None
411 logentry.save()
412
413 should_contain = should_contain.encode()
414 counted_presence_before = response.content.count(should_contain)
415 response = self.client.get(reverse("admin:index"))
416 counted_presence_after = response.content.count(should_contain)
417 self.assertEqual(counted_presence_before - 1, counted_presence_after)
418
419 def test_proxy_model_content_type_is_used_for_log_entries(self):
420 """
421 Log entries for proxy models should have the proxy model's contenttype
422 (#21084).
423 """
424 proxy_content_type = ContentType.objects.get_for_model(
425 ArticleProxy, for_concrete_model=False
426 )
427 post_data = {
428 "site": self.site.pk,
429 "title": "Foo",
430 "hist": "Bar",
431 "created_0": "2015-12-25",
432 "created_1": "00:00",
433 }
434 changelist_url = reverse("admin:admin_utils_articleproxy_changelist")
435 expected_signals = []
436 self.assertEqual(self.signals, expected_signals)
437
438 # add
439 proxy_add_url = reverse("admin:admin_utils_articleproxy_add")
440 response = self.client.post(proxy_add_url, post_data)
441 self.assertRedirects(response, changelist_url)
442 proxy_addition_log = LogEntry.objects.latest("id")
443 self.assertEqual(proxy_addition_log.action_flag, ADDITION)
444 self.assertEqual(proxy_addition_log.content_type, proxy_content_type)
445 expected_signals.extend(
446 [("pre_save", proxy_addition_log), ("post_save", proxy_addition_log, True)]
447 )
448 self.assertEqual(self.signals, expected_signals)
449
450 # change
451 article_id = proxy_addition_log.object_id
452 proxy_change_url = reverse(
453 "admin:admin_utils_articleproxy_change", args=(article_id,)
454 )
455 post_data["title"] = "New"
456 response = self.client.post(proxy_change_url, post_data)
457 self.assertRedirects(response, changelist_url)
458 proxy_change_log = LogEntry.objects.latest("id")
459 self.assertEqual(proxy_change_log.action_flag, CHANGE)
460 self.assertEqual(proxy_change_log.content_type, proxy_content_type)
461 expected_signals.extend(
462 [("pre_save", proxy_change_log), ("post_save", proxy_change_log, True)]
463 )
464 self.assertEqual(self.signals, expected_signals)
465
466 # delete
467 proxy_delete_url = reverse(
468 "admin:admin_utils_articleproxy_delete", args=(article_id,)
469 )
470 response = self.client.post(proxy_delete_url, {"post": "yes"})
471 self.assertRedirects(response, changelist_url)
472 proxy_delete_log = LogEntry.objects.latest("id")
473 self.assertEqual(proxy_delete_log.action_flag, DELETION)
474 self.assertEqual(proxy_delete_log.content_type, proxy_content_type)
475 expected_signals.extend(
476 [("pre_save", proxy_delete_log), ("post_save", proxy_delete_log, True)]
477 )
478 self.assertEqual(self.signals, expected_signals)
479
480 def test_action_flag_choices(self):
481 tests = ((1, "Addition"), (2, "Change"), (3, "Deletion"))
482 for action_flag, display_name in tests:
483 with self.subTest(action_flag=action_flag):
484 log = LogEntry(action_flag=action_flag)
485 self.assertEqual(log.get_action_flag_display(), display_name)
486
487 def test_hook_get_log_entries(self):
488 LogEntry.objects.log_actions(
489 self.user.pk,
490 [self.a1],
491 CHANGE,
492 change_message="Article changed message",
493 )
494 c1 = Car.objects.create()
495 LogEntry.objects.log_actions(
496 self.user.pk,
497 [c1],
498 ADDITION,
499 change_message="Car created message",
500 )
501 exp_str_article = escape(str(self.a1))
502 exp_str_car = escape(str(c1))
503
504 response = self.client.get(reverse("admin:index"))
505 self.assertContains(response, exp_str_article)
506 self.assertContains(response, exp_str_car)
507
508 # site "custom_admin" only renders log entries of registered models
509 response = self.client.get(reverse("custom_admin:index"))
510 self.assertContains(response, exp_str_article)
511 self.assertNotContains(response, exp_str_car)