tests.py

from contextlib import redirect_stderr
from datetime import timedelta
from io import StringIO

from django.contrib.auth.models import User
from django.test import TestCase
from django.urls import reverse
from django.utils import timezone

from .models import ContentFormat, Entry, Event
from .sitemaps import WeblogSitemap


class DateTimeMixin:
    def setUp(self):
        self.now = timezone.now()
        self.yesterday = self.now - timedelta(days=1)
        self.tomorrow = self.now + timedelta(days=1)


class EntryTestCase(DateTimeMixin, TestCase):
    def test_manager_active(self):
        """
        Make sure that the Entry manager's `active` method works
        """
        Entry.objects.create(
            pub_date=self.now, is_active=False, headline="inactive", slug="a"
        )
        Entry.objects.create(
            pub_date=self.now, is_active=True, headline="active", slug="b"
        )

        self.assertQuerySetEqual(
            Entry.objects.published(),
            ["active"],
            transform=lambda entry: entry.headline,
        )

    def test_manager_published(self):
        """
        Make sure that the Entry manager's `published` method works
        """
        Entry.objects.create(
            pub_date=self.yesterday, is_active=False, headline="past inactive", slug="a"
        )
        Entry.objects.create(
            pub_date=self.yesterday, is_active=True, headline="past active", slug="b"
        )
        Entry.objects.create(
            pub_date=self.tomorrow,
            is_active=False,
            headline="future inactive",
            slug="c",
        )
        Entry.objects.create(
            pub_date=self.tomorrow, is_active=True, headline="future active", slug="d"
        )

        self.assertQuerySetEqual(
            Entry.objects.published(),
            ["past active"],
            transform=lambda entry: entry.headline,
        )

    def test_docutils_safe(self):
        """
        Make sure docutils' file inclusion directives are disabled by default.
        """
        with redirect_stderr(StringIO()):
            entry = Entry.objects.create(
                pub_date=self.now,
                is_active=True,
                headline="active",
                content_format="reST",
                body=".. raw:: html\n    :file: somefile\n",
                slug="a",
            )
        self.assertIn("<p>&quot;raw&quot; directive disabled.</p>", entry.body_html)
        self.assertIn(".. raw:: html\n    :file: somefile", entry.body_html)

    def test_content_format_html(self):
        entry = Entry.objects.create(
            pub_date=self.now,
            slug="a",
            body="<strong>test</strong>",
            content_format=ContentFormat.HTML,
        )
        self.assertHTMLEqual(entry.body_html, "<strong>test</strong>")

    def test_content_format_reST(self):
        entry = Entry.objects.create(
            pub_date=self.now,
            slug="a",
            body="**test**",
            content_format=ContentFormat.REST,
        )
        self.assertHTMLEqual(entry.body_html, "<p><strong>test</strong></p>")

    def test_content_format_markdown(self):
        entry = Entry.objects.create(
            pub_date=self.now,
            slug="a",
            body="**test**",
            content_format=ContentFormat.MARKDOWN,
        )
        self.assertHTMLEqual(entry.body_html, "<p><strong>test</strong></p>")

    def test_header_base_level_reST(self):
        entry = Entry.objects.create(
            pub_date=self.now,
            slug="a",
            body="test\n====",
            content_format=ContentFormat.REST,
        )
        self.assertHTMLEqual(
            entry.body_html, '<div class="section" id="s-test"><h3>test</h3></div>'
        )

    def test_header_base_level_markdown(self):
        entry = Entry.objects.create(
            pub_date=self.now,
            slug="a",
            body="# test",
            content_format=ContentFormat.MARKDOWN,
        )
        self.assertHTMLEqual(entry.body_html, '<h3 id="s-test">test</h3>')


