Viewing github.com/django/django-stable-4.1.x/tests/admin_utils/test

```
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="[email protected]"

```
        )
```

        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.assertQuerysetEqual(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 = """<a href="%s">%s</a>""" % (

```
            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)