mirrors/bookwyrm
1
0
Fork 1
mirror of https://github.com/bookwyrm-social/bookwyrm.git synced 2024-06-02 09:20:31 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #3320 from dato/better-fmt-patch-calls

Browse source 
bulk-fmt: bracket-wrap calls to patch() for better readability
This commit is contained in:
Bart Schuurmans 2024-03-29 14:19:16 +01:00 committed by GitHub
parent 699d637bae 3133a47b7c
commit 1464d09a43
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
133 changed files with 1507 additions and 1191 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
bookwyrm/tests/activitypub/test_author.py
View file

@ -7,13 +7,13 @@ class Author(TestCase):
"""serialize author tests""" """serialize author tests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""initial data""" """initial data"""
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
) )
self.author = models.Author.objects.create( cls.author = models.Author.objects.create(
name="Author fullname", name="Author fullname",
aliases=["One", "Two"], aliases=["One", "Two"],
bio="bio bio bio", bio="bio bio bio",

26
bookwyrm/tests/activitypub/test_base_activity.py
View file

@ -29,16 +29,18 @@ class BaseActivity(TestCase):
"""the super class for model-linked activitypub dataclasses""" """the super class for model-linked activitypub dataclasses"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we're probably going to re-use this so why copy/paste""" """we're probably going to re-use this so why copy/paste"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
) )
self.user.remote_id = "http://example.com/a/b" cls.user.remote_id = "http://example.com/a/b"
self.user.save(broadcast=False, update_fields=["remote_id"]) cls.user.save(broadcast=False, update_fields=["remote_id"])
def setUp(self): def setUp(self):
datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json") datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json")
@ -232,10 +234,12 @@ class BaseActivity(TestCase):
) )
# sets the celery task call to the function call # sets the celery task call to the function call
with patch("bookwyrm.activitypub.base_activity.set_related_field.delay"): with (
with patch("bookwyrm.models.status.Status.ignore_activity") as discarder: patch("bookwyrm.activitypub.base_activity.set_related_field.delay"),
discarder.return_value = False patch("bookwyrm.models.status.Status.ignore_activity") as discarder,
update_data.to_model(model=models.Status, instance=status) ):
discarder.return_value = False
update_data.to_model(model=models.Status, instance=status)
self.assertIsNone(status.attachments.first()) self.assertIsNone(status.attachments.first())
@responses.activate @responses.activate

18
bookwyrm/tests/activitypub/test_note.py
View file

@ -11,18 +11,20 @@ class Note(TestCase):
"""the model-linked ActivityPub dataclass for Note-based types""" """the model-linked ActivityPub dataclass for Note-based types"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create a shared user""" """create a shared user"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
) )
self.user.remote_id = "https://test-instance.org/user/critic" cls.user.remote_id = "https://test-instance.org/user/critic"
self.user.save(broadcast=False, update_fields=["remote_id"]) cls.user.save(broadcast=False, update_fields=["remote_id"])
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Test Edition", remote_id="http://book.com/book" title="Test Edition", remote_id="http://book.com/book"
) )

6
bookwyrm/tests/activitypub/test_quotation.py
View file

@ -11,10 +11,10 @@ class Quotation(TestCase):
"""we have hecka ways to create statuses""" """we have hecka ways to create statuses"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""model objects we'll need""" """model objects we'll need"""
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.user = models.User.objects.create_user( cls.user = models.User.objects.create_user(
"mouse", "mouse",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"mouseword", "mouseword",
@ -23,7 +23,7 @@ class Quotation(TestCase):
outbox="https://example.com/user/mouse/outbox", outbox="https://example.com/user/mouse/outbox",
remote_id="https://example.com/user/mouse", remote_id="https://example.com/user/mouse",
) )
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
) )

26
bookwyrm/tests/activitystreams/test_abstractstream.py
View file

@ -16,15 +16,17 @@ class Activitystreams(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""use a test csv""" """use a test csv"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"nutria", "nutria",
"nutria@nutria.nutria", "nutria@nutria.nutria",
"password", "password",
@ -32,7 +34,7 @@ class Activitystreams(TestCase):
localname="nutria", localname="nutria",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -42,7 +44,7 @@ class Activitystreams(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
work = models.Work.objects.create(title="test work") work = models.Work.objects.create(title="test work")
self.book = models.Edition.objects.create(title="test book", parent_work=work) cls.book = models.Edition.objects.create(title="test book", parent_work=work)
def setUp(self): def setUp(self):
"""per-test setUp""" """per-test setUp"""
@ -105,9 +107,11 @@ class Activitystreams(TestCase):
privacy="direct", privacy="direct",
book=self.book, book=self.book,
) )
with patch("bookwyrm.activitystreams.r.set"), patch( with (
"bookwyrm.activitystreams.r.delete" patch("bookwyrm.activitystreams.r.set"),
), patch("bookwyrm.activitystreams.ActivityStream.get_store") as redis_mock: patch("bookwyrm.activitystreams.r.delete"),
patch("bookwyrm.activitystreams.ActivityStream.get_store") as redis_mock,
):
redis_mock.return_value = [status.id, status2.id] redis_mock.return_value = [status.id, status2.id]
result = self.test_stream.get_activity_stream(self.local_user) result = self.test_stream.get_activity_stream(self.local_user)
self.assertEqual(result.count(), 2) self.assertEqual(result.count(), 2)

16
bookwyrm/tests/activitystreams/test_booksstream.py
View file