class EventTestCase(DateTimeMixin, TestCase):
    def test_manager_past_future(self):
        """
        Make sure that the Event manager's `past` and `future` methods works
        """
        Event.objects.create(date=self.yesterday, pub_date=self.now, headline="past")
        Event.objects.create(date=self.tomorrow, pub_date=self.now, headline="future")

        self.assertQuerySetEqual(
            Event.objects.future(), ["future"], transform=lambda event: event.headline
        )
        self.assertQuerySetEqual(
            Event.objects.past(), ["past"], transform=lambda event: event.headline
        )

    def test_manager_past_future_include_today(self):
        """
        Make sure that both .future() and .past() include today's events.
        """
        Event.objects.create(date=self.now, pub_date=self.now, headline="today")

        self.assertQuerySetEqual(
            Event.objects.future(), ["today"], transform=lambda event: event.headline
        )
        self.assertQuerySetEqual(
            Event.objects.past(), ["today"], transform=lambda event: event.headline
        )

    def test_past_future_ordering(self):
        """
        Make sure the that .future() and .past() use the actual date for ordering
        (and not the pub_date).
        """
        D = timedelta(days=1)
        Event.objects.create(
            date=self.yesterday - D, pub_date=self.yesterday - D, headline="a"
        )
        Event.objects.create(date=self.yesterday, pub_date=self.yesterday, headline="b")

        Event.objects.create(date=self.tomorrow, pub_date=self.tomorrow, headline="c")
        Event.objects.create(
            date=self.tomorrow + D, pub_date=self.tomorrow + D, headline="d"
        )

        self.assertQuerySetEqual(
            Event.objects.future(), ["c", "d"], transform=lambda event: event.headline
        )
        self.assertQuerySetEqual(
            Event.objects.past(), ["b", "a"], transform=lambda event: event.headline
        )


