Merge pull request #555 from mouse-reeve/blocking

Blocking

bookwyrm/tests/test_incoming.py

@@ -540,3 +540,46 @@ class Incoming(TestCase):
             incoming.handle_update_work({'object': bookdata})
         book = models.Work.objects.get(id=book.id)
         self.assertEqual(book.title, 'Piranesi')
+
+
+    def test_handle_blocks(self):
+        ''' create a "block" database entry from an activity '''
+        self.local_user.followers.add(self.remote_user)
+        models.UserFollowRequest.objects.create(
+            user_subject=self.local_user,
+            user_object=self.remote_user)
+        self.assertTrue(models.UserFollows.objects.exists())
+        self.assertTrue(models.UserFollowRequest.objects.exists())
+
+        activity = {
+            "@context": "https://www.w3.org/ns/activitystreams",
+            "id": "https://example.com/9e1f41ac-9ddd-4159-aede-9f43c6b9314f",
+            "type": "Block",
+            "actor": "https://example.com/users/rat",
+            "object": "https://example.com/user/mouse"
+        }
+
+        incoming.handle_block(activity)
+        block = models.UserBlocks.objects.get()
+        self.assertEqual(block.user_subject, self.remote_user)
+        self.assertEqual(block.user_object, self.local_user)
+
+        self.assertFalse(models.UserFollows.objects.exists())
+        self.assertFalse(models.UserFollowRequest.objects.exists())
+
+    def test_handle_unblock(self):
+        ''' undoing a block '''
+        activity = {
+            "@context": "https://www.w3.org/ns/activitystreams",
+            "id": "https://friend.camp/users/tripofmice#blocks/1155/undo",
+            "type": "Undo",
+            "actor": "https://friend.camp/users/tripofmice",
+            "object": {
+                "id": "https://friend.camp/0a7d85f7-6359-4c03-8ab6-74e61a8fb678",
+                "type": "Block",
+                "actor": "https://friend.camp/users/tripofmice",
+            "object": "https://1b1a78582461.ngrok.io/user/mouse"
+            }
+        }
+
+        self.remote_user.blocks.add(self.local_user)

bookwyrm/tests/views/test_authentication.py

@@ -42,83 +42,6 @@ class AuthenticationViews(TestCase):
         self.assertEqual(result.status_code, 302)
 
 
-    def test_password_reset_request(self):
-        ''' there are so many views, this just makes sure it LOADS '''
-        view = views.PasswordResetRequest.as_view()
-        request = self.factory.get('')
-        request.user = self.local_user
-
-        result = view(request)
-        self.assertIsInstance(result, TemplateResponse)
-        self.assertEqual(result.template_name, 'password_reset_request.html')
-        self.assertEqual(result.status_code, 200)
-
-
-    def test_password_reset_request_post(self):
-        ''' send 'em an email '''
-        request = self.factory.post('', {'email': 'aa@bb.ccc'})
-        view = views.PasswordResetRequest.as_view()
-        resp = view(request)
-        self.assertEqual(resp.status_code, 302)
-
-        request = self.factory.post('', {'email': 'mouse@mouse.com'})
-        with patch('bookwyrm.emailing.send_email.delay'):
-            resp = view(request)
-        self.assertEqual(resp.template_name, 'password_reset_request.html')
-
-        self.assertEqual(
-            models.PasswordReset.objects.get().user, self.local_user)
-
-    def test_password_reset(self):
-        ''' there are so many views, this just makes sure it LOADS '''
-        view = views.PasswordReset.as_view()
-        code = models.PasswordReset.objects.create(user=self.local_user)
-        request = self.factory.get('')
-        request.user = self.anonymous_user
-        result = view(request, code.code)
-        self.assertIsInstance(result, TemplateResponse)
-        self.assertEqual(result.template_name, 'password_reset.html')
-        self.assertEqual(result.status_code, 200)
-
-
-    def test_password_reset_post(self):
-        ''' reset from code '''
-        view = views.PasswordReset.as_view()
-        code = models.PasswordReset.objects.create(user=self.local_user)
-        request = self.factory.post('', {
-            'password': 'hi',
-            'confirm-password': 'hi'
-        })
-        with patch('bookwyrm.views.password.login'):
-            resp = view(request, code.code)
-        self.assertEqual(resp.status_code, 302)
-        self.assertFalse(models.PasswordReset.objects.exists())
-
-    def test_password_reset_wrong_code(self):
-        ''' reset from code '''
-        view = views.PasswordReset.as_view()
-        models.PasswordReset.objects.create(user=self.local_user)
-        request = self.factory.post('', {
-            'password': 'hi',
-            'confirm-password': 'hi'
-        })
-        resp = view(request, 'jhgdkfjgdf')
-        self.assertEqual(resp.template_name, 'password_reset.html')
-        self.assertTrue(models.PasswordReset.objects.exists())
-
-    def test_password_reset_mismatch(self):
-        ''' reset from code '''
-        view = views.PasswordReset.as_view()
-        code = models.PasswordReset.objects.create(user=self.local_user)
-        request = self.factory.post('', {
-            'password': 'hi',
-            'confirm-password': 'hihi'
-        })
-        resp = view(request, code.code)
-        self.assertEqual(resp.template_name, 'password_reset.html')
-        self.assertTrue(models.PasswordReset.objects.exists())
-
-
     def test_register(self):
         ''' create a user '''
         view = views.Register.as_view()
