Runs black

bookwyrm/tests/models/test_status_model.py

@@ -1,4 +1,4 @@
-''' testing models '''
+""" testing models """
 from unittest.mock import patch
 from io import BytesIO
 import pathlib
@@ -12,44 +12,45 @@ from django.utils import timezone
 from bookwyrm import models, settings
 
 
-@patch('bookwyrm.models.Status.broadcast')
+@patch("bookwyrm.models.Status.broadcast")
 class Status(TestCase):
-    ''' lotta types of statuses '''
+    """ lotta types of statuses """
+
     def setUp(self):
-        ''' useful things for creating a status '''
+        """ useful things for creating a status """
         self.user = models.User.objects.create_user(
-            'mouse', 'mouse@mouse.mouse', 'mouseword',
-            local=True, localname='mouse')
-        self.book = models.Edition.objects.create(title='Test Edition')
+            "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
+        )
+        self.book = models.Edition.objects.create(title="Test Edition")
 
         image_file = pathlib.Path(__file__).parent.joinpath(
-            '../../static/images/default_avi.jpg')
+            "../../static/images/default_avi.jpg"
+        )
         image = Image.open(image_file)
         output = BytesIO()
-        with patch('bookwyrm.models.Status.broadcast'):
+        with patch("bookwyrm.models.Status.broadcast"):
             image.save(output, format=image.format)
-            self.book.cover.save(
-                'test.jpg',
-                ContentFile(output.getvalue())
-            )
+            self.book.cover.save("test.jpg", ContentFile(output.getvalue()))
 
     def test_status_generated_fields(self, _):
-        ''' setting remote id '''
-        status = models.Status.objects.create(content='bleh', user=self.user)
-        expected_id = 'https://%s/user/mouse/status/%d' % \
-                (settings.DOMAIN, status.id)
+        """ setting remote id """
+        status = models.Status.objects.create(content="bleh", user=self.user)
+        expected_id = "https://%s/user/mouse/status/%d" % (settings.DOMAIN, status.id)
         self.assertEqual(status.remote_id, expected_id)
-        self.assertEqual(status.privacy, 'public')
+        self.assertEqual(status.privacy, "public")
 
     def test_replies(self, _):
-        ''' get a list of replies '''
-        parent = models.Status.objects.create(content='hi', user=self.user)
+        """ get a list of replies """
+        parent = models.Status.objects.create(content="hi", user=self.user)
         child = models.Status.objects.create(
-            content='hello', reply_parent=parent, user=self.user)
+            content="hello", reply_parent=parent, user=self.user
+        )
         models.Review.objects.create(
-            content='hey', reply_parent=parent, user=self.user, book=self.book)
+            content="hey", reply_parent=parent, user=self.user, book=self.book
+        )
         models.Status.objects.create(
-            content='hi hello', reply_parent=child, user=self.user)
+            content="hi hello", reply_parent=child, user=self.user
+        )
 
         replies = models.Status.replies(parent)
         self.assertEqual(replies.count(), 2)
@@ -58,199 +59,228 @@ class Status(TestCase):
         self.assertIsInstance(replies.last(), models.Review)
 
     def test_status_type(self, _):
-        ''' class name '''
-        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')
+        """ class name """
+        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")
 
     def test_boostable(self, _):
-        ''' can a status be boosted, based on privacy '''
-        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)
+        """ can a status be boosted, based on privacy """
+        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)
 
     def test_to_replies(self, _):
-        ''' activitypub replies collection '''
-        parent = models.Status.objects.create(content='hi', user=self.user)
+        """ activitypub replies collection """
+        parent = models.Status.objects.create(content="hi", user=self.user)
         child = models.Status.objects.create(
-            content='hello', reply_parent=parent, user=self.user)
+            content="hello", reply_parent=parent, user=self.user
+        )
         models.Review.objects.create(
-            content='hey', reply_parent=parent, user=self.user, book=self.book)
+            content="hey", reply_parent=parent, user=self.user, book=self.book
+        )
         models.Status.objects.create(
-            content='hi hello', reply_parent=child, user=self.user)
+            content="hi hello", reply_parent=child, user=self.user
+        )
 
         replies = parent.to_replies()
