test_views.py

import json
from http import HTTPStatus

import pytest
from django.conf import settings
from django.contrib.auth.models import AnonymousUser
from django.core.exceptions import PermissionDenied
from django.http import Http404
from django.http import HttpResponseRedirect
from django.test import Client
from django.test import RequestFactory
from django.urls import reverse

from democrasite.users.models import User
from democrasite.webiscite import views
from democrasite.webiscite.models import Bill

from .factories import BillFactory


class TestBillListView:
    def test_get_queryset_noauth(self, rf: RequestFactory):
        open_bill = BillFactory.create(status=Bill.Status.OPEN)
        closed_bill = BillFactory.create(status=Bill.Status.CLOSED)

        request = rf.get("/fake-url/")
        request.user = AnonymousUser()
        view = views.BillListView()
        view.request = request

        queryset = view.get_queryset()

        assert open_bill in queryset
        assert closed_bill not in queryset
        with pytest.raises(AttributeError):
            assert queryset.first().user_vote

    def test_get_queryset_auth(self, user: User, rf: RequestFactory):
        open_bill = BillFactory.create(status=Bill.Status.OPEN)
        closed_bill = BillFactory.create(status=Bill.Status.CLOSED)

        request = rf.get("/fake-url/")
        request.user = user
        view = views.BillListView()
        view.request = request

        queryset = view.get_queryset()

        assert open_bill in queryset
        assert closed_bill not in queryset
        assert queryset.first().user_vote is None


class TestBillProposalsView:
    def test_get_queryset(self, bill: Bill, rf: RequestFactory):
        assert bill.author is not None  # type guard

        view = views.BillProposalsView()
        request = rf.get("/fake-url/")
        request.user = bill.author
        view.request = request

        assert bill in view.get_queryset()

        bad_bill = BillFactory()
        assert bad_bill not in view.get_queryset()


class TestBillVotesView:
    def test_get_queryset(self, bill: Bill, rf: RequestFactory):
        # Note that this function depends heavily on the vote method, which is tested in
        # test_models.py
        user = bill.author  # could be any user, this is just for convenience
        request = rf.get("/fake-url/")
        request.user = user

        view = views.BillVotesView()
        view.request = request
        assert bill not in view.get_queryset()

        bill.vote(user, support=True)
        assert bill in view.get_queryset(), "Positive votes are included"

        bill.vote(user, support=False)
        assert bill in view.get_queryset(), "Negative votes are included"

        bill.vote(user, support=False)
        assert bill not in view.get_queryset(), (
            "When a vote is undone it gets removed from queryset"
        )


class TestBillDetailView:
    def test_get_object_noath(self, bill: Bill, user: User, rf: RequestFactory):
        request = rf.get("/fake-url/")
        request.user = AnonymousUser()
        view = views.BillDetailView(kwargs={"pk": bill.id})
        view.request = request

        view_bill = view.get_object()

        with pytest.raises(AttributeError):
            assert view_bill.user_vote

        view.request.user = user

        view_bill = view.get_object()

        assert view_bill.user_vote is None

    def test_view_response(self, bill: Bill, rf: RequestFactory):
        # Basically just test the view exists
        request = rf.get("/fake-url/")
        request.user = AnonymousUser()
        response = views.bill_detail_view(request, pk=bill.id)
        assert response.status_code == HTTPStatus.OK

    def test_bill_retrieved(self, rf: RequestFactory):
        bills = BillFactory.create_batch(5)
        request = rf.get("/fake-url/")
        request.user = AnonymousUser()
        response = views.bill_detail_view(request, pk=bills[3].id)
        assert response.status_code == HTTPStatus.OK

    def test_404(self, rf: RequestFactory):
        request = rf.get("/fake-url/")
        request.user = AnonymousUser()

        with pytest.raises(Http404):
            views.bill_detail_view(request, pk=1)


class TestBillUpdateView:
    def test_test_func(self, user: User, rf: RequestFactory, bill: Bill):
        # Unauthenticated
        noauth_request = rf.get("/fake-url/")
        noauth_request.user = AnonymousUser()

        noauth_response = views.bill_update_view(noauth_request, pk=bill.id)

        assert isinstance(noauth_response, HttpResponseRedirect)
        assert noauth_response.status_code == HTTPStatus.FOUND
        assert noauth_response.url == f"{reverse(settings.LOGIN_URL)}?next=/fake-url/"

        # Authenticated, not author
        not_author_request = rf.get("/fake-url/")
        not_author_request.user = user

        with pytest.raises(PermissionDenied):
            views.bill_update_view(not_author_request, pk=bill.id)

        # Authenticated as author
        author_request = rf.get("/fake-url/")
        author_request.user = bill.author

        author_response = views.bill_update_view(author_request, pk=bill.id)

        assert author_response.status_code == HTTPStatus.OK

    def test_messages(self, bill: Bill, client: Client):
        """Tests that bills update and emit proper messages afterwards"""
        client.force_login(bill.author)

        response = client.post(
            bill.get_update_url(),
            data={"name": "test", "description": "testing"},
            follow=True,
        )

        messages = [m.message for m in response.context["messages"]]
        assert messages == ["Information successfully updated"]


class TestVoteView:
    # I'd normally give a method-based view method-based tests, but this has many tests
    def test_not_authenticated(self, rf: RequestFactory):
        request = rf.post("/fake-url/")
        request.user = AnonymousUser()

        response = views.vote_view(request, 0)

        assert response.status_code == HTTPStatus.UNAUTHORIZED
        assert response.content == b"Login required"

    @pytest.mark.parametrize(
        ("data", "status"),
        [
            (None, HTTPStatus.BAD_REQUEST),
            ({"vote": "idk"}, HTTPStatus.BAD_REQUEST),
            ({"vote": "vote-yes"}, HTTPStatus.FORBIDDEN),
        ],
    )
    def test_not_open(self, user: User, rf: RequestFactory, data, status):
        request = rf.post("/fake-url/", data=data)
        request.user = user

        bill = BillFactory.create(status=Bill.Status.CLOSED)
        response = views.vote_view(request, bill.id)

        assert response.status_code == status
        if data is None:
            assert response.content == b'"vote" field is required.'
        elif data["vote"] == "idk":
            assert response.content == b'"vote" must be one of ("vote-yes", "vote-no").'
        else:
            assert response.content == b"Bill is not open for voting"

    @pytest.mark.parametrize("vote", ["vote-yes", "vote-no"])
    def test_vote(self, rf: RequestFactory, user: User, bill: Bill, vote):
        request = rf.post("/fake-url/", data={"vote": vote})
        request.user = user

        response = views.vote_view(request, bill.id)

        assert response.status_code == HTTPStatus.OK

        data = json.loads(response.content)
        assert data["yes-votes"] == (1 if vote == "vote-yes" else 0)
        assert data["no-votes"] == (1 if vote == "vote-no" else 0)
        assert user.votes.filter(pk=bill.pk).exists()