rafaelcaricio/moviewyrm
1
0
Fork 0
forked from mirrors/bookwyrm
Code Issues 4 Pull requests Projects Releases Wiki Activity

Tests

Browse source
This commit is contained in:
Joachim 2021-05-26 23:57:29 +02:00
parent f848dcd756
commit 2ea1cd8319
69 changed files with 1370 additions and 1105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -1,15 +1,17 @@
import datetime import datetime
from unittest.mock import patch
from django.test import TestCase from django.test import TestCase
from bookwyrm import models from bookwyrm import models
class Author(TestCase): class Author(TestCase):
def setUp(self): def setUp(self):
self.book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Example Edition",
) remote_id="https://example.com/book/1",
)
self.author = models.Author.objects.create( self.author = models.Author.objects.create(
name="Author fullname", name="Author fullname",
aliases=["One", "Two"], aliases=["One", "Two"],

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

@ -25,24 +25,25 @@ class BaseActivity(TestCase):
def setUp(self): def setUp(self):
"""we're probably going to re-use this so why copy/paste""" """we're probably going to re-use this so why copy/paste"""
self.user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" self.user = models.User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
self.user.remote_id = "http://example.com/a/b" )
self.user.save(broadcast=False) self.user.remote_id = "http://example.com/a/b"
self.user.save(broadcast=False)
datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json") datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json")
self.userdata = json.loads(datafile.read_bytes()) self.userdata = json.loads(datafile.read_bytes())
# don't try to load the user icon # don't try to load the user icon
del self.userdata["icon"] del self.userdata["icon"]
image_file = pathlib.Path(__file__).parent.joinpath( image_file = pathlib.Path(__file__).parent.joinpath(
"../../static/images/default_avi.jpg" "../../static/images/default_avi.jpg"
) )
image = Image.open(image_file) image = Image.open(image_file)
output = BytesIO() output = BytesIO()
image.save(output, format=image.format) image.save(output, format=image.format)
self.image_data = output.getvalue() self.image_data = output.getvalue()
def test_init(self, _): def test_init(self, _):
"""simple successfuly init""" """simple successfuly init"""
@ -139,8 +140,9 @@ class BaseActivity(TestCase):
self.user.avatar.file # pylint: disable=pointless-statement self.user.avatar.file # pylint: disable=pointless-statement
# this would trigger a broadcast because it's a local user # this would trigger a broadcast because it's a local user
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
activity.to_model(model=models.User, instance=self.user) with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
activity.to_model(model=models.User, instance=self.user)
self.assertIsNotNone(self.user.avatar.file) self.assertIsNotNone(self.user.avatar.file)
self.assertEqual(self.user.name, "New Name") self.assertEqual(self.user.name, "New Name")
self.assertEqual(self.user.key_pair.public_key, "hi") self.assertEqual(self.user.key_pair.public_key, "hi")
@ -152,9 +154,10 @@ class BaseActivity(TestCase):
content="test status", content="test status",
user=self.user, user=self.user,
) )
book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test Edition", remote_id="http://book.com/book" book = models.Edition.objects.create(
) title="Test Edition", remote_id="http://book.com/book"
)
update_data = activitypub.Note( update_data = activitypub.Note(
id=status.remote_id, id=status.remote_id,
content=status.content, content=status.content,

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

@ -22,10 +22,11 @@ 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( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Example Edition",
) remote_id="https://example.com/book/1",
)
datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_quotation.json") datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_quotation.json")
self.status_data = json.loads(datafile.read_bytes()) self.status_data = json.loads(datafile.read_bytes())

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

@ -74,11 +74,12 @@ class AbstractConnector(TestCase):
Mapping("openlibraryKey"), Mapping("openlibraryKey"),
] ]
self.book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test Book", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1234", title="Test Book",
openlibrary_key="OL1234M", remote_id="https://example.com/book/1234",
) openlibrary_key="OL1234M",
)
def test_abstract_connector_init(self): def test_abstract_connector_init(self):
"""barebones connector for search with defaults""" """barebones connector for search with defaults"""

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

@ -1,4 +1,5 @@
""" testing book data connectors """ """ testing book data connectors """
from unittest.mock import patch
import json import json
import pathlib import pathlib
from django.test import TestCase from django.test import TestCase
@ -25,8 +26,9 @@ class BookWyrmConnector(TestCase):
def test_get_or_create_book_existing(self): def test_get_or_create_book_existing(self):
"""load book activity""" """load book activity"""
work = models.Work.objects.create(title="Test Work") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
book = models.Edition.objects.create(title="Test Edition", parent_work=work) work = models.Work.objects.create(title="Test Work")
book = models.Edition.objects.create(title="Test Edition", parent_work=work)
result = self.connector.get_or_create_book(book.remote_id) result = self.connector.get_or_create_book(book.remote_id)
self.assertEqual(book, result) self.assertEqual(book, result)

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

