import json from datetime import datetime from django.contrib.admin.models import ADDITION, CHANGE, DELETION, LogEntry from django.contrib.admin.utils import quote from django.contrib.auth.models import User from django.contrib.contenttypes.models import ContentType from django.test import TestCase, override_settings from django.urls import reverse from django.utils import translation from django.utils.html import escape from .models import Article, ArticleProxy, Site @override_settings(ROOT_URLCONF="admin_utils.urls") class LogEntryTests(TestCase): @classmethod def setUpTestData(cls): cls.user = User.objects.create_superuser( username="super", password="secret", email="super@example.com" ) cls.site = Site.objects.create(domain="example.org") cls.a1 = Article.objects.create( site=cls.site, title="Title", created=datetime(2008, 3, 12, 11, 54), ) content_type_pk = ContentType.objects.get_for_model(Article).pk LogEntry.objects.log_action( cls.user.pk, content_type_pk, cls.a1.pk, repr(cls.a1), CHANGE, change_message="Changed something", ) def setUp(self): self.client.force_login(self.user) def test_logentry_save(self): """ LogEntry.action_time is a timestamp of the date when the entry was created. It shouldn't be updated on a subsequent save(). """ logentry = LogEntry.objects.get(content_type__model__iexact="article") action_time = logentry.action_time logentry.save() self.assertEqual(logentry.action_time, action_time) def test_logentry_change_message(self): """ LogEntry.change_message is stored as a dumped JSON structure to be able to get the message dynamically translated at display time. """ post_data = { "site": self.site.pk, "title": "Changed", "hist": "Some content", "created_0": "2008-03-12", "created_1": "11:54", } change_url = reverse( "admin:admin_utils_article_change", args=[quote(self.a1.pk)] ) response = self.client.post(change_url, post_data) self.assertRedirects(response, reverse("admin:admin_utils_article_changelist")) logentry = LogEntry.objects.filter( content_type__model__iexact="article" ).latest("id") self.assertEqual(logentry.get_change_message(), "Changed Title and History.") with translation.override("fr"): self.assertEqual( logentry.get_change_message(), "Modification de Title et Historique." ) add_url = reverse("admin:admin_utils_article_add") post_data["title"] = "New" response = self.client.post(add_url, post_data) self.assertRedirects(response, reverse("admin:admin_utils_article_changelist")) logentry = LogEntry.objects.filter( content_type__model__iexact="article" ).latest("id") self.assertEqual(logentry.get_change_message(), "Added.") with translation.override("fr"): self.assertEqual(logentry.get_change_message(), "Ajout.") def test_logentry_change_message_not_json(self): """LogEntry.change_message was a string before Django 1.10.""" logentry = LogEntry(change_message="non-JSON string") self.assertEqual(logentry.get_change_message(), logentry.change_message) def test_logentry_change_message_localized_datetime_input(self): """ Localized date/time inputs shouldn't affect changed form data detection. """ post_data = { "site": self.site.pk, "title": "Changed", "hist": "Some content", "created_0": "12/03/2008", "created_1": "11:54", } with translation.override("fr"): change_url = reverse( "admin:admin_utils_article_change", args=[quote(self.a1.pk)] ) response = self.client.post(change_url, post_data) self.assertRedirects( response, reverse("admin:admin_utils_article_changelist") ) logentry = LogEntry.objects.filter( content_type__model__iexact="article" ).latest("id") self.assertEqual(logentry.get_change_message(), "Changed Title and History.") def test_logentry_change_message_formsets(self): """ All messages for changed formsets are logged in a change message. """ a2 = Article.objects.create( site=self.site, title="Title second article", created=datetime(2012, 3, 18, 11, 54), ) post_data = { "domain": "example.com", # domain changed "admin_articles-TOTAL_FORMS": "5", "admin_articles-INITIAL_FORMS": "2", "admin_articles-MIN_NUM_FORMS": "0", "admin_articles-MAX_NUM_FORMS": "1000", # Changed title for 1st article "admin_articles-0-id": str(self.a1.pk), "admin_articles-0-site": str(self.site.pk), "admin_articles-0-title": "Changed Title", # Second article is deleted "admin_articles-1-id": str(a2.pk), "admin_articles-1-site": str(self.site.pk), "admin_articles-1-title": "Title second article", "admin_articles-1-DELETE": "on", # A new article is added "admin_articles-2-site": str(self.site.pk), "admin_articles-2-title": "Added article", } change_url = reverse( "admin:admin_utils_site_change", args=[quote(self.site.pk)] ) response = self.client.post(change_url, post_data) self.assertRedirects(response, reverse("admin:admin_utils_site_changelist")) self.assertSequenceEqual(Article.objects.filter(pk=a2.pk), []) logentry = LogEntry.objects.filter(content_type__model__iexact="site").latest( "action_time" ) self.assertEqual( json.loads(logentry.change_message), [ {"changed": {"fields": ["Domain"]}}, {"added": {"object": "Added article", "name": "article"}}, { "changed": { "fields": ["Title", "not_a_form_field"], "object": "Changed Title", "name": "article", } }, {"deleted": {"object": "Title second article", "name": "article"}}, ], ) self.assertEqual( logentry.get_change_message(), "Changed Domain. Added article “Added article”. " "Changed Title and not_a_form_field for article “Changed Title”. " "Deleted article “Title second article”.", ) with translation.override("fr"): self.assertEqual( logentry.get_change_message(), "Modification de Domain. Ajout de article « Added article ». " "Modification de Title et not_a_form_field pour l'objet " "article « Changed Title ». " "Suppression de article « Title second article ».", ) def test_logentry_get_edited_object(self): """ LogEntry.get_edited_object() returns the edited object of a LogEntry object. """ logentry = LogEntry.objects.get(content_type__model__iexact="article") edited_obj = logentry.get_edited_object() self.assertEqual(logentry.object_id, str(edited_obj.pk)) def test_logentry_get_admin_url(self): """ LogEntry.get_admin_url returns a URL to edit the entry's object or None for nonexistent (possibly deleted) models. """ logentry = LogEntry.objects.get(content_type__model__iexact="article") expected_url = reverse( "admin:admin_utils_article_change", args=(quote(self.a1.pk),) ) self.assertEqual(logentry.get_admin_url(), expected_url) self.assertIn("article/%d/change/" % self.a1.pk, logentry.get_admin_url()) logentry.content_type.model = "nonexistent" self.assertIsNone(logentry.get_admin_url()) def test_logentry_unicode(self): log_entry = LogEntry() log_entry.action_flag = ADDITION self.assertTrue(str(log_entry).startswith("Added ")) log_entry.action_flag = CHANGE self.assertTrue(str(log_entry).startswith("Changed ")) log_entry.action_flag = DELETION self.assertTrue(str(log_entry).startswith("Deleted ")) # Make sure custom action_flags works log_entry.action_flag = 4 self.assertEqual(str(log_entry), "LogEntry Object") def test_logentry_repr(self): logentry = LogEntry.objects.first() self.assertEqual(repr(logentry), str(logentry.action_time)) def test_log_action(self): content_type_pk = ContentType.objects.get_for_model(Article).pk log_entry = LogEntry.objects.log_action( self.user.pk, content_type_pk, self.a1.pk, repr(self.a1), CHANGE, change_message="Changed something else", ) self.assertEqual(log_entry, LogEntry.objects.latest("id")) def test_recentactions_without_content_type(self): """ If a LogEntry is missing content_type it will not display it in span tag under the hyperlink. """ response = self.client.get(reverse("admin:index")) link = reverse("admin:admin_utils_article_change", args=(quote(self.a1.pk),)) should_contain = """%s""" % ( escape(link), escape(repr(self.a1)), ) self.assertContains(response, should_contain) should_contain = "Article" self.assertContains(response, should_contain) logentry = LogEntry.objects.get(content_type__model__iexact="article") # If the log entry doesn't have a content type it should still be # possible to view the Recent Actions part (#10275). logentry.content_type = None logentry.save() should_contain = should_contain.encode() counted_presence_before = response.content.count(should_contain) response = self.client.get(reverse("admin:index")) counted_presence_after = response.content.count(should_contain) self.assertEqual(counted_presence_before - 1, counted_presence_after) def test_proxy_model_content_type_is_used_for_log_entries(self): """ Log entries for proxy models should have the proxy model's contenttype (#21084). """ proxy_content_type = ContentType.objects.get_for_model( ArticleProxy, for_concrete_model=False ) post_data = { "site": self.site.pk, "title": "Foo", "hist": "Bar", "created_0": "2015-12-25", "created_1": "00:00", } changelist_url = reverse("admin:admin_utils_articleproxy_changelist") # add proxy_add_url = reverse("admin:admin_utils_articleproxy_add") response = self.client.post(proxy_add_url, post_data) self.assertRedirects(response, changelist_url) proxy_addition_log = LogEntry.objects.latest("id") self.assertEqual(proxy_addition_log.action_flag, ADDITION) self.assertEqual(proxy_addition_log.content_type, proxy_content_type) # change article_id = proxy_addition_log.object_id proxy_change_url = reverse( "admin:admin_utils_articleproxy_change", args=(article_id,) ) post_data["title"] = "New" response = self.client.post(proxy_change_url, post_data) self.assertRedirects(response, changelist_url) proxy_change_log = LogEntry.objects.latest("id") self.assertEqual(proxy_change_log.action_flag, CHANGE) self.assertEqual(proxy_change_log.content_type, proxy_content_type) # delete proxy_delete_url = reverse( "admin:admin_utils_articleproxy_delete", args=(article_id,) ) response = self.client.post(proxy_delete_url, {"post": "yes"}) self.assertRedirects(response, changelist_url) proxy_delete_log = LogEntry.objects.latest("id") self.assertEqual(proxy_delete_log.action_flag, DELETION) self.assertEqual(proxy_delete_log.content_type, proxy_content_type) def test_action_flag_choices(self): tests = ((1, "Addition"), (2, "Change"), (3, "Deletion")) for action_flag, display_name in tests: with self.subTest(action_flag=action_flag): log = LogEntry(action_flag=action_flag) self.assertEqual(log.get_action_flag_display(), display_name)