moviewyrm/bookwyrm/tests/views/test_group.py

""" test for app action functionality """
from unittest.mock import patch

from django.template.response import TemplateResponse
from django.test import TestCase
from django.test.client import RequestFactory

from bookwyrm import models, views
from bookwyrm.tests.validate_html import validate_html


@patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async")
class GroupViews(TestCase):
    """view group and edit details"""

    def setUp(self):
        """we need basic test data and mocks"""
        self.factory = RequestFactory()
        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch(
            "bookwyrm.activitystreams.populate_stream_task.delay"
        ):
            self.local_user = models.User.objects.create_user(
                "mouse@local.com",
                "mouse@mouse.mouse",
                "password",
                local=True,
                localname="mouse",
            )
            self.rat = models.User.objects.create_user(
                "rat@local.com",
                "rat@rat.rat",
                "password",
                local=True,
                localname="rat",
            )

        self.testgroup = models.Group.objects.create(
            name="Test Group",
            description="Initial description",
            user=self.local_user,
            privacy="public",
        )
        self.membership = models.GroupMember.objects.create(
            group=self.testgroup, user=self.local_user
        )

        models.SiteSettings.objects.create()

    def test_group_get(self, _):
        """there are so many views, this just makes sure it LOADS"""
        view = views.Group.as_view()
        request = self.factory.get("")
        request.user = self.local_user
        result = view(request, group_id=self.testgroup.id)
        self.assertIsInstance(result, TemplateResponse)
        validate_html(result.render())
        self.assertEqual(result.status_code, 200)

    def test_usergroups_get(self, _):
        """there are so many views, this just makes sure it LOADS"""
        view = views.UserGroups.as_view()
        request = self.factory.get("")
        request.user = self.local_user
        result = view(request, username="mouse@local.com")
        self.assertIsInstance(result, TemplateResponse)
        validate_html(result.render())
        self.assertEqual(result.status_code, 200)

    @patch("bookwyrm.suggested_users.SuggestedUsers.get_suggestions")
    def test_findusers_get(self, *_):
        """there are so many views, this just makes sure it LOADS"""
        view = views.FindUsers.as_view()
        request = self.factory.get("")
        request.user = self.local_user
        result = view(request, group_id=self.testgroup.id)
        self.assertIsInstance(result, TemplateResponse)
        validate_html(result.render())
        self.assertEqual(result.status_code, 200)

    def test_group_create(self, _):
        """create group view"""
        view = views.UserGroups.as_view()
        request = self.factory.post(
            "",
            {
                "name": "A group",
                "description": "wowzers",
                "privacy": "unlisted",
                "user": self.local_user.id,
            },
        )
        request.user = self.local_user
        result = view(request, "username")

        self.assertEqual(result.status_code, 302)
        new_group = models.Group.objects.filter(name="A group").get()
        self.assertEqual(new_group.description, "wowzers")
        self.assertEqual(new_group.privacy, "unlisted")
        self.assertTrue(
            models.GroupMember.objects.filter(
                group=new_group, user=self.local_user
            ).exists()
        )

    def test_group_edit(self, _):
        """test editing a "group" database entry"""
        view = views.Group.as_view()
        request = self.factory.post(
            "",
            {
                "name": "Updated Group name",
                "description": "wow",
                "privacy": "direct",
                "user": self.local_user.id,
            },
        )
        request.user = self.local_user

        result = view(request, group_id=self.testgroup.id)
        self.assertEqual(result.status_code, 302)
        self.testgroup.refresh_from_db()
        self.assertEqual(self.testgroup.name, "Updated Group name")
        self.assertEqual(self.testgroup.description, "wow")
        self.assertEqual(self.testgroup.privacy, "direct")

    def test_delete_group(self, _):
        """delete a group"""
        request = self.factory.post("")
        request.user = self.local_user
        views.delete_group(request, self.testgroup.id)
        self.assertFalse(models.Group.objects.exists())

    def test_invite_member(self, _):
        """invite a member to a group"""
        request = self.factory.post(
            "",
            {
                "group": self.testgroup.id,
                "user": self.rat.localname,
            },
        )
        request.user = self.local_user
        result = views.invite_member(request)
        self.assertEqual(result.status_code, 302)

        invite = models.GroupMemberInvitation.objects.get()
        self.assertEqual(invite.user, self.rat)
        self.assertEqual(invite.group, self.testgroup)

    def test_invite_member_twice(self, _):
        """invite a member to a group again"""
        request = self.factory.post(
            "",
            {
                "group": self.testgroup.id,
                "user": self.rat.localname,
            },
        )
        request.user = self.local_user
        result = views.invite_member(request)
        self.assertEqual(result.status_code, 302)
        result = views.invite_member(request)
        self.assertEqual(result.status_code, 302)

    def test_remove_member_denied(self, _):
        """remove member"""
        request = self.factory.post(
            "",
            {
                "group": self.testgroup.id,
                "user": self.local_user.localname,
            },
        )
        request.user = self.local_user
        result = views.remove_member(request)
        self.assertEqual(result.status_code, 400)

    def test_remove_member_non_member(self, _):
        """remove member but wait, that's not a member"""
        request = self.factory.post(
            "",
            {
                "group": self.testgroup.id,
                "user": self.rat.localname,
            },
        )
        request.user = self.local_user
        result = views.remove_member(request)
        # nothing happens
        self.assertEqual(result.status_code, 302)

    def test_remove_member_invited(self, _):
        """remove an invited member"""
        models.GroupMemberInvitation.objects.create(
            user=self.rat,
            group=self.testgroup,
        )
        request = self.factory.post(
            "",
            {
                "group": self.testgroup.id,
                "user": self.rat.localname,
            },
        )
        request.user = self.local_user
        result = views.remove_member(request)
        self.assertEqual(result.status_code, 302)
        self.assertFalse(models.GroupMemberInvitation.objects.exists())

    def test_remove_member_existing_member(self, _):
        """remove an invited member"""
        models.GroupMember.objects.create(
            user=self.rat,
            group=self.testgroup,
        )
        request = self.factory.post(
            "",
            {
                "group": self.testgroup.id,
                "user": self.rat.localname,
            },
        )
        request.user = self.local_user
        result = views.remove_member(request)
        self.assertEqual(result.status_code, 302)
        self.assertEqual(models.GroupMember.objects.count(), 1)
        self.assertEqual(models.GroupMember.objects.first().user, self.local_user)
        notification = models.Notification.objects.get()
        self.assertEqual(notification.user, self.rat)
        self.assertEqual(notification.related_group, self.testgroup)
        self.assertEqual(notification.notification_type, "REMOVE")

    def test_accept_membership(self, _):
        """accept an invite"""
        models.GroupMemberInvitation.objects.create(
            user=self.rat,
            group=self.testgroup,
        )
        request = self.factory.post("", {"group": self.testgroup.id})
        request.user = self.rat
        views.accept_membership(request)

        self.assertFalse(models.GroupMemberInvitation.objects.exists())
        self.assertTrue(self.rat in [m.user for m in self.testgroup.memberships.all()])

    def test_reject_membership(self, _):
        """reject an invite"""
        models.GroupMemberInvitation.objects.create(
            user=self.rat,
            group=self.testgroup,
        )
        request = self.factory.post("", {"group": self.testgroup.id})
        request.user = self.rat
        views.reject_membership(request)

        self.testgroup.refresh_from_db()
        self.assertFalse(models.GroupMemberInvitation.objects.exists())
        self.assertFalse(self.rat in [m.user for m in self.testgroup.memberships.all()])