@ -15,16 +15,18 @@ class Activitystreams(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""use a test csv""" """use a test csv"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -34,7 +36,7 @@ class Activitystreams(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
work = models.Work.objects.create(title="test work") work = models.Work.objects.create(title="test work")
self.book = models.Edition.objects.create(title="test book", parent_work=work) cls.book = models.Edition.objects.create(title="test book", parent_work=work)
def test_get_statuses_for_user_books(self, *_): def test_get_statuses_for_user_books(self, *_):
"""create a stream for a user""" """create a stream for a user"""

16
bookwyrm/tests/activitystreams/test_homestream.py
View file

@ -13,15 +13,17 @@ class Activitystreams(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""use a test csv""" """use a test csv"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"nutria", "nutria",
"nutria@nutria.nutria", "nutria@nutria.nutria",
"password", "password",
@ -29,7 +31,7 @@ class Activitystreams(TestCase):
localname="nutria", localname="nutria",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",

18
bookwyrm/tests/activitystreams/test_localstream.py
View file

@ -13,15 +13,17 @@ class Activitystreams(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""use a test csv""" """use a test csv"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"nutria", "nutria",
"nutria@nutria.nutria", "nutria@nutria.nutria",
"password", "password",
@ -29,7 +31,7 @@ class Activitystreams(TestCase):
localname="nutria", localname="nutria",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -39,7 +41,7 @@ class Activitystreams(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
work = models.Work.objects.create(title="test work") work = models.Work.objects.create(title="test work")
self.book = models.Edition.objects.create(title="test book", parent_work=work) cls.book = models.Edition.objects.create(title="test book", parent_work=work)
def test_localstream_get_audience_remote_status(self, *_): def test_localstream_get_audience_remote_status(self, *_):
"""get a list of users that should see a status""" """get a list of users that should see a status"""

14
bookwyrm/tests/activitystreams/test_signals.py
View file

@ -15,16 +15,18 @@ class ActivitystreamsSignals(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""use a test csv""" """use a test csv"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",

22
bookwyrm/tests/activitystreams/test_tasks.py
View file

@ -8,15 +8,17 @@ class Activitystreams(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""use a test csv""" """use a test csv"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"nutria", "nutria",
"nutria@nutria.nutria", "nutria@nutria.nutria",
"password", "password",
@ -24,7 +26,7 @@ class Activitystreams(TestCase):
localname="nutria", localname="nutria",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -34,11 +36,9 @@ class Activitystreams(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
work = models.Work.objects.create(title="test work") work = models.Work.objects.create(title="test work")
self.book = models.Edition.objects.create(title="test book", parent_work=work) cls.book = models.Edition.objects.create(title="test book", parent_work=work)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"):
self.status = models.Status.objects.create( cls.status = models.Status.objects.create(content="hi", user=cls.local_user)
content="hi", user=self.local_user
)
def test_add_book_statuses_task(self): def test_add_book_statuses_task(self):
"""statuses related to a book""" """statuses related to a book"""

4
bookwyrm/tests/connectors/test_abstract_connector.py
View file

@ -13,7 +13,7 @@ class AbstractConnector(TestCase):
"""generic code for connecting to outside data sources""" """generic code for connecting to outside data sources"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need an example connector in the database""" """we need an example connector in the database"""
models.Connector.objects.create( models.Connector.objects.create(
identifier="example.com", identifier="example.com",
@ -23,7 +23,7 @@ class AbstractConnector(TestCase):
covers_url="https://example.com/covers", covers_url="https://example.com/covers",
search_url="https://example.com/search?q=", search_url="https://example.com/search?q=",
) )
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Test Book", title="Test Book",
remote_id="https://example.com/book/1234", remote_id="https://example.com/book/1234",
openlibrary_key="OL1234M", openlibrary_key="OL1234M",

4
bookwyrm/tests/connectors/test_abstract_minimal_connector.py
View file

@ -10,9 +10,9 @@ class AbstractConnector(TestCase):
"""generic code for connecting to outside data sources""" """generic code for connecting to outside data sources"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need an example connector in the database""" """we need an example connector in the database"""
self.connector_info = models.Connector.objects.create( cls.connector_info = models.Connector.objects.create(
identifier="example.com", identifier="example.com",
connector_file="openlibrary", connector_file="openlibrary",
base_url="https://example.com", base_url="https://example.com",

2
bookwyrm/tests/connectors/test_bookwyrm_connector.py
View file

@ -12,7 +12,7 @@ class BookWyrmConnector(TestCase):
"""this connector doesn't do much, just search""" """this connector doesn't do much, just search"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create bookwrym_connector in the database""" """create bookwrym_connector in the database"""
models.Connector.objects.create( models.Connector.objects.create(
identifier="example.com", identifier="example.com",

12
bookwyrm/tests/connectors/test_connector_manager.py
View file

@ -11,18 +11,18 @@ class ConnectorManager(TestCase):
"""interface between the app and various connectors""" """interface between the app and various connectors"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we'll need some books and a connector info entry""" """we'll need some books and a connector info entry"""
self.work = models.Work.objects.create(title="Example Work") cls.work = models.Work.objects.create(title="Example Work")
models.Edition.objects.create( models.Edition.objects.create(
title="Example Edition", parent_work=self.work, isbn_10="0000000000" title="Example Edition", parent_work=cls.work, isbn_10="0000000000"
) )
self.edition = models.Edition.objects.create( cls.edition = models.Edition.objects.create(
title="Another Edition", parent_work=self.work, isbn_10="1111111111" title="Another Edition", parent_work=cls.work, isbn_10="1111111111"
) )
self.remote_connector = models.Connector.objects.create( cls.remote_connector = models.Connector.objects.create(
identifier="test_connector_remote", identifier="test_connector_remote",
priority=1, priority=1,
connector_file="bookwyrm_connector", connector_file="bookwyrm_connector",

15
bookwyrm/tests/connectors/test_inventaire_connector.py
View file

@ -15,7 +15,7 @@ class Inventaire(TestCase):
"""test loading data from inventaire.io""" """test loading data from inventaire.io"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""creates the connector in the database""" """creates the connector in the database"""
models.Connector.objects.create( models.Connector.objects.create(
identifier="inventaire.io", identifier="inventaire.io",
@ -212,11 +212,14 @@ class Inventaire(TestCase):
json={"entities": {}}, json={"entities": {}},
) )
data = {"uri": "blah"} data = {"uri": "blah"}
with patch( with (
"bookwyrm.connectors.inventaire.Connector.load_edition_data" patch(
) as loader_mock, patch( "bookwyrm.connectors.inventaire.Connector.load_edition_data"
"bookwyrm.connectors.inventaire.Connector.get_book_data" ) as loader_mock,
) as getter_mock: patch(
"bookwyrm.connectors.inventaire.Connector.get_book_data"
) as getter_mock,
):
loader_mock.return_value = {"uris": ["hello"]} loader_mock.return_value = {"uris": ["hello"]}
self.connector.get_edition_from_work_data(data) self.connector.get_edition_from_work_data(data)
self.assertTrue(getter_mock.called) self.assertTrue(getter_mock.called)

2
bookwyrm/tests/connectors/test_openlibrary_connector.py
View file

@ -19,7 +19,7 @@ class Openlibrary(TestCase):
"""test loading data from openlibrary.org""" """test loading data from openlibrary.org"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""creates the connector in the database""" """creates the connector in the database"""
models.Connector.objects.create( models.Connector.objects.create(
identifier="openlibrary.org", identifier="openlibrary.org",

14
bookwyrm/tests/importers/test_calibre_import.py
View file

@ -23,17 +23,19 @@ class CalibreImport(TestCase):
self.csv = open(datafile, "r", encoding=self.importer.encoding) self.csv = open(datafile, "r", encoding=self.importer.encoding)
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""populate database""" """populate database"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True "mouse", "mouse@mouse.mouse", "password", local=True
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
work = models.Work.objects.create(title="Test Work") work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,

14
bookwyrm/tests/importers/test_goodreads_import.py
View file

@ -30,17 +30,19 @@ class GoodreadsImport(TestCase):
self.csv = open(datafile, "r", encoding=self.importer.encoding) self.csv = open(datafile, "r", encoding=self.importer.encoding)
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""populate database""" """populate database"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True "mouse", "mouse@mouse.mouse", "password", local=True
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
work = models.Work.objects.create(title="Test Work") work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,

22
bookwyrm/tests/importers/test_importer.py
View file

@ -33,17 +33,19 @@ class GenericImporter(TestCase):
self.csv = open(datafile, "r", encoding=self.importer.encoding) self.csv = open(datafile, "r", encoding=self.importer.encoding)
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""populate database""" """populate database"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True "mouse", "mouse@mouse.mouse", "password", local=True
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
work = models.Work.objects.create(title="Test Work") work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,
@ -266,9 +268,11 @@ class GenericImporter(TestCase):
import_item.book = self.book import_item.book = self.book
import_item.save() import_item.save()
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"): with (
with patch("bookwyrm.models.Status.broadcast") as broadcast_mock: patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
handle_imported_book(import_item) patch("bookwyrm.models.Status.broadcast") as broadcast_mock,
):
handle_imported_book(import_item)
kwargs = broadcast_mock.call_args.kwargs kwargs = broadcast_mock.call_args.kwargs
self.assertEqual(kwargs["software"], "bookwyrm") self.assertEqual(kwargs["software"], "bookwyrm")
review = models.Review.objects.get(book=self.book, user=self.local_user) review = models.Review.objects.get(book=self.book, user=self.local_user)

14
bookwyrm/tests/importers/test_librarything_import.py
View file

@ -32,17 +32,19 @@ class LibrarythingImport(TestCase):
self.csv = open(datafile, "r", encoding=self.importer.encoding) self.csv = open(datafile, "r", encoding=self.importer.encoding)
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""populate database""" """populate database"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mmai", "mmai@mmai.mmai", "password", local=True "mmai", "mmai@mmai.mmai", "password", local=True
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
work = models.Work.objects.create(title="Test Work") work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,

14
bookwyrm/tests/importers/test_openlibrary_import.py
View file

@ -30,17 +30,19 @@ class OpenLibraryImport(TestCase):
self.csv = open(datafile, "r", encoding=self.importer.encoding) self.csv = open(datafile, "r", encoding=self.importer.encoding)
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""populate database""" """populate database"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True "mouse", "mouse@mouse.mouse", "password", local=True
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
work = models.Work.objects.create(title="Test Work") work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,

14
bookwyrm/tests/importers/test_storygraph_import.py
View file

@ -30,17 +30,19 @@ class StorygraphImport(TestCase):
self.csv = open(datafile, "r", encoding=self.importer.encoding) self.csv = open(datafile, "r", encoding=self.importer.encoding)
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""populate database""" """populate database"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True "mouse", "mouse@mouse.mouse", "password", local=True
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
work = models.Work.objects.create(title="Test Work") work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,

16
bookwyrm/tests/lists_stream/test_signals.py
View file

@ -9,19 +9,21 @@ class ListsStreamSignals(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""database setup""" """database setup"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"fish", "fish@fish.fish", "password", local=True, localname="fish" "fish", "fish@fish.fish", "password", local=True, localname="fish"
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",

18
bookwyrm/tests/lists_stream/test_stream.py
View file

@ -16,15 +16,17 @@ class ListsStream(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""database setup""" """database setup"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"nutria", "nutria",
"nutria@nutria.nutria", "nutria@nutria.nutria",
"password", "password",
@ -32,7 +34,7 @@ class ListsStream(TestCase):
localname="nutria", localname="nutria",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -41,7 +43,7 @@ class ListsStream(TestCase):
inbox="https://example.com/users/rat/inbox", inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
self.stream = lists_stream.ListsStream() cls.stream = lists_stream.ListsStream()
def test_lists_stream_ids(self, *_): def test_lists_stream_ids(self, *_):
"""the abstract base class for stream objects""" """the abstract base class for stream objects"""

27
bookwyrm/tests/lists_stream/test_tasks.py
View file

@ -11,15 +11,17 @@ class Activitystreams(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""database setup""" """database setup"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"nutria", "nutria",
"nutria@nutria.nutria", "nutria@nutria.nutria",
"password", "password",
@ -27,7 +29,7 @@ class Activitystreams(TestCase):
localname="nutria", localname="nutria",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -36,11 +38,12 @@ class Activitystreams(TestCase):
inbox="https://example.com/users/rat/inbox", inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
self.list = models.List.objects.create( ):
user=self.local_user, name="hi", privacy="public" cls.list = models.List.objects.create(
user=cls.local_user, name="hi", privacy="public"
) )
def test_populate_lists_task(self, *_): def test_populate_lists_task(self, *_):

18
bookwyrm/tests/management/test_populate_lists_streams.py
View file

@ -13,15 +13,17 @@ class Activitystreams(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need some stuff""" """we need some stuff"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"nutria", "nutria",
"nutria@nutria.nutria", "nutria@nutria.nutria",
"password", "password",
@ -37,7 +39,7 @@ class Activitystreams(TestCase):
is_active=False, is_active=False,
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -46,7 +48,7 @@ class Activitystreams(TestCase):
inbox="https://example.com/users/rat/inbox", inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
self.book = models.Edition.objects.create(title="test book") cls.book = models.Edition.objects.create(title="test book")
def test_populate_streams(self, *_): def test_populate_streams(self, *_):
"""make sure the function on the redis manager gets called""" """make sure the function on the redis manager gets called"""

27
bookwyrm/tests/management/test_populate_streams.py
View file

@ -11,15 +11,17 @@ class Activitystreams(TestCase):
"""using redis to build activity streams""" """using redis to build activity streams"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need some stuff""" """we need some stuff"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"nutria", "nutria",
"nutria@nutria.nutria", "nutria@nutria.nutria",
"password", "password",
@ -35,7 +37,7 @@ class Activitystreams(TestCase):
is_active=False, is_active=False,
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -44,7 +46,7 @@ class Activitystreams(TestCase):
inbox="https://example.com/users/rat/inbox", inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
self.book = models.Edition.objects.create(title="test book") cls.book = models.Edition.objects.create(title="test book")
def test_populate_streams(self, _): def test_populate_streams(self, _):
"""make sure the function on the redis manager gets called""" """make sure the function on the redis manager gets called"""
@ -53,11 +55,10 @@ class Activitystreams(TestCase):
user=self.local_user, content="hi", book=self.book user=self.local_user, content="hi", book=self.book
) )
with patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.activitystreams.populate_stream_task.delay") as redis_mock,
) as redis_mock, patch( patch("bookwyrm.lists_stream.populate_lists_task.delay") as list_mock,
"bookwyrm.lists_stream.populate_lists_task.delay" ):
) as list_mock:
populate_streams() populate_streams()
self.assertEqual(redis_mock.call_count, 6) # 2 users x 3 streams self.assertEqual(redis_mock.call_count, 6) # 2 users x 3 streams
self.assertEqual(list_mock.call_count, 2) # 2 users self.assertEqual(list_mock.call_count, 2) # 2 users

18
bookwyrm/tests/models/test_activitypub_mixin.py
View file

@ -27,18 +27,20 @@ class ActivitypubMixins(TestCase):
"""functionality shared across models""" """functionality shared across models"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""shared data""" """shared data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
) )
self.local_user.remote_id = "http://example.com/a/b" cls.local_user.remote_id = "http://example.com/a/b"
self.local_user.save(broadcast=False, update_fields=["remote_id"]) cls.local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",

12
bookwyrm/tests/models/test_automod.py
View file

@ -15,12 +15,14 @@ class AutomodModel(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",

14
bookwyrm/tests/models/test_base_model.py
View file

@ -13,16 +13,18 @@ class BaseModel(TestCase):
"""functionality shared across models""" """functionality shared across models"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""shared data""" """shared data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",

12
bookwyrm/tests/models/test_book_model.py
View file

@ -19,17 +19,17 @@ class Book(TestCase):
"""not too much going on in the books model but here we are""" """not too much going on in the books model but here we are"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we'll need some books""" """we'll need some books"""
self.work = models.Work.objects.create( cls.work = models.Work.objects.create(
title="Example Work", remote_id="https://example.com/book/1" title="Example Work", remote_id="https://example.com/book/1"
) )
self.first_edition = models.Edition.objects.create( cls.first_edition = models.Edition.objects.create(
title="Example Edition", parent_work=self.work title="Example Edition", parent_work=cls.work
) )
self.second_edition = models.Edition.objects.create( cls.second_edition = models.Edition.objects.create(
title="Another Example Edition", title="Another Example Edition",
parent_work=self.work, parent_work=cls.work,
) )
def test_remote_id(self): def test_remote_id(self):

18
bookwyrm/tests/models/test_bookwyrm_export_job.py
View file

@ -16,16 +16,14 @@ class BookwyrmExport(TestCase):
def setUp(self): def setUp(self):
"""lots of stuff to set up for a user export""" """lots of stuff to set up for a user export"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"), patch( patch("bookwyrm.activitystreams.populate_stream_task.delay"),
"bookwyrm.suggested_users.rerank_user_task.delay" patch("bookwyrm.lists_stream.populate_lists_task.delay"),
), patch( patch("bookwyrm.suggested_users.rerank_user_task.delay"),
"bookwyrm.lists_stream.remove_list_task.delay" patch("bookwyrm.lists_stream.remove_list_task.delay"),
), patch( patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.activitystreams.add_book_statuses_task"),
), patch(
"bookwyrm.activitystreams.add_book_statuses_task"
): ):
self.local_user = models.User.objects.create_user( self.local_user = models.User.objects.create_user(

156
bookwyrm/tests/models/test_bookwyrm_import_job.py
View file

@ -18,12 +18,12 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
def setUp(self): def setUp(self):
"""setting stuff up""" """setting stuff up"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"), patch( patch("bookwyrm.activitystreams.populate_stream_task.delay"),
"bookwyrm.suggested_users.rerank_user_task.delay" patch("bookwyrm.lists_stream.populate_lists_task.delay"),
patch("bookwyrm.suggested_users.rerank_user_task.delay"),
): ):
self.local_user = models.User.objects.create_user( self.local_user = models.User.objects.create_user(
"mouse", "mouse",
"mouse@mouse.mouse", "mouse@mouse.mouse",
@ -78,16 +78,18 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
def test_update_user_profile(self): def test_update_user_profile(self):
"""Test update the user's profile from import data""" """Test update the user's profile from import data"""
with patch("bookwyrm.suggested_users.remove_user_task.delay"), patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.suggested_users.remove_user_task.delay"),
), patch("bookwyrm.suggested_users.rerank_user_task.delay"): patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
patch("bookwyrm.suggested_users.rerank_user_task.delay"),
with open(self.archive_file, "rb") as fileobj: ):
with BookwyrmTarFile.open(mode="r:gz", fileobj=fileobj) as tarfile: with (
open(self.archive_file, "rb") as fileobj,
models.bookwyrm_import_job.update_user_profile( BookwyrmTarFile.open(mode="r:gz", fileobj=fileobj) as tarfile,
self.local_user, tarfile, self.json_data ):
) models.bookwyrm_import_job.update_user_profile(
self.local_user, tarfile, self.json_data
)
self.local_user.refresh_from_db() self.local_user.refresh_from_db()
@ -103,10 +105,11 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
def test_update_user_settings(self): def test_update_user_settings(self):
"""Test updating the user's settings from import data""" """Test updating the user's settings from import data"""
with patch("bookwyrm.suggested_users.remove_user_task.delay"), patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.suggested_users.remove_user_task.delay"),
), patch("bookwyrm.suggested_users.rerank_user_task.delay"): patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
patch("bookwyrm.suggested_users.rerank_user_task.delay"),
):
models.bookwyrm_import_job.update_user_settings( models.bookwyrm_import_job.update_user_settings(
self.local_user, self.json_data self.local_user, self.json_data
) )
@ -145,8 +148,9 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
def test_upsert_saved_lists_existing(self): def test_upsert_saved_lists_existing(self):
"""Test upserting an existing saved list""" """Test upserting an existing saved list"""
with patch("bookwyrm.lists_stream.remove_list_task.delay"), patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.lists_stream.remove_list_task.delay"),
patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
): ):
book_list = models.List.objects.create( book_list = models.List.objects.create(
name="My cool list", name="My cool list",
@ -172,8 +176,9 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
def test_upsert_saved_lists_not_existing(self): def test_upsert_saved_lists_not_existing(self):
"""Test upserting a new saved list""" """Test upserting a new saved list"""
with patch("bookwyrm.lists_stream.remove_list_task.delay"), patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.lists_stream.remove_list_task.delay"),
patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
): ):
book_list = models.List.objects.create( book_list = models.List.objects.create(
name="My cool list", name="My cool list",
@ -199,9 +204,11 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
self.assertFalse(before_follow) self.assertFalse(before_follow)
with patch("bookwyrm.activitystreams.add_user_statuses_task.delay"), patch( with (
"bookwyrm.lists_stream.add_user_lists_task.delay" patch("bookwyrm.activitystreams.add_user_statuses_task.delay"),
), patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"): patch("bookwyrm.lists_stream.add_user_lists_task.delay"),
patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
):
models.bookwyrm_import_job.upsert_follows( models.bookwyrm_import_job.upsert_follows(
self.local_user, self.json_data.get("follows") self.local_user, self.json_data.get("follows")
) )
@ -222,10 +229,11 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
).exists() ).exists()
self.assertFalse(blocked_before) self.assertFalse(blocked_before)
with patch("bookwyrm.suggested_users.remove_suggestion_task.delay"), patch( with (
"bookwyrm.activitystreams.remove_user_statuses_task.delay" patch("bookwyrm.suggested_users.remove_suggestion_task.delay"),
), patch("bookwyrm.lists_stream.remove_user_lists_task.delay"), patch( patch("bookwyrm.activitystreams.remove_user_statuses_task.delay"),
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.lists_stream.remove_user_lists_task.delay"),
patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
): ):
models.bookwyrm_import_job.upsert_user_blocks( models.bookwyrm_import_job.upsert_user_blocks(
self.local_user, self.json_data.get("blocks") self.local_user, self.json_data.get("blocks")
@ -246,14 +254,15 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
self.assertEqual(models.Edition.objects.count(), 1) self.assertEqual(models.Edition.objects.count(), 1)
with open(self.archive_file, "rb") as fileobj: with (
with BookwyrmTarFile.open(mode="r:gz", fileobj=fileobj) as tarfile: open(self.archive_file, "rb") as fileobj,
BookwyrmTarFile.open(mode="r:gz", fileobj=fileobj) as tarfile,
):
bookwyrm_import_job.get_or_create_edition(
self.json_data["books"][1], tarfile
) # Sand Talk
bookwyrm_import_job.get_or_create_edition( self.assertEqual(models.Edition.objects.count(), 1)
self.json_data["books"][1], tarfile
) # Sand Talk
self.assertEqual(models.Edition.objects.count(), 1)
def test_get_or_create_edition_not_existing(self): def test_get_or_create_edition_not_existing(self):
"""Test take a JSON string of books and editions, """Test take a JSON string of books and editions,
@ -262,12 +271,13 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
self.assertEqual(models.Edition.objects.count(), 1) self.assertEqual(models.Edition.objects.count(), 1)
with open(self.archive_file, "rb") as fileobj: with (
with BookwyrmTarFile.open(mode="r:gz", fileobj=fileobj) as tarfile: open(self.archive_file, "rb") as fileobj,
BookwyrmTarFile.open(mode="r:gz", fileobj=fileobj) as tarfile,
bookwyrm_import_job.get_or_create_edition( ):
self.json_data["books"][0], tarfile bookwyrm_import_job.get_or_create_edition(
) # Seeing like a state self.json_data["books"][0], tarfile
) # Seeing like a state
self.assertTrue(models.Edition.objects.filter(isbn_13="9780300070163").exists()) self.assertTrue(models.Edition.objects.filter(isbn_13="9780300070163").exists())
self.assertEqual(models.Edition.objects.count(), 2) self.assertEqual(models.Edition.objects.count(), 2)
@ -312,10 +322,10 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
self.assertEqual(models.Review.objects.filter(user=self.local_user).count(), 0) self.assertEqual(models.Review.objects.filter(user=self.local_user).count(), 0)
reviews = self.json_data["books"][0]["reviews"] reviews = self.json_data["books"][0]["reviews"]
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.models.bookwyrm_import_job.is_alias", return_value=True): patch("bookwyrm.models.bookwyrm_import_job.is_alias", return_value=True),
):
bookwyrm_import_job.upsert_statuses( bookwyrm_import_job.upsert_statuses(
self.local_user, models.Review, reviews, self.book.remote_id self.local_user, models.Review, reviews, self.book.remote_id
) )
@ -349,10 +359,10 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
self.assertEqual(models.Comment.objects.filter(user=self.local_user).count(), 0) self.assertEqual(models.Comment.objects.filter(user=self.local_user).count(), 0)
comments = self.json_data["books"][1]["comments"] comments = self.json_data["books"][1]["comments"]
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.models.bookwyrm_import_job.is_alias", return_value=True): patch("bookwyrm.models.bookwyrm_import_job.is_alias", return_value=True),
):
bookwyrm_import_job.upsert_statuses( bookwyrm_import_job.upsert_statuses(
self.local_user, models.Comment, comments, self.book.remote_id self.local_user, models.Comment, comments, self.book.remote_id
) )
@ -378,9 +388,10 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
models.Quotation.objects.filter(user=self.local_user).count(), 0 models.Quotation.objects.filter(user=self.local_user).count(), 0
) )
quotes = self.json_data["books"][1]["quotations"] quotes = self.json_data["books"][1]["quotations"]
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.models.bookwyrm_import_job.is_alias", return_value=True): patch("bookwyrm.models.bookwyrm_import_job.is_alias", return_value=True),
):
bookwyrm_import_job.upsert_statuses( bookwyrm_import_job.upsert_statuses(
self.local_user, models.Quotation, quotes, self.book.remote_id self.local_user, models.Quotation, quotes, self.book.remote_id
@ -411,9 +422,10 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
models.Quotation.objects.filter(user=self.local_user).count(), 0 models.Quotation.objects.filter(user=self.local_user).count(), 0
) )
quotes = self.json_data["books"][1]["quotations"] quotes = self.json_data["books"][1]["quotations"]
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.models.bookwyrm_import_job.is_alias", return_value=False): patch("bookwyrm.models.bookwyrm_import_job.is_alias", return_value=False),
):
bookwyrm_import_job.upsert_statuses( bookwyrm_import_job.upsert_statuses(
self.local_user, models.Quotation, quotes, self.book.remote_id self.local_user, models.Quotation, quotes, self.book.remote_id
@ -432,8 +444,9 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
title="Another Book", remote_id="https://example.com/book/9876" title="Another Book", remote_id="https://example.com/book/9876"
) )
with patch("bookwyrm.lists_stream.remove_list_task.delay"), patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.lists_stream.remove_list_task.delay"),
patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
): ):
book_list = models.List.objects.create( book_list = models.List.objects.create(
name="my list of books", user=self.local_user name="my list of books", user=self.local_user
@ -452,8 +465,9 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
1, 1,
) )
with patch("bookwyrm.lists_stream.remove_list_task.delay"), patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.lists_stream.remove_list_task.delay"),
patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
): ):
bookwyrm_import_job.upsert_lists( bookwyrm_import_job.upsert_lists(
self.local_user, self.local_user,
@ -479,8 +493,9 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
self.assertEqual(models.List.objects.filter(user=self.local_user).count(), 0) self.assertEqual(models.List.objects.filter(user=self.local_user).count(), 0)
self.assertFalse(models.ListItem.objects.filter(book=self.book.id).exists()) self.assertFalse(models.ListItem.objects.filter(book=self.book.id).exists())
with patch("bookwyrm.lists_stream.remove_list_task.delay"), patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.lists_stream.remove_list_task.delay"),
patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
): ):
bookwyrm_import_job.upsert_lists( bookwyrm_import_job.upsert_lists(
self.local_user, self.local_user,
@ -503,16 +518,18 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
shelf = models.Shelf.objects.get(name="Read", user=self.local_user) shelf = models.Shelf.objects.get(name="Read", user=self.local_user)
with patch("bookwyrm.activitystreams.add_book_statuses_task.delay"), patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.activitystreams.add_book_statuses_task.delay"),
patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
): ):
models.ShelfBook.objects.create( models.ShelfBook.objects.create(
book=self.book, shelf=shelf, user=self.local_user book=self.book, shelf=shelf, user=self.local_user
) )
book_data = self.json_data["books"][0] book_data = self.json_data["books"][0]
with patch("bookwyrm.activitystreams.add_book_statuses_task.delay"), patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.activitystreams.add_book_statuses_task.delay"),
patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
): ):
bookwyrm_import_job.upsert_shelves(self.book, self.local_user, book_data) bookwyrm_import_job.upsert_shelves(self.book, self.local_user, book_data)
@ -530,8 +547,9 @@ class BookwyrmImport(TestCase): # pylint: disable=too-many-public-methods
book_data = self.json_data["books"][0] book_data = self.json_data["books"][0]
with patch("bookwyrm.activitystreams.add_book_statuses_task.delay"), patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.activitystreams.add_book_statuses_task.delay"),
patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
): ):
bookwyrm_import_job.upsert_shelves(self.book, self.local_user, book_data) bookwyrm_import_job.upsert_shelves(self.book, self.local_user, book_data)