-        self.assertEqual(replies['id'], '%s/replies' % parent.remote_id)
-        self.assertEqual(replies['totalItems'], 2)
+        self.assertEqual(replies["id"], "%s/replies" % parent.remote_id)
+        self.assertEqual(replies["totalItems"], 2)
 
     def test_status_to_activity(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
-        status = models.Status.objects.create(
-            content='test content', user=self.user)
+        """ subclass of the base model version with a "pure" serializer """
+        status = models.Status.objects.create(content="test content", user=self.user)
         activity = status.to_activity()
-        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["id"], status.remote_id)
+        self.assertEqual(activity["type"], "Note")
+        self.assertEqual(activity["content"], "test content")
+        self.assertEqual(activity["sensitive"], False)
 
     def test_status_to_activity_tombstone(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
+        """ subclass of the base model version with a "pure" serializer """
         status = models.Status.objects.create(
-            content='test content', user=self.user,
-            deleted=True, deleted_date=timezone.now())
+            content="test content",
+            user=self.user,
+            deleted=True,
+            deleted_date=timezone.now(),
+        )
         activity = status.to_activity()
-        self.assertEqual(activity['id'], status.remote_id)
-        self.assertEqual(activity['type'], 'Tombstone')
-        self.assertFalse(hasattr(activity, 'content'))
+        self.assertEqual(activity["id"], status.remote_id)
+        self.assertEqual(activity["type"], "Tombstone")
+        self.assertFalse(hasattr(activity, "content"))
 
     def test_status_to_pure_activity(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
-        status = models.Status.objects.create(
-            content='test content', user=self.user)
+        """ subclass of the base model version with a "pure" serializer """
+        status = models.Status.objects.create(content="test content", user=self.user)
         activity = status.to_activity(pure=True)
-        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'], [])
+        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"], [])
 
     def test_generated_note_to_activity(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
+        """ subclass of the base model version with a "pure" serializer """
         status = models.GeneratedNote.objects.create(
-            content='test content', user=self.user)
+            content="test content", user=self.user
+        )
         status.mention_books.set([self.book])
         status.mention_users.set([self.user])
         activity = status.to_activity()
-        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)
+        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)
 
     def test_generated_note_to_pure_activity(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
+        """ subclass of the base model version with a "pure" serializer """
         status = models.GeneratedNote.objects.create(
-            content='test content', user=self.user)
+            content="test content", user=self.user
+        )
         status.mention_books.set([self.book])
         status.mention_users.set([self.user])
         activity = status.to_activity(pure=True)
-        self.assertEqual(activity['id'], status.remote_id)
+        self.assertEqual(activity["id"], status.remote_id)
         self.assertEqual(
-            activity['content'],
-            'mouse test content <a href="%s">"Test Edition"</a>' % \
-                self.book.remote_id)
-        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, 'Image')
-        self.assertEqual(activity['attachment'][0].url, 'https://%s%s' % \
-                (settings.DOMAIN, self.book.cover.url))
+            activity["content"],
+            'mouse test content <a href="%s">"Test Edition"</a>' % self.book.remote_id,
+        )
+        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, "Image")
         self.assertEqual(
-            activity['attachment'][0].name, 'Test Edition')
+            activity["attachment"][0].url,
+            "https://%s%s" % (settings.DOMAIN, self.book.cover.url),
+        )
+        self.assertEqual(activity["attachment"][0].name, "Test Edition")
 
     def test_comment_to_activity(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
+        """ subclass of the base model version with a "pure" serializer """
         status = models.Comment.objects.create(
-            content='test content', user=self.user, book=self.book)
+            content="test content", user=self.user, book=self.book
+        )
         activity = status.to_activity()