class ViewsTestCase(DateTimeMixin, TestCase):
    """
    TODO:
        * anon users can't see unpublished entries at all (list or detail)
        * logged in users (non-staff) can't see unpublished entries at all
        * staff users without write permission on BlogEntry can't see unpublished
        entries at all
        * staff users with write permission on BlogEntry can't see unpublished
        entries in the list, but can view the detail page
    """

    # def test_anonymous_user_cant_see_entries(self):
    #     """
    #     A test which creates an unpublished entry and then loads the list view
    #     followed by detail view as an anonymous user to check that the entry cannot
    #     be seen.
    #     """
    #     e1 = Entry.objects.create(
    #         pub_date=self.yesterday, is_active=False, headline="inactive", slug="a"
    #     )
    #     e2 = Entry.objects.create(
    #         pub_date=self.yesterday, is_active=True, headline="active", slug="b"
    #     )
    #     response = self.client.get(reverse("weblog:index"))
    #     self.assertNotContains(response, "active")
    #     response = self.client.get(
    #         reverse(
    #             "weblog:entry",
    #             kwargs={
    #                 "year": e1.pub_date.year,
    #                 "month": e1.pub_date.month,
    #                 "day": e1.pub_date.day,
    #                 "slug": e1.slug,
    #             },
    #         )
    #     )
    #     self.assertEqual(response.status_code, 404)
    #     response = self.client.get(
    #         reverse(
    #             "weblog:entry",
    #             kwargs={
    #                 "year": e2.pub_date.year,
    #                 "month": e2.pub_date.month,
    #                 "day": e2.pub_date.day,
    #                 "slug": e2.slug,
    #             },
    #         )
    #     )
    #     self.assertEqual(response.status_code, 404)
    #
    # def test_logged_in_user_cant_see_entries(self):
    #     """
    #     A test which creates an unpublished entry and then loads the list view
    #     followed by detail view as a non-staff user to check that the entry cannot be
    #     seen.
    #     """
    #     e = Entry.objects.create(
    #         pub_date=self.yesterday, is_active=False, headline="inactive", slug="a"
    #     )
    #     user = User.objects.create_user("user", "user@example.com", "password")
    #     self.client.force_login(user)
    #     response = self.client.get(reverse("weblog:index"))
    #     self.assertNotContains(response, "active")
    #     response = self.client.get(
    #         reverse(
    #             "weblog:entry",
    #             kwargs={
    #                 "year": e.pub_date.year,
    #                 "month": e.pub_date.month,
    #                 "day": e.pub_date.day,
    #                 "slug": e.slug,
    #             },
    #         )
    #     )
    #     self.assertEqual(response.status_code, 404)
    #
    # def test_staff_no_write_permission_cant_see_entries(self):
    #     """
    #     A test which creates an unpublished entry and then loads the list view
    #     followed by detail view as a staff user without blog write permissions to
    #     check that the entry cannot be seen.
    #     """
    #     e1 = Entry.objects.create(
    #         pub_date=self.yesterday, is_active=False, headline="inactive", slug="a"
    #     )
    #     e2 = Entry.objects.create(
    #         pub_date=self.yesterday, is_active=True, headline="active", slug="b"
    #     )
    #     user = User.objects.create_user(
    #         "staff", "staff@example.com", "password", is_staff=True
    #     )
    #     self.client.force_login(user)
    #     response = self.client.get(reverse("weblog:index"))
    #
    #     self.assertContains(response, "active")
    #     response = self.client.get(
    #         reverse(
    #             "weblog:entry",
    #             kwargs={
    #                 "year": e1.pub_date.year,
    #                 "month": e1.pub_date.month,
    #                 "day": e1.pub_date.day,
    #                 "slug": e1.slug,
    #             },
    #         )
    #     )
    #     self.assertEqual(response.status_code, 404)
    #     response = self.client.get(
    #         reverse(
    #             "weblog:entry",
    #             kwargs={
    #                 "year": e2.pub_date.year,
    #                 "month": e2.pub_date.month,
    #                 "day": e2.pub_date.day,
    #                 "slug": e2.slug,
    #             },
    #         )
    #     )
    #     self.assertEqual(response.status_code, 404)

    def test_staff_with_write_permission_can_see_unpublished_detail_view(self):
        """
        staff users with write permission on BlogEntry can't see unpublished entries
        in the list, but can view the detail page
        """
        e1 = Entry.objects.create(
            pub_date=self.yesterday, is_active=False, headline="inactive", slug="a"
        )
        user = User.objects.create(username="staff", is_staff=True)
        self.client.force_login(user)
        self.assertEqual(Entry.objects.all().count(), 1)
        response = self.client.get(reverse("weblog:index"))
        self.assertEqual(response.status_code, 404)

        response = self.client.get(
            reverse(
                "weblog:entry",
                kwargs={
                    "year": e1.pub_date.year,
                    "month": e1.pub_date.month,
                    "day": e1.pub_date.day,
                    "slug": e1.slug,
                },
            )
        )
        request = response.context["request"]
        self.assertTrue(request.user.is_staff)
        self.assertEqual(response.status_code, 200)

    def test_no_past_upcoming_events(self):
        """
        Make sure there are no past event in the "upcoming events" sidebar (#399)
        """
        # We need a published entry on the index page so that it doesn't return a 404
        Entry.objects.create(pub_date=self.yesterday, is_active=True, slug="a")
        Event.objects.create(
            date=self.yesterday, pub_date=self.now, is_active=True, headline="Jezdezcon"
        )
        response = self.client.get(reverse("weblog:index"))
        self.assertEqual(response.status_code, 200)
        self.assertQuerySetEqual(response.context["events"], [])

    def test_no_unpublished_future_events(self):
        """
        Make sure there are no unpublished future events in the "upcoming events" sidebar
        """
        # We need a published entry on the index page so that it doesn't return a 404
        Entry.objects.create(pub_date=self.yesterday, is_active=True, slug="a")
        Event.objects.create(
            date=self.tomorrow,
            pub_date=self.yesterday,
            is_active=False,
            headline="inactive",
        )
        Event.objects.create(
            date=self.tomorrow,
            pub_date=self.tomorrow,
            is_active=True,
            headline="future publish date",
        )

        for user in [
            None,
            User.objects.create(username="non-staff", is_staff=False),
            User.objects.create(username="staff", is_staff=True),
            User.objects.create_superuser(username="superuser"),
        ]:
            if user:
                self.client.force_login(user)
            response = self.client.get(reverse("weblog:index"))
            with self.subTest(user=user):
                self.assertEqual(response.status_code, 200)
                self.assertQuerySetEqual(response.context["events"], [])


class SitemapTests(DateTimeMixin, TestCase):
    def test_sitemap(self):
        entry = Entry.objects.create(
            pub_date=self.yesterday, is_active=True, headline="foo", slug="foo"
        )
        sitemap = WeblogSitemap()
        urls = sitemap.get_urls()
        self.assertEqual(len(urls), 1)
        url_info = urls[0]
        self.assertEqual(url_info["location"], entry.get_absolute_url())