50
bookwyrm/tests/models/test_group.py
View file

@ -10,21 +10,23 @@ class Group(TestCase):
"""some activitypub oddness ahead""" """some activitypub oddness ahead"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""Set up for tests""" """Set up for tests"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.owner_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.owner_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
) )
self.rat = models.User.objects.create_user( cls.rat = models.User.objects.create_user(
"rat", "rat@rat.rat", "ratword", local=True, localname="rat" "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
) )
self.badger = models.User.objects.create_user( cls.badger = models.User.objects.create_user(
"badger", "badger",
"badger@badger.badger", "badger@badger.badger",
"badgerword", "badgerword",
@ -32,7 +34,7 @@ class Group(TestCase):
localname="badger", localname="badger",
) )
self.capybara = models.User.objects.create_user( cls.capybara = models.User.objects.create_user(
"capybara", "capybara",
"capybara@capybara.capybara", "capybara@capybara.capybara",
"capybaraword", "capybaraword",
@ -40,32 +42,32 @@ class Group(TestCase):
localname="capybara", localname="capybara",
) )
self.public_group = models.Group.objects.create( cls.public_group = models.Group.objects.create(
name="Public Group", name="Public Group",
description="Initial description", description="Initial description",
user=self.owner_user, user=cls.owner_user,
privacy="public", privacy="public",
) )
self.private_group = models.Group.objects.create( cls.private_group = models.Group.objects.create(
name="Private Group", name="Private Group",
description="Top secret", description="Top secret",
user=self.owner_user, user=cls.owner_user,
privacy="direct", privacy="direct",
) )
self.followers_only_group = models.Group.objects.create( cls.followers_only_group = models.Group.objects.create(
name="Followers Group", name="Followers Group",
description="No strangers", description="No strangers",
user=self.owner_user, user=cls.owner_user,
privacy="followers", privacy="followers",
) )
models.GroupMember.objects.create(group=self.private_group, user=self.badger) models.GroupMember.objects.create(group=cls.private_group, user=cls.badger)
models.GroupMember.objects.create( models.GroupMember.objects.create(
group=self.followers_only_group, user=self.badger group=cls.followers_only_group, user=cls.badger
) )
models.GroupMember.objects.create(group=self.public_group, user=self.capybara) models.GroupMember.objects.create(group=cls.public_group, user=cls.capybara)
def test_group_members_can_see_private_groups(self, _): def test_group_members_can_see_private_groups(self, _):
"""direct privacy group should not be excluded from group listings for group """direct privacy group should not be excluded from group listings for group
@ -81,9 +83,10 @@ class Group(TestCase):
"""follower-only group booklists should not be excluded from group booklist """follower-only group booklists should not be excluded from group booklist
listing for group members who do not follower list owner""" listing for group members who do not follower list owner"""
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
):
followers_list = models.List.objects.create( followers_list = models.List.objects.create(
name="Followers List", name="Followers List",
curation="group", curation="group",
@ -104,9 +107,10 @@ class Group(TestCase):
"""private group booklists should not be excluded from group booklist listing """private group booklists should not be excluded from group booklist listing
for group members""" for group members"""
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
):
private_list = models.List.objects.create( private_list = models.List.objects.create(
name="Private List", name="Private List",
privacy="direct", privacy="direct",

30
bookwyrm/tests/models/test_import_model.py
View file

@ -17,12 +17,14 @@ class ImportJob(TestCase):
"""this is a fancy one!!!""" """this is a fancy one!!!"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""data is from a goodreads export of The Raven Tower""" """data is from a goodreads export of The Raven Tower"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True "mouse", "mouse@mouse.mouse", "password", local=True
) )
@ -192,14 +194,16 @@ class ImportJob(TestCase):
status=200, status=200,
) )
with patch("bookwyrm.connectors.abstract_connector.load_more_data.delay"): with (
with patch( patch("bookwyrm.connectors.abstract_connector.load_more_data.delay"),
patch(
"bookwyrm.connectors.connector_manager.first_search_result" "bookwyrm.connectors.connector_manager.first_search_result"
) as search: ) as search,
search.return_value = result ):
with patch( search.return_value = result
"bookwyrm.connectors.openlibrary.Connector.get_authors_from_data" with patch(
): "bookwyrm.connectors.openlibrary.Connector.get_authors_from_data"
book = item.get_book_from_identifier() ):
book = item.get_book_from_identifier()
self.assertEqual(book.title, "Sabriel") self.assertEqual(book.title, "Sabriel")

14
bookwyrm/tests/models/test_list.py
View file

@ -12,16 +12,18 @@ class List(TestCase):
"""some activitypub oddness ahead""" """some activitypub oddness ahead"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""look, a list""" """look, a list"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
) )
work = models.Work.objects.create(title="hello") work = models.Work.objects.create(title="hello")
self.book = models.Edition.objects.create(title="hi", parent_work=work) cls.book = models.Edition.objects.create(title="hi", parent_work=work)
def test_remote_id(self, *_): def test_remote_id(self, *_):
"""shelves use custom remote ids""" """shelves use custom remote ids"""

44
bookwyrm/tests/models/test_notification.py
View file

@ -8,19 +8,21 @@ class Notification(TestCase):
"""let people know things""" """let people know things"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""useful things for creating a notification""" """useful things for creating a notification"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"rat", "rat@rat.rat", "ratword", local=True, localname="rat" "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -29,14 +31,14 @@ class Notification(TestCase):
inbox="https://example.com/users/rat/inbox", inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
self.work = models.Work.objects.create(title="Test Work") cls.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Test Book", title="Test Book",
isbn_13="1234567890123", isbn_13="1234567890123",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=self.work, parent_work=cls.work,
) )
self.another_book = models.Edition.objects.create( cls.another_book = models.Edition.objects.create(
title="Second Test Book", title="Second Test Book",
parent_work=models.Work.objects.create(title="Test Work"), parent_work=models.Work.objects.create(title="Test Work"),
) )
@ -199,12 +201,14 @@ class NotifyInviteRequest(TestCase):
"""let admins know of invite requests""" """let admins know of invite requests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""ensure there is one admin""" """ensure there is one admin"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -264,9 +268,11 @@ class NotifyInviteRequest(TestCase):
def test_notify_multiple_admins(self): def test_notify_multiple_admins(self):
"""all admins are notified""" """all admins are notified"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
self.local_user = models.User.objects.create_user( self.local_user = models.User.objects.create_user(
"admin@local.com", "admin@local.com",
"admin@example.com", "admin@example.com",

18
bookwyrm/tests/models/test_readthrough_model.py
View file

@ -12,18 +12,20 @@ class ReadThrough(TestCase):
"""some activitypub oddness ahead""" """some activitypub oddness ahead"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""look, a shelf""" """look, a shelf"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
) )
self.work = models.Work.objects.create(title="Example Work") cls.work = models.Work.objects.create(title="Example Work")
self.edition = models.Edition.objects.create( cls.edition = models.Edition.objects.create(
title="Example Edition", parent_work=self.work title="Example Edition", parent_work=cls.work
) )
def test_valid_date(self): def test_valid_date(self):

18
bookwyrm/tests/models/test_relationship_models.py
View file

@ -15,10 +15,10 @@ class Relationship(TestCase):
"""following, blocking, stuff like that""" """following, blocking, stuff like that"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need some users for this""" """we need some users for this"""
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -27,14 +27,16 @@ class Relationship(TestCase):
inbox="https://example.com/users/rat/inbox", inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
) )
self.local_user.remote_id = "http://local.com/user/mouse" cls.local_user.remote_id = "http://local.com/user/mouse"
self.local_user.save(broadcast=False, update_fields=["remote_id"]) cls.local_user.save(broadcast=False, update_fields=["remote_id"])
def test_user_follows(self, *_): def test_user_follows(self, *_):
"""basic functionality of user follows""" """basic functionality of user follows"""