@@ -274,29 +197,3 @@ class AuthenticationViews(TestCase):
         with self.assertRaises(Http404):
             response = view(request)
         self.assertEqual(models.User.objects.count(), 2)
-
-
-    def test_password_change(self):
-        ''' change password '''
-        view = views.ChangePassword.as_view()
-        password_hash = self.local_user.password
-        request = self.factory.post('', {
-            'password': 'hi',
-            'confirm-password': 'hi'
-        })
-        request.user = self.local_user
-        with patch('bookwyrm.views.password.login'):
-            view(request)
-        self.assertNotEqual(self.local_user.password, password_hash)
-
-    def test_password_change_mismatch(self):
-        ''' change password '''
-        view = views.ChangePassword.as_view()
-        password_hash = self.local_user.password
-        request = self.factory.post('', {
-            'password': 'hi',
-            'confirm-password': 'hihi'
-        })
-        request.user = self.local_user
-        view(request)
-        self.assertEqual(self.local_user.password, password_hash)

bookwyrm/tests/views/test_block.py

@@ -0,0 +1,68 @@
+''' 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
+
+
+class BlockViews(TestCase):
+    ''' view user and edit profile '''
+    def setUp(self):
+        ''' we need basic test data and mocks '''
+        self.factory = RequestFactory()
+        self.local_user = models.User.objects.create_user(
+            'mouse@local.com', 'mouse@mouse.mouse', 'password',
+            local=True, localname='mouse')
+        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',
+            )
+
+
+    def test_block_get(self):
+        ''' there are so many views, this just makes sure it LOADS '''
+        view = views.Block.as_view()
+        request = self.factory.get('')
+        request.user = self.local_user
+        result = view(request)
+        self.assertIsInstance(result, TemplateResponse)
+        self.assertEqual(result.template_name, 'blocks.html')
+        self.assertEqual(result.status_code, 200)
+
+    def test_block_post(self):
+        ''' create a "block" database entry from an activity '''
+        view = views.Block.as_view()
+        self.local_user.followers.add(self.remote_user)
+        models.UserFollowRequest.objects.create(
+            user_subject=self.local_user,
+            user_object=self.remote_user)
+        self.assertTrue(models.UserFollows.objects.exists())
+        self.assertTrue(models.UserFollowRequest.objects.exists())
+
+        request = self.factory.post('')
+        request.user = self.local_user
+        with patch('bookwyrm.broadcast.broadcast_task.delay'):
+            view(request, self.remote_user.id)
+        block = models.UserBlocks.objects.get()
+        self.assertEqual(block.user_subject, self.local_user)
+        self.assertEqual(block.user_object, self.remote_user)
+
+        self.assertFalse(models.UserFollows.objects.exists())
+        self.assertFalse(models.UserFollowRequest.objects.exists())
+
+    def test_unblock(self):
+        ''' undo a block '''
+        self.local_user.blocks.add(self.remote_user)
+        request = self.factory.post('')
+        request.user = self.local_user
+
+        with patch('bookwyrm.broadcast.broadcast_task.delay'):
+            views.block.unblock(request, self.remote_user.id)
+
+        self.assertFalse(models.UserBlocks.objects.exists())

bookwyrm/tests/views/test_helpers.py

@@ -154,6 +154,34 @@ class ViewsHelpers(TestCase):
         self.assertEqual(statuses[0], rat_mention)
 
 
+    def test_get_activity_feed_blocks(self):
+        ''' feed generation with blocked users '''
+        rat = models.User.objects.create_user(
+            'rat', 'rat@rat.rat', 'password', local=True)
+
+        public_status = models.Comment.objects.create(
+            content='public status', book=self.book, user=self.local_user)
+        rat_public = models.Status.objects.create(
+            content='blah blah', user=rat)
+
+        statuses = views.helpers.get_activity_feed(
+            self.local_user, ['public'])
+        self.assertEqual(len(statuses), 2)
+
+        # block relationship
+        rat.blocks.add(self.local_user)
+        statuses = views.helpers.get_activity_feed(
+            self.local_user, ['public'])
+        self.assertEqual(len(statuses), 1)
+        self.assertEqual(statuses[0], public_status)
+
+        statuses = views.helpers.get_activity_feed(
+            rat, ['public'])
+        self.assertEqual(len(statuses), 1)
+        self.assertEqual(statuses[0], rat_public)
+
+
+
     def test_is_bookwyrm_request(self):
         ''' checks if a request came from a bookwyrm instance '''
         request = self.factory.get('', {'q': 'Test Book'})
@@ -248,3 +276,63 @@ class ViewsHelpers(TestCase):
             views.helpers.handle_reading_status(
                 self.local_user, self.shelf, self.book, 'public')
         self.assertFalse(models.GeneratedNote.objects.exists())
+
+    def test_object_visible_to_user(self):
+        ''' does a user have permission to view an object '''
+        obj = models.Status.objects.create(
+            content='hi', user=self.remote_user, privacy='public')
+        self.assertTrue(
+            views.helpers.object_visible_to_user(self.local_user, obj))
+
+        obj = models.Shelf.objects.create(
+            name='test', user=self.remote_user, privacy='unlisted')
+        self.assertTrue(
+            views.helpers.object_visible_to_user(self.local_user, obj))
+
+        obj = models.Status.objects.create(
+            content='hi', user=self.remote_user, privacy='followers')
+        self.assertFalse(
+            views.helpers.object_visible_to_user(self.local_user, obj))
+
+        obj = models.Status.objects.create(
+            content='hi', user=self.remote_user, privacy='direct')
+        self.assertFalse(
+            views.helpers.object_visible_to_user(self.local_user, obj))
+
+        obj = models.Status.objects.create(
+            content='hi', user=self.remote_user, privacy='direct')
+        obj.mention_users.add(self.local_user)
+        self.assertTrue(
+            views.helpers.object_visible_to_user(self.local_user, obj))
+
+    def test_object_visible_to_user_follower(self):
+        ''' what you can see if you follow a user '''
+        self.remote_user.followers.add(self.local_user)
+        obj = models.Status.objects.create(
+            content='hi', user=self.remote_user, privacy='followers')
+        self.assertTrue(
+            views.helpers.object_visible_to_user(self.local_user, obj))
+
+        obj = models.Status.objects.create(
+            content='hi', user=self.remote_user, privacy='direct')
+        self.assertFalse(
+            views.helpers.object_visible_to_user(self.local_user, obj))
+
+        obj = models.Status.objects.create(
+            content='hi', user=self.remote_user, privacy='direct')
+        obj.mention_users.add(self.local_user)
+        self.assertTrue(
+            views.helpers.object_visible_to_user(self.local_user, obj))
+
+    def test_object_visible_to_user_blocked(self):
+        ''' you can't see it if they block you '''
+        self.remote_user.blocks.add(self.local_user)
+        obj = models.Status.objects.create(
+            content='hi', user=self.remote_user, privacy='public')
+        self.assertFalse(
+            views.helpers.object_visible_to_user(self.local_user, obj))
+
+        obj = models.Shelf.objects.create(
+            name='test', user=self.remote_user, privacy='unlisted')
+        self.assertFalse(
+            views.helpers.object_visible_to_user(self.local_user, obj))

