moviewyrm/bookwyrm/tests/views/test_group.py

285 lines
10 KiB
Python

""" test for app action functionality """
from unittest.mock import patch
from django.contrib.auth.models import AnonymousUser
from django.http import Http404
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"
), patch("bookwyrm.lists_stream.populate_lists_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
)
self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False
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_group_get_anonymous(self, _):
"""there are so many views, this just makes sure it LOADS"""
self.testgroup.privacy = "followers"
self.testgroup.save()
view = views.Group.as_view()
request = self.factory.get("")
request.user = self.anonymous_user
with self.assertRaises(Http404):
view(request, group_id=self.testgroup.id)
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_findusers_get_with_query(self, _):
"""there are so many views, this just makes sure it LOADS"""
view = views.FindUsers.as_view()
request = self.factory.get("", {"user_query": "rat"})
request.user = self.local_user
with patch("bookwyrm.suggested_users.SuggestedUsers.get_suggestions") as mock:
mock.return_value = models.User.objects.all()
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()])