Adds tests files

bookwyrm/lists_stream.py

@@ -69,7 +69,7 @@ class ListsStream(RedisStore):
         # only visible to the poster and mentioned users
         if book_list.privacy == "direct":
             audience = audience.filter(
-                Q(id=list.user.id)  # if the user is the post's author
+                Q(id=book_list.user.id)  # if the user is the post's author
             )
         # only visible to the poster's followers and tagged users
         elif book_list.privacy == "followers":
@@ -98,18 +98,17 @@ class ListsStream(RedisStore):
 # pylint: disable=unused-argument
 def add_list_on_create(sender, instance, created, *args, **kwargs):
     """add newly created lists to activity feeds"""
-    # we're only interested in new lists
-    if not issubclass(sender, models.List):
-        return
-
-    if instance.deleted:
-        remove_list_task.delay(instance.id)
-        return
-
     # when creating new things, gotta wait on the transaction
     transaction.on_commit(lambda: add_list_on_create_command(instance, created))
 
 
+@receiver(signals.pre_delete, sender=models.List)
+# pylint: disable=unused-argument
+def remove_list_on_delete(sender, instance, created, *args, **kwargs):
+    """add newly created lists to activity feeds"""
+    remove_list_task.delay(instance.id)
+
+
 def add_list_on_create_command(instance, created):
     """runs this code only after the database commit completes"""
     priority = HIGH

bookwyrm/tests/lists_stream/__init__.py

@@ -0,0 +1 @@
+from . import *

bookwyrm/tests/lists_stream/test_signals.py

@@ -0,0 +1,118 @@
+""" testing activitystreams """
+from unittest.mock import patch
+from django.test import TestCase
+from bookwyrm import activitystreams, models
+
+
+@patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async")
+class ActivitystreamsSignals(TestCase):
+    """using redis to build activity streams"""
+
+    def setUp(self):
+        """use a test csv"""
+        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", "mouse@mouse.mouse", "password", local=True, localname="mouse"
+            )
+            self.another_user = models.User.objects.create_user(
+                "fish", "fish@fish.fish", "password", local=True, localname="fish"
+            )
+        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",
+            )
+        work = models.Work.objects.create(title="test work")
+        self.book = models.Edition.objects.create(title="test book", parent_work=work)
+
+    def test_add_status_on_create_ignore(self, _):
+        """a new statuses has entered"""
+        activitystreams.add_status_on_create(models.User, self.local_user, False)
+
+    def test_add_status_on_create_deleted(self, _):
+        """a new statuses has entered"""
+        with patch("bookwyrm.activitystreams.remove_status_task.delay"):
+            status = models.Status.objects.create(
+                user=self.remote_user, content="hi", privacy="public", deleted=True
+            )
+        with patch("bookwyrm.activitystreams.remove_status_task.delay") as mock:
+            activitystreams.add_status_on_create(models.Status, status, False)
+        self.assertEqual(mock.call_count, 1)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], status.id)
+
+    def test_add_status_on_create_created(self, _):
+        """a new statuses has entered"""
+        status = models.Status.objects.create(
+            user=self.remote_user, content="hi", privacy="public"
+        )
+        with patch("bookwyrm.activitystreams.add_status_task.apply_async") as mock:
+            activitystreams.add_status_on_create_command(models.Status, status, False)
+        self.assertEqual(mock.call_count, 1)
+        args = mock.call_args[1]
+        self.assertEqual(args["args"][0], status.id)
+        self.assertEqual(args["queue"], "high_priority")
+
+    def test_populate_streams_on_account_create(self, _):
+        """create streams for a user"""
+        with patch("bookwyrm.activitystreams.populate_stream_task.delay") as mock:
+            activitystreams.populate_streams_on_account_create(
+                models.User, self.local_user, True
+            )
+        self.assertEqual(mock.call_count, 3)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], "books")
+        self.assertEqual(args[1], self.local_user.id)
+
+    def test_remove_statuses_on_block(self, _):
+        """don't show statuses from blocked users"""
+        with patch("bookwyrm.activitystreams.remove_user_statuses_task.delay") as mock:
+            models.UserBlocks.objects.create(
+                user_subject=self.local_user,
+                user_object=self.remote_user,
+            )
+
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.local_user.id)
+        self.assertEqual(args[1], self.remote_user.id)
+
+    def test_add_statuses_on_unblock(self, _):
+        """re-add statuses on unblock"""
+        with patch("bookwyrm.activitystreams.remove_user_statuses_task.delay"):
+            block = models.UserBlocks.objects.create(
+                user_subject=self.local_user,
+                user_object=self.remote_user,
+            )
+
+        with patch("bookwyrm.activitystreams.add_user_statuses_task.delay") as mock:
+            block.delete()
+
+        args = mock.call_args[0]
+        kwargs = mock.call_args.kwargs
+        self.assertEqual(args[0], self.local_user.id)
+        self.assertEqual(args[1], self.remote_user.id)
+        self.assertEqual(kwargs["stream_list"], ["local", "books"])
+
+    def test_add_statuses_on_unblock_reciprocal_block(self, _):
+        """re-add statuses on unblock"""
+        with patch("bookwyrm.activitystreams.remove_user_statuses_task.delay"):
+            block = models.UserBlocks.objects.create(
+                user_subject=self.local_user,
+                user_object=self.remote_user,
+            )
+            block = models.UserBlocks.objects.create(
+                user_subject=self.remote_user,
+                user_object=self.local_user,
+            )
+
+        with patch("bookwyrm.activitystreams.add_user_statuses_task.delay") as mock:
+            block.delete()
+
+        self.assertEqual(mock.call_count, 0)