@ -1,4 +1,5 @@
""" interface between the app and various connectors """ """ interface between the app and various connectors """
from unittest.mock import patch
from django.test import TestCase from django.test import TestCase
import responses import responses
@ -13,14 +14,15 @@ class ConnectorManager(TestCase):
def setUp(self): def setUp(self):
"""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") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.work = models.Work.objects.create(title="Example Work")
self.edition = models.Edition.objects.create( self.edition = models.Edition.objects.create(
title="Example Edition", parent_work=self.work, isbn_10="0000000000" title="Example Edition", parent_work=self.work, isbn_10="0000000000"
) )
self.edition = models.Edition.objects.create( self.edition = models.Edition.objects.create(
title="Another Edition", parent_work=self.work, isbn_10="1111111111" title="Another Edition", parent_work=self.work, isbn_10="1111111111"
) )
self.connector = models.Connector.objects.create( self.connector = models.Connector.objects.create(
identifier="test_connector", identifier="test_connector",

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

@ -178,20 +178,26 @@ class Openlibrary(TestCase):
@responses.activate @responses.activate
def test_expand_book_data(self): def test_expand_book_data(self):
"""given a book, get more editions""" """given a book, get more editions"""
work = models.Work.objects.create(title="Test Work", openlibrary_key="OL1234W") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
edition = models.Edition.objects.create(title="Test Edition", parent_work=work) work = models.Work.objects.create(
title="Test Work", openlibrary_key="OL1234W"
)
edition = models.Edition.objects.create(
title="Test Edition", parent_work=work
)
responses.add( responses.add(
responses.GET, responses.GET,
"https://openlibrary.org/works/OL1234W/editions", "https://openlibrary.org/works/OL1234W/editions",
json={"entries": []}, json={"entries": []},
) )
with patch( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"bookwyrm.connectors.abstract_connector.AbstractConnector." with patch(
"create_edition_from_data" "bookwyrm.connectors.abstract_connector.AbstractConnector."
): "create_edition_from_data"
self.connector.expand_book_data(edition) ):
self.connector.expand_book_data(work) self.connector.expand_book_data(edition)
self.connector.expand_book_data(work)
def test_get_description(self): def test_get_description(self):
"""should do some cleanup on the description data""" """should do some cleanup on the description data"""

84
bookwyrm/tests/connectors/test_self_connector.py
View file

@ -1,4 +1,5 @@
""" testing book data connectors """ """ testing book data connectors """
from unittest.mock import patch
import datetime import datetime
from django.test import TestCase from django.test import TestCase
from django.utils import timezone from django.utils import timezone
@ -29,11 +30,12 @@ class SelfConnector(TestCase):
def test_format_search_result(self): def test_format_search_result(self):
"""create a SearchResult""" """create a SearchResult"""
author = models.Author.objects.create(name="Anonymous") author = models.Author.objects.create(name="Anonymous")
edition = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Edition of Example Work", edition = models.Edition.objects.create(
published_date=datetime.datetime(1980, 5, 10, tzinfo=timezone.utc), title="Edition of Example Work",
) published_date=datetime.datetime(1980, 5, 10, tzinfo=timezone.utc),
edition.authors.add(author) )
edition.authors.add(author)
result = self.connector.search("Edition of Example")[0] result = self.connector.search("Edition of Example")[0]
self.assertEqual(result.title, "Edition of Example Work") self.assertEqual(result.title, "Edition of Example Work")
self.assertEqual(result.key, edition.remote_id) self.assertEqual(result.key, edition.remote_id)
@ -44,32 +46,33 @@ class SelfConnector(TestCase):
def test_search_rank(self): def test_search_rank(self):
"""prioritize certain results""" """prioritize certain results"""
author = models.Author.objects.create(name="Anonymous") author = models.Author.objects.create(name="Anonymous")
edition = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
title="Edition of Example Work", edition = models.Edition.objects.create(
published_date=datetime.datetime(1980, 5, 10, tzinfo=timezone.utc), title="Edition of Example Work",
parent_work=models.Work.objects.create(title=""), published_date=datetime.datetime(1980, 5, 10, tzinfo=timezone.utc),
) parent_work=models.Work.objects.create(title=""),
# author text is rank C )
edition.authors.add(author) # author text is rank C
edition.authors.add(author)
# series is rank D # series is rank D
models.Edition.objects.create( models.Edition.objects.create(
title="Another Edition", title="Another Edition",
series="Anonymous", series="Anonymous",
parent_work=models.Work.objects.create(title=""), parent_work=models.Work.objects.create(title=""),
) )
# subtitle is rank B # subtitle is rank B
models.Edition.objects.create( models.Edition.objects.create(
title="More Editions", title="More Editions",
subtitle="The Anonymous Edition", subtitle="The Anonymous Edition",
parent_work=models.Work.objects.create(title=""), parent_work=models.Work.objects.create(title=""),
) )
# title is rank A # title is rank A
models.Edition.objects.create(title="Anonymous") models.Edition.objects.create(title="Anonymous")
# doesn't rank in this search # doesn't rank in this search
edition = models.Edition.objects.create( edition = models.Edition.objects.create(
title="An Edition", parent_work=models.Work.objects.create(title="") title="An Edition", parent_work=models.Work.objects.create(title="")
) )
results = self.connector.search("Anonymous") results = self.connector.search("Anonymous")
self.assertEqual(len(results), 3) self.assertEqual(len(results), 3)
@ -79,16 +82,17 @@ class SelfConnector(TestCase):
def test_search_multiple_editions(self): def test_search_multiple_editions(self):
"""it should get rid of duplicate editions for the same work""" """it should get rid of duplicate editions for the same work"""
work = models.Work.objects.create(title="Work Title") with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
edition_1 = models.Edition.objects.create( work = models.Work.objects.create(title="Work Title")
title="Edition 1 Title", parent_work=work edition_1 = models.Edition.objects.create(
) title="Edition 1 Title", parent_work=work
edition_2 = models.Edition.objects.create( )
title="Edition 2 Title", edition_2 = models.Edition.objects.create(
parent_work=work, title="Edition 2 Title",
edition_rank=20, # that's default babey parent_work=work,
) edition_rank=20, # that's default babey
edition_3 = models.Edition.objects.create(title="Fish", parent_work=work) )
edition_3 = models.Edition.objects.create(title="Fish", parent_work=work)
# pick the best edition # pick the best edition
results = self.connector.search("Edition 1 Title") results = self.connector.search("Edition 1 Title")

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

@ -21,9 +21,10 @@ class GoodreadsImport(TestCase):
self.importer = GoodreadsImporter() self.importer = GoodreadsImporter()
datafile = pathlib.Path(__file__).parent.joinpath("../data/goodreads.csv") datafile = pathlib.Path(__file__).parent.joinpath("../data/goodreads.csv")
self.csv = open(datafile, "r", encoding=self.importer.encoding) self.csv = open(datafile, "r", encoding=self.importer.encoding)
self.user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "password", local=True self.user = models.User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "password", local=True
)
models.Connector.objects.create( models.Connector.objects.create(
identifier=DOMAIN, identifier=DOMAIN,
@ -36,12 +37,13 @@ class GoodreadsImport(TestCase):
search_url="https://%s/search?q=" % DOMAIN, search_url="https://%s/search?q=" % DOMAIN,
priority=1, priority=1,
) )
work = models.Work.objects.create(title="Test Work") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create( work = models.Work.objects.create(title="Test Work")
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Example Edition",
parent_work=work, remote_id="https://example.com/book/1",
) parent_work=work,
)
def test_create_job(self): def test_create_job(self):
"""creates the import job entry and checks csv""" """creates the import job entry and checks csv"""
@ -92,7 +94,8 @@ class GoodreadsImport(TestCase):
def test_import_data(self): def test_import_data(self):
"""resolve entry""" """resolve entry"""
import_job = self.importer.create_job(self.user, self.csv, False, "unlisted") import_job = self.importer.create_job(self.user, self.csv, False, "unlisted")
book = models.Edition.objects.create(title="Test Book") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
book = models.Edition.objects.create(title="Test Book")
with patch( with patch(
"bookwyrm.models.import_job.ImportItem.get_book_from_isbn" "bookwyrm.models.import_job.ImportItem.get_book_from_isbn"
@ -119,10 +122,11 @@ class GoodreadsImport(TestCase):
) )
break break
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
handle_imported_book( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.importer.service, self.user, import_item, False, "public" handle_imported_book(
) self.importer.service, self.user, import_item, False, "public"
)
shelf.refresh_from_db() shelf.refresh_from_db()
self.assertEqual(shelf.books.first(), self.book) self.assertEqual(shelf.books.first(), self.book)
@ -183,13 +187,14 @@ class GoodreadsImport(TestCase):
) )
break break
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
handle_imported_book( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.importer.service, self.user, import_item, False, "public" handle_imported_book(
) self.importer.service, self.user, import_item, False, "public"
handle_imported_book( )
self.importer.service, self.user, import_item, False, "public" handle_imported_book(
) self.importer.service, self.user, import_item, False, "public"
)
shelf.refresh_from_db() shelf.refresh_from_db()
self.assertEqual(shelf.books.first(), self.book) self.assertEqual(shelf.books.first(), self.book)
@ -216,10 +221,11 @@ class GoodreadsImport(TestCase):
job_id=import_job.id, index=0, data=entry, book=self.book job_id=import_job.id, index=0, data=entry, book=self.book
) )
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
handle_imported_book( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.importer.service, self.user, import_item, True, "unlisted" handle_imported_book(
) self.importer.service, self.user, import_item, True, "unlisted"
)
review = models.Review.objects.get(book=self.book, user=self.user) review = models.Review.objects.get(book=self.book, user=self.user)
self.assertEqual(review.content, "mixed feelings") self.assertEqual(review.content, "mixed feelings")
self.assertEqual(review.rating, 2) self.assertEqual(review.rating, 2)
@ -242,10 +248,11 @@ class GoodreadsImport(TestCase):
job_id=import_job.id, index=0, data=entry, book=self.book job_id=import_job.id, index=0, data=entry, book=self.book
) )
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
handle_imported_book( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.importer.service, self.user, import_item, True, "unlisted" handle_imported_book(
) self.importer.service, self.user, import_item, True, "unlisted"
)
review = models.ReviewRating.objects.get(book=self.book, user=self.user) review = models.ReviewRating.objects.get(book=self.book, user=self.user)
self.assertIsInstance(review, models.ReviewRating) self.assertIsInstance(review, models.ReviewRating)
self.assertEqual(review.rating, 2) self.assertEqual(review.rating, 2)
@ -265,10 +272,11 @@ class GoodreadsImport(TestCase):
job_id=import_job.id, index=0, data=entry, book=self.book job_id=import_job.id, index=0, data=entry, book=self.book
) )
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
handle_imported_book( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.importer.service, self.user, import_item, False, "unlisted" handle_imported_book(
) self.importer.service, self.user, import_item, False, "unlisted"
)
self.assertFalse( self.assertFalse(
models.Review.objects.filter(book=self.book, user=self.user).exists() models.Review.objects.filter(book=self.book, user=self.user).exists()
) )

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

@ -22,9 +22,10 @@ class LibrarythingImport(TestCase):
# Librarything generates latin encoded exports... # Librarything generates latin encoded exports...
self.csv = open(datafile, "r", encoding=self.importer.encoding) self.csv = open(datafile, "r", encoding=self.importer.encoding)
self.user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mmai", "mmai@mmai.mmai", "password", local=True self.user = models.User.objects.create_user(
) "mmai", "mmai@mmai.mmai", "password", local=True
)
models.Connector.objects.create( models.Connector.objects.create(
identifier=DOMAIN, identifier=DOMAIN,
@ -37,12 +38,13 @@ class LibrarythingImport(TestCase):
search_url="https://%s/search?q=" % DOMAIN, search_url="https://%s/search?q=" % DOMAIN,
priority=1, priority=1,
) )
work = models.Work.objects.create(title="Test Work") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create( work = models.Work.objects.create(title="Test Work")
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Example Edition",
parent_work=work, remote_id="https://example.com/book/1",
) parent_work=work,
)
def test_create_job(self): def test_create_job(self):
"""creates the import job entry and checks csv""" """creates the import job entry and checks csv"""
@ -82,7 +84,8 @@ class LibrarythingImport(TestCase):
def test_import_data(self): def test_import_data(self):
"""resolve entry""" """resolve entry"""
import_job = self.importer.create_job(self.user, self.csv, False, "unlisted") import_job = self.importer.create_job(self.user, self.csv, False, "unlisted")
book = models.Edition.objects.create(title="Test Book") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
book = models.Edition.objects.create(title="Test Book")
with patch( with patch(
"bookwyrm.models.import_job.ImportItem.get_book_from_isbn" "bookwyrm.models.import_job.ImportItem.get_book_from_isbn"
@ -111,10 +114,11 @@ class LibrarythingImport(TestCase):
) )
break break
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
handle_imported_book( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.importer.service, self.user, import_item, False, "public" handle_imported_book(
) self.importer.service, self.user, import_item, False, "public"
)
shelf.refresh_from_db() shelf.refresh_from_db()
self.assertEqual(shelf.books.first(), self.book) self.assertEqual(shelf.books.first(), self.book)
@ -147,10 +151,11 @@ class LibrarythingImport(TestCase):
) )
break break
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
handle_imported_book( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.importer.service, self.user, import_item, False, "public" handle_imported_book(
) self.importer.service, self.user, import_item, False, "public"
)
shelf.refresh_from_db() shelf.refresh_from_db()
self.assertEqual(shelf.books.first(), self.book) self.assertEqual(shelf.books.first(), self.book)
@ -179,13 +184,14 @@ class LibrarythingImport(TestCase):
) )
break break
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
handle_imported_book( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.importer.service, self.user, import_item, False, "public" handle_imported_book(
) self.importer.service, self.user, import_item, False, "public"
handle_imported_book( )
self.importer.service, self.user, import_item, False, "public" handle_imported_book(
) self.importer.service, self.user, import_item, False, "public"
)
shelf.refresh_from_db() shelf.refresh_from_db()
self.assertEqual(shelf.books.first(), self.book) self.assertEqual(shelf.books.first(), self.book)
@ -212,10 +218,11 @@ class LibrarythingImport(TestCase):
job_id=import_job.id, index=0, data=entry, book=self.book job_id=import_job.id, index=0, data=entry, book=self.book
) )
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
handle_imported_book( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.importer.service, self.user, import_item, True, "unlisted" handle_imported_book(
) self.importer.service, self.user, import_item, True, "unlisted"
)
review = models.Review.objects.get(book=self.book, user=self.user) review = models.Review.objects.get(book=self.book, user=self.user)
self.assertEqual(review.content, "chef d'oeuvre") self.assertEqual(review.content, "chef d'oeuvre")
self.assertEqual(review.rating, 5) self.assertEqual(review.rating, 5)
@ -235,10 +242,11 @@ class LibrarythingImport(TestCase):
job_id=import_job.id, index=0, data=entry, book=self.book job_id=import_job.id, index=0, data=entry, book=self.book
) )
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
handle_imported_book( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.importer.service, self.user, import_item, False, "unlisted" handle_imported_book(
) self.importer.service, self.user, import_item, False, "unlisted"
)
self.assertFalse( self.assertFalse(
models.Review.objects.filter(book=self.book, user=self.user).exists() models.Review.objects.filter(book=self.book, user=self.user).exists()
) )

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

@ -12,12 +12,17 @@ class Activitystreams(TestCase):
def setUp(self): def setUp(self):
"""we need some stuff""" """we need some stuff"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" self.local_user = models.User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
self.another_user = models.User.objects.create_user( )
"nutria", "nutria@nutria.nutria", "password", local=True, localname="nutria" self.another_user = models.User.objects.create_user(
) "nutria",
"nutria@nutria.nutria",
"password",
local=True,
localname="nutria",
)
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -28,7 +33,8 @@ 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") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.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/models/test_activitypub_mixin.py
View file

@ -19,11 +19,12 @@ class ActivitypubMixins(TestCase):
def setUp(self): def setUp(self):
"""shared data""" """shared data"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse" self.local_user = models.User.objects.create_user(
) "mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
self.local_user.remote_id = "http://example.com/a/b" )
self.local_user.save(broadcast=False) self.local_user.remote_id = "http://example.com/a/b"
self.local_user.save(broadcast=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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -70,9 +71,10 @@ class ActivitypubMixins(TestCase):
"""attempt to match a remote id to an object in the db""" """attempt to match a remote id to an object in the db"""
# uses a different remote id scheme # uses a different remote id scheme
# this isn't really part of this test directly but it's helpful to state # this isn't really part of this test directly but it's helpful to state
book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test Edition", remote_id="http://book.com/book" book = models.Edition.objects.create(
) title="Test Edition", remote_id="http://book.com/book"
)
self.assertEqual(book.origin_id, "http://book.com/book") self.assertEqual(book.origin_id, "http://book.com/book")
self.assertNotEqual(book.remote_id, "http://book.com/book") self.assertNotEqual(book.remote_id, "http://book.com/book")
@ -101,10 +103,11 @@ class ActivitypubMixins(TestCase):
def test_find_existing(self, _): def test_find_existing(self, _):
"""match a blob of data to a model""" """match a blob of data to a model"""
book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test edition", book = models.Edition.objects.create(
openlibrary_key="OL1234", title="Test edition",
) openlibrary_key="OL1234",
)
result = models.Edition.find_existing({"openlibraryKey": "OL1234"}) result = models.Edition.find_existing({"openlibraryKey": "OL1234"})
self.assertEqual(result, book) self.assertEqual(result, book)

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

@ -12,9 +12,10 @@ class BaseModel(TestCase):
def setUp(self): def setUp(self):
"""shared data""" """shared data"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse" self.local_user = models.User.objects.create_user(
) "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( self.remote_user = models.User.objects.create_user(
"rat", "rat",

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

