dynamicweb/digitalglarus/tests.py

from datetime import date
from unittest.mock import patch

from django.contrib.auth import get_user_model
from django.test import RequestFactory, TestCase
from django.urls import reverse

from digitalglarus.forms import (
    BookingDateForm
)
from utils.forms import ContactUsForm
from digitalglarus.models import (
    BookingPrice,
    MembershipType,
    Supporter,
)
from digitalglarus.views import (
    IndexView,
    SupportusView,
    LoginView,
    SignupView,
    PasswordResetView,
    PasswordResetConfirmView,
    HistoryView,
    MembershipPricingView,
    MembershipActivatedView,
    ContactView,
    BookingSelectDatesView,
)

from factories import (
    SupporterFactory,
    BookingPriceFactory,
    CustomUserFactory,
    PostFactory,
)


User = get_user_model()


class IndexViewTests(TestCase):

    def test_get_renders_template(self):
        response = self.client.get(
            reverse("digitalglarus:landing")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "digitalglarus/index.html",
        )


class SupportusViewTests(TestCase):

    @patch("digitalglarus.views.Post.objects.filter")
    def test_get_renders_template(self, mock_filter):
        mock_filter.return_value.translated.return_value = []

        response = self.client.get(
            reverse("digitalglarus:supportus")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "digitalglarus/supportus.html",
        )
        self.assertIn("post_list", response.context)

    @patch("digitalglarus.views.Post.objects.filter")
    def test_context_contains_posts(self, mock_filter):
        posts = ["post1", "post2"]

        mock_filter.return_value.translated.return_value = posts

        request = RequestFactory().get(
            reverse("digitalglarus:supportus")
        )

        view = SupportusView()
        view.setup(request)

        context = view.get_context_data()

        self.assertEqual(
            context["post_list"],
            posts,
        )


class HistoryViewTests(TestCase):

    def test_get_renders_template(self):
        SupporterFactory()

        response = self.client.get(
            reverse("digitalglarus:history")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "digitalglarus/history.html",
        )

        self.assertIn(
            "supporters",
            response.context,
        )

    def test_context_contains_supporters(self):
        supporter = SupporterFactory()

        request = RequestFactory().get(
            reverse("digitalglarus:history")
        )

        view = HistoryView()
        view.setup(request)

        context = view.get_context_data()

        self.assertIn(
            supporter,
            context["supporters"],
        )


class LoginViewTests(TestCase):

    def test_get_renders_template(self):
        response = self.client.get(
            reverse("digitalglarus:login")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "digitalglarus/login.html",
        )

    def test_get_success_url_without_membership_orders(self):
        request = RequestFactory().get(
            reverse("digitalglarus:login")
        )

        request.user = CustomUserFactory.create()

        view = LoginView()
        view.setup(request)

        result = view.get_success_url()

        self.assertEqual(
            result,
            reverse("digitalglarus:membership_pricing"),
        )


class SignupViewTests(TestCase):

    def test_get_renders_template(self):
        response = self.client.get(
            reverse("digitalglarus:signup")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "digitalglarus/signup.html",
        )

    def test_success_url(self):
        view = SignupView()

        self.assertEqual(
            str(view.success_url),
            reverse("digitalglarus:login"),
        )


class PasswordResetViewTests(TestCase):

    def test_get_renders_template(self):
        response = self.client.get(
            reverse("digitalglarus:reset_password")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "digitalglarus/reset_password.html",
        )


class PasswordResetConfirmViewTests(TestCase):

    def test_template_name(self):
        view = PasswordResetConfirmView()

        self.assertEqual(
            view.template_name,
            "digitalglarus/confirm_reset_password.html",
        )

    def test_success_url(self):
        view = PasswordResetConfirmView()

        self.assertEqual(
            str(view.success_url),
            reverse("digitalglarus:login"),
        )


class MembershipPricingViewTests(TestCase):

    @patch(
        "digitalglarus.views.MembershipType.objects.last"
    )
    def test_get_renders_template(self, mock_last):
        membership_type = object()
        mock_last.return_value = membership_type

        response = self.client.get(
            reverse("digitalglarus:membership_pricing")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "digitalglarus/membership_pricing.html",
        )

        self.assertEqual(
            response.context["membership_type"],
            membership_type,
        )