bookwyrm/tests/views/test_password.py

@@ -0,0 +1,136 @@
+''' test for app action functionality '''
+from unittest.mock import patch
+
+from django.contrib.auth.models import AnonymousUser
+from django.template.response import TemplateResponse
+from django.test import TestCase
+from django.test.client import RequestFactory
+
+from bookwyrm import models, views
+
+
+class PasswordViews(TestCase):
+    ''' view user and edit profile '''
+    def setUp(self):
+        ''' we need basic test data and mocks '''
+        self.factory = RequestFactory()
+        self.local_user = models.User.objects.create_user(
+            'mouse@local.com', 'mouse@mouse.com', 'password',
+            local=True, localname='mouse')
+        self.anonymous_user = AnonymousUser
+        self.anonymous_user.is_authenticated = False
+
+
+    def test_password_reset_request(self):
+        ''' there are so many views, this just makes sure it LOADS '''
+        view = views.PasswordResetRequest.as_view()
+        request = self.factory.get('')
+        request.user = self.local_user
+
+        result = view(request)
+        self.assertIsInstance(result, TemplateResponse)
+        self.assertEqual(result.template_name, 'password_reset_request.html')
+        self.assertEqual(result.status_code, 200)
+
+
+    def test_password_reset_request_post(self):
+        ''' send 'em an email '''
+        request = self.factory.post('', {'email': 'aa@bb.ccc'})
+        view = views.PasswordResetRequest.as_view()
+        resp = view(request)
+        self.assertEqual(resp.status_code, 302)
+
+        request = self.factory.post('', {'email': 'mouse@mouse.com'})
+        with patch('bookwyrm.emailing.send_email.delay'):
+            resp = view(request)
+        self.assertEqual(resp.template_name, 'password_reset_request.html')
+
+        self.assertEqual(
+            models.PasswordReset.objects.get().user, self.local_user)
+
+    def test_password_reset(self):
+        ''' there are so many views, this just makes sure it LOADS '''
+        view = views.PasswordReset.as_view()
+        code = models.PasswordReset.objects.create(user=self.local_user)
+        request = self.factory.get('')
+        request.user = self.anonymous_user
+        result = view(request, code.code)
+        self.assertIsInstance(result, TemplateResponse)
+        self.assertEqual(result.template_name, 'password_reset.html')
+        self.assertEqual(result.status_code, 200)
+
+
+    def test_password_reset_post(self):
+        ''' reset from code '''
+        view = views.PasswordReset.as_view()
+        code = models.PasswordReset.objects.create(user=self.local_user)
+        request = self.factory.post('', {
+            'password': 'hi',
+            'confirm-password': 'hi'
+        })
+        with patch('bookwyrm.views.password.login'):
+            resp = view(request, code.code)
+        self.assertEqual(resp.status_code, 302)
+        self.assertFalse(models.PasswordReset.objects.exists())
+
+    def test_password_reset_wrong_code(self):
+        ''' reset from code '''
+        view = views.PasswordReset.as_view()
+        models.PasswordReset.objects.create(user=self.local_user)
+        request = self.factory.post('', {
+            'password': 'hi',
+            'confirm-password': 'hi'
+        })
+        resp = view(request, 'jhgdkfjgdf')
+        self.assertEqual(resp.template_name, 'password_reset.html')
+        self.assertTrue(models.PasswordReset.objects.exists())
+
+    def test_password_reset_mismatch(self):
+        ''' reset from code '''
+        view = views.PasswordReset.as_view()
+        code = models.PasswordReset.objects.create(user=self.local_user)
+        request = self.factory.post('', {
+            'password': 'hi',
+            'confirm-password': 'hihi'
+        })
+        resp = view(request, code.code)
+        self.assertEqual(resp.template_name, 'password_reset.html')
+        self.assertTrue(models.PasswordReset.objects.exists())
+
+
+    def test_password_change_get(self):
+        ''' there are so many views, this just makes sure it LOADS '''
+        view = views.ChangePassword.as_view()
+        request = self.factory.get('')
+        request.user = self.local_user
+
+        result = view(request)
+        self.assertIsInstance(result, TemplateResponse)
+        self.assertEqual(result.template_name, 'change_password.html')
+        self.assertEqual(result.status_code, 200)
+
+
+    def test_password_change(self):
+        ''' change password '''
+        view = views.ChangePassword.as_view()
+        password_hash = self.local_user.password
+        request = self.factory.post('', {
+            'password': 'hi',
+            'confirm-password': 'hi'
+        })
+        request.user = self.local_user
+        with patch('bookwyrm.views.password.login'):
+            view(request)
+        self.assertNotEqual(self.local_user.password, password_hash)
+
+    def test_password_change_mismatch(self):
+        ''' change password '''
+        view = views.ChangePassword.as_view()
+        password_hash = self.local_user.password
+        request = self.factory.post('', {
+            'password': 'hi',
+            'confirm-password': 'hihi'
+        })
+        request.user = self.local_user
+        view(request)
+        self.assertEqual(self.local_user.password, password_hash)