@ -2,6 +2,7 @@
from dateutil.parser import parse from dateutil.parser import parse
from django.test import TestCase from django.test import TestCase
from django.utils import timezone from django.utils import timezone
from unittest.mock import patch
from bookwyrm import models, settings from bookwyrm import models, settings
from bookwyrm.models.book import isbn_10_to_13, isbn_13_to_10 from bookwyrm.models.book import isbn_10_to_13, isbn_13_to_10
@ -12,17 +13,18 @@ class Book(TestCase):
def setUp(self): def setUp(self):
"""we'll need some books""" """we'll need some books"""
self.work = models.Work.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Example Work", remote_id="https://example.com/book/1" self.work = models.Work.objects.create(
) title="Example Work", remote_id="https://example.com/book/1"
self.first_edition = models.Edition.objects.create( )
title="Example Edition", self.first_edition = models.Edition.objects.create(
parent_work=self.work, title="Example Edition",
) parent_work=self.work,
self.second_edition = models.Edition.objects.create( )
title="Another Example Edition", self.second_edition = models.Edition.objects.create(
parent_work=self.work, title="Another Example Edition",
) parent_work=self.work,
)
def test_remote_id(self): def test_remote_id(self):
"""fanciness with remote/origin ids""" """fanciness with remote/origin ids"""
@ -56,7 +58,8 @@ class Book(TestCase):
def test_get_edition_info(self): def test_get_edition_info(self):
"""text slug about an edition""" """text slug about an edition"""
book = models.Edition.objects.create(title="Test Edition") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
book = models.Edition.objects.create(title="Test Edition")
self.assertEqual(book.edition_info, "") self.assertEqual(book.edition_info, "")
book.physical_format = "worm" book.physical_format = "worm"

73
bookwyrm/tests/models/test_fields.py
View file

@ -188,9 +188,10 @@ class ActivitypubFields(TestCase):
@patch("bookwyrm.activitystreams.ActivityStream.add_status") @patch("bookwyrm.activitystreams.ActivityStream.add_status")
def test_privacy_field_set_activity_from_field(self, *_): def test_privacy_field_set_activity_from_field(self, *_):
"""translate between to/cc fields and privacy""" """translate between to/cc fields and privacy"""
user = User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"rat", "rat@rat.rat", "ratword", local=True, localname="rat" user = User.objects.create_user(
) "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
)
public = "https://www.w3.org/ns/activitystreams#Public" public = "https://www.w3.org/ns/activitystreams#Public"
followers = "%s/followers" % user.remote_id followers = "%s/followers" % user.remote_id
@ -248,9 +249,10 @@ class ActivitypubFields(TestCase):
del userdata["icon"] del userdata["icon"]
# it shouldn't match with this unrelated user: # it shouldn't match with this unrelated user:
unrelated_user = User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"rat", "rat@rat.rat", "ratword", local=True, localname="rat" unrelated_user = User.objects.create_user(
) "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
)
# test receiving an unknown remote id and loading data # test receiving an unknown remote id and loading data
responses.add( responses.add(
@ -272,9 +274,10 @@ class ActivitypubFields(TestCase):
del userdata["icon"] del userdata["icon"]
# it shouldn't match with this unrelated user: # it shouldn't match with this unrelated user:
unrelated_user = User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"rat", "rat@rat.rat", "ratword", local=True, localname="rat" unrelated_user = User.objects.create_user(
) "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"):
value = instance.field_from_activity(activitypub.Person(**userdata)) value = instance.field_from_activity(activitypub.Person(**userdata))
self.assertIsInstance(value, User) self.assertIsInstance(value, User)
@ -288,14 +291,16 @@ class ActivitypubFields(TestCase):
instance = fields.ForeignKey(User, on_delete=models.CASCADE) instance = fields.ForeignKey(User, on_delete=models.CASCADE)
datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json") datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json")
userdata = json.loads(datafile.read_bytes()) userdata = json.loads(datafile.read_bytes())
user = User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" user = User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
user.remote_id = "https://example.com/user/mouse" )
user.save(broadcast=False) user.remote_id = "https://example.com/user/mouse"
User.objects.create_user( user.save(broadcast=False)
"rat", "rat@rat.rat", "ratword", local=True, localname="rat"
) User.objects.create_user(
"rat", "rat@rat.rat", "ratword", local=True, localname="rat"
)
with patch("bookwyrm.models.activitypub_mixin.ObjectMixin.broadcast"): with patch("bookwyrm.models.activitypub_mixin.ObjectMixin.broadcast"):
value = instance.field_from_activity(activitypub.Person(**userdata)) value = instance.field_from_activity(activitypub.Person(**userdata))
@ -304,12 +309,13 @@ class ActivitypubFields(TestCase):
def test_foreign_key_from_activity_str_existing(self): def test_foreign_key_from_activity_str_existing(self):
"""test receiving a remote id of an existing object in the db""" """test receiving a remote id of an existing object in the db"""
instance = fields.ForeignKey(User, on_delete=models.CASCADE) instance = fields.ForeignKey(User, on_delete=models.CASCADE)
user = User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" user = User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
User.objects.create_user( )
"rat", "rat@rat.rat", "ratword", local=True, localname="rat" User.objects.create_user(
) "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
)
value = instance.field_from_activity(user.remote_id) value = instance.field_from_activity(user.remote_id)
self.assertEqual(value, user) self.assertEqual(value, user)
@ -386,16 +392,17 @@ class ActivitypubFields(TestCase):
@patch("bookwyrm.models.activitypub_mixin.ObjectMixin.broadcast") @patch("bookwyrm.models.activitypub_mixin.ObjectMixin.broadcast")
def test_image_field(self, _): def test_image_field(self, _):
"""storing images""" """storing images"""
user = User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" user = User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
image_file = pathlib.Path(__file__).parent.joinpath( )
"../../static/images/default_avi.jpg" image_file = pathlib.Path(__file__).parent.joinpath(
) "../../static/images/default_avi.jpg"
image = Image.open(image_file) )
output = BytesIO() image = Image.open(image_file)
image.save(output, format=image.format) output = BytesIO()
user.avatar.save("test.jpg", ContentFile(output.getvalue())) image.save(output, format=image.format)
user.avatar.save("test.jpg", ContentFile(output.getvalue()))
output = fields.image_serializer(user.avatar, alt="alt text") output = fields.image_serializer(user.avatar, alt="alt text")
self.assertIsNotNone( self.assertIsNotNone(

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

@ -59,9 +59,10 @@ class ImportJob(TestCase):
unknown_read_data["Exclusive Shelf"] = "read" unknown_read_data["Exclusive Shelf"] = "read"
unknown_read_data["Date Read"] = "" unknown_read_data["Date Read"] = ""
user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" user = models.User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
)
job = models.ImportJob.objects.create(user=user) job = models.ImportJob.objects.create(user=user)
self.item_1 = models.ImportItem.objects.create( self.item_1 = models.ImportItem.objects.create(
job=job, index=1, data=currently_reading_data job=job, index=1, data=currently_reading_data

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

@ -11,11 +11,13 @@ class List(TestCase):
def setUp(self): def setUp(self):
"""look, a list""" """look, a list"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" self.local_user = models.User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
work = models.Work.objects.create(title="hello") )
self.book = models.Edition.objects.create(title="hi", parent_work=work) with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
work = models.Work.objects.create(title="hello")
self.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"""

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

@ -1,6 +1,7 @@
""" testing models """ """ testing models """
from django.test import TestCase from django.test import TestCase
from django.core.exceptions import ValidationError from django.core.exceptions import ValidationError
from unittest.mock import patch
from bookwyrm import models from bookwyrm import models
@ -10,15 +11,16 @@ class ReadThrough(TestCase):
def setUp(self): def setUp(self):
"""look, a shelf""" """look, a shelf"""
self.user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" self.user = models.User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
)
self.work = models.Work.objects.create(title="Example Work") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.work = models.Work.objects.create(title="Example Work")
self.edition = models.Edition.objects.create( self.edition = models.Edition.objects.create(
title="Example Edition", parent_work=self.work title="Example Edition", parent_work=self.work
) )
self.readthrough = models.ReadThrough.objects.create( self.readthrough = models.ReadThrough.objects.create(
user=self.user, book=self.edition user=self.user, book=self.edition

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

@ -20,11 +20,12 @@ 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",
) )
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse" self.local_user = models.User.objects.create_user(
) "mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
self.local_user.remote_id = "http://local.com/user/mouse" )
self.local_user.save(broadcast=False) self.local_user.remote_id = "http://local.com/user/mouse"
self.local_user.save(broadcast=False)
def test_user_follows_from_request(self): def test_user_follows_from_request(self):
"""convert a follow request into a follow""" """convert a follow request into a follow"""

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

@ -12,11 +12,15 @@ class Shelf(TestCase):
def setUp(self): def setUp(self):
"""look, a shelf""" """look, a shelf"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" self.local_user = models.User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
work = models.Work.objects.create(title="Test Work") )
self.book = models.Edition.objects.create(title="test book", parent_work=work) with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
work = models.Work.objects.create(title="Test Work")
self.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"""

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