14
bookwyrm/tests/models/test_shelf_model.py
View file

@ -16,16 +16,18 @@ class Shelf(TestCase):
"""some activitypub oddness ahead""" """some activitypub oddness ahead"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""look, a shelf""" """look, a shelf"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
) )
work = models.Work.objects.create(title="Test Work") work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create(title="test book", parent_work=work) cls.book = models.Edition.objects.create(title="test book", parent_work=work)
def test_remote_id(self, *_): def test_remote_id(self, *_):
"""shelves use custom remote ids""" """shelves use custom remote ids"""

12
bookwyrm/tests/models/test_site.py
View file

@ -13,12 +13,14 @@ class SiteModels(TestCase):
"""tests for site models""" """tests for site models"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",

16
bookwyrm/tests/models/test_status_model.py
View file

@ -25,16 +25,18 @@ class Status(TestCase):
"""lotta types of statuses""" """lotta types of statuses"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""useful things for creating a status""" """useful things for creating a status"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -43,7 +45,7 @@ class Status(TestCase):
inbox="https://example.com/users/rat/inbox", inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
self.book = models.Edition.objects.create(title="Test Edition") cls.book = models.Edition.objects.create(title="Test Edition")
def setUp(self): def setUp(self):
"""individual test setup""" """individual test setup"""

43
bookwyrm/tests/models/test_user_model.py
View file

@ -19,11 +19,13 @@ class User(TestCase):
protocol = "https://" if USE_HTTPS else "http://" protocol = "https://" if USE_HTTPS else "http://"
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.user = models.User.objects.create_user(
f"mouse@{DOMAIN}", f"mouse@{DOMAIN}",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"mouseword", "mouseword",
@ -33,7 +35,7 @@ class User(TestCase):
summary="a summary", summary="a summary",
bookwyrm_user=False, bookwyrm_user=False,
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
f"nutria@{DOMAIN}", f"nutria@{DOMAIN}",
"nutria@nutria.nutria", "nutria@nutria.nutria",
"nutriaword", "nutriaword",
@ -122,9 +124,11 @@ class User(TestCase):
site.default_user_auth_group = Group.objects.get(name="editor") site.default_user_auth_group = Group.objects.get(name="editor")
site.save() site.save()
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
user = models.User.objects.create_user( user = models.User.objects.create_user(
f"test2{DOMAIN}", f"test2{DOMAIN}",
"test2@bookwyrm.test", "test2@bookwyrm.test",
@ -135,9 +139,11 @@ class User(TestCase):
site.default_user_auth_group = None site.default_user_auth_group = None
site.save() site.save()
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
user = models.User.objects.create_user( user = models.User.objects.create_user(
f"test1{DOMAIN}", f"test1{DOMAIN}",
"test1@bookwyrm.test", "test1@bookwyrm.test",
@ -228,11 +234,14 @@ class User(TestCase):
self.assertEqual(self.user.name, "hi") self.assertEqual(self.user.name, "hi")
self.assertEqual(self.user.summary, "a summary") self.assertEqual(self.user.summary, "a summary")
self.assertEqual(self.user.email, "mouse@mouse.mouse") self.assertEqual(self.user.email, "mouse@mouse.mouse")
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch(
) as broadcast_mock, patch( "bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"
"bookwyrm.models.user.User.erase_user_statuses" ) as broadcast_mock,
) as erase_statuses_mock: patch(
"bookwyrm.models.user.User.erase_user_statuses"
) as erase_statuses_mock,
):
self.user.delete() self.user.delete()
self.assertEqual(erase_statuses_mock.call_count, 1) self.assertEqual(erase_statuses_mock.call_count, 1)

14
bookwyrm/tests/templatetags/test_book_display_tags.py
View file

@ -14,19 +14,21 @@ class BookDisplayTags(TestCase):
"""lotta different things here""" """lotta different things here"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create some filler objects""" """create some filler objects"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"mouseword", "mouseword",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.book = models.Edition.objects.create(title="Test Book") cls.book = models.Edition.objects.create(title="Test Book")
def test_get_book_description(self, *_): def test_get_book_description(self, *_):
"""grab it from the edition or the parent""" """grab it from the edition or the parent"""

14
bookwyrm/tests/templatetags/test_feed_page_tags.py
View file

@ -13,19 +13,21 @@ class FeedPageTags(TestCase):
"""lotta different things here""" """lotta different things here"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create some filler objects""" """create some filler objects"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"mouseword", "mouseword",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.book = models.Edition.objects.create(title="Test Book") cls.book = models.Edition.objects.create(title="Test Book")
@patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async") @patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async")
def test_load_subclass(self, *_): def test_load_subclass(self, *_):

16
bookwyrm/tests/templatetags/test_interaction.py
View file

@ -13,12 +13,14 @@ class InteractionTags(TestCase):
"""lotta different things here""" """lotta different things here"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create some filler objects""" """create some filler objects"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"mouseword", "mouseword",
@ -26,14 +28,14 @@ class InteractionTags(TestCase):
localname="mouse", localname="mouse",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.rat", "rat@rat.rat",
"ratword", "ratword",
remote_id="http://example.com/rat", remote_id="http://example.com/rat",
local=False, local=False,
) )
self.book = models.Edition.objects.create(title="Test Book") cls.book = models.Edition.objects.create(title="Test Book")
def test_get_user_liked(self, *_): def test_get_user_liked(self, *_):
"""did a user like a status""" """did a user like a status"""

12
bookwyrm/tests/templatetags/test_notification_page_tags.py
View file

@ -13,12 +13,14 @@ class NotificationPageTags(TestCase):
"""lotta different things here""" """lotta different things here"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create some filler objects""" """create some filler objects"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"mouseword", "mouseword",

16
bookwyrm/tests/templatetags/test_rating_tags.py
View file

@ -13,12 +13,14 @@ class RatingTags(TestCase):
"""lotta different things here""" """lotta different things here"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create some filler objects""" """create some filler objects"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"mouseword", "mouseword",
@ -26,7 +28,7 @@ class RatingTags(TestCase):
localname="mouse", localname="mouse",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.rat", "rat@rat.rat",
"ratword", "ratword",
@ -34,7 +36,7 @@ class RatingTags(TestCase):
local=False, local=False,
) )
work = models.Work.objects.create(title="Work title") work = models.Work.objects.create(title="Work title")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Test Book", title="Test Book",
parent_work=work, parent_work=work,
) )

16
bookwyrm/tests/templatetags/test_shelf_tags.py
View file

@ -16,12 +16,14 @@ class ShelfTags(TestCase):
"""lotta different things here""" """lotta different things here"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create some filler objects""" """create some filler objects"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"mouseword", "mouseword",
@ -29,14 +31,14 @@ class ShelfTags(TestCase):
localname="mouse", localname="mouse",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.rat", "rat@rat.rat",
"ratword", "ratword",
remote_id="http://example.com/rat", remote_id="http://example.com/rat",
local=False, local=False,
) )
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Test Book", title="Test Book",
parent_work=models.Work.objects.create(title="Test work"), parent_work=models.Work.objects.create(title="Test work"),
) )

16
bookwyrm/tests/templatetags/test_status_display.py
View file

@ -15,12 +15,14 @@ class StatusDisplayTags(TestCase):
"""lotta different things here""" """lotta different things here"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create some filler objects""" """create some filler objects"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"mouseword", "mouseword",
@ -28,14 +30,14 @@ class StatusDisplayTags(TestCase):
localname="mouse", localname="mouse",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.rat", "rat@rat.rat",
"ratword", "ratword",
remote_id="http://example.com/rat", remote_id="http://example.com/rat",
local=False, local=False,
) )
self.book = models.Edition.objects.create(title="Test Book") cls.book = models.Edition.objects.create(title="Test Book")
def test_get_mentions(self, *_): def test_get_mentions(self, *_):
"""list of people mentioned""" """list of people mentioned"""

18
bookwyrm/tests/templatetags/test_utilities.py
View file

@ -15,12 +15,14 @@ class UtilitiesTags(TestCase):
"""lotta different things here""" """lotta different things here"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create some filler objects""" """create some filler objects"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"mouseword", "mouseword",
@ -28,15 +30,15 @@ class UtilitiesTags(TestCase):
localname="mouse", localname="mouse",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.rat", "rat@rat.rat",
"ratword", "ratword",
remote_id="http://example.com/rat", remote_id="http://example.com/rat",
local=False, local=False,
) )
self.author = models.Author.objects.create(name="Jessica", isni="4") cls.author = models.Author.objects.create(name="Jessica", isni="4")
self.book = models.Edition.objects.create(title="Test Book") cls.book = models.Edition.objects.create(title="Test Book")
def test_get_uuid(self, *_): def test_get_uuid(self, *_):
"""uuid functionality""" """uuid functionality"""

30
bookwyrm/tests/test_book_search.py
View file

@ -12,43 +12,43 @@ class BookSearch(TestCase):
"""look for some books""" """look for some books"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
self.first_author = models.Author.objects.create( cls.first_author = models.Author.objects.create(
name="Author One", aliases=["The First"] name="Author One", aliases=["The First"]
) )
self.second_author = models.Author.objects.create( cls.second_author = models.Author.objects.create(
name="Author Two", aliases=["The Second"] name="Author Two", aliases=["The Second"]
) )
self.work = models.Work.objects.create(title="Example Work") cls.work = models.Work.objects.create(title="Example Work")
self.first_edition = models.Edition.objects.create( cls.first_edition = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
parent_work=self.work, parent_work=cls.work,
isbn_10="0000000000", isbn_10="0000000000",
physical_format="Paperback", physical_format="Paperback",
published_date=datetime.datetime(2019, 4, 9, 0, 0, tzinfo=timezone.utc), published_date=datetime.datetime(2019, 4, 9, 0, 0, tzinfo=timezone.utc),
) )
self.first_edition.authors.add(self.first_author) cls.first_edition.authors.add(cls.first_author)
self.second_edition = models.Edition.objects.create( cls.second_edition = models.Edition.objects.create(
title="Another Edition", title="Another Edition",
parent_work=self.work, parent_work=cls.work,
isbn_10="1111111111", isbn_10="1111111111",
openlibrary_key="hello", openlibrary_key="hello",
pages=150, pages=150,
) )
self.second_edition.authors.add(self.first_author) cls.second_edition.authors.add(cls.first_author)
self.second_edition.authors.add(self.second_author) cls.second_edition.authors.add(cls.second_author)
self.third_edition = models.Edition.objects.create( cls.third_edition = models.Edition.objects.create(
title="Another Edition with annoying ISBN", title="Another Edition with annoying ISBN",
parent_work=self.work, parent_work=cls.work,
isbn_10="022222222X", isbn_10="022222222X",
) )
self.third_edition.authors.add(self.first_author) cls.third_edition.authors.add(cls.first_author)
self.third_edition.authors.add(self.second_author) cls.third_edition.authors.add(cls.second_author)
def test_search(self): def test_search(self):
"""search for a book in the db""" """search for a book in the db"""