-        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)
+        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)
 
     def test_comment_to_pure_activity(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
+        """ subclass of the base model version with a "pure" serializer """
         status = models.Comment.objects.create(
-            content='test content', user=self.user, book=self.book)
+            content="test content", user=self.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["id"], status.remote_id)
+        self.assertEqual(activity["type"], "Note")
         self.assertEqual(
-            activity['content'],
-            'test content<p>(comment on <a href="%s">"Test Edition"</a>)</p>' %
-            self.book.remote_id)
-        self.assertEqual(activity['attachment'][0].type, 'Image')
-        self.assertEqual(activity['attachment'][0].url, 'https://%s%s' % \
-                (settings.DOMAIN, self.book.cover.url))
+            activity["content"],
+            'test content<p>(comment on <a href="%s">"Test Edition"</a>)</p>'
+            % self.book.remote_id,
+        )
+        self.assertEqual(activity["attachment"][0].type, "Image")
         self.assertEqual(
-            activity['attachment'][0].name, 'Test Edition')
+            activity["attachment"][0].url,
+            "https://%s%s" % (settings.DOMAIN, self.book.cover.url),
+        )
+        self.assertEqual(activity["attachment"][0].name, "Test Edition")
 
     def test_quotation_to_activity(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
+        """ subclass of the base model version with a "pure" serializer """
         status = models.Quotation.objects.create(
-            quote='a sickening sense', content='test content',
-            user=self.user, book=self.book)
+            quote="a sickening sense",
+            content="test content",
+            user=self.user,
+            book=self.book,
+        )
         activity = status.to_activity()
-        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)
+        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)
 
     def test_quotation_to_pure_activity(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
+        """ subclass of the base model version with a "pure" serializer """
         status = models.Quotation.objects.create(
-            quote='a sickening sense', content='test content',
-            user=self.user, book=self.book)
+            quote="a sickening sense",
+            content="test content",
+            user=self.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["id"], status.remote_id)
+        self.assertEqual(activity["type"], "Note")
         self.assertEqual(
-            activity['content'],
-            'a sickening sense <p>-- <a href="%s">"Test Edition"</a></p>' \
-                    'test content' % self.book.remote_id)
-        self.assertEqual(activity['attachment'][0].type, 'Image')
-        self.assertEqual(activity['attachment'][0].url, 'https://%s%s' % \
-                (settings.DOMAIN, self.book.cover.url))
+            activity["content"],
+            'a sickening sense <p>-- <a href="%s">"Test Edition"</a></p>'
+            "test content" % self.book.remote_id,
+        )
+        self.assertEqual(activity["attachment"][0].type, "Image")
         self.assertEqual(
-            activity['attachment'][0].name, 'Test Edition')
+            activity["attachment"][0].url,
+            "https://%s%s" % (settings.DOMAIN, self.book.cover.url),
+        )
+        self.assertEqual(activity["attachment"][0].name, "Test Edition")
 
     def test_review_to_activity(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
+        """ subclass of the base model version with a "pure" serializer """
         status = models.Review.objects.create(
-            name='Review name', content='test content', rating=3,
-            user=self.user, book=self.book)
+            name="Review name",
+            content="test content",
+            rating=3,
+            user=self.user,
+            book=self.book,
+        )
         activity = status.to_activity()
-        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)
+        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)
 
     def test_review_to_pure_activity(self, _):
-        ''' subclass of the base model version with a "pure" serializer '''
+        """ subclass of the base model version with a "pure" serializer """
         status = models.Review.objects.create(
-            name='Review name', content='test content', rating=3,
-            user=self.user, book=self.book)
+            name="Review name",
+            content="test content",
+            rating=3,
+            user=self.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["id"], status.remote_id)
+        self.assertEqual(activity["type"], "Article")
         self.assertEqual(
-            activity['name'], 'Review of "%s" (3 stars): Review name' \
-                % self.book.title)
-        self.assertEqual(activity['content'], 'test content')
-        self.assertEqual(activity['attachment'][0].type, 'Image')
-        self.assertEqual(activity['attachment'][0].url, 'https://%s%s' % \
-                (settings.DOMAIN, self.book.cover.url))
+            activity["name"], 'Review of "%s" (3 stars): Review name' % self.book.title
+        )
+        self.assertEqual(activity["content"], "test content")
+        self.assertEqual(activity["attachment"][0].type, "Image")
         self.assertEqual(
-            activity['attachment'][0].name, 'Test Edition')
+            activity["attachment"][0].url,
+            "https://%s%s" % (settings.DOMAIN, self.book.cover.url),
+        )
+        self.assertEqual(activity["attachment"][0].name, "Test Edition")
 
     def test_favorite(self, _):