@ -21,9 +21,10 @@ class Status(TestCase):
def setUp(self): def setUp(self):
"""useful things for creating a status""" """useful things for creating a status"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" self.local_user = models.User.objects.create_user(
) "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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -34,16 +35,17 @@ 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") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create(title="Test Edition")
image_file = pathlib.Path(__file__).parent.joinpath( image_file = pathlib.Path(__file__).parent.joinpath(
"../../static/images/default_avi.jpg" "../../static/images/default_avi.jpg"
) )
image = Image.open(image_file) image = Image.open(image_file)
output = BytesIO() output = BytesIO()
with patch("bookwyrm.models.Status.broadcast"): with patch("bookwyrm.models.Status.broadcast"):
image.save(output, format=image.format) image.save(output, format=image.format)
self.book.cover.save("test.jpg", ContentFile(output.getvalue())) self.book.cover.save("test.jpg", ContentFile(output.getvalue()))
def test_status_generated_fields(self, *_): def test_status_generated_fields(self, *_):
"""setting remote id""" """setting remote id"""
@ -58,9 +60,10 @@ class Status(TestCase):
child = models.Status.objects.create( child = models.Status.objects.create(
content="hello", reply_parent=parent, user=self.local_user content="hello", reply_parent=parent, user=self.local_user
) )
models.Review.objects.create( with patch("bookwyrm.preview_images.generate_edition_image_task.delay"):
content="hey", reply_parent=parent, user=self.local_user, book=self.book models.Review.objects.create(
) content="hey", reply_parent=parent, user=self.local_user, book=self.book
)
models.Status.objects.create( models.Status.objects.create(
content="hi hello", reply_parent=child, user=self.local_user content="hi hello", reply_parent=child, user=self.local_user
) )
@ -92,9 +95,10 @@ class Status(TestCase):
child = models.Status.objects.create( child = models.Status.objects.create(
content="hello", reply_parent=parent, user=self.local_user content="hello", reply_parent=parent, user=self.local_user
) )
models.Review.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
content="hey", reply_parent=parent, user=self.local_user, book=self.book models.Review.objects.create(
) content="hey", reply_parent=parent, user=self.local_user, book=self.book
)
models.Status.objects.create( models.Status.objects.create(
content="hi hello", reply_parent=child, user=self.local_user content="hi hello", reply_parent=child, user=self.local_user
) )
@ -251,14 +255,15 @@ class Status(TestCase):
def test_review_to_activity(self, *_): def test_review_to_activity(self, *_):
"""subclass of the base model version with a "pure" serializer""" """subclass of the base model version with a "pure" serializer"""
status = models.Review.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
name="Review name", status = models.Review.objects.create(
content="test content", name="Review name",
rating=3.0, content="test content",
user=self.local_user, rating=3.0,
book=self.book, user=self.local_user,
) book=self.book,
activity = status.to_activity() )
activity = status.to_activity()
self.assertEqual(activity["id"], status.remote_id) self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Review") self.assertEqual(activity["type"], "Review")
self.assertEqual(activity["rating"], 3) self.assertEqual(activity["rating"], 3)
@ -268,14 +273,15 @@ class Status(TestCase):
def test_review_to_pure_activity(self, *_): def test_review_to_pure_activity(self, *_):
"""subclass of the base model version with a "pure" serializer""" """subclass of the base model version with a "pure" serializer"""
status = models.Review.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
name="Review's name", status = models.Review.objects.create(
content="test content", name="Review's name",
rating=3.0, content="test content",
user=self.local_user, rating=3.0,
book=self.book, user=self.local_user,
) book=self.book,
activity = status.to_activity(pure=True) )
activity = status.to_activity(pure=True)
self.assertEqual(activity["id"], status.remote_id) self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Article") self.assertEqual(activity["type"], "Article")
self.assertEqual( self.assertEqual(
@ -292,13 +298,14 @@ class Status(TestCase):
def test_review_to_pure_activity_no_rating(self, *_): def test_review_to_pure_activity_no_rating(self, *_):
"""subclass of the base model version with a "pure" serializer""" """subclass of the base model version with a "pure" serializer"""
status = models.Review.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
name="Review name", status = models.Review.objects.create(
content="test content", name="Review name",
user=self.local_user, content="test content",
book=self.book, user=self.local_user,
) book=self.book,
activity = status.to_activity(pure=True) )
activity = status.to_activity(pure=True)
self.assertEqual(activity["id"], status.remote_id) self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Article") self.assertEqual(activity["type"], "Article")
self.assertEqual( self.assertEqual(
@ -314,12 +321,13 @@ class Status(TestCase):
def test_reviewrating_to_pure_activity(self, *_): def test_reviewrating_to_pure_activity(self, *_):
"""subclass of the base model version with a "pure" serializer""" """subclass of the base model version with a "pure" serializer"""
status = models.ReviewRating.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
rating=3.0, status = models.ReviewRating.objects.create(
user=self.local_user, rating=3.0,
book=self.book, user=self.local_user,
) book=self.book,
activity = status.to_activity(pure=True) )
activity = status.to_activity(pure=True)
self.assertEqual(activity["id"], status.remote_id) self.assertEqual(activity["id"], status.remote_id)
self.assertEqual(activity["type"], "Note") self.assertEqual(activity["type"], "Note")
self.assertEqual( self.assertEqual(

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

@ -11,15 +11,16 @@ from bookwyrm.settings import DOMAIN
# pylint: disable=missing-function-docstring # pylint: disable=missing-function-docstring
class User(TestCase): class User(TestCase):
def setUp(self): def setUp(self):
self.user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@%s" % DOMAIN, self.user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@%s" % DOMAIN,
"mouseword", "mouse@mouse.mouse",
local=True, "mouseword",
localname="mouse", local=True,
name="hi", localname="mouse",
bookwyrm_user=False, name="hi",
) bookwyrm_user=False,
)
def test_computed_fields(self): def test_computed_fields(self):
"""username instead of id here""" """username instead of id here"""

20
bookwyrm/tests/test_activitystreams.py
View file

@ -11,12 +11,17 @@ class Activitystreams(TestCase):
def setUp(self): def setUp(self):
"""use a test csv""" """use a test csv"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" self.local_user = models.User.objects.create_user(
) "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
self.another_user = models.User.objects.create_user( )
"nutria", "nutria@nutria.nutria", "password", local=True, localname="nutria" self.another_user = models.User.objects.create_user(
) "nutria",
"nutria@nutria.nutria",
"password",
local=True,
localname="nutria",
)
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -27,7 +32,8 @@ 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") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create(title="test book")
class TestStream(activitystreams.ActivityStream): class TestStream(activitystreams.ActivityStream):
"""test stream, don't have to do anything here""" """test stream, don't have to do anything here"""

18
bookwyrm/tests/test_emailing.py
View file

@ -15,14 +15,16 @@ class Emailing(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_invite_email(self, email_mock): def test_invite_email(self, email_mock):
"""load the invite email""" """load the invite email"""

26
bookwyrm/tests/test_signing.py
View file

@ -37,15 +37,20 @@ class Signature(TestCase):
def setUp(self): def setUp(self):
"""create users and test data""" """create users and test data"""
self.mouse = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@%s" % DOMAIN, "mouse@example.com", "", local=True, localname="mouse" self.mouse = models.User.objects.create_user(
) "mouse@%s" % DOMAIN,
self.rat = models.User.objects.create_user( "mouse@example.com",
"rat@%s" % DOMAIN, "rat@example.com", "", local=True, localname="rat" "",
) local=True,
self.cat = models.User.objects.create_user( localname="mouse",
"cat@%s" % DOMAIN, "cat@example.com", "", local=True, localname="cat" )
) self.rat = models.User.objects.create_user(
"rat@%s" % DOMAIN, "rat@example.com", "", local=True, localname="rat"
)
self.cat = models.User.objects.create_user(
"cat@%s" % DOMAIN, "cat@example.com", "", local=True, localname="cat"
)
private_key, public_key = create_key_pair() private_key, public_key = create_key_pair()
@ -53,7 +58,8 @@ class Signature(TestCase):
"http://localhost/user/remote", KeyPair(private_key, public_key) "http://localhost/user/remote", KeyPair(private_key, public_key)
) )
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def send(self, signature, now, data, digest): def send(self, signature, now, data, digest):
"""test request""" """test request"""

58
bookwyrm/tests/test_templatetags.py
View file

@ -21,13 +21,14 @@ class TemplateTags(TestCase):
def setUp(self): def setUp(self):
"""create some filler objects""" """create some filler objects"""
self.user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@example.com", self.user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@example.com",
"mouseword", "mouse@mouse.mouse",
local=True, "mouseword",
localname="mouse", 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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -36,12 +37,14 @@ class TemplateTags(TestCase):
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") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create(title="Test Book")
def test_get_user_rating(self, _): def test_get_user_rating(self, _):
"""get a user's most recent rating of a book""" """get a user's most recent rating of a book"""
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
models.Review.objects.create(user=self.user, book=self.book, rating=3) with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.Review.objects.create(user=self.user, book=self.book, rating=3)
self.assertEqual(bookwyrm_tags.get_user_rating(self.book, self.user), 3) self.assertEqual(bookwyrm_tags.get_user_rating(self.book, self.user), 3)
def test_get_user_rating_doesnt_exist(self, _): def test_get_user_rating_doesnt_exist(self, _):
@ -62,9 +65,12 @@ class TemplateTags(TestCase):
def test_get_replies(self, _): def test_get_replies(self, _):
"""direct replies to a status""" """direct replies to a status"""
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
parent = models.Review.objects.create( with patch(
user=self.user, book=self.book, content="hi" "bookwyrm.preview_images.generate_edition_preview_image_task.delay"
) ):
parent = models.Review.objects.create(
user=self.user, book=self.book, content="hi"
)
first_child = models.Status.objects.create( first_child = models.Status.objects.create(
reply_parent=parent, user=self.user, content="hi" reply_parent=parent, user=self.user, content="hi"
) )
@ -90,9 +96,12 @@ class TemplateTags(TestCase):
def test_get_parent(self, _): def test_get_parent(self, _):
"""get the reply parent of a status""" """get the reply parent of a status"""
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
parent = models.Review.objects.create( with patch(
user=self.user, book=self.book, content="hi" "bookwyrm.preview_images.generate_edition_preview_image_task.delay"
) ):
parent = models.Review.objects.create(
user=self.user, book=self.book, content="hi"
)
child = models.Status.objects.create( child = models.Status.objects.create(
reply_parent=parent, user=self.user, content="hi" reply_parent=parent, user=self.user, content="hi"
) )
@ -103,7 +112,8 @@ class TemplateTags(TestCase):
def test_get_user_liked(self, _): def test_get_user_liked(self, _):
"""did a user like a status""" """did a user like a status"""
status = models.Review.objects.create(user=self.remote_user, book=self.book) with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
status = models.Review.objects.create(user=self.remote_user, book=self.book)
self.assertFalse(interaction.get_user_liked(self.user, status)) self.assertFalse(interaction.get_user_liked(self.user, status))
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
@ -112,7 +122,8 @@ class TemplateTags(TestCase):
def test_get_user_boosted(self, _): def test_get_user_boosted(self, _):
"""did a user boost a status""" """did a user boost a status"""
status = models.Review.objects.create(user=self.remote_user, book=self.book) with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
status = models.Review.objects.create(user=self.remote_user, book=self.book)
self.assertFalse(interaction.get_user_boosted(self.user, status)) self.assertFalse(interaction.get_user_boosted(self.user, status))
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
@ -121,9 +132,14 @@ class TemplateTags(TestCase):
def test_get_boosted(self, _): def test_get_boosted(self, _):
"""load a boosted status""" """load a boosted status"""
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
status = models.Review.objects.create(user=self.remote_user, book=self.book) with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
boost = models.Boost.objects.create(user=self.user, boosted_status=status) status = models.Review.objects.create(
user=self.remote_user, book=self.book
)
boost = models.Boost.objects.create(
user=self.user, boosted_status=status
)
boosted = status_display.get_boosted(boost) boosted = status_display.get_boosted(boost)
self.assertIsInstance(boosted, models.Review) self.assertIsInstance(boosted, models.Review)
self.assertEqual(boosted, status) self.assertEqual(boosted, status)

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

@ -18,15 +18,17 @@ class Inbox(TestCase):
"""basic user and book data""" """basic user and book data"""
self.client = Client() self.client = Client()
self.factory = RequestFactory() self.factory = RequestFactory()
local_user = models.User.objects.create_user(
"mouse@example.com", with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@mouse.com", local_user = models.User.objects.create_user(
"mouseword", "mouse@example.com",
local=True, "mouse@mouse.com",
localname="mouse", "mouseword",
) local=True,
local_user.remote_id = "https://example.com/user/mouse" localname="mouse",
local_user.save(broadcast=False) )
local_user.remote_id = "https://example.com/user/mouse"
local_user.save(broadcast=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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -45,7 +47,8 @@ class Inbox(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_inbox_invalid_get(self): def test_inbox_invalid_get(self):
"""shouldn't try to handle if the user is not found""" """shouldn't try to handle if the user is not found"""

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

@ -13,15 +13,16 @@ class InboxAdd(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@example.com", local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@example.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
) localname="mouse",
local_user.remote_id = "https://example.com/user/mouse" )
local_user.save(broadcast=False) local_user.remote_id = "https://example.com/user/mouse"
local_user.save(broadcast=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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -32,14 +33,15 @@ class InboxAdd(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",
) )
work = models.Work.objects.create(title="work title") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create( work = models.Work.objects.create(title="work title")
title="Test", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/37292", title="Test",
parent_work=work, remote_id="https://example.com/book/37292",
) parent_work=work,
)
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
@responses.activate @responses.activate
def test_handle_add_book_to_shelf(self): def test_handle_add_book_to_shelf(self):

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