18
bookwyrm/tests/test_context_processors.py
View file

@ -12,21 +12,23 @@ class ContextProcessor(TestCase):
"""pages you land on without really trying""" """pages you land on without really trying"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.anonymous_user = AnonymousUser cls.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False cls.anonymous_user.is_authenticated = False
self.site = models.SiteSettings.objects.create() cls.site = models.SiteSettings.objects.create()
def setUp(self): def setUp(self):
"""other test data""" """other test data"""

12
bookwyrm/tests/test_emailing.py
View file

@ -12,12 +12,14 @@ class Emailing(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",

24
bookwyrm/tests/test_preview_images.py
View file

@ -31,9 +31,11 @@ class PreviewImages(TestCase):
avatar_file = pathlib.Path(__file__).parent.joinpath( avatar_file = pathlib.Path(__file__).parent.joinpath(
"../static/images/no_cover.jpg" "../static/images/no_cover.jpg"
) )
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
self.local_user = models.User.objects.create_user( self.local_user = models.User.objects.create_user(
"possum@local.com", "possum@local.com",
"possum@possum.possum", "possum@possum.possum",
@ -47,9 +49,11 @@ class PreviewImages(TestCase):
), ),
) )
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
self.remote_user = models.User.objects.create_user( self.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
@ -60,9 +64,11 @@ class PreviewImages(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
self.remote_user_with_preview = models.User.objects.create_user( self.remote_user_with_preview = models.User.objects.create_user(
"badger@your.domain.here", "badger@your.domain.here",
"badger@badger.com", "badger@badger.com",

24
bookwyrm/tests/test_signing.py
View file

@ -36,22 +36,24 @@ class Signature(TestCase):
"""signature test""" """signature test"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""create users and test data""" """create users and test data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.mouse = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.mouse = models.User.objects.create_user(
f"mouse@{DOMAIN}", f"mouse@{DOMAIN}",
"mouse@example.com", "mouse@example.com",
"", "",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.rat = models.User.objects.create_user( cls.rat = models.User.objects.create_user(
f"rat@{DOMAIN}", "rat@example.com", "", local=True, localname="rat" f"rat@{DOMAIN}", "rat@example.com", "", local=True, localname="rat"
) )
self.cat = models.User.objects.create_user( cls.cat = models.User.objects.create_user(
f"cat@{DOMAIN}", "cat@example.com", "", local=True, localname="cat" f"cat@{DOMAIN}", "cat@example.com", "", local=True, localname="cat"
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
@ -89,9 +91,11 @@ class Signature(TestCase):
signature = make_signature( signature = make_signature(
"post", signer or sender, self.rat.inbox, now, digest=digest "post", signer or sender, self.rat.inbox, now, digest=digest
) )
with patch("bookwyrm.views.inbox.activity_task.apply_async"): with (
with patch("bookwyrm.models.user.set_remote_server.delay"): patch("bookwyrm.views.inbox.activity_task.apply_async"),
return self.send(signature, now, send_data or data, digest) patch("bookwyrm.models.user.set_remote_server.delay"),
):
return self.send(signature, now, send_data or data, digest)
def test_correct_signature(self): def test_correct_signature(self):
"""this one should just work""" """this one should just work"""

8
bookwyrm/tests/test_suggested_users.py
View file

@ -22,9 +22,11 @@ class SuggestedUsers(TestCase):
def setUp(self): def setUp(self):
"""use a test csv""" """use a test csv"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
self.local_user = models.User.objects.create_user( self.local_user = models.User.objects.create_user(
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
) )