bookwyrm/tests/views/test_user.py

@@ -20,6 +20,9 @@ class UserViews(TestCase):
         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')
 
 
     def test_user_page(self):
@@ -41,6 +44,18 @@ class UserViews(TestCase):
         self.assertEqual(result.status_code, 200)
 
 
+    def test_user_page_blocked(self):
+        ''' there are so many views, this just makes sure it LOADS '''
+        view = views.User.as_view()
+        request = self.factory.get('')
+        request.user = self.local_user
+        self.rat.blocks.add(self.local_user)
+        with patch('bookwyrm.views.user.is_api_request') as is_api:
+            is_api.return_value = False
+            result = view(request, 'rat')
+        self.assertEqual(result.status_code, 404)
+
+
     def test_followers_page(self):
         ''' there are so many views, this just makes sure it LOADS '''
         view = views.Followers.as_view()
@@ -60,6 +75,18 @@ class UserViews(TestCase):
         self.assertEqual(result.status_code, 200)
 
 
+    def test_followers_page_blocked(self):
+        ''' there are so many views, this just makes sure it LOADS '''
+        view = views.Followers.as_view()
+        request = self.factory.get('')
+        request.user = self.local_user
+        self.rat.blocks.add(self.local_user)
+        with patch('bookwyrm.views.user.is_api_request') as is_api:
+            is_api.return_value = False
+            result = view(request, 'rat')
+        self.assertEqual(result.status_code, 404)
+
+
     def test_following_page(self):
         ''' there are so many views, this just makes sure it LOADS '''
         view = views.Following.as_view()
@@ -79,6 +106,18 @@ class UserViews(TestCase):
         self.assertEqual(result.status_code, 200)
 
 
+    def test_following_page_blocked(self):
+        ''' there are so many views, this just makes sure it LOADS '''
+        view = views.Following.as_view()
+        request = self.factory.get('')
+        request.user = self.local_user
+        self.rat.blocks.add(self.local_user)
+        with patch('bookwyrm.views.user.is_api_request') as is_api:
+            is_api.return_value = False
+            result = view(request, 'rat')
+        self.assertEqual(result.status_code, 404)
+
+
     def test_edit_profile_page(self):
         ''' there are so many views, this just makes sure it LOADS '''
         view = views.EditUser.as_view()