Add black code formatter

bookmarks/tests/test_bookmark_shared_view.py

@@ -15,39 +15,50 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         user = self.get_or_create_test_user()
         self.client.force_login(user)
 
-    def assertBookmarkCount(self, html: str, bookmark: Bookmark, count: int, link_target: str = '_blank'):
+    def assertBookmarkCount(
+        self, html: str, bookmark: Bookmark, count: int, link_target: str = "_blank"
+    ):
         self.assertInHTML(
             f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
-            html, count=count
+            html,
+            count=count,
         )
 
-    def assertVisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
+    def assertVisibleBookmarks(
+        self, response, bookmarks: List[Bookmark], link_target: str = "_blank"
+    ):
         soup = self.make_soup(response.content.decode())
-        bookmark_list = soup.select_one(f'ul.bookmark-list[data-bookmarks-total="{len(bookmarks)}"]')
+        bookmark_list = soup.select_one(
+            f'ul.bookmark-list[data-bookmarks-total="{len(bookmarks)}"]'
+        )
         self.assertIsNotNone(bookmark_list)
 
-        bookmark_items = bookmark_list.select('li[ld-bookmark-item]')
+        bookmark_items = bookmark_list.select("li[ld-bookmark-item]")
         self.assertEqual(len(bookmark_items), len(bookmarks))
 
         for bookmark in bookmarks:
             bookmark_item = bookmark_list.select_one(
-                f'li[ld-bookmark-item] a[href="{bookmark.url}"][target="{link_target}"]')
+                f'li[ld-bookmark-item] a[href="{bookmark.url}"][target="{link_target}"]'
+            )
             self.assertIsNotNone(bookmark_item)
 
-    def assertInvisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
+    def assertInvisibleBookmarks(
+        self, response, bookmarks: List[Bookmark], link_target: str = "_blank"
+    ):
         soup = self.make_soup(response.content.decode())
 
         for bookmark in bookmarks:
             bookmark_item = soup.select_one(
-                f'li[ld-bookmark-item] a[href="{bookmark.url}"][target="{link_target}"]')
+                f'li[ld-bookmark-item] a[href="{bookmark.url}"][target="{link_target}"]'
+            )
             self.assertIsNone(bookmark_item)
 
     def assertVisibleTags(self, response, tags: List[Tag]):
         soup = self.make_soup(response.content.decode())
-        tag_cloud = soup.select_one('div.tag-cloud')
+        tag_cloud = soup.select_one("div.tag-cloud")
         self.assertIsNotNone(tag_cloud)
 
-        tag_items = tag_cloud.select('a[data-is-tag-item]')
+        tag_items = tag_cloud.select("a[data-is-tag-item]")
         self.assertEqual(len(tag_items), len(tags))
 
         tag_item_names = [tag_item.text.strip() for tag_item in tag_items]
@@ -57,7 +68,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
 
     def assertInvisibleTags(self, response, tags: List[Tag]):
         soup = self.make_soup(response.content.decode())
-        tag_items = soup.select('a[data-is-tag-item]')
+        tag_items = soup.select("a[data-is-tag-item]")
 
         tag_item_names = [tag_item.text.strip() for tag_item in tag_items]
 
@@ -67,26 +78,31 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
     def assertVisibleUserOptions(self, response, users: List[User]):
         html = response.content.decode()
 
-        user_options = [
-            '<option value="" selected="">Everyone</option>'
-        ]
+        user_options = ['<option value="" selected="">Everyone</option>']
         for user in users:
-            user_options.append(f'<option value="{user.username}">{user.username}</option>')
-        user_select_html = f'''
+            user_options.append(
+                f'<option value="{user.username}">{user.username}</option>'
+            )
+        user_select_html = f"""
         <select name="user" class="form-select" required="" id="id_user">
             {''.join(user_options)}
         </select>
-        '''
+        """
 
         self.assertInHTML(user_select_html, html)
 
     def assertEditLink(self, response, url):
         html = response.content.decode()
-        self.assertInHTML(f'''
+        self.assertInHTML(
+            f"""
             <a href="{url}">Edit</a>        