@ -13,15 +13,16 @@ class InboxActivities(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@example.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@example.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
) localname="mouse",
self.local_user.remote_id = "https://example.com/user/mouse" )
self.local_user.save(broadcast=False) self.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -32,13 +33,14 @@ class InboxActivities(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.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
with patch("bookwyrm.activitystreams.ActivityStream.add_status"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.status = models.Status.objects.create( with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
user=self.local_user, self.status = models.Status.objects.create(
content="Test status", user=self.local_user,
remote_id="https://example.com/status/1", content="Test status",
) remote_id="https://example.com/status/1",
)
self.create_json = { self.create_json = {
"id": "hi", "id": "hi",
@ -48,7 +50,8 @@ class InboxActivities(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
@patch("bookwyrm.activitystreams.ActivityStream.add_status") @patch("bookwyrm.activitystreams.ActivityStream.add_status")
def test_boost(self, redis_mock): def test_boost(self, redis_mock):
@ -83,12 +86,13 @@ class InboxActivities(TestCase):
@patch("bookwyrm.activitystreams.ActivityStream.add_status") @patch("bookwyrm.activitystreams.ActivityStream.add_status")
def test_boost_remote_status(self, redis_mock): def test_boost_remote_status(self, redis_mock):
"""boost a status from a remote server""" """boost a status from a remote server"""
work = models.Work.objects.create(title="work title") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
book = models.Edition.objects.create( work = models.Work.objects.create(title="work title")
title="Test", book = models.Edition.objects.create(
remote_id="https://bookwyrm.social/book/37292", title="Test",
parent_work=work, remote_id="https://bookwyrm.social/book/37292",
) parent_work=work,
)
self.assertEqual(models.Notification.objects.count(), 0) self.assertEqual(models.Notification.objects.count(), 0)
activity = { activity = {
"type": "Announce", "type": "Announce",

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

@ -12,15 +12,16 @@ class InboxBlock(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
"mouse@example.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@example.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
) localname="mouse",
self.local_user.remote_id = "https://example.com/user/mouse" )
self.local_user.save(broadcast=False) self.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -31,8 +32,8 @@ class InboxBlock(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.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
def test_handle_blocks(self): def test_handle_blocks(self):
"""create a "block" database entry from an activity""" """create a "block" database entry from an activity"""

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

@ -15,15 +15,16 @@ class InboxCreate(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
"mouse@example.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@example.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
) localname="mouse",
self.local_user.remote_id = "https://example.com/user/mouse" )
self.local_user.save(broadcast=False) self.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=False)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.activitystreams.ActivityStream.add_status"): with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
self.status = models.Status.objects.create( self.status = models.Status.objects.create(
@ -50,7 +51,8 @@ class InboxCreate(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_create_status(self): def test_create_status(self):
"""the "it justs works" mode""" """the "it justs works" mode"""
@ -60,9 +62,11 @@ class InboxCreate(TestCase):
"../../data/ap_quotation.json" "../../data/ap_quotation.json"
) )
status_data = json.loads(datafile.read_bytes()) status_data = json.loads(datafile.read_bytes())
models.Edition.objects.create(
title="Test Book", remote_id="https://example.com/book/1" with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
) models.Edition.objects.create(
title="Test Book", remote_id="https://example.com/book/1"
)
activity = self.create_json activity = self.create_json
activity["object"] = status_data activity["object"] = status_data
@ -129,9 +133,10 @@ class InboxCreate(TestCase):
def test_create_rating(self): def test_create_rating(self):
"""a remote rating activity""" """a remote rating activity"""
book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test Book", remote_id="https://example.com/book/1" book = models.Edition.objects.create(
) title="Test Book", remote_id="https://example.com/book/1"
)
activity = self.create_json activity = self.create_json
activity["object"] = { activity["object"] = {
"id": "https://example.com/user/mouse/reviewrating/12", "id": "https://example.com/user/mouse/reviewrating/12",

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

@ -13,15 +13,16 @@ class InboxActivities(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@example.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@example.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
) localname="mouse",
self.local_user.remote_id = "https://example.com/user/mouse" )
self.local_user.save(broadcast=False) self.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -47,7 +48,8 @@ class InboxActivities(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_delete_status(self): def test_delete_status(self):
"""remove a status""" """remove a status"""

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

@ -13,15 +13,17 @@ class InboxRelationships(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@example.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@example.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
) localname="mouse",
self.local_user.remote_id = "https://example.com/user/mouse" )
self.local_user.save(broadcast=False) self.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -32,8 +34,8 @@ class InboxRelationships(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.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
def test_follow(self): def test_follow(self):
"""remote user wants to follow local user""" """remote user wants to follow local user"""

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

@ -12,15 +12,16 @@ class InboxActivities(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@example.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@example.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
) localname="mouse",
self.local_user.remote_id = "https://example.com/user/mouse" )
self.local_user.save(broadcast=False) self.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -31,6 +32,7 @@ class InboxActivities(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.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.activitystreams.ActivityStream.add_status"): with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
self.status = models.Status.objects.create( self.status = models.Status.objects.create(
@ -47,7 +49,9 @@ class InboxActivities(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
models.SiteSettings.objects.create()
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_handle_favorite(self): def test_handle_favorite(self):
"""fav a status""" """fav a status"""

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

@ -12,15 +12,16 @@ class InboxRemove(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@example.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@example.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
) localname="mouse",
self.local_user.remote_id = "https://example.com/user/mouse" )
self.local_user.save(broadcast=False) self.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -31,14 +32,17 @@ class InboxRemove(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="work title")
self.book = models.Edition.objects.create(
title="Test",
remote_id="https://bookwyrm.social/book/37292",
parent_work=self.work,
)
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.work = models.Work.objects.create(title="work title")
self.book = models.Edition.objects.create(
title="Test",
remote_id="https://bookwyrm.social/book/37292",
parent_work=self.work,
)
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_handle_unshelve_book(self): def test_handle_unshelve_book(self):
"""remove a book from a shelf""" """remove a book from a shelf"""

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

@ -14,15 +14,16 @@ class InboxUpdate(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@example.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@example.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
) localname="mouse",
self.local_user.remote_id = "https://example.com/user/mouse" )
self.local_user.save(broadcast=False) self.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -42,7 +43,8 @@ class InboxUpdate(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_update_list(self): def test_update_list(self):
"""a new list""" """a new list"""
@ -120,12 +122,13 @@ class InboxUpdate(TestCase):
datafile = pathlib.Path(__file__).parent.joinpath("../../data/bw_edition.json") datafile = pathlib.Path(__file__).parent.joinpath("../../data/bw_edition.json")
bookdata = json.loads(datafile.read_bytes()) bookdata = json.loads(datafile.read_bytes())
models.Work.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test Work", remote_id="https://bookwyrm.social/book/5988" models.Work.objects.create(
) title="Test Work", remote_id="https://bookwyrm.social/book/5988"
book = models.Edition.objects.create( )
title="Test Book", remote_id="https://bookwyrm.social/book/5989" book = models.Edition.objects.create(
) title="Test Book", remote_id="https://bookwyrm.social/book/5989"
)
del bookdata["authors"] del bookdata["authors"]
self.assertEqual(book.title, "Test Book") self.assertEqual(book.title, "Test Book")
@ -150,9 +153,10 @@ class InboxUpdate(TestCase):
datafile = pathlib.Path(__file__).parent.joinpath("../../data/bw_work.json") datafile = pathlib.Path(__file__).parent.joinpath("../../data/bw_work.json")
bookdata = json.loads(datafile.read_bytes()) bookdata = json.loads(datafile.read_bytes())
book = models.Work.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test Book", remote_id="https://bookwyrm.social/book/5988" book = models.Work.objects.create(
) title="Test Book", remote_id="https://bookwyrm.social/book/5988"
)
del bookdata["authors"] del bookdata["authors"]
self.assertEqual(book.title, "Test Book") self.assertEqual(book.title, "Test Book")

19
bookwyrm/tests/views/test_announcements.py
View file

@ -2,6 +2,7 @@
from django.template.response import TemplateResponse from django.template.response import TemplateResponse
from django.test import TestCase from django.test import TestCase
from django.test.client import RequestFactory from django.test.client import RequestFactory
from unittest.mock import patch
from bookwyrm import forms, models, views from bookwyrm import forms, models, views
@ -12,14 +13,16 @@ class AnnouncementViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_announcements_page(self): def test_announcements_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

33
bookwyrm/tests/views/test_authentication.py
View file

@ -19,16 +19,18 @@ class AuthenticationViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"password", "mouse@mouse.com",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
)
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
self.settings = models.SiteSettings.objects.create(id=1) with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
self.settings = models.SiteSettings.objects.create(id=1)
def test_login_get(self): def test_login_get(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""
@ -58,8 +60,9 @@ class AuthenticationViews(TestCase):
"email": "aa@bb.cccc", "email": "aa@bb.cccc",
}, },
) )
with patch("bookwyrm.views.authentication.login"): with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
response = view(request) with patch("bookwyrm.views.authentication.login"):
response = view(request)
self.assertEqual(models.User.objects.count(), 2) self.assertEqual(models.User.objects.count(), 2)
self.assertEqual(response.status_code, 302) self.assertEqual(response.status_code, 302)
nutria = models.User.objects.last() nutria = models.User.objects.last()
@ -74,8 +77,9 @@ class AuthenticationViews(TestCase):
"register/", "register/",
{"localname": "nutria ", "password": "mouseword", "email": "aa@bb.ccc"}, {"localname": "nutria ", "password": "mouseword", "email": "aa@bb.ccc"},
) )
with patch("bookwyrm.views.authentication.login"): with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
response = view(request) with patch("bookwyrm.views.authentication.login"):
response = view(request)
self.assertEqual(models.User.objects.count(), 2) self.assertEqual(models.User.objects.count(), 2)
self.assertEqual(response.status_code, 302) self.assertEqual(response.status_code, 302)
nutria = models.User.objects.last() nutria = models.User.objects.last()
@ -153,8 +157,9 @@ class AuthenticationViews(TestCase):
"invite_code": "testcode", "invite_code": "testcode",
}, },
) )
with patch("bookwyrm.views.authentication.login"): with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
response = view(request) with patch("bookwyrm.views.authentication.login"):
response = view(request)
self.assertEqual(models.User.objects.count(), 2) self.assertEqual(models.User.objects.count(), 2)
self.assertEqual(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assertEqual(models.SiteInvite.objects.get().times_used, 1) self.assertEqual(models.SiteInvite.objects.get().times_used, 1)

33
bookwyrm/tests/views/test_author.py
View file

@ -17,14 +17,15 @@ class AuthorViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
)
self.group = Group.objects.create(name="editor") self.group = Group.objects.create(name="editor")
self.group.permissions.add( self.group.permissions.add(
Permission.objects.create( Permission.objects.create(
@ -33,13 +34,15 @@ class AuthorViews(TestCase):
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") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create( self.work = models.Work.objects.create(title="Test Work")
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Example Edition",
parent_work=self.work, remote_id="https://example.com/book/1",
) parent_work=self.work,
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_author_page(self): def test_author_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

18
bookwyrm/tests/views/test_block.py
View file

@ -14,13 +14,14 @@ class BlockViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", 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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -31,7 +32,8 @@ class BlockViews(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",
) )
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_block_get(self, _): def test_block_get(self, _):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

79
bookwyrm/tests/views/test_book.py
View file

@ -23,14 +23,15 @@ class BookViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
)
self.group = Group.objects.create(name="editor") self.group = Group.objects.create(name="editor")
self.group.permissions.add( self.group.permissions.add(
Permission.objects.create( Permission.objects.create(
@ -39,13 +40,15 @@ class BookViews(TestCase):
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") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create( self.work = models.Work.objects.create(title="Test Work")
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Example Edition",
parent_work=self.work, remote_id="https://example.com/book/1",
) parent_work=self.work,
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_book_page(self): def test_book_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""
@ -85,8 +88,11 @@ class BookViews(TestCase):
form.data["last_edited_by"] = self.local_user.id form.data["last_edited_by"] = self.local_user.id
request = self.factory.post("", form.data) request = self.factory.post("", form.data)
request.user = self.local_user request.user = self.local_user
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, self.book.id) with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, self.book.id)
self.book.refresh_from_db() self.book.refresh_from_db()
self.assertEqual(self.book.title, "New Title") self.assertEqual(self.book.title, "New Title")
@ -101,8 +107,9 @@ class BookViews(TestCase):
request = self.factory.post("", form.data) request = self.factory.post("", form.data)
request.user = self.local_user request.user = self.local_user
result = view(request, self.book.id) with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
result.render() result = view(request, self.book.id)
result.render()
# the changes haven't been saved yet # the changes haven't been saved yet
self.book.refresh_from_db() self.book.refresh_from_db()
@ -120,8 +127,9 @@ class BookViews(TestCase):
request = self.factory.post("", form.data) request = self.factory.post("", form.data)
request.user = self.local_user request.user = self.local_user
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
view(request, self.book.id) with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, self.book.id)
self.book.refresh_from_db() self.book.refresh_from_db()
self.assertEqual(self.book.title, "New Title") self.assertEqual(self.book.title, "New Title")
@ -197,8 +205,11 @@ class BookViews(TestCase):
def test_switch_edition(self): def test_switch_edition(self):
"""updates user's relationships to a book""" """updates user's relationships to a book"""
work = models.Work.objects.create(title="test work") work = models.Work.objects.create(title="test work")
edition1 = models.Edition.objects.create(title="first ed", parent_work=work) with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
edition2 = models.Edition.objects.create(title="second ed", parent_work=work) edition1 = models.Edition.objects.create(title="first ed", parent_work=work)
edition2 = models.Edition.objects.create(
title="second ed", parent_work=work
)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
shelf = models.Shelf.objects.create(name="Test Shelf", user=self.local_user) shelf = models.Shelf.objects.create(name="Test Shelf", user=self.local_user)
models.ShelfBook.objects.create( models.ShelfBook.objects.create(
@ -251,11 +262,12 @@ class BookViews(TestCase):
request = self.factory.post("", form.data) request = self.factory.post("", form.data)
request.user = self.local_user request.user = self.local_user
with patch( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
"bookwyrm.models.activitypub_mixin.broadcast_task.delay" with patch(
) as delay_mock: "bookwyrm.models.activitypub_mixin.broadcast_task.delay"
views.upload_cover(request, self.book.id) ) as delay_mock:
self.assertEqual(delay_mock.call_count, 1) views.upload_cover(request, self.book.id)
self.assertEqual(delay_mock.call_count, 1)
self.book.refresh_from_db() self.book.refresh_from_db()
self.assertTrue(self.book.cover) self.assertTrue(self.book.cover)
@ -283,11 +295,12 @@ class BookViews(TestCase):
request = self.factory.post("", form.data) request = self.factory.post("", form.data)
request.user = self.local_user request.user = self.local_user
with patch( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
"bookwyrm.models.activitypub_mixin.broadcast_task.delay" with patch(
) as delay_mock: "bookwyrm.models.activitypub_mixin.broadcast_task.delay"
views.upload_cover(request, self.book.id) ) as delay_mock:
self.assertEqual(delay_mock.call_count, 1) views.upload_cover(request, self.book.id)
self.assertEqual(delay_mock.call_count, 1)
self.book.refresh_from_db() self.book.refresh_from_db()
self.assertTrue(self.book.cover) self.assertTrue(self.book.cover)

39
bookwyrm/tests/views/test_directory.py
View file

@ -2,6 +2,7 @@
from django.template.response import TemplateResponse from django.template.response import TemplateResponse
from django.test import TestCase from django.test import TestCase
from django.test.client import RequestFactory from django.test.client import RequestFactory
from unittest.mock import patch
from bookwyrm import models, views from bookwyrm import models, views
@ -12,24 +13,26 @@ class DirectoryViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
self.rat = models.User.objects.create_user( )
"rat@local.com", self.rat = models.User.objects.create_user(
"rat@rat.com", "rat@local.com",
"ratword", "rat@rat.com",
local=True, "ratword",
localname="rat", local=True,
remote_id="https://example.com/users/rat", localname="rat",
discoverable=True, remote_id="https://example.com/users/rat",
) discoverable=True,
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_directory_page(self): def test_directory_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

18
bookwyrm/tests/views/test_federation.py
View file

@ -15,13 +15,14 @@ class FederationViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", 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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -32,7 +33,8 @@ class FederationViews(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",
) )
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_federation_page(self): def test_federation_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