12
bookwyrm/tests/views/admin/test_announcements.py
View file

@ -12,12 +12,14 @@ class AnnouncementViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",

14
bookwyrm/tests/views/admin/test_automod.py
View file

@ -16,12 +16,14 @@ class AutomodViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -31,7 +33,7 @@ class AutomodViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="moderator") group = Group.objects.get(name="moderator")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
def setUp(self): def setUp(self):

14
bookwyrm/tests/views/admin/test_celery.py
View file

@ -15,12 +15,14 @@ class CeleryStatusViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -30,7 +32,7 @@ class CeleryStatusViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="admin") group = Group.objects.get(name="admin")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
def setUp(self): def setUp(self):

14
bookwyrm/tests/views/admin/test_dashboard.py
View file

@ -15,12 +15,14 @@ class DashboardViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -30,7 +32,7 @@ class DashboardViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="moderator") group = Group.objects.get(name="moderator")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

14
bookwyrm/tests/views/admin/test_email_blocks.py
View file

@ -15,12 +15,14 @@ class EmailBlocklistViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -30,7 +32,7 @@ class EmailBlocklistViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="moderator") group = Group.objects.get(name="moderator")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

14
bookwyrm/tests/views/admin/test_email_config.py
View file

@ -15,12 +15,14 @@ class EmailConfigViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -30,7 +32,7 @@ class EmailConfigViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="admin") group = Group.objects.get(name="admin")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
def setUp(self): def setUp(self):

16
bookwyrm/tests/views/admin/test_federation.py
View file

@ -18,12 +18,14 @@ class FederationViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -31,7 +33,7 @@ class FederationViews(TestCase):
localname="mouse", localname="mouse",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -43,7 +45,7 @@ class FederationViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="moderator") group = Group.objects.get(name="moderator")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

14
bookwyrm/tests/views/admin/test_imports.py
View file

@ -15,12 +15,14 @@ class ImportsAdminViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -30,7 +32,7 @@ class ImportsAdminViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="admin") group = Group.objects.get(name="admin")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
def setUp(self): def setUp(self):

14
bookwyrm/tests/views/admin/test_ip_blocklist.py
View file

@ -15,12 +15,14 @@ class IPBlocklistViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -30,7 +32,7 @@ class IPBlocklistViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="moderator") group = Group.objects.get(name="moderator")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

20
bookwyrm/tests/views/admin/test_link_domains.py
View file

@ -15,12 +15,14 @@ class LinkDomainViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -30,13 +32,13 @@ class LinkDomainViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="moderator") group = Group.objects.get(name="moderator")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
self.book = models.Edition.objects.create(title="hello") cls.book = models.Edition.objects.create(title="hello")
models.FileLink.objects.create( models.FileLink.objects.create(
book=self.book, book=cls.book,
url="https://beep.com/book/1", url="https://beep.com/book/1",
added_by=self.local_user, added_by=cls.local_user,
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

16
bookwyrm/tests/views/admin/test_reports.py
View file

@ -16,19 +16,21 @@ class ReportViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.rat = models.User.objects.create_user( cls.rat = models.User.objects.create_user(
"rat@local.com", "rat@local.com",
"rat@mouse.mouse", "rat@mouse.mouse",
"password", "password",
@ -38,7 +40,7 @@ class ReportViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="moderator") group = Group.objects.get(name="moderator")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
def setUp(self): def setUp(self):

16
bookwyrm/tests/views/admin/test_site.py
View file

@ -15,12 +15,14 @@ class SiteSettingsViews(TestCase):
"""Edit site settings""" """Edit site settings"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -30,9 +32,9 @@ class SiteSettingsViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="admin") group = Group.objects.get(name="admin")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
self.site = models.SiteSettings.objects.create() cls.site = models.SiteSettings.objects.create()
def setUp(self): def setUp(self):
"""individual test setup""" """individual test setup"""

18
bookwyrm/tests/views/admin/test_themes.py
View file

@ -16,19 +16,21 @@ class AdminThemesViews(TestCase):
"""Edit site settings""" """Edit site settings"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"rat@local.com", "rat@local.com",
"rat@rat.rat", "rat@rat.rat",
"password", "password",
@ -38,9 +40,9 @@ class AdminThemesViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="admin") group = Group.objects.get(name="admin")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
self.site = models.SiteSettings.objects.create() cls.site = models.SiteSettings.objects.create()
def setUp(self): def setUp(self):
"""individual test setup""" """individual test setup"""

14
bookwyrm/tests/views/admin/test_user_admin.py
View file

@ -16,12 +16,14 @@ class UserAdminViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -31,7 +33,7 @@ class UserAdminViews(TestCase):
initdb.init_groups() initdb.init_groups()
initdb.init_permissions() initdb.init_permissions()
group = Group.objects.get(name="moderator") group = Group.objects.get(name="moderator")
self.local_user.groups.set([group]) cls.local_user.groups.set([group])
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
def setUp(self): def setUp(self):

22
bookwyrm/tests/views/books/test_book.py
View file

@ -24,12 +24,14 @@ class BookViews(TestCase):
"""books books books""" """books books books"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
@ -37,19 +39,19 @@ class BookViews(TestCase):
localname="mouse", localname="mouse",
remote_id="https://example.com/users/mouse", remote_id="https://example.com/users/mouse",
) )
self.group = Group.objects.create(name="editor") cls.group = Group.objects.create(name="editor")
self.group.permissions.add( cls.group.permissions.add(
Permission.objects.create( Permission.objects.create(
name="edit_book", name="edit_book",
codename="edit_book", codename="edit_book",
content_type=ContentType.objects.get_for_model(models.User), content_type=ContentType.objects.get_for_model(models.User),
).id ).id
) )
self.work = models.Work.objects.create(title="Test Work") cls.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=self.work, parent_work=cls.work,
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

22
bookwyrm/tests/views/books/test_edit_book.py
View file

@ -20,12 +20,14 @@ class EditBookViews(TestCase):
"""books books books""" """books books books"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
@ -33,19 +35,19 @@ class EditBookViews(TestCase):
localname="mouse", localname="mouse",
remote_id="https://example.com/users/mouse", remote_id="https://example.com/users/mouse",
) )
self.group = Group.objects.create(name="editor") cls.group = Group.objects.create(name="editor")
self.group.permissions.add( cls.group.permissions.add(
Permission.objects.create( Permission.objects.create(
name="edit_book", name="edit_book",
codename="edit_book", codename="edit_book",
content_type=ContentType.objects.get_for_model(models.User), content_type=ContentType.objects.get_for_model(models.User),
).id ).id
) )
self.work = models.Work.objects.create(title="Test Work") cls.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=self.work, parent_work=cls.work,
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

18
bookwyrm/tests/views/books/test_editions.py
View file

@ -14,12 +14,14 @@ class BookViews(TestCase):
"""books books books""" """books books books"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
@ -27,11 +29,11 @@ class BookViews(TestCase):
localname="mouse", localname="mouse",
remote_id="https://example.com/users/mouse", remote_id="https://example.com/users/mouse",
) )
self.work = models.Work.objects.create(title="Test Work") cls.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=self.work, parent_work=cls.work,
physical_format="paperback", physical_format="paperback",
) )

17
bookwyrm/tests/views/books/test_links.py
View file

@ -16,12 +16,13 @@ class LinkViews(TestCase):
"""books books books""" """books books books"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
patch("bookwyrm.activitystreams.populate_stream_task.delay"),
): ):
self.local_user = models.User.objects.create_user( cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
@ -37,13 +38,13 @@ class LinkViews(TestCase):
content_type=ContentType.objects.get_for_model(models.User), content_type=ContentType.objects.get_for_model(models.User),
).id ).id
) )
self.local_user.groups.add(group) cls.local_user.groups.add(group)
self.work = models.Work.objects.create(title="Test Work") cls.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=self.work, parent_work=cls.work,
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