class MembershipActivatedViewTests(TestCase):

    def test_get_renders_template(self):
        session = self.client.session

        session["membership_price"] = 100
        session["membership_dates"] = "01/01/2026 - 01/31/2026"
        session.save()

        response = self.client.get(
            reverse("digitalglarus:membership_activated")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "digitalglarus/membership_activated.html",
        )

        self.assertEqual(
            response.context["membership_price"],
            100,
        )

        self.assertEqual(
            response.context["membership_dates"],
            "01/01/2026 - 01/31/2026",
        )


class ContactViewTests(TestCase):

    def test_get_renders_template(self):
        response = self.client.get(
            reverse("digitalglarus:contact")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "contact.html",
        )

    def test_get_uses_contact_form(self):
        response = self.client.get(
            reverse("digitalglarus:contact")
        )

        self.assertIsInstance(
            response.context["form"],
            ContactUsForm,
        )

    def test_form_valid_redirects_to_contact(self):
        view = ContactView()

        request = RequestFactory().post(
            reverse("digitalglarus:contact")
        )

        view.setup(request)

        form = ContactUsForm()

        with patch.object(
            ContactUsForm,
            "is_valid",
            return_value=True,
        ):
            response = view.form_valid(form)

        self.assertEqual(
            response.status_code,
            302,
        )

        self.assertEqual(
            response.url,
            reverse("digitalglarus:contact"),
        )


class BookingSelectDatesViewTests(TestCase):

    def test_get_requires_login(self):
        response = self.client.get(
            reverse("digitalglarus:booking")
        )

        self.assertEqual(response.status_code, 302)

    def test_success_url(self):
        view = BookingSelectDatesView()

        self.assertEqual(
            str(view.success_url),
            reverse("digitalglarus:booking_payment"),
        )

    def test_get_form_kwargs_contains_user(self):
        user = CustomUserFactory.create(
            email="test@example.com",
            password="password123",
        )

        request = RequestFactory().get(
            reverse("digitalglarus:booking")
        )
        request.user = user

        view = BookingSelectDatesView()
        view.setup(request)

        with patch(
            "digitalglarus.views.FormView.get_form_kwargs",
            return_value={},
        ):
            kwargs = view.get_form_kwargs()

        self.assertEqual(
            kwargs["user"],
            user,
        )


class OldFunctionViewTests(TestCase):

    @patch("digitalglarus.views.Post.objects.translated")
    def test_blog_renders_template(self, mock_translated):
        mock_translated.return_value = []

        response = self.client.get(
            reverse("digitalglarus:blog")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "glarus_blog/post_list.html",
        )

        self.assertIn(
            "post_list",
            response.context,
        )

    def test_blog_detail_renders_template(self):
        post = PostFactory.create()
        response = self.client.get(
            reverse(
                "digitalglarus:blog-detail",
                kwargs={"slug": post.slug},
            )
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "glarus_blog/post_detail.html",
        )

        self.assertIn(
            "post",
            response.context,
        )

    def test_blog_detail_returns_404_when_post_does_not_exist(self):
        with patch(
            "digitalglarus.views.Post.objects.translated"
        ) as mock_translated:

            mock_translated.return_value.first.return_value = None

            response = self.client.get(
                reverse(
                    "digitalglarus:blog-detail",
                    kwargs={"slug": "missing-post"},
                )
            )

        self.assertEqual(response.status_code, 404)

    def test_support_renders_template(self):
        response = self.client.get(
            reverse("digitalglarus:support")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "digitalglarus/supportus.html",
        )

    def test_supporters_renders_template(self):
        SupporterFactory()

        response = self.client.get(
            reverse("digitalglarus:supporters")
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(
            response,
            "supporters.html",
        )

        self.assertIn(
            "supporters",
            response.context,
        )


class BookingPaymentViewTests(TestCase):

    def test_get_without_booking_data_redirects_to_booking(self):
        response = self.client.get(
            reverse("digitalglarus:booking_payment")
        )

        self.assertRedirects(
            response,
            reverse("digitalglarus:booking"),
            fetch_redirect_response=False,
        )


class MembershipDeactivateViewTests(TestCase):

    def test_get_requires_login(self):
        response = self.client.get(
            reverse("digitalglarus:membership_deactivate")
        )

        self.assertEqual(response.status_code, 302)