55
bookwyrm/tests/views/test_feed.py
View file

@ -22,19 +22,22 @@ class FeedViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
self.book = models.Edition.objects.create( )
parent_work=models.Work.objects.create(title="hi"), with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", parent_work=models.Work.objects.create(title="hi"),
) title="Example Edition",
models.SiteSettings.objects.create() remote_id="https://example.com/book/1",
)
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_feed(self, *_): def test_feed(self, *_):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""
@ -89,11 +92,14 @@ class FeedViews(TestCase):
output = BytesIO() output = BytesIO()
image.save(output, format=image.format) image.save(output, format=image.format)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Review.objects.create( with patch(
content="hi", "bookwyrm.preview_images.generate_edition_preview_image_task.delay"
user=self.local_user, ):
book=self.book, status = models.Review.objects.create(
) content="hi",
user=self.local_user,
book=self.book,
)
attachment = models.Image.objects.create( attachment = models.Image.objects.create(
status=status, caption="alt text here" status=status, caption="alt text here"
) )
@ -146,12 +152,13 @@ class FeedViews(TestCase):
def test_get_suggested_book(self, *_): def test_get_suggested_book(self, *_):
"""gets books the ~*~ algorithm ~*~ thinks you want to post about""" """gets books the ~*~ algorithm ~*~ thinks you want to post about"""
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
models.ShelfBook.objects.create( with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
book=self.book, models.ShelfBook.objects.create(
user=self.local_user, book=self.book,
shelf=self.local_user.shelf_set.get(identifier="reading"), user=self.local_user,
) shelf=self.local_user.shelf_set.get(identifier="reading"),
)
suggestions = views.feed.get_suggested_books(self.local_user) suggestions = views.feed.get_suggested_books(self.local_user)
self.assertEqual(suggestions[0]["name"], "Currently Reading") self.assertEqual(suggestions[0]["name"], "Currently Reading")
self.assertEqual(suggestions[0]["books"][0], self.book) self.assertEqual(suggestions[0]["books"][0], self.book)

66
bookwyrm/tests/views/test_follow.py
View file

@ -16,14 +16,15 @@ class BookViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
)
with patch("bookwyrm.models.user.set_remote_server"): with patch("bookwyrm.models.user.set_remote_server"):
self.remote_user = models.User.objects.create_user( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -42,12 +43,13 @@ class BookViews(TestCase):
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") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create( self.work = models.Work.objects.create(title="Test Work")
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Example Edition",
parent_work=self.work, remote_id="https://example.com/book/1",
) parent_work=self.work,
)
def test_handle_follow_remote(self): def test_handle_follow_remote(self):
"""send a follow request""" """send a follow request"""
@ -66,15 +68,16 @@ class BookViews(TestCase):
def test_handle_follow_local_manually_approves(self): def test_handle_follow_local_manually_approves(self):
"""send a follow request""" """send a follow request"""
rat = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"rat@local.com", rat = models.User.objects.create_user(
"rat@rat.com", "rat@local.com",
"ratword", "rat@rat.com",
local=True, "ratword",
localname="rat", local=True,
remote_id="https://example.com/users/rat", localname="rat",
manually_approves_followers=True, remote_id="https://example.com/users/rat",
) manually_approves_followers=True,
)
request = self.factory.post("", {"user": rat}) request = self.factory.post("", {"user": rat})
request.user = self.local_user request.user = self.local_user
self.assertEqual(models.UserFollowRequest.objects.count(), 0) self.assertEqual(models.UserFollowRequest.objects.count(), 0)
@ -89,14 +92,15 @@ class BookViews(TestCase):
def test_handle_follow_local(self): def test_handle_follow_local(self):
"""send a follow request""" """send a follow request"""
rat = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"rat@local.com", rat = models.User.objects.create_user(
"rat@rat.com", "rat@local.com",
"ratword", "rat@rat.com",
local=True, "ratword",
localname="rat", local=True,
remote_id="https://example.com/users/rat", localname="rat",
) remote_id="https://example.com/users/rat",
)
request = self.factory.post("", {"user": rat}) request = self.factory.post("", {"user": rat})
request.user = self.local_user request.user = self.local_user
self.assertEqual(models.UserFollowRequest.objects.count(), 0) self.assertEqual(models.UserFollowRequest.objects.count(), 0)

29
bookwyrm/tests/views/test_get_started.py
View file

@ -13,22 +13,25 @@ class GetStartedViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
self.book = models.Edition.objects.create( )
parent_work=models.Work.objects.create(title="hi"), with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", parent_work=models.Work.objects.create(title="hi"),
) title="Example Edition",
remote_id="https://example.com/book/1",
)
models.Connector.objects.create( models.Connector.objects.create(
identifier="self", connector_file="self_connector", local=True identifier="self", connector_file="self_connector", local=True
) )
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_profile_view(self): def test_profile_view(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

45
bookwyrm/tests/views/test_goal.py
View file

@ -16,29 +16,32 @@ class GoalViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
self.rat = models.User.objects.create_user( )
"rat@local.com", self.rat = models.User.objects.create_user(
"rat@rat.com", "rat@local.com",
"ratword", "rat@rat.com",
local=True, "ratword",
localname="rat", local=True,
remote_id="https://example.com/users/rat", localname="rat",
) remote_id="https://example.com/users/rat",
self.book = models.Edition.objects.create( )
title="Example Edition", with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
remote_id="https://example.com/book/1", self.book = models.Edition.objects.create(
) title="Example Edition",
remote_id="https://example.com/book/1",
)
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_goal_page_no_goal(self): def test_goal_page_no_goal(self):
"""view a reading goal page for another's unset goal""" """view a reading goal page for another's unset goal"""

124
bookwyrm/tests/views/test_helpers.py
View file