12
bookwyrm/tests/views/imports/test_import.py
View file

@ -17,12 +17,14 @@ class ImportViews(TestCase):
"""goodreads import views""" """goodreads import views"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",

16
bookwyrm/tests/views/imports/test_import_review.py
View file

@ -12,12 +12,14 @@ class ImportManualReviewViews(TestCase):
"""goodreads import views""" """goodreads import views"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -25,10 +27,10 @@ class ImportManualReviewViews(TestCase):
localname="mouse", localname="mouse",
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
self.job = models.ImportJob.objects.create(user=self.local_user, mappings={}) cls.job = models.ImportJob.objects.create(user=cls.local_user, mappings={})
work = models.Work.objects.create(title="Test Work") work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,

12
bookwyrm/tests/views/imports/test_import_troubleshoot.py
View file

@ -13,12 +13,14 @@ class ImportTroubleshootViews(TestCase):
"""goodreads import views""" """goodreads import views"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",

8
bookwyrm/tests/views/imports/test_user_import.py
View file

@ -18,9 +18,11 @@ class ImportUserViews(TestCase):
def setUp(self): def setUp(self):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
self.factory = RequestFactory() self.factory = RequestFactory()
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
self.local_user = models.User.objects.create_user( self.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",

12
bookwyrm/tests/views/inbox/test_inbox.py
View file

@ -29,11 +29,13 @@ class Inbox(TestCase):
} }
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
local_user = models.User.objects.create_user( local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
@ -44,7 +46,7 @@ class Inbox(TestCase):
local_user.remote_id = "https://example.com/user/mouse" local_user.remote_id = "https://example.com/user/mouse"
local_user.save(broadcast=False, update_fields=["remote_id"]) local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",

14
bookwyrm/tests/views/inbox/test_inbox_add.py
View file

@ -12,11 +12,13 @@ class InboxAdd(TestCase):
"""inbox tests""" """inbox tests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
local_user = models.User.objects.create_user( local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
@ -27,7 +29,7 @@ class InboxAdd(TestCase):
local_user.remote_id = "https://example.com/user/mouse" local_user.remote_id = "https://example.com/user/mouse"
local_user.save(broadcast=False, update_fields=["remote_id"]) local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -38,7 +40,7 @@ class InboxAdd(TestCase):
) )
work = models.Work.objects.create(title="work title") work = models.Work.objects.create(title="work title")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Test", title="Test",
remote_id="https://example.com/book/37292", remote_id="https://example.com/book/37292",
parent_work=work, parent_work=work,

34
bookwyrm/tests/views/inbox/test_inbox_announce.py
View file

@ -12,22 +12,24 @@ class InboxActivities(TestCase):
"""inbox tests""" """inbox tests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.local_user.remote_id = "https://example.com/user/mouse" cls.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=False, update_fields=["remote_id"]) cls.local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -37,13 +39,15 @@ class InboxActivities(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"): with (
with patch("bookwyrm.activitystreams.add_status_task.delay"): patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
self.status = models.Status.objects.create( patch("bookwyrm.activitystreams.add_status_task.delay"),
user=self.local_user, ):
content="Test status", cls.status = models.Status.objects.create(
remote_id="https://example.com/status/1", user=cls.local_user,
) content="Test status",
remote_id="https://example.com/status/1",
)
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

27
bookwyrm/tests/views/inbox/test_inbox_block.py
View file

@ -11,22 +11,24 @@ class InboxBlock(TestCase):
"""inbox tests""" """inbox tests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.local_user.remote_id = "https://example.com/user/mouse" cls.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=False, update_fields=["remote_id"]) cls.local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -56,9 +58,12 @@ class InboxBlock(TestCase):
"object": "https://example.com/user/mouse", "object": "https://example.com/user/mouse",
} }
with patch( with (
"bookwyrm.activitystreams.remove_user_statuses_task.delay" patch(
) as redis_mock, patch("bookwyrm.lists_stream.remove_user_lists_task.delay"): "bookwyrm.activitystreams.remove_user_statuses_task.delay"
) as redis_mock,
patch("bookwyrm.lists_stream.remove_user_lists_task.delay"),
):
views.inbox.activity_task(activity) views.inbox.activity_task(activity)
self.assertTrue(redis_mock.called) self.assertTrue(redis_mock.called)
views.inbox.activity_task(activity) views.inbox.activity_task(activity)

26
bookwyrm/tests/views/inbox/test_inbox_create.py
View file

@ -15,9 +15,11 @@ class TransactionInboxCreate(TransactionTestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
self.local_user = models.User.objects.create_user( self.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
@ -72,22 +74,24 @@ class InboxCreate(TestCase):
"""readthrough tests""" """readthrough tests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.local_user.remote_id = "https://example.com/user/mouse" cls.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=False, update_fields=["remote_id"]) cls.local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",

22
bookwyrm/tests/views/inbox/test_inbox_delete.py
View file

@ -12,22 +12,24 @@ class InboxActivities(TestCase):
"""inbox tests""" """inbox tests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.local_user.remote_id = "https://example.com/user/mouse" cls.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=False, update_fields=["remote_id"]) cls.local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -37,8 +39,8 @@ class InboxActivities(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.activitystreams.add_status_task.delay"): with patch("bookwyrm.activitystreams.add_status_task.delay"):
self.status = models.Status.objects.create( cls.status = models.Status.objects.create(
user=self.remote_user, user=cls.remote_user,
content="Test status", content="Test status",
remote_id="https://example.com/status/1", remote_id="https://example.com/status/1",
) )

18
bookwyrm/tests/views/inbox/test_inbox_follow.py
View file

@ -12,22 +12,24 @@ class InboxRelationships(TestCase):
"""inbox tests""" """inbox tests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.local_user.remote_id = "https://example.com/user/mouse" cls.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=False, update_fields=["remote_id"]) cls.local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",

34
bookwyrm/tests/views/inbox/test_inbox_like.py
View file

@ -11,22 +11,24 @@ class InboxActivities(TestCase):
"""inbox tests""" """inbox tests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.local_user.remote_id = "https://example.com/user/mouse" cls.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=False, update_fields=["remote_id"]) cls.local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -36,13 +38,15 @@ class InboxActivities(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"): with (
with patch("bookwyrm.activitystreams.add_status_task.delay"): patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
self.status = models.Status.objects.create( patch("bookwyrm.activitystreams.add_status_task.delay"),
user=self.local_user, ):
content="Test status", cls.status = models.Status.objects.create(
remote_id="https://example.com/status/1", user=cls.local_user,
) content="Test status",
remote_id="https://example.com/status/1",
)
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

31
bookwyrm/tests/views/inbox/test_inbox_remove.py
View file

@ -11,22 +11,24 @@ class InboxRemove(TestCase):
"""inbox tests""" """inbox tests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.local_user.remote_id = "https://example.com/user/mouse" cls.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=False, update_fields=["remote_id"]) cls.local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -36,11 +38,11 @@ class InboxRemove(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
self.work = models.Work.objects.create(title="work title") cls.work = models.Work.objects.create(title="work title")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Test", title="Test",
remote_id="https://bookwyrm.social/book/37292", remote_id="https://bookwyrm.social/book/37292",
parent_work=self.work, parent_work=cls.work,
) )
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
@ -76,9 +78,10 @@ class InboxRemove(TestCase):
def test_handle_remove_book_from_list(self): def test_handle_remove_book_from_list(self):
"""listing a book""" """listing a book"""
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
):
booklist = models.List.objects.create( booklist = models.List.objects.create(
name="test list", name="test list",
user=self.local_user, user=self.local_user,

25
bookwyrm/tests/views/inbox/test_inbox_update.py
View file

@ -13,22 +13,24 @@ class InboxUpdate(TestCase):
"""inbox tests""" """inbox tests"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@example.com", "mouse@example.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.local_user.remote_id = "https://example.com/user/mouse" cls.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=False, update_fields=["remote_id"]) cls.local_user.save(broadcast=False, update_fields=["remote_id"])
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -53,9 +55,10 @@ class InboxUpdate(TestCase):
def test_update_list(self): def test_update_list(self):
"""a new list""" """a new list"""
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
):
book_list = models.List.objects.create( book_list = models.List.objects.create(
name="hi", remote_id="https://example.com/list/22", user=self.local_user name="hi", remote_id="https://example.com/list/22", user=self.local_user
) )

12
bookwyrm/tests/views/landing/test_invite.py
View file

@ -15,12 +15,14 @@ class InviteViews(TestCase):
"""every response to a get request, html or json""" """every response to a get request, html or json"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",

12
bookwyrm/tests/views/landing/test_landing.py
View file

@ -15,12 +15,14 @@ class LandingViews(TestCase):
"""pages you land on without really trying""" """pages you land on without really trying"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",

16
bookwyrm/tests/views/landing/test_login.py
View file

@ -18,12 +18,14 @@ class LoginViews(TestCase):
"""login and password management""" """login and password management"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@your.domain.here", "mouse@your.domain.here",
"mouse@mouse.com", "mouse@mouse.com",
"password", "password",
@ -31,14 +33,14 @@ class LoginViews(TestCase):
localname="mouse", localname="mouse",
two_factor_auth=False, two_factor_auth=False,
) )
self.rat = models.User.objects.create_user( cls.rat = models.User.objects.create_user(
"rat@your.domain.here", "rat@your.domain.here",
"rat@rat.com", "rat@rat.com",
"password", "password",
local=True, local=True,
localname="rat", localname="rat",
) )
self.badger = models.User.objects.create_user( cls.badger = models.User.objects.create_user(
"badger@your.domain.here", "badger@your.domain.here",
"badger@badger.com", "badger@badger.com",
"password", "password",

12
bookwyrm/tests/views/landing/test_password.py
View file

@ -17,12 +17,14 @@ class PasswordViews(TestCase):
"""view user and edit profile""" """view user and edit profile"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"password", "password",

14
bookwyrm/tests/views/landing/test_register.py
View file

@ -21,19 +21,21 @@ class RegisterViews(TestCase):
"""login and password management""" """login and password management"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@your.domain.here", "mouse@your.domain.here",
"mouse@mouse.com", "mouse@mouse.com",
"password", "password",
local=True, local=True,
localname="mouse", localname="mouse",
) )
self.settings = models.SiteSettings.objects.create( cls.settings = models.SiteSettings.objects.create(
id=1, require_confirm_email=False, allow_registration=True id=1, require_confirm_email=False, allow_registration=True
) )

25
bookwyrm/tests/views/lists/test_curate.py
View file

@ -16,12 +16,14 @@ class ListViews(TestCase):
"""list view""" """list view"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
@ -30,18 +32,17 @@ class ListViews(TestCase):
remote_id="https://example.com/users/mouse", remote_id="https://example.com/users/mouse",
) )
work = models.Work.objects.create(title="Work") work = models.Work.objects.create(title="Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,
) )
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
self.list = models.List.objects.create( ):
name="Test List", user=self.local_user cls.list = models.List.objects.create(name="Test List", user=cls.local_user)
)
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

