moviewyrm/bookwyrm/tests/models/test_status_model.py

533 lines
22 KiB
Python
Raw Normal View History

2021-03-08 16:49:10 +00:00
""" testing models """
2021-02-09 20:48:46 +00:00
from unittest.mock import patch
2020-12-18 19:00:30 +00:00
from io import BytesIO
import pathlib
2021-11-11 21:35:56 +00:00
import re
2020-12-18 19:00:30 +00:00
from django.http import Http404
2020-12-18 19:00:30 +00:00
from django.core.files.base import ContentFile
2020-12-18 19:34:21 +00:00
from django.db import IntegrityError
from django.contrib.auth.models import AnonymousUser
2020-05-10 00:10:02 +00:00
from django.test import TestCase
2020-12-18 19:00:30 +00:00
from django.utils import timezone
from PIL import Image
import responses
2020-05-10 00:10:02 +00:00
from bookwyrm import activitypub, models, settings
2020-05-10 00:10:02 +00:00
# pylint: disable=too-many-public-methods
2021-10-01 21:41:30 +00:00
# pylint: disable=line-too-long
2021-03-08 16:49:10 +00:00
@patch("bookwyrm.models.Status.broadcast")
2021-09-06 20:53:49 +00:00
@patch("bookwyrm.activitystreams.add_status_task.delay")
2021-09-06 23:59:58 +00:00
@patch("bookwyrm.activitystreams.remove_status_task.delay")
2020-05-10 00:10:02 +00:00
class Status(TestCase):
2021-04-26 16:15:42 +00:00
"""lotta types of statuses"""
2021-03-08 16:49:10 +00:00
2020-05-10 00:10:02 +00:00
def setUp(self):
2021-04-26 16:15:42 +00:00
"""useful things for creating a status"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch(
"bookwyrm.activitystreams.populate_stream_task.delay"
):
2021-08-03 17:25:53 +00:00
self.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
)
2021-08-02 23:05:40 +00:00
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
2021-05-26 21:57:29 +00:00
)
2021-08-02 23:05:40 +00:00
self.book = models.Edition.objects.create(title="Test Edition")
image_file = pathlib.Path(__file__).parent.joinpath(
"../../static/images/default_avi.jpg"
)
image = Image.open(image_file)
output = BytesIO()
with patch("bookwyrm.models.Status.broadcast"):
image.save(output, format=image.format)
self.book.cover.save("test.jpg", ContentFile(output.getvalue()))
2020-05-10 00:10:02 +00:00
self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False
2021-03-23 17:41:18 +00:00
def test_status_generated_fields(self, *_):
2021-04-26 16:15:42 +00:00
"""setting remote id"""
status = models.Status.objects.create(content="bleh", user=self.local_user)
expected_id = f"https://{settings.DOMAIN}/user/mouse/status/{status.id}"
self.assertEqual(status.remote_id, expected_id)
2021-03-08 16:49:10 +00:00
self.assertEqual(status.privacy, "public")
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_replies(self, *_):
2021-04-26 16:15:42 +00:00
"""get a list of replies"""
2021-10-01 21:41:30 +00:00
parent = models.Status(content="hi", user=self.local_user)
parent.save(broadcast=False)
child = models.Status(
content="hello", reply_parent=parent, user=self.local_user
2021-03-08 16:49:10 +00:00
)
2021-10-01 21:41:30 +00:00
child.save(broadcast=False)
sibling = models.Review(
2021-08-02 23:05:40 +00:00
content="hey", reply_parent=parent, user=self.local_user, book=self.book
)
2021-10-01 21:41:30 +00:00
sibling.save(broadcast=False)
grandchild = models.Status(
content="hi hello", reply_parent=child, user=self.local_user
2021-03-08 16:49:10 +00:00
)
2021-10-01 21:41:30 +00:00
grandchild.save(broadcast=False)
2020-12-18 19:00:30 +00:00
replies = models.Status.replies(parent)
self.assertEqual(replies.count(), 2)
self.assertEqual(replies.first(), child)
# should select subclasses
self.assertIsInstance(replies.last(), models.Review)
2021-10-01 21:41:30 +00:00
self.assertEqual(parent.thread_id, parent.id)
self.assertEqual(child.thread_id, parent.id)
self.assertEqual(sibling.thread_id, parent.id)
self.assertEqual(grandchild.thread_id, parent.id)
2021-03-23 17:41:18 +00:00
def test_status_type(self, *_):
2021-04-26 16:15:42 +00:00
"""class name"""
2021-03-08 16:49:10 +00:00
self.assertEqual(models.Status().status_type, "Note")
self.assertEqual(models.Review().status_type, "Review")
self.assertEqual(models.Quotation().status_type, "Quotation")
self.assertEqual(models.Comment().status_type, "Comment")
self.assertEqual(models.Boost().status_type, "Announce")
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_boostable(self, *_):
2021-04-26 16:15:42 +00:00
"""can a status be boosted, based on privacy"""
2021-03-08 16:49:10 +00:00
self.assertTrue(models.Status(privacy="public").boostable)
self.assertTrue(models.Status(privacy="unlisted").boostable)
self.assertFalse(models.Status(privacy="followers").boostable)
self.assertFalse(models.Status(privacy="direct").boostable)
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_to_replies(self, *_):
2021-04-26 16:15:42 +00:00
"""activitypub replies collection"""
parent = models.Status.objects.create(content="hi", user=self.local_user)
2020-12-18 19:00:30 +00:00
child = models.Status.objects.create(
content="hello", reply_parent=parent, user=self.local_user
2021-03-08 16:49:10 +00:00
)
2021-08-02 23:05:40 +00:00
models.Review.objects.create(
content="hey", reply_parent=parent, user=self.local_user, book=self.book
)
2020-12-18 19:00:30 +00:00
models.Status.objects.create(
content="hi hello", reply_parent=child, user=self.local_user
2021-03-08 16:49:10 +00:00
)
2020-12-18 19:00:30 +00:00
replies = parent.to_replies()
self.assertEqual(replies["id"], f"{parent.remote_id}/replies")
2021-03-08 16:49:10 +00:00
self.assertEqual(replies["totalItems"], 2)
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_status_to_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
status = models.Status.objects.create(
content="test content", user=self.local_user
)
2020-12-18 19:00:30 +00:00
activity = status.to_activity()
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Note")
self.assertEqual(activity["content"], "test content")
self.assertEqual(activity["sensitive"], False)
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_status_to_activity_tombstone(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2021-09-06 23:59:58 +00:00
status = models.Status.objects.create(
content="test content",
user=self.local_user,
deleted=True,
deleted_date=timezone.now(),
)
2020-12-18 19:00:30 +00:00
activity = status.to_activity()
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Tombstone")
self.assertFalse(hasattr(activity, "content"))
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_status_to_pure_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
status = models.Status.objects.create(
content="test content", user=self.local_user
)
2020-12-18 19:00:30 +00:00
activity = status.to_activity(pure=True)
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Note")
self.assertEqual(activity["content"], "test content")
self.assertEqual(activity["sensitive"], False)
self.assertEqual(activity["attachment"], [])
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_generated_note_to_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2020-12-18 19:00:30 +00:00
status = models.GeneratedNote.objects.create(
content="test content", user=self.local_user
2021-03-08 16:49:10 +00:00
)
2020-12-18 19:00:30 +00:00
status.mention_books.set([self.book])
status.mention_users.set([self.local_user])
2020-12-18 19:00:30 +00:00
activity = status.to_activity()
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "GeneratedNote")
self.assertEqual(activity["content"], "test content")
self.assertEqual(activity["sensitive"], False)
self.assertEqual(len(activity["tag"]), 2)
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_generated_note_to_pure_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2020-12-18 19:00:30 +00:00
status = models.GeneratedNote.objects.create(
content="test content", user=self.local_user
2021-03-08 16:49:10 +00:00
)
2020-12-18 19:00:30 +00:00
status.mention_books.set([self.book])
status.mention_users.set([self.local_user])
2020-12-18 19:00:30 +00:00
activity = status.to_activity(pure=True)
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
2020-12-18 19:00:30 +00:00
self.assertEqual(
2021-03-08 16:49:10 +00:00
activity["content"],
f'mouse test content <a href="{self.book.remote_id}">"Test Edition"</a>',
2021-03-08 16:49:10 +00:00
)
self.assertEqual(len(activity["tag"]), 2)
self.assertEqual(activity["type"], "Note")
self.assertEqual(activity["sensitive"], False)
self.assertIsInstance(activity["attachment"], list)
self.assertEqual(activity["attachment"][0].type, "Document")
2021-11-11 21:35:56 +00:00
self.assertTrue(
re.match(
r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
activity["attachment"][0].url,
)
2021-03-08 16:49:10 +00:00
)
self.assertEqual(activity["attachment"][0].name, "Test Edition")
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_comment_to_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2020-12-18 19:00:30 +00:00
status = models.Comment.objects.create(
content="test content", user=self.local_user, book=self.book
2021-03-08 16:49:10 +00:00
)
2020-12-18 19:00:30 +00:00
activity = status.to_activity()
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Comment")
self.assertEqual(activity["content"], "test content")
self.assertEqual(activity["inReplyToBook"], self.book.remote_id)
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_comment_to_pure_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2020-12-18 19:00:30 +00:00
status = models.Comment.objects.create(
content="test content", user=self.local_user, book=self.book
2021-03-08 16:49:10 +00:00
)
2020-12-18 19:00:30 +00:00
activity = status.to_activity(pure=True)
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Note")
2020-12-18 19:00:30 +00:00
self.assertEqual(
2021-03-08 16:49:10 +00:00
activity["content"],
f'test content<p>(comment on <a href="{self.book.remote_id}">"Test Edition"</a>)</p>',
2021-03-08 16:49:10 +00:00
)
self.assertEqual(activity["attachment"][0].type, "Document")
2021-11-11 21:35:56 +00:00
self.assertTrue(
re.match(
r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
activity["attachment"][0].url,
)
2021-03-08 16:49:10 +00:00
)
self.assertEqual(activity["attachment"][0].name, "Test Edition")
2020-12-18 19:00:30 +00:00
2021-03-23 17:41:18 +00:00
def test_quotation_to_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2020-12-18 19:00:30 +00:00
status = models.Quotation.objects.create(
2021-03-08 16:49:10 +00:00
quote="a sickening sense",
content="test content",
user=self.local_user,
2021-03-08 16:49:10 +00:00
book=self.book,
)
2020-12-18 19:00:30 +00:00
activity = status.to_activity()
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Quotation")
self.assertEqual(activity["quote"], "a sickening sense")
self.assertEqual(activity["content"], "test content")
self.assertEqual(activity["inReplyToBook"], self.book.remote_id)
2020-05-10 00:10:02 +00:00
2021-03-23 17:41:18 +00:00
def test_quotation_to_pure_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2020-12-18 19:00:30 +00:00
status = models.Quotation.objects.create(
2021-03-08 16:49:10 +00:00
quote="a sickening sense",
content="test content",
user=self.local_user,
2021-03-08 16:49:10 +00:00
book=self.book,
)
2020-12-18 19:00:30 +00:00
activity = status.to_activity(pure=True)
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Note")
2020-12-18 19:00:30 +00:00
self.assertEqual(
2021-03-08 16:49:10 +00:00
activity["content"],
f'a sickening sense <p>-- <a href="{self.book.remote_id}">"Test Edition"</a></p>test content',
2021-03-08 16:49:10 +00:00
)
self.assertEqual(activity["attachment"][0].type, "Document")
2021-11-11 21:35:56 +00:00
self.assertTrue(
re.match(
r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
activity["attachment"][0].url,
)
2021-03-08 16:49:10 +00:00
)
self.assertEqual(activity["attachment"][0].name, "Test Edition")
2020-12-18 19:34:21 +00:00
2021-03-23 17:41:18 +00:00
def test_review_to_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2021-08-02 23:05:40 +00:00
status = models.Review.objects.create(
name="Review name",
content="test content",
rating=3.0,
user=self.local_user,
book=self.book,
)
activity = status.to_activity()
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Review")
self.assertEqual(activity["rating"], 3)
self.assertEqual(activity["name"], "Review name")
self.assertEqual(activity["content"], "test content")
self.assertEqual(activity["inReplyToBook"], self.book.remote_id)
2020-12-18 19:34:21 +00:00
2021-03-23 17:41:18 +00:00
def test_review_to_pure_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2021-08-02 23:05:40 +00:00
status = models.Review.objects.create(
name="Review's name",
content="test content",
rating=3.0,
user=self.local_user,
book=self.book,
)
activity = status.to_activity(pure=True)
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Article")
2020-12-18 19:34:21 +00:00
self.assertEqual(
activity["name"],
f'Review of "{self.book.title}" (3 stars): Review\'s name',
)
self.assertEqual(activity["content"], "test content")
self.assertEqual(activity["attachment"][0].type, "Document")
2021-11-11 21:35:56 +00:00
self.assertTrue(
re.match(
r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
activity["attachment"][0].url,
)
)
self.assertEqual(activity["attachment"][0].name, "Test Edition")
def test_review_to_pure_activity_no_rating(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2021-08-02 23:05:40 +00:00
status = models.Review.objects.create(
name="Review name",
content="test content",
user=self.local_user,
book=self.book,
)
activity = status.to_activity(pure=True)
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Article")
self.assertEqual(
activity["name"], f'Review of "{self.book.title}": Review name'
2021-03-08 16:49:10 +00:00
)
self.assertEqual(activity["content"], "test content")
self.assertEqual(activity["attachment"][0].type, "Document")
2021-11-11 21:35:56 +00:00
self.assertTrue(
re.match(
r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
activity["attachment"][0].url,
)
2021-03-08 16:49:10 +00:00
)
self.assertEqual(activity["attachment"][0].name, "Test Edition")
2020-12-18 19:34:21 +00:00
def test_reviewrating_to_pure_activity(self, *_):
2021-04-26 16:15:42 +00:00
"""subclass of the base model version with a "pure" serializer"""
2021-08-02 23:05:40 +00:00
status = models.ReviewRating.objects.create(
rating=3.0,
user=self.local_user,
book=self.book,
)
activity = status.to_activity(pure=True)
self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Note")
self.assertEqual(
activity["content"],
f'rated <em><a href="{self.book.remote_id}">{self.book.title}</a></em>: 3 stars',
)
self.assertEqual(activity["attachment"][0].type, "Document")
2021-11-11 21:35:56 +00:00
self.assertTrue(
re.match(
r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
activity["attachment"][0].url,
)
)
self.assertEqual(activity["attachment"][0].name, "Test Edition")
2021-03-23 17:41:18 +00:00
def test_favorite(self, *_):
2021-04-26 16:15:42 +00:00
"""fav a status"""
status = models.Status.objects.create(
content="test content", user=self.local_user
)
2021-11-12 18:49:49 +00:00
with patch("bookwyrm.models.Favorite.broadcast") as mock:
fav = models.Favorite.objects.create(status=status, user=self.local_user)
args = mock.call_args[0]
self.assertEqual(args[1].remote_id, self.local_user.remote_id)
self.assertEqual(args[0]["type"], "Like")
2020-12-18 19:34:21 +00:00
2021-08-02 23:05:40 +00:00
# can't fav a status twice
with self.assertRaises(IntegrityError):
models.Favorite.objects.create(status=status, user=self.local_user)
2020-12-18 19:34:21 +00:00
activity = fav.to_activity()
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["type"], "Like")
self.assertEqual(activity["actor"], self.local_user.remote_id)
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["object"], status.remote_id)
2020-12-18 19:34:21 +00:00
2021-03-23 17:41:18 +00:00
def test_boost(self, *_):
2021-04-26 16:15:42 +00:00
"""boosting, this one's a bit fussy"""
status = models.Status.objects.create(
content="test content", user=self.local_user
)
boost = models.Boost.objects.create(boosted_status=status, user=self.local_user)
2020-12-18 19:34:21 +00:00
activity = boost.to_activity()
self.assertEqual(activity["actor"], self.local_user.remote_id)
2021-03-08 16:49:10 +00:00
self.assertEqual(activity["object"], status.remote_id)
self.assertEqual(activity["type"], "Announce")
2020-12-18 19:34:21 +00:00
self.assertEqual(activity, boost.to_activity(pure=True))
2021-03-23 17:41:18 +00:00
def test_notification(self, *_):
2021-04-26 16:15:42 +00:00
"""a simple model"""
2020-12-18 19:34:21 +00:00
notification = models.Notification.objects.create(
user=self.local_user, notification_type="FAVORITE"
2021-03-08 16:49:10 +00:00
)
2020-12-18 19:34:21 +00:00
self.assertFalse(notification.read)
with self.assertRaises(IntegrityError):
models.Notification.objects.create(
user=self.local_user, notification_type="GLORB"
2021-03-08 16:49:10 +00:00
)
2021-02-20 19:24:41 +00:00
2021-06-17 19:58:37 +00:00
# pylint: disable=unused-argument
def test_create_broadcast(self, one, two, broadcast_mock, *_):
2021-04-26 16:15:42 +00:00
"""should send out two verions of a status on create"""
models.Comment.objects.create(
content="hi", user=self.local_user, book=self.book
)
2021-02-20 19:24:41 +00:00
self.assertEqual(broadcast_mock.call_count, 2)
pure_call = broadcast_mock.call_args_list[0]
bw_call = broadcast_mock.call_args_list[1]
2021-03-08 16:49:10 +00:00
self.assertEqual(pure_call[1]["software"], "other")
2021-02-20 19:24:41 +00:00
args = pure_call[0][0]
2021-03-08 16:49:10 +00:00
self.assertEqual(args["type"], "Create")
self.assertEqual(args["object"]["type"], "Note")
self.assertTrue("content" in args["object"])
2021-02-20 19:24:41 +00:00
2021-03-08 16:49:10 +00:00
self.assertEqual(bw_call[1]["software"], "bookwyrm")
2021-02-20 19:24:41 +00:00
args = bw_call[0][0]
2021-03-08 16:49:10 +00:00
self.assertEqual(args["type"], "Create")
self.assertEqual(args["object"]["type"], "Comment")
2021-03-23 17:41:18 +00:00
def test_recipients_with_mentions(self, *_):
2021-04-26 16:15:42 +00:00
"""get recipients to broadcast a status"""
status = models.GeneratedNote.objects.create(
content="test content", user=self.local_user
)
status.mention_users.add(self.remote_user)
self.assertEqual(status.recipients, [self.remote_user])
2021-03-23 17:41:18 +00:00
def test_recipients_with_reply_parent(self, *_):
2021-04-26 16:15:42 +00:00
"""get recipients to broadcast a status"""
parent_status = models.GeneratedNote.objects.create(
content="test content", user=self.remote_user
)
status = models.GeneratedNote.objects.create(
content="test content", user=self.local_user, reply_parent=parent_status
)
self.assertEqual(status.recipients, [self.remote_user])
2021-03-23 17:41:18 +00:00
def test_recipients_with_reply_parent_and_mentions(self, *_):
2021-04-26 16:15:42 +00:00
"""get recipients to broadcast a status"""
parent_status = models.GeneratedNote.objects.create(
content="test content", user=self.remote_user
)
status = models.GeneratedNote.objects.create(
content="test content", user=self.local_user, reply_parent=parent_status
)
status.mention_users.set([self.remote_user])
self.assertEqual(status.recipients, [self.remote_user])
@responses.activate
2021-03-23 17:41:18 +00:00
def test_ignore_activity_boost(self, *_):
2021-04-26 16:15:42 +00:00
"""don't bother with most remote statuses"""
activity = activitypub.Announce(
id="http://www.faraway.com/boost/12",
actor=self.remote_user.remote_id,
object="http://fish.com/nothing",
2021-03-24 21:19:12 +00:00
published="2021-03-24T18:59:41.841208+00:00",
cc="",
to="",
)
responses.add(responses.GET, "http://fish.com/nothing", status=404)
self.assertTrue(models.Status.ignore_activity(activity))
def test_raise_visible_to_user_public(self, *_):
"""privacy settings"""
status = models.Status.objects.create(
content="bleh", user=self.local_user, privacy="public"
)
self.assertIsNone(status.raise_visible_to_user(self.remote_user))
self.assertIsNone(status.raise_visible_to_user(self.local_user))
self.assertIsNone(status.raise_visible_to_user(self.anonymous_user))
def test_raise_visible_to_user_unlisted(self, *_):
"""privacy settings"""
status = models.Status.objects.create(
content="bleh", user=self.local_user, privacy="unlisted"
)
self.assertIsNone(status.raise_visible_to_user(self.remote_user))
self.assertIsNone(status.raise_visible_to_user(self.local_user))
self.assertIsNone(status.raise_visible_to_user(self.anonymous_user))
@patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
def test_raise_visible_to_user_followers(self, *_):
"""privacy settings"""
status = models.Status.objects.create(
content="bleh", user=self.local_user, privacy="followers"
)
status.raise_visible_to_user(self.local_user)
with self.assertRaises(Http404):
status.raise_visible_to_user(self.remote_user)
with self.assertRaises(Http404):
status.raise_visible_to_user(self.anonymous_user)
self.local_user.followers.add(self.remote_user)
self.assertIsNone(status.raise_visible_to_user(self.remote_user))
def test_raise_visible_to_user_followers_mentioned(self, *_):
"""privacy settings"""
status = models.Status.objects.create(
content="bleh", user=self.local_user, privacy="followers"
)
status.mention_users.set([self.remote_user])
self.assertIsNone(status.raise_visible_to_user(self.remote_user))
@patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
def test_raise_visible_to_user_direct(self, *_):
"""privacy settings"""
status = models.Status.objects.create(
content="bleh", user=self.local_user, privacy="direct"
)
status.raise_visible_to_user(self.local_user)
with self.assertRaises(Http404):
status.raise_visible_to_user(self.remote_user)
with self.assertRaises(Http404):
status.raise_visible_to_user(self.anonymous_user)
# mentioned user
status.mention_users.set([self.remote_user])
self.assertIsNone(status.raise_visible_to_user(self.remote_user))