@ -19,21 +19,23 @@ class ViewsHelpers(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
discoverable=True, local=True,
localname="mouse", discoverable=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
self.work = models.Work.objects.create(title="Test Work") )
self.book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test Book", self.work = models.Work.objects.create(title="Test Work")
remote_id="https://example.com/book/1", self.book = models.Edition.objects.create(
parent_work=self.work, title="Test Book",
) remote_id="https://example.com/book/1",
parent_work=self.work,
)
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( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -202,21 +204,22 @@ class ViewsHelpers(TestCase):
def test_get_annotated_users(self, _): def test_get_annotated_users(self, _):
"""list of people you might know""" """list of people you might know"""
user_1 = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"nutria@local.com", user_1 = models.User.objects.create_user(
"nutria@nutria.com", "nutria@local.com",
"nutriaword", "nutria@nutria.com",
local=True, "nutriaword",
localname="nutria", local=True,
discoverable=True, localname="nutria",
) discoverable=True,
user_2 = models.User.objects.create_user( )
"fish@local.com", user_2 = models.User.objects.create_user(
"fish@fish.com", "fish@local.com",
"fishword", "fish@fish.com",
local=True, "fishword",
localname="fish", local=True,
) localname="fish",
)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
# 1 shared follow # 1 shared follow
self.local_user.following.add(user_2) self.local_user.following.add(user_2)
@ -249,39 +252,42 @@ class ViewsHelpers(TestCase):
def test_get_annotated_users_counts(self, _): def test_get_annotated_users_counts(self, _):
"""correct counting for multiple shared attributed""" """correct counting for multiple shared attributed"""
user_1 = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"nutria@local.com", user_1 = models.User.objects.create_user(
"nutria@nutria.com", "nutria@local.com",
"nutriaword", "nutria@nutria.com",
local=True, "nutriaword",
localname="nutria",
discoverable=True,
)
for i in range(3):
user = models.User.objects.create_user(
"{:d}@local.com".format(i),
"{:d}@nutria.com".format(i),
"password",
local=True, local=True,
localname=i, localname="nutria",
discoverable=True,
) )
user.following.add(user_1) with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
user.followers.add(self.local_user)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
for i in range(3): for i in range(3):
book = models.Edition.objects.create( user = models.User.objects.create_user(
title=i, "{:d}@local.com".format(i),
parent_work=models.Work.objects.create(title=i), "{:d}@nutria.com".format(i),
) "password",
models.ShelfBook.objects.create( local=True,
user=self.local_user, localname=i,
book=book,
shelf=self.local_user.shelf_set.first(),
)
models.ShelfBook.objects.create(
user=user_1, book=book, shelf=user_1.shelf_set.first()
) )
user.following.add(user_1)
user.followers.add(self.local_user)
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
for i in range(3):
book = models.Edition.objects.create(
title=i,
parent_work=models.Work.objects.create(title=i),
)
models.ShelfBook.objects.create(
user=self.local_user,
book=book,
shelf=self.local_user.shelf_set.first(),
)
models.ShelfBook.objects.create(
user=user_1, book=book, shelf=user_1.shelf_set.first()
)
result = views.helpers.get_annotated_users( result = views.helpers.get_annotated_users(
self.local_user, self.local_user,

18
bookwyrm/tests/views/test_import.py
View file

@ -14,14 +14,16 @@ class ImportViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_import_page(self): def test_import_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

30
bookwyrm/tests/views/test_interaction.py
View file

@ -14,14 +14,15 @@ class InteractionViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
)
with patch("bookwyrm.models.user.set_remote_server"): with patch("bookwyrm.models.user.set_remote_server"):
self.remote_user = models.User.objects.create_user( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -33,12 +34,13 @@ class InteractionViews(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
work = models.Work.objects.create(title="Test Work") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create( work = models.Work.objects.create(title="Test Work")
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Example Edition",
parent_work=work, remote_id="https://example.com/book/1",
) parent_work=work,
)
def test_favorite(self, _): def test_favorite(self, _):
"""create and broadcast faving a status""" """create and broadcast faving a status"""

18
bookwyrm/tests/views/test_invite.py
View file

@ -16,14 +16,16 @@ class InviteViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_invite_page(self): def test_invite_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

35
bookwyrm/tests/views/test_isbn.py
View file

@ -16,25 +16,28 @@ class IsbnViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
self.work = models.Work.objects.create(title="Test Work") )
self.book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test Book", self.work = models.Work.objects.create(title="Test Work")
isbn_13="1234567890123", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Test Book",
parent_work=self.work, isbn_13="1234567890123",
) remote_id="https://example.com/book/1",
parent_work=self.work,
)
models.Connector.objects.create( models.Connector.objects.create(
identifier="self", connector_file="self_connector", local=True identifier="self", connector_file="self_connector", local=True
) )
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_isbn_json_response(self): def test_isbn_json_response(self):
"""searches local data only and returns book data in json format""" """searches local data only and returns book data in json format"""

18
bookwyrm/tests/views/test_landing.py
View file

@ -15,16 +15,18 @@ class LandingViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
)
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_home_page(self): def test_home_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

85
bookwyrm/tests/views/test_list.py
View file