25
bookwyrm/tests/views/lists/test_embed.py
View file

@ -16,12 +16,14 @@ class ListViews(TestCase):
"""list view""" """list view"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
@ -30,18 +32,17 @@ class ListViews(TestCase):
remote_id="https://example.com/users/mouse", remote_id="https://example.com/users/mouse",
) )
work = models.Work.objects.create(title="Work") work = models.Work.objects.create(title="Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,
) )
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
self.list = models.List.objects.create( ):
name="Test List", user=self.local_user cls.list = models.List.objects.create(name="Test List", user=cls.local_user)
)
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

51
bookwyrm/tests/views/lists/test_list.py
View file

@ -19,12 +19,14 @@ class ListViews(TestCase):
"""list view""" """list view"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
@ -32,7 +34,7 @@ class ListViews(TestCase):
localname="mouse", localname="mouse",
remote_id="https://example.com/users/mouse", remote_id="https://example.com/users/mouse",
) )
self.rat = models.User.objects.create_user( cls.rat = models.User.objects.create_user(
"rat@local.com", "rat@local.com",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -41,36 +43,35 @@ class ListViews(TestCase):
remote_id="https://example.com/users/rat", remote_id="https://example.com/users/rat",
) )
work = models.Work.objects.create(title="Work") work = models.Work.objects.create(title="Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,
) )
work_two = models.Work.objects.create(title="Labori") work_two = models.Work.objects.create(title="Labori")
self.book_two = models.Edition.objects.create( cls.book_two = models.Edition.objects.create(
title="Example Edition 2", title="Example Edition 2",
remote_id="https://example.com/book/2", remote_id="https://example.com/book/2",
parent_work=work_two, parent_work=work_two,
) )
work_three = models.Work.objects.create(title="Trabajar") work_three = models.Work.objects.create(title="Trabajar")
self.book_three = models.Edition.objects.create( cls.book_three = models.Edition.objects.create(
title="Example Edition 3", title="Example Edition 3",
remote_id="https://example.com/book/3", remote_id="https://example.com/book/3",
parent_work=work_three, parent_work=work_three,
) )
work_four = models.Work.objects.create(title="Travailler") work_four = models.Work.objects.create(title="Travailler")
self.book_four = models.Edition.objects.create( cls.book_four = models.Edition.objects.create(
title="Example Edition 4", title="Example Edition 4",
remote_id="https://example.com/book/4", remote_id="https://example.com/book/4",
parent_work=work_four, parent_work=work_four,
) )
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
self.list = models.List.objects.create( ):
name="Test List", user=self.local_user cls.list = models.List.objects.create(name="Test List", user=cls.local_user)
)
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
@ -248,9 +249,12 @@ class ListViews(TestCase):
) )
request.user = self.local_user request.user = self.local_user
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch(
) as mock, patch("bookwyrm.lists_stream.remove_list_task.delay"): "bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"
) as mock,
patch("bookwyrm.lists_stream.remove_list_task.delay"),
):
result = view(request, self.list.id) result = view(request, self.list.id)
self.assertEqual(mock.call_count, 1) self.assertEqual(mock.call_count, 1)
@ -286,9 +290,12 @@ class ListViews(TestCase):
) )
request = self.factory.post("") request = self.factory.post("")
request.user = self.local_user request.user = self.local_user
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch(
) as mock, patch("bookwyrm.lists_stream.remove_list_task.delay") as redis_mock: "bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"
) as mock,
patch("bookwyrm.lists_stream.remove_list_task.delay") as redis_mock,
):
views.delete_list(request, self.list.id) views.delete_list(request, self.list.id)
self.assertTrue(redis_mock.called) self.assertTrue(redis_mock.called)
activity = json.loads(mock.call_args[1]["args"][1]) activity = json.loads(mock.call_args[1]["args"][1])

25
bookwyrm/tests/views/lists/test_list_item.py
View file

@ -13,12 +13,14 @@ class ListItemViews(TestCase):
"""list view""" """list view"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
@ -27,17 +29,16 @@ class ListItemViews(TestCase):
remote_id="https://example.com/users/mouse", remote_id="https://example.com/users/mouse",
) )
work = models.Work.objects.create(title="Work") work = models.Work.objects.create(title="Work")
self.book = models.Edition.objects.create( cls.book = models.Edition.objects.create(
title="Example Edition", title="Example Edition",
remote_id="https://example.com/book/1", remote_id="https://example.com/book/1",
parent_work=work, parent_work=work,
) )
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
self.list = models.List.objects.create( ):
name="Test List", user=self.local_user cls.list = models.List.objects.create(name="Test List", user=cls.local_user)
)
models.SiteSettings.objects.create() models.SiteSettings.objects.create()

52
bookwyrm/tests/views/lists/test_lists.py
View file

@ -16,12 +16,14 @@ class ListViews(TestCase):
"""lists of lists""" """lists of lists"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.com", "mouse@mouse.com",
"mouseword", "mouseword",
@ -29,7 +31,7 @@ class ListViews(TestCase):
localname="mouse", localname="mouse",
remote_id="https://example.com/users/mouse", remote_id="https://example.com/users/mouse",
) )
self.another_user = models.User.objects.create_user( cls.another_user = models.User.objects.create_user(
"rat@local.com", "rat@rat.com", "ratword", local=True, localname="rat" "rat@local.com", "rat@rat.com", "ratword", local=True, localname="rat"
) )
@ -45,10 +47,10 @@ class ListViews(TestCase):
def test_lists_page(self, _): def test_lists_page(self, _):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""
view = views.Lists.as_view() view = views.Lists.as_view()
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.add_list_task.delay"), patch( patch("bookwyrm.lists_stream.add_list_task.delay"),
"bookwyrm.lists_stream.remove_list_task.delay" patch("bookwyrm.lists_stream.remove_list_task.delay"),
): ):
models.List.objects.create(name="Public list", user=self.local_user) models.List.objects.create(name="Public list", user=self.local_user)
models.List.objects.create( models.List.objects.create(
@ -72,9 +74,10 @@ class ListViews(TestCase):
def test_saved_lists_page(self): def test_saved_lists_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""
view = views.SavedLists.as_view() view = views.SavedLists.as_view()
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
):
booklist = models.List.objects.create( booklist = models.List.objects.create(
name="Public list", user=self.local_user name="Public list", user=self.local_user
) )
@ -94,9 +97,10 @@ class ListViews(TestCase):
def test_saved_lists_page_empty(self): def test_saved_lists_page_empty(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""
view = views.SavedLists.as_view() view = views.SavedLists.as_view()
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
):
models.List.objects.create(name="Public list", user=self.local_user) models.List.objects.create(name="Public list", user=self.local_user)
models.List.objects.create( models.List.objects.create(
name="Private list", privacy="direct", user=self.local_user name="Private list", privacy="direct", user=self.local_user
@ -122,9 +126,10 @@ class ListViews(TestCase):
def test_user_lists_page(self): def test_user_lists_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""
view = views.UserLists.as_view() view = views.UserLists.as_view()
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"),
), patch("bookwyrm.lists_stream.remove_list_task.delay"): patch("bookwyrm.lists_stream.remove_list_task.delay"),
):
models.List.objects.create(name="Public list", user=self.local_user) models.List.objects.create(name="Public list", user=self.local_user)
models.List.objects.create( models.List.objects.create(
name="Private list", privacy="direct", user=self.local_user name="Private list", privacy="direct", user=self.local_user
@ -160,9 +165,12 @@ class ListViews(TestCase):
}, },
) )
request.user = self.local_user request.user = self.local_user
with patch( with (
"bookwyrm.models.activitypub_mixin.broadcast_task.apply_async" patch(
) as mock, patch("bookwyrm.lists_stream.remove_list_task.delay"): "bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"
) as mock,
patch("bookwyrm.lists_stream.remove_list_task.delay"),
):
result = view(request) result = view(request)
self.assertEqual(mock.call_count, 1) self.assertEqual(mock.call_count, 1)

24
bookwyrm/tests/views/preferences/test_block.py
View file

@ -14,12 +14,14 @@ class BlockViews(TestCase):
"""view user and edit profile""" """view user and edit profile"""
@classmethod @classmethod
def setUpTestData(self): # pylint: disable=bad-classmethod-argument def setUpTestData(cls):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch( with (
"bookwyrm.activitystreams.populate_stream_task.delay" patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"),
), patch("bookwyrm.lists_stream.populate_lists_task.delay"): patch("bookwyrm.activitystreams.populate_stream_task.delay"),
self.local_user = models.User.objects.create_user( patch("bookwyrm.lists_stream.populate_lists_task.delay"),
):
cls.local_user = models.User.objects.create_user(
"mouse@local.com", "mouse@local.com",
"mouse@mouse.mouse", "mouse@mouse.mouse",
"password", "password",
@ -27,7 +29,7 @@ class BlockViews(TestCase):
localname="mouse", localname="mouse",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( cls.remote_user = models.User.objects.create_user(
"rat", "rat",
"rat@rat.com", "rat@rat.com",
"ratword", "ratword",
@ -65,8 +67,9 @@ class BlockViews(TestCase):
request = self.factory.post("") request = self.factory.post("")
request.user = self.local_user request.user = self.local_user
with patch("bookwyrm.activitystreams.remove_user_statuses_task.delay"), patch( with (
"bookwyrm.lists_stream.remove_user_lists_task.delay" patch("bookwyrm.activitystreams.remove_user_statuses_task.delay"),
patch("bookwyrm.lists_stream.remove_user_lists_task.delay"),
): ):
view(request, self.remote_user.id) view(request, self.remote_user.id)
block = models.UserBlocks.objects.get() block = models.UserBlocks.objects.get()
@ -82,8 +85,9 @@ class BlockViews(TestCase):
request = self.factory.post("") request = self.factory.post("")
request.user = self.local_user request.user = self.local_user
with patch("bookwyrm.activitystreams.add_user_statuses_task.delay"), patch( with (
"bookwyrm.lists_stream.add_user_lists_task.delay" patch("bookwyrm.activitystreams.add_user_statuses_task.delay"),
patch("bookwyrm.lists_stream.add_user_lists_task.delay"),
): ):
views.unblock(request, self.remote_user.id) views.unblock(request, self.remote_user.id)

Some files were not shown because too many files have changed in this diff Show more