bookwyrm/tests/lists_stream/test_stream.py

@@ -0,0 +1,113 @@
+""" testing activitystreams """
+from unittest.mock import patch
+from django.test import TestCase
+from bookwyrm import lists_stream, models
+
+
+@patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async")
+@patch("bookwyrm.activitystreams.add_status_task.delay")
+@patch("bookwyrm.activitystreams.add_book_statuses_task.delay")
+@patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
+@patch("bookwyrm.activitystreams.populate_stream_task.delay")
+class ListsStream(TestCase):
+    """using redis to build activity streams"""
+
+    def setUp(self):
+        """use a test csv"""
+        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", "mouse@mouse.mouse", "password", local=True, localname="mouse"
+            )
+            self.another_user = models.User.objects.create_user(
+                "nutria",
+                "nutria@nutria.nutria",
+                "password",
+                local=True,
+                localname="nutria",
+            )
+        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",
+            )
+        self.stream = lists_stream.ListsStream()
+
+    def test_lists_stream_ids(self, *_):
+        """the abstract base class for stream objects"""
+        self.assertEqual(
+            self.stream.stream_id(self.local_user),
+            f"{self.local_user.id}-lists",
+        )
+
+    def test_get_audience(self, *_):
+        """get a list of users that should see a list"""
+        book_list = models.List.objects.create(
+            user=self.remote_user, name="hi", privacy="public"
+        )
+        users = self.stream.get_audience(book_list)
+        # remote users don't have feeds
+        self.assertFalse(self.remote_user in users)
+        self.assertTrue(self.local_user in users)
+        self.assertTrue(self.another_user in users)
+
+    def test_get_audience_direct(self, *_):
+        """get a list of users that should see a list"""
+        book_list = models.List.objects.create(
+            user=self.remote_user,
+            name="hi",
+            privacy="direct",
+        )
+        users = self.stream.get_audience(book_list)
+        self.assertFalse(users.exists())
+
+        book_list = models.List.objects.create(
+            user=self.local_user,
+            name="hi",
+            privacy="direct",
+        )
+        users = self.stream.get_audience(book_list)
+        self.assertTrue(self.local_user in users)
+        self.assertFalse(self.another_user in users)
+        self.assertFalse(self.remote_user in users)
+
+    def test_get_audience_followers_remote_user(self, *_):
+        """get a list of users that should see a list"""
+        book_list = models.List.objects.create(
+            user=self.remote_user,
+            name="hi",
+            privacy="followers",
+        )
+        users = self.stream.get_audience(book_list)
+        self.assertFalse(users.exists())
+
+    def test_get_audience_followers_self(self, *_):
+        """get a list of users that should see a list"""
+        book_list = models.List.objects.create(
+            user=self.local_user,
+            name="hi",
+            privacy="direct",
+        )
+        users = self.stream.get_audience(book_list)
+        self.assertTrue(self.local_user in users)
+        self.assertFalse(self.another_user in users)
+        self.assertFalse(self.remote_user in users)
+
+    def test_get_audience_followers_with_relationship(self, *_):
+        """get a list of users that should see a list"""
+        self.remote_user.followers.add(self.local_user)
+        book_list = models.List.objects.create(
+            user=self.remote_user,
+            name="hi",
+            privacy="direct",
+        )
+        users = self.stream.get_audience(book_list)
+        self.assertFalse(self.local_user in users)
+        self.assertFalse(self.another_user in users)
+        self.assertFalse(self.remote_user in users)