@ -17,46 +17,48 @@ class ListViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
self.rat = models.User.objects.create_user( )
"rat@local.com", self.rat = models.User.objects.create_user(
"rat@rat.com", "rat@local.com",
"ratword", "rat@rat.com",
local=True, "ratword",
localname="rat", local=True,
remote_id="https://example.com/users/rat", localname="rat",
) remote_id="https://example.com/users/rat",
work = models.Work.objects.create(title="Work") )
self.book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Example Edition", work = models.Work.objects.create(title="Work")
remote_id="https://example.com/book/1", self.book = models.Edition.objects.create(
parent_work=work, title="Example Edition",
) remote_id="https://example.com/book/1",
work_two = models.Work.objects.create(title="Labori") parent_work=work,
self.book_two = models.Edition.objects.create( )
title="Example Edition 2", work_two = models.Work.objects.create(title="Labori")
remote_id="https://example.com/book/2", self.book_two = models.Edition.objects.create(
parent_work=work_two, title="Example Edition 2",
) remote_id="https://example.com/book/2",
work_three = models.Work.objects.create(title="Trabajar") parent_work=work_two,
self.book_three = models.Edition.objects.create( )
title="Example Edition 3", work_three = models.Work.objects.create(title="Trabajar")
remote_id="https://example.com/book/3", self.book_three = models.Edition.objects.create(
parent_work=work_three, title="Example Edition 3",
) remote_id="https://example.com/book/3",
work_four = models.Work.objects.create(title="Travailler") parent_work=work_three,
self.book_four = models.Edition.objects.create( )
title="Example Edition 4", work_four = models.Work.objects.create(title="Travailler")
remote_id="https://example.com/book/4", self.book_four = models.Edition.objects.create(
parent_work=work_four, title="Example Edition 4",
) remote_id="https://example.com/book/4",
parent_work=work_four,
)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.list = models.List.objects.create( self.list = models.List.objects.create(
@ -64,7 +66,8 @@ class ListViews(TestCase):
) )
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
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"""

86
bookwyrm/tests/views/test_list_actions.py
View file

@ -15,46 +15,49 @@ class ListActionViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
self.rat = models.User.objects.create_user( )
"rat@local.com", self.rat = models.User.objects.create_user(
"rat@rat.com", "rat@local.com",
"ratword", "rat@rat.com",
local=True, "ratword",
localname="rat", local=True,
remote_id="https://example.com/users/rat", localname="rat",
) remote_id="https://example.com/users/rat",
work = models.Work.objects.create(title="Work") )
self.book = models.Edition.objects.create(
title="Example Edition", with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
remote_id="https://example.com/book/1", work = models.Work.objects.create(title="Work")
parent_work=work, self.book = models.Edition.objects.create(
) title="Example Edition",
work_two = models.Work.objects.create(title="Labori") remote_id="https://example.com/book/1",
self.book_two = models.Edition.objects.create( parent_work=work,
title="Example Edition 2", )
remote_id="https://example.com/book/2", work_two = models.Work.objects.create(title="Labori")
parent_work=work_two, self.book_two = models.Edition.objects.create(
) title="Example Edition 2",
work_three = models.Work.objects.create(title="Trabajar") remote_id="https://example.com/book/2",
self.book_three = models.Edition.objects.create( parent_work=work_two,
title="Example Edition 3", )
remote_id="https://example.com/book/3", work_three = models.Work.objects.create(title="Trabajar")
parent_work=work_three, self.book_three = models.Edition.objects.create(
) title="Example Edition 3",
work_four = models.Work.objects.create(title="Travailler") remote_id="https://example.com/book/3",
self.book_four = models.Edition.objects.create( parent_work=work_three,
title="Example Edition 4", )
remote_id="https://example.com/book/4", work_four = models.Work.objects.create(title="Travailler")
parent_work=work_four, self.book_four = models.Edition.objects.create(
) title="Example Edition 4",
remote_id="https://example.com/book/4",
parent_work=work_four,
)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.list = models.List.objects.create( self.list = models.List.objects.create(
@ -62,7 +65,8 @@ class ListActionViews(TestCase):
) )
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_curate_approve(self): def test_curate_approve(self):
"""approve a pending item""" """approve a pending item"""

19
bookwyrm/tests/views/test_notifications.py
View file

@ -2,6 +2,7 @@
from django.template.response import TemplateResponse from django.template.response import TemplateResponse
from django.test import TestCase from django.test import TestCase
from django.test.client import RequestFactory from django.test.client import RequestFactory
from unittest.mock import patch
from bookwyrm import models from bookwyrm import models
from bookwyrm import views from bookwyrm import views
@ -13,14 +14,16 @@ class NotificationViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_notifications_page(self): def test_notifications_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

81
bookwyrm/tests/views/test_outbox.py
View file

@ -18,20 +18,22 @@ class OutboxView(TestCase):
def setUp(self): def setUp(self):
"""we'll need some data""" """we'll need some data"""
self.factory = RequestFactory() self.factory = RequestFactory()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
work = models.Work.objects.create(title="Test Work") )
self.book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Example Edition", work = models.Work.objects.create(title="Test Work")
remote_id="https://example.com/book/1", self.book = models.Edition.objects.create(
parent_work=work, title="Example Edition",
) remote_id="https://example.com/book/1",
parent_work=work,
)
def test_outbox(self, _): def test_outbox(self, _):
"""returns user's statuses""" """returns user's statuses"""
@ -79,13 +81,16 @@ class OutboxView(TestCase):
def test_outbox_filter(self, _): def test_outbox_filter(self, _):
"""if we only care about reviews, only get reviews""" """if we only care about reviews, only get reviews"""
with patch("bookwyrm.activitystreams.ActivityStream.add_status"): with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
models.Review.objects.create( with patch(
content="look at this", "bookwyrm.preview_images.generate_edition_preview_image_task.delay"
name="hi", ):
rating=1, models.Review.objects.create(
book=self.book, content="look at this",
user=self.local_user, name="hi",
) rating=1,
book=self.book,
user=self.local_user,
)
models.Status.objects.create(content="look at this", user=self.local_user) models.Status.objects.create(content="look at this", user=self.local_user)
request = self.factory.get("", {"type": "bleh"}) request = self.factory.get("", {"type": "bleh"})
@ -105,13 +110,16 @@ class OutboxView(TestCase):
def test_outbox_bookwyrm_request_true(self, _): def test_outbox_bookwyrm_request_true(self, _):
"""should differentiate between bookwyrm and outside requests""" """should differentiate between bookwyrm and outside requests"""
with patch("bookwyrm.activitystreams.ActivityStream.add_status"): with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
models.Review.objects.create( with patch(
name="hi", "bookwyrm.preview_images.generate_edition_preview_image_task.delay"
content="look at this", ):
user=self.local_user, models.Review.objects.create(
book=self.book, name="hi",
privacy="public", content="look at this",
) user=self.local_user,
book=self.book,
privacy="public",
)
request = self.factory.get("", {"page": 1}, HTTP_USER_AGENT=USER_AGENT) request = self.factory.get("", {"page": 1}, HTTP_USER_AGENT=USER_AGENT)
result = views.Outbox.as_view()(request, "mouse") result = views.Outbox.as_view()(request, "mouse")
@ -123,13 +131,16 @@ class OutboxView(TestCase):
def test_outbox_bookwyrm_request_false(self, _): def test_outbox_bookwyrm_request_false(self, _):
"""should differentiate between bookwyrm and outside requests""" """should differentiate between bookwyrm and outside requests"""
with patch("bookwyrm.activitystreams.ActivityStream.add_status"): with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
models.Review.objects.create( with patch(
name="hi", "bookwyrm.preview_images.generate_edition_preview_image_task.delay"
content="look at this", ):
user=self.local_user, models.Review.objects.create(
book=self.book, name="hi",
privacy="public", content="look at this",
) user=self.local_user,
book=self.book,
privacy="public",
)
request = self.factory.get("", {"page": 1}) request = self.factory.get("", {"page": 1})
result = views.Outbox.as_view()(request, "mouse") result = views.Outbox.as_view()(request, "mouse")

18
bookwyrm/tests/views/test_password.py
View file

@ -15,16 +15,18 @@ class PasswordViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"password", "mouse@mouse.com",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
)
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
models.SiteSettings.objects.create(id=1) with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create(id=1)
def test_password_reset_request(self): def test_password_reset_request(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

30
bookwyrm/tests/views/test_reading.py
View file

@ -15,20 +15,22 @@ class ReadingViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
self.work = models.Work.objects.create(title="Test Work") )
self.book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test Book", self.work = models.Work.objects.create(title="Test Work")
remote_id="https://example.com/book/1", self.book = models.Edition.objects.create(
parent_work=self.work, title="Test Book",
) remote_id="https://example.com/book/1",
parent_work=self.work,
)
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( self.remote_user = models.User.objects.create_user(
"rat", "rat",

16
bookwyrm/tests/views/test_readthrough.py
View file

@ -15,15 +15,17 @@ class ReadThrough(TestCase):
"""basic user and book data""" """basic user and book data"""
self.client = Client() self.client = Client()
self.work = models.Work.objects.create(title="Example Work") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.work = models.Work.objects.create(title="Example Work")
self.edition = models.Edition.objects.create( self.edition = models.Edition.objects.create(
title="Example Edition", parent_work=self.work title="Example Edition", parent_work=self.work
) )
self.user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"cinco", "cinco@example.com", "seissiete", local=True, localname="cinco" self.user = models.User.objects.create_user(
) "cinco", "cinco@example.com", "seissiete", local=True, localname="cinco"
)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.client.force_login(self.user) self.client.force_login(self.user)

33
bookwyrm/tests/views/test_reports.py
View file

@ -2,6 +2,7 @@
from django.template.response import TemplateResponse from django.template.response import TemplateResponse
from django.test import TestCase from django.test import TestCase
from django.test.client import RequestFactory from django.test.client import RequestFactory
from unittest.mock import patch
from bookwyrm import forms, models, views from bookwyrm import forms, models, views
@ -12,21 +13,23 @@ class ReportViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
self.rat = models.User.objects.create_user( )
"rat@local.com", self.rat = models.User.objects.create_user(
"rat@mouse.mouse", "rat@local.com",
"password", "rat@mouse.mouse",
local=True, "password",
localname="rat", local=True,
) localname="rat",
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_reports_page(self): def test_reports_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

62
bookwyrm/tests/views/test_rss_feed.py
View file

@ -12,39 +12,45 @@ class RssFeedView(TestCase):
def setUp(self): def setUp(self):
"""test data""" """test data"""
self.site = models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
self.site = models.SiteSettings.objects.create()
self.user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"rss_user", "rss@test.rss", "password", local=True self.user = models.User.objects.create_user(
) "rss_user", "rss@test.rss", "password", local=True
)
work = models.Work.objects.create(title="Test Work") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create( work = models.Work.objects.create(title="Test Work")
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Example Edition",
parent_work=work, remote_id="https://example.com/book/1",
) parent_work=work,
)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.activitystreams.ActivityStream.add_status"): with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
self.review = models.Review.objects.create( with patch(
name="Review name", "bookwyrm.preview_images.generate_edition_preview_image_task.delay"
content="test content", ):
rating=3, self.review = models.Review.objects.create(
user=self.user, name="Review name",
book=self.book, content="test content",
) rating=3,
user=self.user,
book=self.book,
)
self.quote = models.Quotation.objects.create( self.quote = models.Quotation.objects.create(
quote="a sickening sense", quote="a sickening sense",
content="test content", content="test content",
user=self.user, user=self.user,
book=self.book, book=self.book,
) )
self.generatednote = models.GeneratedNote.objects.create( self.generatednote = models.GeneratedNote.objects.create(
content="test content", user=self.user content="test content", user=self.user
) )
self.factory = RequestFactory() self.factory = RequestFactory()

33
bookwyrm/tests/views/test_search.py
View file

@ -19,24 +19,27 @@ class Views(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
self.work = models.Work.objects.create(title="Test Work") )
self.book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Test Book", self.work = models.Work.objects.create(title="Test Work")
remote_id="https://example.com/book/1", self.book = models.Edition.objects.create(
parent_work=self.work, title="Test Book",
) remote_id="https://example.com/book/1",
parent_work=self.work,
)
models.Connector.objects.create( models.Connector.objects.create(
identifier="self", connector_file="self_connector", local=True identifier="self", connector_file="self_connector", local=True
) )
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_search_json_response(self): def test_search_json_response(self):
"""searches local data only and returns book data in json format""" """searches local data only and returns book data in json format"""

33
bookwyrm/tests/views/test_shelf.py
View file

@ -16,25 +16,28 @@ class ShelfViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
self.work = models.Work.objects.create(title="Test Work") )
self.book = models.Edition.objects.create( with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
title="Example Edition", self.work = models.Work.objects.create(title="Test Work")
remote_id="https://example.com/book/1", self.book = models.Edition.objects.create(
parent_work=self.work, title="Example Edition",
) remote_id="https://example.com/book/1",
parent_work=self.work,
)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.shelf = models.Shelf.objects.create( self.shelf = models.Shelf.objects.create(
name="Test Shelf", identifier="test-shelf", user=self.local_user name="Test Shelf", identifier="test-shelf", user=self.local_user
) )
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_shelf_page(self, _): def test_shelf_page(self, _):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

82
bookwyrm/tests/views/test_status.py
View file

@ -15,14 +15,15 @@ class StatusViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.com", "mouse@local.com",
"mouseword", "mouse@mouse.com",
local=True, "mouseword",
localname="mouse", local=True,
remote_id="https://example.com/users/mouse", localname="mouse",
) remote_id="https://example.com/users/mouse",
)
with patch("bookwyrm.models.user.set_remote_server"): with patch("bookwyrm.models.user.set_remote_server"):
self.remote_user = models.User.objects.create_user( self.remote_user = models.User.objects.create_user(
"rat", "rat",
@ -34,13 +35,15 @@ class StatusViews(TestCase):
outbox="https://example.com/users/rat/outbox", outbox="https://example.com/users/rat/outbox",
) )
work = models.Work.objects.create(title="Test Work") with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create( work = models.Work.objects.create(title="Test Work")
title="Example Edition", self.book = models.Edition.objects.create(
remote_id="https://example.com/book/1", title="Example Edition",
parent_work=work, remote_id="https://example.com/book/1",
) parent_work=work,
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_handle_status(self, _): def test_handle_status(self, _):
"""create a status""" """create a status"""
@ -68,9 +71,10 @@ class StatusViews(TestCase):
def test_handle_status_reply(self, _): def test_handle_status_reply(self, _):
"""create a status in reply to an existing status""" """create a status in reply to an existing status"""
view = views.CreateStatus.as_view() view = views.CreateStatus.as_view()
user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"rat", "rat@rat.com", "password", local=True user = models.User.objects.create_user(
) "rat", "rat@rat.com", "password", local=True
)
with patch("bookwyrm.activitystreams.ActivityStream.add_status"): with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
parent = models.Status.objects.create( parent = models.Status.objects.create(
content="parent status", user=self.local_user content="parent status", user=self.local_user
@ -98,9 +102,14 @@ class StatusViews(TestCase):
def test_handle_status_mentions(self, _): def test_handle_status_mentions(self, _):
"""@mention a user in a post""" """@mention a user in a post"""
view = views.CreateStatus.as_view() view = views.CreateStatus.as_view()
user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"rat@%s" % DOMAIN, "rat@rat.com", "password", local=True, localname="rat" user = models.User.objects.create_user(
) "rat@%s" % DOMAIN,
"rat@rat.com",
"password",
local=True,
localname="rat",
)
form = forms.CommentForm( form = forms.CommentForm(
{ {
"content": "hi @rat", "content": "hi @rat",
@ -126,9 +135,10 @@ class StatusViews(TestCase):
def test_handle_status_reply_with_mentions(self, _): def test_handle_status_reply_with_mentions(self, _):
"""reply to a post with an @mention'ed user""" """reply to a post with an @mention'ed user"""
view = views.CreateStatus.as_view() view = views.CreateStatus.as_view()
user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"rat", "rat@rat.com", "password", local=True, localname="rat" user = models.User.objects.create_user(
) "rat", "rat@rat.com", "password", local=True, localname="rat"
)
form = forms.CommentForm( form = forms.CommentForm(
{ {
"content": "hi @rat@example.com", "content": "hi @rat@example.com",
@ -193,10 +203,11 @@ class StatusViews(TestCase):
view = views.DeleteAndRedraft.as_view() view = views.DeleteAndRedraft.as_view()
request = self.factory.post("") request = self.factory.post("")
request.user = self.local_user request.user = self.local_user
with patch("bookwyrm.activitystreams.ActivityStream.add_status"): with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
status = models.ReviewRating.objects.create( with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
book=self.book, rating=2.0, user=self.local_user status = models.ReviewRating.objects.create(
) book=self.book, rating=2.0, user=self.local_user
)
with patch( with patch(
"bookwyrm.activitystreams.ActivityStream.remove_object_from_related_stores" "bookwyrm.activitystreams.ActivityStream.remove_object_from_related_stores"
@ -230,13 +241,14 @@ class StatusViews(TestCase):
def test_find_mentions(self, _): def test_find_mentions(self, _):
"""detect and look up @ mentions of users""" """detect and look up @ mentions of users"""
user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"nutria@%s" % DOMAIN, user = models.User.objects.create_user(
"nutria@nutria.com", "nutria@%s" % DOMAIN,
"password", "nutria@nutria.com",
local=True, "password",
localname="nutria", local=True,
) localname="nutria",
)
self.assertEqual(user.username, "nutria@%s" % DOMAIN) self.assertEqual(user.username, "nutria@%s" % DOMAIN)
self.assertEqual( self.assertEqual(

20
bookwyrm/tests/views/test_updates.py
View file

@ -14,15 +14,17 @@ class UpdateViews(TestCase):
def setUp(self): def setUp(self):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
self.factory = RequestFactory() with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
self.local_user = models.User.objects.create_user( self.factory = RequestFactory()
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_get_notification_count(self): def test_get_notification_count(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

29
bookwyrm/tests/views/test_user.py
View file

@ -20,18 +20,20 @@ class UserViews(TestCase):
def setUp(self): def setUp(self):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
self.factory = RequestFactory() with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
self.local_user = models.User.objects.create_user( self.factory = RequestFactory()
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
self.rat = models.User.objects.create_user( )
"rat@local.com", "rat@rat.rat", "password", local=True, localname="rat" self.rat = models.User.objects.create_user(
) "rat@local.com", "rat@rat.rat", "password", local=True, localname="rat"
self.book = models.Edition.objects.create(title="test") )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create(title="test")
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.ShelfBook.objects.create( models.ShelfBook.objects.create(
book=self.book, book=self.book,
@ -39,7 +41,8 @@ class UserViews(TestCase):
shelf=self.local_user.shelf_set.first(), shelf=self.local_user.shelf_set.first(),
) )
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False

18
bookwyrm/tests/views/test_user_admin.py
View file

@ -14,14 +14,16 @@ class UserAdminViews(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()
self.local_user = models.User.objects.create_user( with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
models.SiteSettings.objects.create() )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
def test_user_admin_list_page(self): def test_user_admin_list_page(self):
"""there are so many views, this just makes sure it LOADS""" """there are so many views, this just makes sure it LOADS"""

26
bookwyrm/tests/views/test_wellknown.py
View file

@ -15,17 +15,18 @@ class UserViews(TestCase):
def setUp(self): def setUp(self):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
self.factory = RequestFactory() with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
self.local_user = models.User.objects.create_user( self.factory = RequestFactory()
"mouse@local.com", self.local_user = models.User.objects.create_user(
"mouse@mouse.mouse", "mouse@local.com",
"password", "mouse@mouse.mouse",
local=True, "password",
localname="mouse", local=True,
) localname="mouse",
models.User.objects.create_user( )
"rat@local.com", "rat@rat.rat", "password", local=True, localname="rat" models.User.objects.create_user(
) "rat@local.com", "rat@rat.rat", "password", local=True, localname="rat"
)
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
models.User.objects.create_user( models.User.objects.create_user(
"rat", "rat",
@ -36,7 +37,8 @@ class UserViews(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",
) )
models.SiteSettings.objects.create() with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create()
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False