-        ''', html)
+        """,
+            html,
+        )
 
-    def test_should_list_shared_bookmarks_from_all_users_that_have_sharing_enabled(self):
+    def test_should_list_shared_bookmarks_from_all_users_that_have_sharing_enabled(
+        self,
+    ):
         self.authenticate()
         user1 = self.setup_user(enable_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
@@ -105,7 +121,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
             self.setup_bookmark(shared=True, user=user4),
         ]
 
-        response = self.client.get(reverse('bookmarks:shared'))
+        response = self.client.get(reverse("bookmarks:shared"))
 
         self.assertVisibleBookmarks(response, visible_bookmarks)
         self.assertInvisibleBookmarks(response, invisible_bookmarks)
@@ -124,7 +140,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
             self.setup_bookmark(shared=True, user=user3),
         ]
 
-        url = reverse('bookmarks:shared') + '?user=' + user1.username
+        url = reverse("bookmarks:shared") + "?user=" + user1.username
         response = self.client.get(url)
 
         self.assertVisibleBookmarks(response, visible_bookmarks)
@@ -134,10 +150,12 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         self.authenticate()
         user = self.setup_user(enable_sharing=True)
 
-        visible_bookmarks = self.setup_numbered_bookmarks(3, shared=True, user=user, prefix='foo')
+        visible_bookmarks = self.setup_numbered_bookmarks(
+            3, shared=True, user=user, prefix="foo"
+        )
         invisible_bookmarks = self.setup_numbered_bookmarks(3, shared=True, user=user)
 
-        response = self.client.get(reverse('bookmarks:shared') + '?q=foo')
+        response = self.client.get(reverse("bookmarks:shared") + "?q=foo")
 
         self.assertVisibleBookmarks(response, visible_bookmarks)
         self.assertInvisibleBookmarks(response, invisible_bookmarks)
@@ -146,15 +164,21 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
 
-        visible_bookmarks = self.setup_numbered_bookmarks(3, shared=True, user=user1, prefix='user1')
-        invisible_bookmarks = self.setup_numbered_bookmarks(3, shared=True, user=user2, prefix='user2')
+        visible_bookmarks = self.setup_numbered_bookmarks(
+            3, shared=True, user=user1, prefix="user1"
+        )
+        invisible_bookmarks = self.setup_numbered_bookmarks(
+            3, shared=True, user=user2, prefix="user2"
+        )
 
-        response = self.client.get(reverse('bookmarks:shared'))
+        response = self.client.get(reverse("bookmarks:shared"))
 
         self.assertVisibleBookmarks(response, visible_bookmarks)
         self.assertInvisibleBookmarks(response, invisible_bookmarks)
 
-    def test_should_list_tags_for_shared_bookmarks_from_all_users_that_have_sharing_enabled(self):
+    def test_should_list_tags_for_shared_bookmarks_from_all_users_that_have_sharing_enabled(
+        self,
+    ):
         self.authenticate()
         user1 = self.setup_user(enable_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
@@ -181,7 +205,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         self.setup_bookmark(shared=False, user=user3, tags=[invisible_tags[2]])
         self.setup_bookmark(shared=True, user=user4, tags=[invisible_tags[3]])
 
-        response = self.client.get(reverse('bookmarks:shared'))
+        response = self.client.get(reverse("bookmarks:shared"))
 
         self.assertVisibleTags(response, visible_tags)
         self.assertInvisibleTags(response, invisible_tags)
@@ -203,7 +227,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         self.setup_bookmark(shared=True, user=user2, tags=[invisible_tags[0]])
         self.setup_bookmark(shared=True, user=user3, tags=[invisible_tags[1]])
 
-        url = reverse('bookmarks:shared') + '?user=' + user1.username
+        url = reverse("bookmarks:shared") + "?user=" + user1.username
         response = self.client.get(url)
 
         self.assertVisibleTags(response, visible_tags)
@@ -225,15 +249,21 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
             self.setup_tag(user=user3),
         ]
 
-        self.setup_bookmark(shared=True, user=user1, title='searchvalue', tags=[visible_tags[0]])
-        self.setup_bookmark(shared=True, user=user2, title='searchvalue', tags=[visible_tags[1]])
-        self.setup_bookmark(shared=True, user=user3, title='searchvalue', tags=[visible_tags[2]])
+        self.setup_bookmark(
+            shared=True, user=user1, title="searchvalue", tags=[visible_tags[0]]
+        )
+        self.setup_bookmark(
+            shared=True, user=user2, title="searchvalue", tags=[visible_tags[1]]
+        )
+        self.setup_bookmark(
+            shared=True, user=user3, title="searchvalue", tags=[visible_tags[2]]
+        )
 
         self.setup_bookmark(shared=True, user=user1, tags=[invisible_tags[0]])
         self.setup_bookmark(shared=True, user=user2, tags=[invisible_tags[1]])
         self.setup_bookmark(shared=True, user=user3, tags=[invisible_tags[2]])
 
-        response = self.client.get(reverse('bookmarks:shared') + '?q=searchvalue')
+        response = self.client.get(reverse("bookmarks:shared") + "?q=searchvalue")
 
         self.assertVisibleTags(response, visible_tags)
         self.assertInvisibleTags(response, invisible_tags)
@@ -257,7 +287,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         self.setup_bookmark(shared=True, user=user2, tags=[invisible_tags[0]])
         self.setup_bookmark(shared=True, user=user2, tags=[invisible_tags[1]])
 
-        response = self.client.get(reverse('bookmarks:shared'))
+        response = self.client.get(reverse("bookmarks:shared"))
 
         self.assertVisibleTags(response, visible_tags)
         self.assertInvisibleTags(response, invisible_tags)
@@ -265,8 +295,8 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
     def test_should_list_users_with_shared_bookmarks_if_sharing_is_enabled(self):
         self.authenticate()
         expected_visible_users = [
-            self.setup_user(name='user_a', enable_sharing=True),
-            self.setup_user(name='user_b', enable_sharing=True),
+            self.setup_user(name="user_a", enable_sharing=True),
+            self.setup_user(name="user_b", enable_sharing=True),
         ]
         self.setup_bookmark(shared=True, user=expected_visible_users[0])
         self.setup_bookmark(shared=True, user=expected_visible_users[1])
@@ -274,14 +304,18 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         self.setup_bookmark(shared=False, user=self.setup_user(enable_sharing=True))
         self.setup_bookmark(shared=True, user=self.setup_user(enable_sharing=False))
 
-        response = self.client.get(reverse('bookmarks:shared'))
+        response = self.client.get(reverse("bookmarks:shared"))
         self.assertVisibleUserOptions(response, expected_visible_users)
 
     def test_should_list_only_users_with_publicly_shared_bookmarks_without_login(self):
         # users with public sharing enabled
         expected_visible_users = [
-            self.setup_user(name='user_a', enable_sharing=True, enable_public_sharing=True),
-            self.setup_user(name='user_b', enable_sharing=True, enable_public_sharing=True),
+            self.setup_user(
+                name="user_a", enable_sharing=True, enable_public_sharing=True
+            ),
+            self.setup_user(
+                name="user_b", enable_sharing=True, enable_public_sharing=True
+            ),
         ]
         self.setup_bookmark(shared=True, user=expected_visible_users[0])
         self.setup_bookmark(shared=True, user=expected_visible_users[1])
@@ -290,7 +324,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         self.setup_bookmark(shared=True, user=self.setup_user(enable_sharing=True))
         self.setup_bookmark(shared=True, user=self.setup_user(enable_sharing=True))
 
-        response = self.client.get(reverse('bookmarks:shared'))
+        response = self.client.get(reverse("bookmarks:shared"))
         self.assertVisibleUserOptions(response, expected_visible_users)
 
     def test_should_list_bookmarks_and_tags_for_search_preferences(self):
@@ -299,19 +333,33 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
 
         user_profile = self.get_or_create_test_user().profile
         user_profile.search_preferences = {
-            'unread': BookmarkSearch.FILTER_UNREAD_YES,
+            "unread": BookmarkSearch.FILTER_UNREAD_YES,
         }
         user_profile.save()
 
-        unread_bookmarks = self.setup_numbered_bookmarks(3, shared=True, unread=True, with_tags=True, prefix='unread',
-                                                         tag_prefix='unread', user=other_user)
-        read_bookmarks = self.setup_numbered_bookmarks(3, shared=True, unread=False, with_tags=True, prefix='read',
-                                                       tag_prefix='read', user=other_user)
+        unread_bookmarks = self.setup_numbered_bookmarks(
+            3,
+            shared=True,
+            unread=True,
+            with_tags=True,
+            prefix="unread",
+            tag_prefix="unread",
+            user=other_user,
+        )
+        read_bookmarks = self.setup_numbered_bookmarks(
+            3,
+            shared=True,
+            unread=False,
+            with_tags=True,
+            prefix="read",
+            tag_prefix="read",
+            user=other_user,
+        )
 
         unread_tags = self.get_tags_from_bookmarks(unread_bookmarks)
         read_tags = self.get_tags_from_bookmarks(read_bookmarks)
 
-        response = self.client.get(reverse('bookmarks:shared'))
+        response = self.client.get(reverse("bookmarks:shared"))
         self.assertVisibleBookmarks(response, unread_bookmarks)
         self.assertInvisibleBookmarks(response, read_bookmarks)
         self.assertVisibleTags(response, unread_tags)
@@ -325,12 +373,12 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         visible_bookmarks = [
             self.setup_bookmark(shared=True),
             self.setup_bookmark(shared=True),
-            self.setup_bookmark(shared=True)
+            self.setup_bookmark(shared=True),
         ]
 
-        response = self.client.get(reverse('bookmarks:shared'))
+        response = self.client.get(reverse("bookmarks:shared"))
 
-        self.assertVisibleBookmarks(response, visible_bookmarks, '_blank')
+        self.assertVisibleBookmarks(response, visible_bookmarks, "_blank")
 
     def test_should_open_bookmarks_in_same_page_if_specified_in_user_profile(self):
         self.authenticate()
@@ -342,12 +390,12 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         visible_bookmarks = [
             self.setup_bookmark(shared=True),
             self.setup_bookmark(shared=True),
-            self.setup_bookmark(shared=True)
+            self.setup_bookmark(shared=True),
         ]
 
-        response = self.client.get(reverse('bookmarks:shared'))
+        response = self.client.get(reverse("bookmarks:shared"))
 
-        self.assertVisibleBookmarks(response, visible_bookmarks, '_self')
+        self.assertVisibleBookmarks(response, visible_bookmarks, "_self")
 
     def test_edit_link_return_url_respects_search_options(self):
         self.authenticate()
@@ -355,180 +403,227 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         user.profile.enable_sharing = True
         user.profile.save()
 
-        bookmark = self.setup_bookmark(title='foo', shared=True, user=user)
-        edit_url = reverse('bookmarks:edit', args=[bookmark.id])
-        base_url = reverse('bookmarks:shared')
+        bookmark = self.setup_bookmark(title="foo", shared=True, user=user)
+        edit_url = reverse("bookmarks:edit", args=[bookmark.id])
+        base_url = reverse("bookmarks:shared")
 
         # without query params
         return_url = urllib.parse.quote(base_url)
-        url = f'{edit_url}?return_url={return_url}'
+        url = f"{edit_url}?return_url={return_url}"
 
         response = self.client.get(base_url)
         self.assertEditLink(response, url)
 
         # with query
-        url_params = '?q=foo'
+        url_params = "?q=foo"
         return_url = urllib.parse.quote(base_url + url_params)
-        url = f'{edit_url}?return_url={return_url}'
+        url = f"{edit_url}?return_url={return_url}"
 
         response = self.client.get(base_url + url_params)
         self.assertEditLink(response, url)
 
         # with query and user
-        url_params = f'?q=foo&user={user.username}'
+        url_params = f"?q=foo&user={user.username}"
         return_url = urllib.parse.quote(base_url + url_params)
-        url = f'{edit_url}?return_url={return_url}'
+        url = f"{edit_url}?return_url={return_url}"
 
         response = self.client.get(base_url + url_params)
         self.assertEditLink(response, url)
 
         # with query and sort and page
-        url_params = '?q=foo&sort=title_asc&page=2'
+        url_params = "?q=foo&sort=title_asc&page=2"
         return_url = urllib.parse.quote(base_url + url_params)
-        url = f'{edit_url}?return_url={return_url}'
+        url = f"{edit_url}?return_url={return_url}"
 
         response = self.client.get(base_url + url_params)
         self.assertEditLink(response, url)
 
     def test_apply_search_preferences(self):
         # no params
-        response = self.client.post(reverse('bookmarks:shared'))
+        response = self.client.post(reverse("bookmarks:shared"))
         self.assertEqual(response.status_code, 302)
-        self.assertEqual(response.url, reverse('bookmarks:shared'))
+        self.assertEqual(response.url, reverse("bookmarks:shared"))
 
         # some params
-        response = self.client.post(reverse('bookmarks:shared'), {
-            'q': 'foo',
-            'sort': BookmarkSearch.SORT_TITLE_ASC,
-        })
+        response = self.client.post(
+            reverse("bookmarks:shared"),
+            {
+                "q": "foo",
+                "sort": BookmarkSearch.SORT_TITLE_ASC,
+            },
+        )
         self.assertEqual(response.status_code, 302)
-        self.assertEqual(response.url, reverse('bookmarks:shared') + '?q=foo&sort=title_asc')
+        self.assertEqual(
+            response.url, reverse("bookmarks:shared") + "?q=foo&sort=title_asc"
+        )
 
         # params with default value are removed
-        response = self.client.post(reverse('bookmarks:shared'), {
-            'q': 'foo',
-            'user': '',
-            'sort': BookmarkSearch.SORT_ADDED_DESC,
-            'shared': BookmarkSearch.FILTER_SHARED_OFF,
-            'unread': BookmarkSearch.FILTER_UNREAD_YES,
-        })
+        response = self.client.post(
+            reverse("bookmarks:shared"),
+            {
+                "q": "foo",
+                "user": "",
+                "sort": BookmarkSearch.SORT_ADDED_DESC,
+                "shared": BookmarkSearch.FILTER_SHARED_OFF,
+                "unread": BookmarkSearch.FILTER_UNREAD_YES,
+            },
+        )
         self.assertEqual(response.status_code, 302)
-        self.assertEqual(response.url, reverse('bookmarks:shared') + '?q=foo&unread=yes')
+        self.assertEqual(
+            response.url, reverse("bookmarks:shared") + "?q=foo&unread=yes"
+        )
 
         # page is removed
-        response = self.client.post(reverse('bookmarks:shared'), {
-            'q': 'foo',
-            'page': '2',
-            'sort': BookmarkSearch.SORT_TITLE_ASC,
-        })
+        response = self.client.post(
+            reverse("bookmarks:shared"),
+            {
+                "q": "foo",
+                "page": "2",
+                "sort": BookmarkSearch.SORT_TITLE_ASC,
+            },
+        )
         self.assertEqual(response.status_code, 302)
-        self.assertEqual(response.url, reverse('bookmarks:shared') + '?q=foo&sort=title_asc')
+        self.assertEqual(
+            response.url, reverse("bookmarks:shared") + "?q=foo&sort=title_asc"
+        )
 
     def test_save_search_preferences(self):
         self.authenticate()
         user_profile = self.user.profile
 
         # no params
-        self.client.post(reverse('bookmarks:shared'), {
-            'save': '',
-        })
+        self.client.post(
+            reverse("bookmarks:shared"),
+            {
+                "save": "",
+            },
+        )
         user_profile.refresh_from_db()
-        self.assertEqual(user_profile.search_preferences, {
-            'sort': BookmarkSearch.SORT_ADDED_DESC,
-            'shared': BookmarkSearch.FILTER_SHARED_OFF,
-            'unread': BookmarkSearch.FILTER_UNREAD_OFF,
-        })
+        self.assertEqual(
+            user_profile.search_preferences,
+            {
+                "sort": BookmarkSearch.SORT_ADDED_DESC,
+                "shared": BookmarkSearch.FILTER_SHARED_OFF,
+                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
+            },
+        )
 
         # with param
-        self.client.post(reverse('bookmarks:shared'), {
-            'save': '',
-            'sort': BookmarkSearch.SORT_TITLE_ASC,
-        })
+        self.client.post(
+            reverse("bookmarks:shared"),
+            {
+                "save": "",
+                "sort": BookmarkSearch.SORT_TITLE_ASC,
+            },
+        )
         user_profile.refresh_from_db()
-        self.assertEqual(user_profile.search_preferences, {
-            'sort': BookmarkSearch.SORT_TITLE_ASC,
-            'shared': BookmarkSearch.FILTER_SHARED_OFF,
-            'unread': BookmarkSearch.FILTER_UNREAD_OFF,
-        })
+        self.assertEqual(
+            user_profile.search_preferences,
+            {
+                "sort": BookmarkSearch.SORT_TITLE_ASC,
+                "shared": BookmarkSearch.FILTER_SHARED_OFF,
+                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
+            },
+        )
 
         # add a param
-        self.client.post(reverse('bookmarks:shared'), {
-            'save': '',
-            'sort': BookmarkSearch.SORT_TITLE_ASC,
-            'unread': BookmarkSearch.FILTER_UNREAD_YES,
-        })
+        self.client.post(
+            reverse("bookmarks:shared"),
+            {
+                "save": "",
+                "sort": BookmarkSearch.SORT_TITLE_ASC,
+                "unread": BookmarkSearch.FILTER_UNREAD_YES,
+            },
+        )
         user_profile.refresh_from_db()
-        self.assertEqual(user_profile.search_preferences, {
-            'sort': BookmarkSearch.SORT_TITLE_ASC,
-            'shared': BookmarkSearch.FILTER_SHARED_OFF,
-            'unread': BookmarkSearch.FILTER_UNREAD_YES,
-        })
+        self.assertEqual(
+            user_profile.search_preferences,
+            {
+                "sort": BookmarkSearch.SORT_TITLE_ASC,
+                "shared": BookmarkSearch.FILTER_SHARED_OFF,
+                "unread": BookmarkSearch.FILTER_UNREAD_YES,
+            },
+        )
 
         # remove a param
-        self.client.post(reverse('bookmarks:shared'), {
-            'save': '',
-            'unread': BookmarkSearch.FILTER_UNREAD_YES,
-        })
+        self.client.post(
+            reverse("bookmarks:shared"),
+            {
+                "save": "",
+                "unread": BookmarkSearch.FILTER_UNREAD_YES,
+            },
+        )
         user_profile.refresh_from_db()
-        self.assertEqual(user_profile.search_preferences, {
-            'sort': BookmarkSearch.SORT_ADDED_DESC,
-            'shared': BookmarkSearch.FILTER_SHARED_OFF,
-            'unread': BookmarkSearch.FILTER_UNREAD_YES,
-        })
+        self.assertEqual(
+            user_profile.search_preferences,
+            {
+                "sort": BookmarkSearch.SORT_ADDED_DESC,
+                "shared": BookmarkSearch.FILTER_SHARED_OFF,
+                "unread": BookmarkSearch.FILTER_UNREAD_YES,
+            },
+        )
 
         # ignores non-preferences
-        self.client.post(reverse('bookmarks:shared'), {
-            'save': '',
-            'q': 'foo',
-            'user': 'john',
-            'page': '3',
-            'sort': BookmarkSearch.SORT_TITLE_ASC,
-        })
+        self.client.post(
+            reverse("bookmarks:shared"),
+            {
+                "save": "",
+                "q": "foo",
+                "user": "john",
+                "page": "3",
+                "sort": BookmarkSearch.SORT_TITLE_ASC,
+            },
+        )
         user_profile.refresh_from_db()
-        self.assertEqual(user_profile.search_preferences, {
-            'sort': BookmarkSearch.SORT_TITLE_ASC,
-            'shared': BookmarkSearch.FILTER_SHARED_OFF,
-            'unread': BookmarkSearch.FILTER_UNREAD_OFF,
-        })
+        self.assertEqual(
+            user_profile.search_preferences,
+            {
+                "sort": BookmarkSearch.SORT_TITLE_ASC,
+                "shared": BookmarkSearch.FILTER_SHARED_OFF,
+                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
+            },
+        )
 
     def test_url_encode_bookmark_actions_url(self):
-        url = reverse('bookmarks:shared') + '?q=%23foo'
+        url = reverse("bookmarks:shared") + "?q=%23foo"
         response = self.client.get(url)
         html = response.content.decode()
         soup = self.make_soup(html)
-        actions_form = soup.select('form.bookmark-actions')[0]
+        actions_form = soup.select("form.bookmark-actions")[0]
 
-        self.assertEqual(actions_form.attrs['action'],
-                         '/bookmarks/shared/action?q=%23foo&return_url=%2Fbookmarks%2Fshared%3Fq%3D%2523foo')
+        self.assertEqual(
+            actions_form.attrs["action"],
+            "/bookmarks/shared/action?q=%23foo&return_url=%2Fbookmarks%2Fshared%3Fq%3D%2523foo",
+        )
 
     def test_encode_search_params(self):
         self.authenticate()
         user = self.get_or_create_test_user()
         user.profile.enable_sharing = True
         user.profile.save()
-        bookmark = self.setup_bookmark(description='alert(\'xss\')', shared=True)
+        bookmark = self.setup_bookmark(description="alert('xss')", shared=True)
 
-        url = reverse('bookmarks:shared') + '?q=alert(%27xss%27)'
+        url = reverse("bookmarks:shared") + "?q=alert(%27xss%27)"
         response = self.client.get(url)
-        self.assertNotContains(response, 'alert(\'xss\')')
+        self.assertNotContains(response, "alert('xss')")
         self.assertContains(response, bookmark.url)
 
-        url = reverse('bookmarks:shared') + '?sort=alert(%27xss%27)'
+        url = reverse("bookmarks:shared") + "?sort=alert(%27xss%27)"
         response = self.client.get(url)
-        self.assertNotContains(response, 'alert(\'xss\')')
+        self.assertNotContains(response, "alert('xss')")
 
-        url = reverse('bookmarks:shared') + '?unread=alert(%27xss%27)'
+        url = reverse("bookmarks:shared") + "?unread=alert(%27xss%27)"
         response = self.client.get(url)
-        self.assertNotContains(response, 'alert(\'xss\')')
+        self.assertNotContains(response, "alert('xss')")
 
-        url = reverse('bookmarks:shared') + '?shared=alert(%27xss%27)'
+        url = reverse("bookmarks:shared") + "?shared=alert(%27xss%27)"
         response = self.client.get(url)
-        self.assertNotContains(response, 'alert(\'xss\')')
+        self.assertNotContains(response, "alert('xss')")
 
-        url = reverse('bookmarks:shared') + '?user=alert(%27xss%27)'
+        url = reverse("bookmarks:shared") + "?user=alert(%27xss%27)"
         response = self.client.get(url)
-        self.assertNotContains(response, 'alert(\'xss\')')
+        self.assertNotContains(response, "alert('xss')")
 
-        url = reverse('bookmarks:shared') + '?page=alert(%27xss%27)'
+        url = reverse("bookmarks:shared") + "?page=alert(%27xss%27)"
         response = self.client.get(url)
-        self.assertNotContains(response, 'alert(\'xss\')')
+        self.assertNotContains(response, "alert('xss')")