bookwyrm/tests/lists_stream/test_tasks.py

@@ -0,0 +1,218 @@
+""" testing activitystreams """
+from unittest.mock import patch
+from django.test import TestCase
+from bookwyrm import activitystreams, models
+
+
+class Activitystreams(TestCase):
+    """using redis to build activity streams"""
+
+    def setUp(self):
+        """use a test csv"""
+        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", "mouse@mouse.mouse", "password", local=True, localname="mouse"
+            )
+            self.another_user = models.User.objects.create_user(
+                "nutria",
+                "nutria@nutria.nutria",
+                "password",
+                local=True,
+                localname="nutria",
+            )
+        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",
+            )
+        work = models.Work.objects.create(title="test work")
+        self.book = models.Edition.objects.create(title="test book", parent_work=work)
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"):
+            self.status = models.Status.objects.create(
+                content="hi", user=self.local_user
+            )
+
+    def test_add_book_statuses_task(self):
+        """statuses related to a book"""
+        with patch("bookwyrm.activitystreams.BooksStream.add_book_statuses") as mock:
+            activitystreams.add_book_statuses_task(self.local_user.id, self.book.id)
+        self.assertTrue(mock.called)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.local_user)
+        self.assertEqual(args[1], self.book)
+
+    def test_remove_book_statuses_task(self):
+        """remove stauses related to a book"""
+        with patch("bookwyrm.activitystreams.BooksStream.remove_book_statuses") as mock:
+            activitystreams.remove_book_statuses_task(self.local_user.id, self.book.id)
+        self.assertTrue(mock.called)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.local_user)
+        self.assertEqual(args[1], self.book)
+
+    def test_populate_stream_task(self):
+        """populate a given stream"""
+        with patch("bookwyrm.activitystreams.BooksStream.populate_streams") as mock:
+            activitystreams.populate_stream_task("books", self.local_user.id)
+        self.assertTrue(mock.called)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.local_user)
+
+        with patch("bookwyrm.activitystreams.HomeStream.populate_streams") as mock:
+            activitystreams.populate_stream_task("home", self.local_user.id)
+        self.assertTrue(mock.called)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.local_user)
+
+    def test_remove_status_task(self):
+        """remove a status from all streams"""
+        with patch(
+            "bookwyrm.activitystreams.ActivityStream.remove_object_from_related_stores"
+        ) as mock:
+            activitystreams.remove_status_task(self.status.id)
+        self.assertEqual(mock.call_count, 3)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.status)
+
+    def test_add_status_task(self):
+        """add a status to all streams"""
+        with patch("bookwyrm.activitystreams.ActivityStream.add_status") as mock:
+            activitystreams.add_status_task(self.status.id)
+        self.assertEqual(mock.call_count, 3)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.status)
+
+    def test_remove_user_statuses_task(self):
+        """remove all statuses by a user from another users' feeds"""
+        with patch(
+            "bookwyrm.activitystreams.ActivityStream.remove_user_statuses"
+        ) as mock:
+            activitystreams.remove_user_statuses_task(
+                self.local_user.id, self.another_user.id
+            )
+        self.assertEqual(mock.call_count, 3)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.local_user)
+        self.assertEqual(args[1], self.another_user)
+
+        with patch("bookwyrm.activitystreams.HomeStream.remove_user_statuses") as mock:
+            activitystreams.remove_user_statuses_task(
+                self.local_user.id, self.another_user.id, stream_list=["home"]
+            )
+        self.assertEqual(mock.call_count, 1)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.local_user)
+        self.assertEqual(args[1], self.another_user)
+
+    def test_add_user_statuses_task(self):
+        """add a user's statuses to another users feeds"""
+        with patch("bookwyrm.activitystreams.ActivityStream.add_user_statuses") as mock:
+            activitystreams.add_user_statuses_task(
+                self.local_user.id, self.another_user.id
+            )
+        self.assertEqual(mock.call_count, 3)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.local_user)
+        self.assertEqual(args[1], self.another_user)
+
+        with patch("bookwyrm.activitystreams.HomeStream.add_user_statuses") as mock:
+            activitystreams.add_user_statuses_task(
+                self.local_user.id, self.another_user.id, stream_list=["home"]
+            )
+        self.assertEqual(mock.call_count, 1)
+        args = mock.call_args[0]
+        self.assertEqual(args[0], self.local_user)
+        self.assertEqual(args[1], self.another_user)
+
+    @patch("bookwyrm.activitystreams.LocalStream.remove_object_from_related_stores")
+    @patch("bookwyrm.activitystreams.BooksStream.remove_object_from_related_stores")
+    @patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async")
+    def test_boost_to_another_timeline(self, *_):
+        """boost from a non-follower doesn't remove original status from feed"""
+        status = models.Status.objects.create(user=self.local_user, content="hi")
+        with patch("bookwyrm.activitystreams.handle_boost_task.delay"):
+            boost = models.Boost.objects.create(
+                boosted_status=status,
+                user=self.another_user,
+            )
+        with patch(
+            "bookwyrm.activitystreams.HomeStream.remove_object_from_related_stores"
+        ) as mock:
+            activitystreams.handle_boost_task(boost.id)
+
+        self.assertTrue(mock.called)
+        self.assertEqual(mock.call_count, 1)
+        call_args = mock.call_args
+        self.assertEqual(call_args[0][0], status)
+        self.assertEqual(call_args[1]["stores"], [f"{self.another_user.id}-home"])
+
+    @patch("bookwyrm.activitystreams.LocalStream.remove_object_from_related_stores")
+    @patch("bookwyrm.activitystreams.BooksStream.remove_object_from_related_stores")
+    @patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async")
+    def test_boost_to_another_timeline_remote(self, *_):
+        """boost from a remote non-follower doesn't remove original status from feed"""
+        status = models.Status.objects.create(user=self.local_user, content="hi")
+        with patch("bookwyrm.activitystreams.handle_boost_task.delay"):
+            boost = models.Boost.objects.create(
+                boosted_status=status,
+                user=self.remote_user,
+            )
+        with patch(
+            "bookwyrm.activitystreams.HomeStream.remove_object_from_related_stores"
+        ) as mock:
+            activitystreams.handle_boost_task(boost.id)
+
+        self.assertTrue(mock.called)
+        self.assertEqual(mock.call_count, 1)
+        call_args = mock.call_args
+        self.assertEqual(call_args[0][0], status)
+        self.assertEqual(call_args[1]["stores"], [])
+
+    @patch("bookwyrm.activitystreams.LocalStream.remove_object_from_related_stores")
+    @patch("bookwyrm.activitystreams.BooksStream.remove_object_from_related_stores")
+    @patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async")
+    def test_boost_to_following_timeline(self, *_):
+        """add a boost and deduplicate the boosted status on the timeline"""
+        self.local_user.following.add(self.another_user)
+        status = models.Status.objects.create(user=self.local_user, content="hi")
+        with patch("bookwyrm.activitystreams.handle_boost_task.delay"):
+            boost = models.Boost.objects.create(
+                boosted_status=status,
+                user=self.another_user,
+            )
+        with patch(
+            "bookwyrm.activitystreams.HomeStream.remove_object_from_related_stores"
+        ) as mock:
+            activitystreams.handle_boost_task(boost.id)
+        self.assertTrue(mock.called)
+        call_args = mock.call_args
+        self.assertEqual(call_args[0][0], status)
+        self.assertTrue(f"{self.another_user.id}-home" in call_args[1]["stores"])
+        self.assertTrue(f"{self.local_user.id}-home" in call_args[1]["stores"])
+
+    @patch("bookwyrm.activitystreams.LocalStream.remove_object_from_related_stores")
+    @patch("bookwyrm.activitystreams.BooksStream.remove_object_from_related_stores")
+    @patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async")
+    def test_boost_to_same_timeline(self, *_):
+        """add a boost and deduplicate the boosted status on the timeline"""
+        status = models.Status.objects.create(user=self.local_user, content="hi")
+        with patch("bookwyrm.activitystreams.handle_boost_task.delay"):
+            boost = models.Boost.objects.create(
+                boosted_status=status,
+                user=self.local_user,
+            )
+        with patch(
+            "bookwyrm.activitystreams.HomeStream.remove_object_from_related_stores"
+        ) as mock:
+            activitystreams.handle_boost_task(boost.id)
+        self.assertTrue(mock.called)
+        call_args = mock.call_args
+        self.assertEqual(call_args[0][0], status)
+        self.assertEqual(call_args[1]["stores"], [f"{self.local_user.id}-home"])