-        ''' fav a status '''
+        """ fav a status """
         real_broadcast = models.Favorite.broadcast
+
         def fav_broadcast_mock(_, activity, user):
-            ''' ok '''
+            """ ok """
             self.assertEqual(user.remote_id, self.user.remote_id)
-            self.assertEqual(activity['type'], 'Like')
+            self.assertEqual(activity["type"], "Like")
+
         models.Favorite.broadcast = fav_broadcast_mock
 
-        status = models.Status.objects.create(
-            content='test content', user=self.user)
+        status = models.Status.objects.create(content="test content", user=self.user)
         fav = models.Favorite.objects.create(status=status, user=self.user)
 
         # can't fav a status twice
@@ -258,50 +288,47 @@ class Status(TestCase):
             models.Favorite.objects.create(status=status, user=self.user)
 
         activity = fav.to_activity()
-        self.assertEqual(activity['type'], 'Like')
-        self.assertEqual(activity['actor'], self.user.remote_id)
-        self.assertEqual(activity['object'], status.remote_id)
+        self.assertEqual(activity["type"], "Like")
+        self.assertEqual(activity["actor"], self.user.remote_id)
+        self.assertEqual(activity["object"], status.remote_id)
         models.Favorite.broadcast = real_broadcast
 
     def test_boost(self, _):
-        ''' boosting, this one's a bit fussy '''
-        status = models.Status.objects.create(
-            content='test content', user=self.user)
-        boost = models.Boost.objects.create(
-            boosted_status=status, user=self.user)
+        """ boosting, this one's a bit fussy """
+        status = models.Status.objects.create(content="test content", user=self.user)
+        boost = models.Boost.objects.create(boosted_status=status, user=self.user)
         activity = boost.to_activity()
-        self.assertEqual(activity['actor'], self.user.remote_id)
-        self.assertEqual(activity['object'], status.remote_id)
-        self.assertEqual(activity['type'], 'Announce')
+        self.assertEqual(activity["actor"], self.user.remote_id)
+        self.assertEqual(activity["object"], status.remote_id)
+        self.assertEqual(activity["type"], "Announce")
         self.assertEqual(activity, boost.to_activity(pure=True))
 
     def test_notification(self, _):
-        ''' a simple model '''
+        """ a simple model """
         notification = models.Notification.objects.create(
-            user=self.user, notification_type='FAVORITE')
+            user=self.user, notification_type="FAVORITE"
+        )
         self.assertFalse(notification.read)
 
         with self.assertRaises(IntegrityError):
             models.Notification.objects.create(
-                user=self.user, notification_type='GLORB')
-
+                user=self.user, notification_type="GLORB"
+            )
 
     def test_create_broadcast(self, broadcast_mock):
-        ''' should send out two verions of a status on create '''
-        models.Comment.objects.create(
-            content='hi', user=self.user, book=self.book)
+        """ should send out two verions of a status on create """
+        models.Comment.objects.create(content="hi", user=self.user, book=self.book)
         self.assertEqual(broadcast_mock.call_count, 2)
         pure_call = broadcast_mock.call_args_list[0]
         bw_call = broadcast_mock.call_args_list[1]
 
-        self.assertEqual(pure_call[1]['software'], 'other')
+        self.assertEqual(pure_call[1]["software"], "other")
         args = pure_call[0][0]
-        self.assertEqual(args['type'], 'Create')
-        self.assertEqual(args['object']['type'], 'Note')
-        self.assertTrue('content' in args['object'])
+        self.assertEqual(args["type"], "Create")
+        self.assertEqual(args["object"]["type"], "Note")
+        self.assertTrue("content" in args["object"])
 
-
-        self.assertEqual(bw_call[1]['software'], 'bookwyrm')
+        self.assertEqual(bw_call[1]["software"], "bookwyrm")
         args = bw_call[0][0]
-        self.assertEqual(args['type'], 'Create')
-        self.assertEqual(args['object']['type'], 'Comment')
+        self.assertEqual(args["type"], "Create")
+        self.assertEqual(args["object"]["type"], "Comment")