mirrors/bookwyrm
1
0
Fork 1
mirror of https://github.com/bookwyrm-social/bookwyrm.git synced 2024-11-29 13:01:08 +00:00
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/main' into images-django-imagekit

Browse source
This commit is contained in:
Joachim 2021-08-04 10:00:20 +02:00
commit 843127efa8
84 changed files with 1633 additions and 1869 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
.github/workflows/black.yml vendored
View file

@ -1,6 +1,10 @@
name: Python Formatting (run ./bw-dev black to fix) name: Python Formatting (run ./bw-dev black to fix)
on: [push, pull_request] on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs: jobs:
lint: lint:

25
.github/workflows/django-tests.yml vendored
View file

@ -9,18 +9,9 @@ jobs:
build: build:
runs-on: ubuntu-20.04 runs-on: ubuntu-20.04
strategy:
max-parallel: 4
matrix:
db: [postgres]
python-version: [3.9]
include:
- db: postgres
db_port: 5432
services: services:
postgres: postgres:
image: postgres:12 image: postgres:13
env: env:
POSTGRES_USER: postgres POSTGRES_USER: postgres
POSTGRES_PASSWORD: hunter2 POSTGRES_PASSWORD: hunter2
@ -33,22 +24,18 @@ jobs:
- 5432:5432 - 5432:5432
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- name: Set up Python ${{ matrix.python-version }} - name: Set up Python
uses: actions/setup-python@v2 uses: actions/setup-python@v2
with: with:
python-version: ${{ matrix.python-version }} python-version: 3.9
- name: Install Dependencies - name: Install Dependencies
run: | run: |
python -m pip install --upgrade pip python -m pip install --upgrade pip
pip install -r requirements.txt pip install -r requirements.txt
- name: Run Tests - name: Run Tests
env: env:
DB: ${{ matrix.db }}
DB_HOST: 127.0.0.1
DB_PORT: ${{ matrix.db_port }}
DB_PASSWORD: hunter2
SECRET_KEY: beepbeep SECRET_KEY: beepbeep
DEBUG: true DEBUG: false
DOMAIN: your.domain.here DOMAIN: your.domain.here
BOOKWYRM_DATABASE_BACKEND: postgres BOOKWYRM_DATABASE_BACKEND: postgres
MEDIA_ROOT: images/ MEDIA_ROOT: images/
@ -64,6 +51,6 @@ jobs:
EMAIL_HOST_USER: "" EMAIL_HOST_USER: ""
EMAIL_HOST_PASSWORD: "" EMAIL_HOST_PASSWORD: ""
EMAIL_USE_TLS: true EMAIL_USE_TLS: true
ENABLE_PREVIEW_IMAGES: true ENABLE_PREVIEW_IMAGES: false
run: | run: |
pytest pytest -n 3

6
.github/workflows/pylint.yml vendored
View file

@ -1,6 +1,10 @@
name: Pylint name: Pylint
on: [push, pull_request] on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs: jobs:
build: build:

4
bookwyrm/models/fields.py
View file

@ -13,6 +13,7 @@ from django.db import models
from django.forms import ClearableFileInput, ImageField as DjangoImageField from django.forms import ClearableFileInput, ImageField as DjangoImageField
from django.utils import timezone from django.utils import timezone
from django.utils.translation import gettext_lazy as _ from django.utils.translation import gettext_lazy as _
from bookwyrm import activitypub from bookwyrm import activitypub
from bookwyrm.connectors import get_image from bookwyrm.connectors import get_image
from bookwyrm.sanitize_html import InputHtmlParser from bookwyrm.sanitize_html import InputHtmlParser
@ -354,7 +355,8 @@ def image_serializer(value, alt):
url = value.url url = value.url
else: else:
return None return None
url = "https://%s%s" % (DOMAIN, url) if not url[:4] == "http":
url = "https://{:s}{:s}".format(DOMAIN, url)
return activitypub.Document(url=url, name=alt) return activitypub.Document(url=url, name=alt)

2
bookwyrm/templates/layout.html
View file

@ -151,7 +151,7 @@
{% if request.path != '/login' and request.path != '/login/' %} {% if request.path != '/login' and request.path != '/login/' %}
<div class="columns"> <div class="columns">
<div class="column"> <div class="column">
<form name="login" method="post" action="/login"> <form name="login" method="post" action="{% url 'login' %}?next={{ request.path }}">
{% csrf_token %} {% csrf_token %}
<div class="columns is-variable is-1"> <div class="columns is-variable is-1">
<div class="column"> <div class="column">

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

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

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

@ -25,25 +25,24 @@ 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"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.user = models.User.objects.create_user(
self.user = models.User.objects.create_user( "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" )
) self.user.remote_id = "http://example.com/a/b"
self.user.remote_id = "http://example.com/a/b" self.user.save(broadcast=False)
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"""
@ -98,11 +97,10 @@ class BaseActivity(TestCase):
status=200, status=200,
) )
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
with patch("bookwyrm.models.user.set_remote_server.delay"): result = resolve_remote_id(
result = resolve_remote_id( "https://example.com/user/mouse", model=models.User
"https://example.com/user/mouse", model=models.User )
)
self.assertIsInstance(result, models.User) self.assertIsInstance(result, models.User)
self.assertEqual(result.remote_id, "https://example.com/user/mouse") self.assertEqual(result.remote_id, "https://example.com/user/mouse")
self.assertEqual(result.name, "MOUSE?? MOUSE!!") self.assertEqual(result.name, "MOUSE?? MOUSE!!")
@ -141,9 +139,8 @@ 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.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): activity.to_model(model=models.User, instance=self.user)
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")
@ -155,10 +152,9 @@ class BaseActivity(TestCase):
content="test status", content="test status",
user=self.user, user=self.user,
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): book = models.Edition.objects.create(
book = models.Edition.objects.create( title="Test Edition", remote_id="http://book.com/book"
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,

5
bookwyrm/tests/activitypub/test_person.py
View file

@ -20,9 +20,8 @@ class Person(TestCase):
def test_user_to_model(self): def test_user_to_model(self):
activity = activitypub.Person(**self.user_data) activity = activitypub.Person(**self.user_data)
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
with patch("bookwyrm.models.user.set_remote_server.delay"): user = activity.to_model(model=models.User)
user = activity.to_model(model=models.User)
self.assertEqual(user.username, "mouse@example.com") self.assertEqual(user.username, "mouse@example.com")
self.assertEqual(user.remote_id, "https://example.com/user/mouse") self.assertEqual(user.remote_id, "https://example.com/user/mouse")
self.assertFalse(user.local) self.assertFalse(user.local)

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

@ -12,22 +12,20 @@ class Quotation(TestCase):
def setUp(self): def setUp(self):
"""model objects we'll need""" """model objects we'll need"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
with patch("bookwyrm.models.user.set_remote_server.delay"): self.user = models.User.objects.create_user(
self.user = models.User.objects.create_user( "mouse",
"mouse", "mouse@mouse.mouse",
"mouse@mouse.mouse", "mouseword",
"mouseword", local=False,
local=False, inbox="https://example.com/user/mouse/inbox",
inbox="https://example.com/user/mouse/inbox", 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",
)
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.book = models.Edition.objects.create(
title="Example Edition",
remote_id="https://example.com/book/1",
) )
self.book = models.Edition.objects.create(
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())

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

@ -74,12 +74,11 @@ class AbstractConnector(TestCase):
Mapping("openlibraryKey"), Mapping("openlibraryKey"),
] ]
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): self.book = models.Edition.objects.create(
self.book = models.Edition.objects.create( title="Test Book",
title="Test Book", remote_id="https://example.com/book/1234",
remote_id="https://example.com/book/1234", openlibrary_key="OL1234M",
openlibrary_key="OL1234M", )
)
def test_abstract_connector_init(self): def test_abstract_connector_init(self):
"""barebones connector for search with defaults""" """barebones connector for search with defaults"""
@ -111,11 +110,8 @@ class AbstractConnector(TestCase):
responses.add( responses.add(
responses.GET, "https://example.com/book/abcd", json=self.edition_data responses.GET, "https://example.com/book/abcd", json=self.edition_data
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.connectors.abstract_connector.load_more_data.delay"):
with patch("bookwyrm.connectors.abstract_connector.load_more_data.delay"): result = self.connector.get_or_create_book("https://example.com/book/abcd")
result = self.connector.get_or_create_book(
"https://example.com/book/abcd"
)
self.assertEqual(result, self.book) self.assertEqual(result, self.book)
self.assertEqual(models.Edition.objects.count(), 1) self.assertEqual(models.Edition.objects.count(), 1)
self.assertEqual(models.Edition.objects.count(), 1) self.assertEqual(models.Edition.objects.count(), 1)

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

@ -1,5 +1,4 @@
""" 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
@ -26,9 +25,8 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): work = models.Work.objects.create(title="Test Work")
work = models.Work.objects.create(title="Test Work") book = models.Edition.objects.create(title="Test Edition", parent_work=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,5 +1,4 @@
""" 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
@ -14,15 +13,14 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): self.work = models.Work.objects.create(title="Example Work")
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",

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

@ -178,26 +178,20 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): work = models.Work.objects.create(title="Test Work", openlibrary_key="OL1234W")
work = models.Work.objects.create( edition = models.Edition.objects.create(title="Test Edition", parent_work=work)
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("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch(
with patch( "bookwyrm.connectors.abstract_connector.AbstractConnector."
"bookwyrm.connectors.abstract_connector.AbstractConnector." "create_edition_from_data"
"create_edition_from_data" ):
): self.connector.expand_book_data(edition)
self.connector.expand_book_data(edition) self.connector.expand_book_data(work)
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"""
@ -230,14 +224,11 @@ class Openlibrary(TestCase):
json={"hi": "there"}, json={"hi": "there"},
status=200, status=200,
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): with patch(
with patch( "bookwyrm.connectors.openlibrary.Connector." "get_authors_from_data"
"bookwyrm.connectors.openlibrary.Connector." "get_authors_from_data" ) as mock:
) as mock: mock.return_value = []
mock.return_value = [] result = self.connector.create_edition_from_data(work, self.edition_data)
result = self.connector.create_edition_from_data(
work, self.edition_data
)
self.assertEqual(result.parent_work, work) self.assertEqual(result.parent_work, work)
self.assertEqual(result.title, "Sabriel") self.assertEqual(result.title, "Sabriel")
self.assertEqual(result.isbn_10, "0060273224") self.assertEqual(result.isbn_10, "0060273224")

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

@ -1,5 +1,4 @@
""" 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
@ -30,21 +29,19 @@ 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")
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): edition = models.Edition.objects.create(
edition = models.Edition.objects.create( title="Edition of Example Work",
title="Edition of Example Work", published_date=datetime.datetime(1980, 5, 10, tzinfo=timezone.utc),
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)
self.assertEqual(result.author, "Anonymous") self.assertEqual(result.author, "Anonymous")
self.assertEqual(result.year, 1980) self.assertEqual(result.year, 1980)
self.assertEqual(result.connector, self.connector) self.assertEqual(result.connector, self.connector)
@patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay") 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( edition = models.Edition.objects.create(
@ -81,8 +78,7 @@ class SelfConnector(TestCase):
self.assertEqual(results[2].title, "Edition of Example Work") self.assertEqual(results[2].title, "Edition of Example Work")
self.assertEqual(results[3].title, "Another Edition") self.assertEqual(results[3].title, "Another Edition")
@patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay") 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") work = models.Work.objects.create(title="Work Title")
edition_1 = models.Edition.objects.create( edition_1 = models.Edition.objects.create(

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

@ -27,10 +27,9 @@ 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)
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.user = models.User.objects.create_user(
self.user = models.User.objects.create_user( "mouse", "mouse@mouse.mouse", "password", local=True
"mouse", "mouse@mouse.mouse", "password", local=True )
)
models.Connector.objects.create( models.Connector.objects.create(
identifier=DOMAIN, identifier=DOMAIN,
@ -43,13 +42,12 @@ class GoodreadsImport(TestCase):
search_url="https://%s/search?q=" % DOMAIN, search_url="https://%s/search?q=" % DOMAIN,
priority=1, priority=1,
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): work = models.Work.objects.create(title="Test Work")
work = models.Work.objects.create(title="Test Work") self.book = models.Edition.objects.create(
self.book = models.Edition.objects.create( title="Example Edition",
title="Example Edition", remote_id="https://example.com/book/1",
remote_id="https://example.com/book/1", parent_work=work,
parent_work=work, )
)
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"""
@ -100,8 +98,7 @@ 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")
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): book = models.Edition.objects.create(title="Test Book")
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"
@ -128,11 +125,10 @@ class GoodreadsImport(TestCase):
) )
break break
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, False, "public"
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)
@ -196,14 +192,13 @@ class GoodreadsImport(TestCase):
) )
break break
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, False, "public"
self.importer.service, self.user, import_item, False, "public" )
) handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, False, "public"
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)
@ -228,11 +223,10 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, True, "unlisted"
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)
@ -253,11 +247,10 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, True, "unlisted"
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)
@ -275,11 +268,10 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, False, "unlisted"
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()
) )

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

@ -15,6 +15,7 @@ from bookwyrm.settings import DOMAIN
def make_date(*args): def make_date(*args):
"""helper function to easily generate a date obj"""
return datetime.datetime(*args, tzinfo=pytz.UTC) return datetime.datetime(*args, tzinfo=pytz.UTC)
@ -28,10 +29,9 @@ 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)
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.user = models.User.objects.create_user(
self.user = models.User.objects.create_user( "mmai", "mmai@mmai.mmai", "password", local=True
"mmai", "mmai@mmai.mmai", "password", local=True )
)
models.Connector.objects.create( models.Connector.objects.create(
identifier=DOMAIN, identifier=DOMAIN,
@ -44,13 +44,12 @@ class LibrarythingImport(TestCase):
search_url="https://%s/search?q=" % DOMAIN, search_url="https://%s/search?q=" % DOMAIN,
priority=1, priority=1,
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): work = models.Work.objects.create(title="Test Work")
work = models.Work.objects.create(title="Test Work") self.book = models.Edition.objects.create(
self.book = models.Edition.objects.create( title="Example Edition",
title="Example Edition", remote_id="https://example.com/book/1",
remote_id="https://example.com/book/1", parent_work=work,
parent_work=work, )
)
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"""
@ -90,8 +89,7 @@ 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")
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): book = models.Edition.objects.create(title="Test Book")
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"
@ -120,11 +118,10 @@ class LibrarythingImport(TestCase):
) )
break break
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, False, "public"
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)
@ -152,11 +149,10 @@ class LibrarythingImport(TestCase):
) )
break break
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, False, "public"
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)
@ -182,14 +178,13 @@ class LibrarythingImport(TestCase):
) )
break break
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, False, "public"
self.importer.service, self.user, import_item, False, "public" )
) handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, False, "public"
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)
@ -211,11 +206,10 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, True, "unlisted"
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)
@ -233,11 +227,10 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): handle_imported_book(
handle_imported_book( self.importer.service, self.user, import_item, False, "unlisted"
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()
) )

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

@ -12,29 +12,27 @@ class Activitystreams(TestCase):
def setUp(self): def setUp(self):
"""we need some stuff""" """we need some stuff"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
self.another_user = models.User.objects.create_user( self.book = models.Edition.objects.create(title="test book")
"nutria",
"nutria@nutria.nutria",
"password",
local=True,
localname="nutria",
)
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
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"""

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

@ -21,28 +21,27 @@ from bookwyrm.settings import PAGE_LENGTH
# pylint: disable=invalid-name # pylint: disable=invalid-name
@patch("bookwyrm.activitystreams.ActivityStream.add_status") @patch("bookwyrm.activitystreams.ActivityStream.add_status")
@patch("bookwyrm.preview_images.generate_user_preview_image_task.delay") @patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
class ActivitypubMixins(TestCase): class ActivitypubMixins(TestCase):
"""functionality shared across models""" """functionality shared across models"""
def setUp(self): def setUp(self):
"""shared data""" """shared data"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
"mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse" )
self.local_user.remote_id = "http://example.com/a/b"
self.local_user.save(broadcast=False)
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
self.object_mock = { self.object_mock = {
"to": "to field", "to": "to field",
@ -78,22 +77,20 @@ 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
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): book = models.Edition.objects.create(
book = models.Edition.objects.create( title="Test Edition", remote_id="http://book.com/book"
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")
# uses subclasses # uses subclasses
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): models.Comment.objects.create(
models.Comment.objects.create( user=self.local_user,
user=self.local_user, content="test status",
content="test status", book=book,
book=book, remote_id="https://comment.net",
remote_id="https://comment.net", )
)
result = models.User.find_existing_by_remote_id("hi") result = models.User.find_existing_by_remote_id("hi")
self.assertIsNone(result) self.assertIsNone(result)
@ -110,11 +107,10 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): book = models.Edition.objects.create(
book = models.Edition.objects.create( title="Test edition",
title="Test edition", openlibrary_key="OL1234",
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)
@ -369,7 +365,6 @@ class ActivitypubMixins(TestCase):
self.assertEqual(activity["type"], "Undo") self.assertEqual(activity["type"], "Undo")
self.assertIsInstance(activity["object"], dict) self.assertIsInstance(activity["object"], dict)
@patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
def test_to_ordered_collection_page(self, *_): def test_to_ordered_collection_page(self, *_):
"""make sure the paged results of an ordered collection work""" """make sure the paged results of an ordered collection work"""
self.assertEqual(PAGE_LENGTH, 15) self.assertEqual(PAGE_LENGTH, 15)
@ -395,7 +390,6 @@ class ActivitypubMixins(TestCase):
self.assertEqual(page_2.orderedItems[0]["content"], "test status 14") self.assertEqual(page_2.orderedItems[0]["content"], "test status 14")
self.assertEqual(page_2.orderedItems[-1]["content"], "test status 0") self.assertEqual(page_2.orderedItems[-1]["content"], "test status 0")
@patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
def test_to_ordered_collection(self, *_): def test_to_ordered_collection(self, *_):
"""convert a queryset into an ordered collection object""" """convert a queryset into an ordered collection object"""
self.assertEqual(PAGE_LENGTH, 15) self.assertEqual(PAGE_LENGTH, 15)

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

@ -7,25 +7,25 @@ from bookwyrm.models import base_model
from bookwyrm.settings import DOMAIN from bookwyrm.settings import DOMAIN
# pylint: disable=attribute-defined-outside-init
class BaseModel(TestCase): class BaseModel(TestCase):
"""functionality shared across models""" """functionality shared across models"""
def setUp(self): def setUp(self):
"""shared data""" """shared data"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
"mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse" )
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
class BookWyrmTestModel(base_model.BookWyrmModel): class BookWyrmTestModel(base_model.BookWyrmModel):
"""just making it not abstract""" """just making it not abstract"""

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

@ -1,6 +1,4 @@
""" testing models """ """ testing models """
from unittest.mock import patch
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
@ -14,18 +12,17 @@ class Book(TestCase):
def setUp(self): def setUp(self):
"""we'll need some books""" """we'll need some books"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): self.work = models.Work.objects.create(
self.work = models.Work.objects.create( title="Example Work", remote_id="https://example.com/book/1"
title="Example Work", remote_id="https://example.com/book/1" )
) self.first_edition = models.Edition.objects.create(
self.first_edition = models.Edition.objects.create( title="Example Edition",
title="Example Edition", parent_work=self.work,
parent_work=self.work, )
) self.second_edition = models.Edition.objects.create(
self.second_edition = models.Edition.objects.create( title="Another Example Edition",
title="Another Example Edition", parent_work=self.work,
parent_work=self.work, )
)
def test_remote_id(self): def test_remote_id(self):
"""fanciness with remote/origin ids""" """fanciness with remote/origin ids"""
@ -59,8 +56,7 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): book = models.Edition.objects.create(title="Test Edition")
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"

47
bookwyrm/tests/models/test_federated_server.py
View file

@ -11,30 +11,29 @@ class FederatedServer(TestCase):
def setUp(self): def setUp(self):
"""we'll need a user""" """we'll need a user"""
self.server = models.FederatedServer.objects.create(server_name="test.server") self.server = models.FederatedServer.objects.create(server_name="test.server")
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): 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", "rat@rat.com",
"rat@rat.com", "ratword",
"ratword", federated_server=self.server,
federated_server=self.server, local=False,
local=False, remote_id="https://example.com/users/rat",
remote_id="https://example.com/users/rat", 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.inactive_remote_user = models.User.objects.create_user(
self.inactive_remote_user = models.User.objects.create_user( "nutria",
"nutria", "nutria@nutria.com",
"nutria@nutria.com", "nutriaword",
"nutriaword", federated_server=self.server,
federated_server=self.server, local=False,
local=False, remote_id="https://example.com/users/nutria",
remote_id="https://example.com/users/nutria", inbox="https://example.com/users/nutria/inbox",
inbox="https://example.com/users/nutria/inbox", outbox="https://example.com/users/nutria/outbox",
outbox="https://example.com/users/nutria/outbox", is_active=False,
is_active=False, deactivation_reason="self_deletion",
deactivation_reason="self_deletion", )
)
def test_block_unblock(self): def test_block_unblock(self):
"""block a server and all users on it""" """block a server and all users on it"""

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

@ -188,10 +188,9 @@ 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"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user = User.objects.create_user(
user = User.objects.create_user( "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
"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
@ -249,20 +248,19 @@ 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:
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): unrelated_user = User.objects.create_user(
unrelated_user = User.objects.create_user( "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
"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(
responses.GET, responses.GET,
"https://example.com/user/mouse", "https://example.com/user/mouse",
json=userdata, json=userdata,
status=200, status=200,
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
value = instance.field_from_activity("https://example.com/user/mouse") value = instance.field_from_activity("https://example.com/user/mouse")
self.assertIsInstance(value, User) self.assertIsInstance(value, User)
self.assertNotEqual(value, unrelated_user) self.assertNotEqual(value, unrelated_user)
self.assertEqual(value.remote_id, "https://example.com/user/mouse") self.assertEqual(value.remote_id, "https://example.com/user/mouse")
@ -277,12 +275,11 @@ 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:
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): unrelated_user = User.objects.create_user(
unrelated_user = User.objects.create_user( "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
"rat", "rat@rat.rat", "ratword", local=True, localname="rat" )
) with patch("bookwyrm.models.user.set_remote_server.delay"):
with patch("bookwyrm.models.user.set_remote_server.delay"): value = instance.field_from_activity(activitypub.Person(**userdata))
value = instance.field_from_activity(activitypub.Person(**userdata))
self.assertIsInstance(value, User) self.assertIsInstance(value, User)
self.assertNotEqual(value, unrelated_user) self.assertNotEqual(value, unrelated_user)
self.assertEqual(value.remote_id, "https://example.com/user/mouse") self.assertEqual(value.remote_id, "https://example.com/user/mouse")
@ -294,31 +291,29 @@ 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())
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user = User.objects.create_user(
user = User.objects.create_user( "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" )
) user.remote_id = "https://example.com/user/mouse"
user.remote_id = "https://example.com/user/mouse" user.save(broadcast=False)
user.save(broadcast=False)
User.objects.create_user( User.objects.create_user(
"rat", "rat@rat.rat", "ratword", local=True, localname="rat" "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
) )
with patch("bookwyrm.models.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))
self.assertEqual(value, user) self.assertEqual(value, user)
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)
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user = User.objects.create_user(
user = User.objects.create_user( "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" )
) User.objects.create_user(
User.objects.create_user( "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
"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)
@ -360,11 +355,10 @@ class ActivitypubFields(TestCase):
responses.add( responses.add(
responses.GET, "https://example.com/user/mouse", json=userdata, status=200 responses.GET, "https://example.com/user/mouse", json=userdata, status=200
) )
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
with patch("bookwyrm.models.user.set_remote_server.delay"): value = instance.field_from_activity(
value = instance.field_from_activity( ["https://example.com/user/mouse", "bleh"]
["https://example.com/user/mouse", "bleh"] )
)
self.assertIsInstance(value, list) self.assertIsInstance(value, list)
self.assertEqual(len(value), 1) self.assertEqual(len(value), 1)
self.assertIsInstance(value[0], User) self.assertIsInstance(value[0], User)
@ -396,17 +390,16 @@ 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"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user = User.objects.create_user(
user = User.objects.create_user( "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" )
) 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) user.avatar.save("test.jpg", ContentFile(output.getvalue()))
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(
@ -433,6 +426,15 @@ class ActivitypubFields(TestCase):
self.assertIsInstance(loaded_image, list) self.assertIsInstance(loaded_image, list)
self.assertIsInstance(loaded_image[1], ContentFile) self.assertIsInstance(loaded_image[1], ContentFile)
def test_image_serialize(self):
"""make sure we're creating sensible image paths"""
ValueMock = namedtuple("ValueMock", ("url"))
value_mock = ValueMock("/images/fish.jpg")
result = fields.image_serializer(value_mock, "hello")
self.assertEqual(result.type, "Document")
self.assertEqual(result.url, "https://your.domain.here/images/fish.jpg")
self.assertEqual(result.name, "hello")
def test_datetime_field(self): def test_datetime_field(self):
"""this one is pretty simple, it just has to use isoformat""" """this one is pretty simple, it just has to use isoformat"""
instance = fields.DateTimeField() instance = fields.DateTimeField()

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

@ -59,10 +59,9 @@ 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"] = ""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user = models.User.objects.create_user(
user = models.User.objects.create_user( "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
"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
@ -175,9 +174,6 @@ class ImportJob(TestCase):
with patch( with patch(
"bookwyrm.connectors.openlibrary.Connector." "get_authors_from_data" "bookwyrm.connectors.openlibrary.Connector." "get_authors_from_data"
): ):
with patch( book = self.item_1.get_book_from_isbn()
"bookwyrm.preview_images.generate_edition_preview_image_task.delay"
):
book = self.item_1.get_book_from_isbn()
self.assertEqual(book.title, "Sabriel") self.assertEqual(book.title, "Sabriel")

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

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

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

@ -1,7 +1,6 @@
""" 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
@ -11,16 +10,14 @@ class ReadThrough(TestCase):
def setUp(self): def setUp(self):
"""look, a shelf""" """look, a shelf"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.user = models.User.objects.create_user(
self.user = models.User.objects.create_user( "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" )
)
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): self.work = models.Work.objects.create(title="Example Work")
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

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

@ -10,22 +10,21 @@ class Relationship(TestCase):
def setUp(self): def setUp(self):
"""we need some users for this""" """we need some users for this"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): 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", "rat@rat.com",
"rat@rat.com", "ratword",
"ratword", local=False,
local=False, remote_id="https://example.com/users/rat",
remote_id="https://example.com/users/rat", 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(
"mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
) )
self.local_user.remote_id = "http://local.com/user/mouse" self.local_user = models.User.objects.create_user(
self.local_user.save(broadcast=False) "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)
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,15 +12,11 @@ class Shelf(TestCase):
def setUp(self): def setUp(self):
"""look, a shelf""" """look, a shelf"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" )
) work = models.Work.objects.create(title="Test Work")
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): self.book = models.Edition.objects.create(title="test book", parent_work=work)
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"""

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

@ -22,31 +22,29 @@ class Status(TestCase):
def setUp(self): def setUp(self):
"""useful things for creating a status""" """useful things for creating a status"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
"mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse" )
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): self.book = models.Edition.objects.create(title="Test Edition")
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
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"""
@ -61,10 +59,9 @@ 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
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): models.Review.objects.create(
models.Review.objects.create( content="hey", reply_parent=parent, user=self.local_user, book=self.book
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
) )
@ -96,10 +93,9 @@ 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
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): models.Review.objects.create(
models.Review.objects.create( content="hey", reply_parent=parent, user=self.local_user, book=self.book
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
) )
@ -256,15 +252,14 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): status = models.Review.objects.create(
status = models.Review.objects.create( name="Review name",
name="Review name", content="test content",
content="test content", rating=3.0,
rating=3.0, user=self.local_user,
user=self.local_user, book=self.book,
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)
@ -274,15 +269,14 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): status = models.Review.objects.create(
status = models.Review.objects.create( name="Review's name",
name="Review's name", content="test content",
content="test content", rating=3.0,
rating=3.0, user=self.local_user,
user=self.local_user, book=self.book,
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(
@ -299,14 +293,13 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): status = models.Review.objects.create(
status = models.Review.objects.create( name="Review name",
name="Review name", content="test content",
content="test content", user=self.local_user,
user=self.local_user, book=self.book,
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(
@ -322,13 +315,12 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): status = models.ReviewRating.objects.create(
status = models.ReviewRating.objects.create( rating=3.0,
rating=3.0, user=self.local_user,
user=self.local_user, book=self.book,
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(
@ -357,12 +349,11 @@ class Status(TestCase):
status = models.Status.objects.create( status = models.Status.objects.create(
content="test content", user=self.local_user content="test content", user=self.local_user
) )
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): fav = models.Favorite.objects.create(status=status, user=self.local_user)
fav = models.Favorite.objects.create(status=status, user=self.local_user)
# can't fav a status twice # can't fav a status twice
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
models.Favorite.objects.create(status=status, user=self.local_user) models.Favorite.objects.create(status=status, user=self.local_user)
activity = fav.to_activity() activity = fav.to_activity()
self.assertEqual(activity["type"], "Like") self.assertEqual(activity["type"], "Like")

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

@ -11,16 +11,15 @@ 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):
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.user = models.User.objects.create_user(
self.user = models.User.objects.create_user( "mouse@%s" % DOMAIN,
"mouse@%s" % DOMAIN, "mouse@mouse.mouse",
"mouse@mouse.mouse", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", name="hi",
name="hi", bookwyrm_user=False,
bookwyrm_user=False, )
)
def test_computed_fields(self): def test_computed_fields(self):
"""username instead of id here""" """username instead of id here"""
@ -35,16 +34,15 @@ class User(TestCase):
self.assertIsNotNone(self.user.key_pair.public_key) self.assertIsNotNone(self.user.key_pair.public_key)
def test_remote_user(self): def test_remote_user(self):
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
with patch("bookwyrm.models.user.set_remote_server.delay"): user = models.User.objects.create_user(
user = models.User.objects.create_user( "rat",
"rat", "rat@rat.rat",
"rat@rat.rat", "ratword",
"ratword", local=False,
local=False, remote_id="https://example.com/dfjkg",
remote_id="https://example.com/dfjkg", bookwyrm_user=False,
bookwyrm_user=False, )
)
self.assertEqual(user.username, "rat@example.com") self.assertEqual(user.username, "rat@example.com")
def test_user_shelves(self): def test_user_shelves(self):

42
bookwyrm/tests/test_activitystreams.py
View file

@ -11,29 +11,27 @@ class Activitystreams(TestCase):
def setUp(self): def setUp(self):
"""use a test csv""" """use a test csv"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
"mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse" )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
self.another_user = models.User.objects.create_user( self.book = models.Edition.objects.create(title="test book")
"nutria",
"nutria@nutria.nutria",
"password",
local=True,
localname="nutria",
)
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
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"""

19
bookwyrm/tests/test_emailing.py
View file

@ -3,7 +3,6 @@ from unittest.mock import patch
from django.test import TestCase from django.test import TestCase
from django.test.client import RequestFactory from django.test.client import RequestFactory
import responses
from bookwyrm import emailing, models from bookwyrm import emailing, models
@ -15,16 +14,14 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
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"""

13
bookwyrm/tests/test_postgres.py
View file

@ -6,17 +6,16 @@ from bookwyrm import models
@patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay") @patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
@patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay")
class PostgresTriggers(TestCase): class PostgresTriggers(TestCase):
"""special migrations, fancy stuff ya know""" """special migrations, fancy stuff ya know"""
def test_search_vector_on_create(self, *_): def test_search_vector_on_create(self, _):
"""make sure that search_vector is being set correctly on create""" """make sure that search_vector is being set correctly on create"""
book = models.Edition.objects.create(title="The Long Goodbye") book = models.Edition.objects.create(title="The Long Goodbye")
book.refresh_from_db() book.refresh_from_db()
self.assertEqual(book.search_vector, "'goodby':3A 'long':2A") self.assertEqual(book.search_vector, "'goodby':3A 'long':2A")
def test_search_vector_on_update(self, *_): def test_search_vector_on_update(self, _):
"""make sure that search_vector is being set correctly on edit""" """make sure that search_vector is being set correctly on edit"""
book = models.Edition.objects.create(title="The Long Goodbye") book = models.Edition.objects.create(title="The Long Goodbye")
book.title = "The Even Longer Goodbye" book.title = "The Even Longer Goodbye"
@ -24,7 +23,7 @@ class PostgresTriggers(TestCase):
book.refresh_from_db() book.refresh_from_db()
self.assertEqual(book.search_vector, "'even':2A 'goodby':4A 'longer':3A") self.assertEqual(book.search_vector, "'even':2A 'goodby':4A 'longer':3A")
def test_search_vector_fields(self, *_): def test_search_vector_fields(self, _):
"""use multiple fields to create search vector""" """use multiple fields to create search vector"""
author = models.Author.objects.create(name="The Rays") author = models.Author.objects.create(name="The Rays")
book = models.Edition.objects.create( book = models.Edition.objects.create(
@ -40,7 +39,7 @@ class PostgresTriggers(TestCase):
"'cool':5B 'goodby':3A 'long':2A 'name':9 'rays':7C 'seri':8 'the':6C 'wow':4B", "'cool':5B 'goodby':3A 'long':2A 'name':9 'rays':7C 'seri':8 'the':6C 'wow':4B",
) )
def test_seach_vector_on_author_update(self, *_): def test_seach_vector_on_author_update(self, _):
"""update search when an author name changes""" """update search when an author name changes"""
author = models.Author.objects.create(name="The Rays") author = models.Author.objects.create(name="The Rays")
book = models.Edition.objects.create( book = models.Edition.objects.create(
@ -53,7 +52,7 @@ class PostgresTriggers(TestCase):
self.assertEqual(book.search_vector, "'goodby':3A 'jeremy':4C 'long':2A") self.assertEqual(book.search_vector, "'goodby':3A 'jeremy':4C 'long':2A")
def test_seach_vector_on_author_delete(self, *_): def test_seach_vector_on_author_delete(self, _):
"""update search when an author name changes""" """update search when an author name changes"""
author = models.Author.objects.create(name="Jeremy") author = models.Author.objects.create(name="Jeremy")
book = models.Edition.objects.create( book = models.Edition.objects.create(
@ -68,7 +67,7 @@ class PostgresTriggers(TestCase):
book.refresh_from_db() book.refresh_from_db()
self.assertEqual(book.search_vector, "'goodby':3A 'long':2A") self.assertEqual(book.search_vector, "'goodby':3A 'long':2A")
def test_search_vector_stop_word_fallback(self, *_): def test_search_vector_stop_word_fallback(self, _):
"""use a fallback when removing stop words leads to an empty vector""" """use a fallback when removing stop words leads to an empty vector"""
book = models.Edition.objects.create( book = models.Edition.objects.create(
title="there there", title="there there",

52
bookwyrm/tests/test_preview_images.py
View file

@ -1,6 +1,5 @@
""" test generating preview images """ """ test generating preview images """
import pathlib import pathlib
from unittest.mock import patch
from PIL import Image from PIL import Image
from django.test import TestCase from django.test import TestCase
@ -27,31 +26,32 @@ class PreviewImages(TestCase):
def setUp(self): def setUp(self):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
self.factory = RequestFactory() self.factory = RequestFactory()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): avatar_file = pathlib.Path(__file__).parent.joinpath(
avatar_file = pathlib.Path(__file__).parent.joinpath( "../static/images/no_cover.jpg"
"../static/images/no_cover.jpg" )
) self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "possum@local.com",
"possum@local.com", "possum@possum.possum",
"possum@possum.possum", "password",
"password", local=True,
local=True, localname="possum",
localname="possum", avatar=SimpleUploadedFile(
avatar=SimpleUploadedFile( avatar_file,
avatar_file, open(avatar_file, "rb").read(),
open(avatar_file, "rb").read(), content_type="image/jpeg",
content_type="image/jpeg", ),
), )
)
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): self.work = models.Work.objects.create(title="Test Work")
self.work = models.Work.objects.create(title="Test Work") self.edition = models.Edition.objects.create(
self.edition = models.Edition.objects.create( title="Example Edition",
title="Example Edition", remote_id="https://example.com/book/1",
remote_id="https://example.com/book/1", parent_work=self.work,
parent_work=self.work, )
)
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): self.site = models.SiteSettings.objects.create()
self.site = models.SiteSettings.objects.create()
settings.ENABLE_PREVIEW_IMAGES = True
def test_generate_preview_image(self, *args, **kwargs): def test_generate_preview_image(self, *args, **kwargs):
image_file = pathlib.Path(__file__).parent.joinpath( image_file = pathlib.Path(__file__).parent.joinpath(

64
bookwyrm/tests/test_signing.py
View file

@ -37,20 +37,19 @@ class Signature(TestCase):
def setUp(self): def setUp(self):
"""create users and test data""" """create users and test data"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.mouse = models.User.objects.create_user(
self.mouse = models.User.objects.create_user( "mouse@%s" % DOMAIN,
"mouse@%s" % DOMAIN, "mouse@example.com",
"mouse@example.com", "",
"", local=True,
local=True, localname="mouse",
localname="mouse", )
) self.rat = models.User.objects.create_user(
self.rat = models.User.objects.create_user( "rat@%s" % DOMAIN, "rat@example.com", "", local=True, localname="rat"
"rat@%s" % DOMAIN, "rat@example.com", "", local=True, localname="rat" )
) self.cat = models.User.objects.create_user(
self.cat = models.User.objects.create_user( "cat@%s" % DOMAIN, "cat@example.com", "", local=True, localname="cat"
"cat@%s" % DOMAIN, "cat@example.com", "", local=True, localname="cat" )
)
private_key, public_key = create_key_pair() private_key, public_key = create_key_pair()
@ -58,8 +57,7 @@ class Signature(TestCase):
"http://localhost/user/remote", KeyPair(private_key, public_key) "http://localhost/user/remote", KeyPair(private_key, public_key)
) )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
models.SiteSettings.objects.create()
def send(self, signature, now, data, digest): def send(self, signature, now, data, digest):
"""test request""" """test request"""
@ -119,10 +117,9 @@ class Signature(TestCase):
status=200, status=200,
) )
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.models.user.get_remote_reviews.delay"):
with patch("bookwyrm.models.user.get_remote_reviews.delay"): response = self.send_test_request(sender=self.fake_remote)
response = self.send_test_request(sender=self.fake_remote) self.assertEqual(response.status_code, 200)
self.assertEqual(response.status_code, 200)
@responses.activate @responses.activate
def test_key_needs_refresh(self): def test_key_needs_refresh(self):
@ -143,23 +140,22 @@ class Signature(TestCase):
data["publicKey"]["publicKeyPem"] = key_pair.public_key data["publicKey"]["publicKeyPem"] = key_pair.public_key
responses.add(responses.GET, self.fake_remote.remote_id, json=data, status=200) responses.add(responses.GET, self.fake_remote.remote_id, json=data, status=200)
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.models.user.get_remote_reviews.delay"):
with patch("bookwyrm.models.user.get_remote_reviews.delay"): # Key correct:
# Key correct: response = self.send_test_request(sender=self.fake_remote)
response = self.send_test_request(sender=self.fake_remote) self.assertEqual(response.status_code, 200)
self.assertEqual(response.status_code, 200)
# Old key is cached, so still works: # Old key is cached, so still works:
response = self.send_test_request(sender=self.fake_remote) response = self.send_test_request(sender=self.fake_remote)
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)
# Try with new key: # Try with new key:
response = self.send_test_request(sender=new_sender) response = self.send_test_request(sender=new_sender)
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)
# Now the old key will fail: # Now the old key will fail:
response = self.send_test_request(sender=self.fake_remote) response = self.send_test_request(sender=self.fake_remote)
self.assertEqual(response.status_code, 401) self.assertEqual(response.status_code, 401)
@responses.activate @responses.activate
def test_nonexistent_signer(self): def test_nonexistent_signer(self):

123
bookwyrm/tests/test_templatetags.py
View file

@ -22,30 +22,27 @@ class TemplateTags(TestCase):
def setUp(self): def setUp(self):
"""create some filler objects""" """create some filler objects"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.user = models.User.objects.create_user(
self.user = models.User.objects.create_user( "mouse@example.com",
"mouse@example.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", )
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.rat",
"ratword",
remote_id="http://example.com/rat",
local=False,
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): self.book = models.Edition.objects.create(title="Test Book")
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.rat",
"ratword",
remote_id="http://example.com/rat",
local=False,
)
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.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): models.Review.objects.create(user=self.user, book=self.book, rating=3)
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, *_):
@ -63,30 +60,27 @@ class TemplateTags(TestCase):
utilities.get_user_identifier(self.remote_user), "rat@example.com" utilities.get_user_identifier(self.remote_user), "rat@example.com"
) )
@patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
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"): parent = models.Review.objects.create(
with patch( user=self.user, book=self.book, content="hi"
"bookwyrm.preview_images.generate_edition_preview_image_task.delay" )
): first_child = models.Status.objects.create(
parent = models.Review.objects.create( reply_parent=parent, user=self.user, content="hi"
user=self.user, book=self.book, content="hi" )
) second_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" )
with patch(
"bookwyrm.activitystreams.ActivityStream.remove_object_from_related_stores"
):
third_child = models.Status.objects.create(
reply_parent=parent,
user=self.user,
deleted=True,
deleted_date=timezone.now(),
) )
second_child = models.Status.objects.create(
reply_parent=parent, user=self.user, content="hi"
)
with patch(
"bookwyrm.activitystreams.ActivityStream.remove_object_from_related_stores"
):
third_child = models.Status.objects.create(
reply_parent=parent,
user=self.user,
deleted=True,
deleted_date=timezone.now(),
)
replies = status_display.get_replies(parent) replies = status_display.get_replies(parent)
self.assertEqual(len(replies), 2) self.assertEqual(len(replies), 2)
@ -97,12 +91,9 @@ 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"):
with patch( parent = models.Review.objects.create(
"bookwyrm.preview_images.generate_edition_preview_image_task.delay" user=self.user, book=self.book, content="hi"
): )
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"
) )
@ -113,8 +104,7 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): status = models.Review.objects.create(user=self.remote_user, book=self.book)
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"):
@ -123,8 +113,7 @@ 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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): status = models.Review.objects.create(user=self.remote_user, book=self.book)
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"):
@ -133,34 +122,28 @@ class TemplateTags(TestCase):
def test_get_boosted(self, *_): def test_get_boosted(self, *_):
"""load a boosted status""" """load a boosted status"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): status = models.Review.objects.create(user=self.remote_user, book=self.book)
status = models.Review.objects.create( boost = models.Boost.objects.create(user=self.user, boosted_status=status)
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)
def test_get_book_description(self, *_): def test_get_book_description(self, *_):
"""grab it from the edition or the parent""" """grab it from the edition or the parent"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): work = models.Work.objects.create(title="Test Work")
work = models.Work.objects.create(title="Test Work") self.book.parent_work = work
self.book.parent_work = work self.book.save()
self.book.save()
self.assertIsNone(bookwyrm_tags.get_book_description(self.book)) self.assertIsNone(bookwyrm_tags.get_book_description(self.book))
work.description = "hi" work.description = "hi"
work.save() work.save()
self.assertEqual(bookwyrm_tags.get_book_description(self.book), "hi") self.assertEqual(bookwyrm_tags.get_book_description(self.book), "hi")
self.book.description = "hello" self.book.description = "hello"
self.book.save() self.book.save()
self.assertEqual(bookwyrm_tags.get_book_description(self.book), "hello") self.assertEqual(bookwyrm_tags.get_book_description(self.book), "hello")
def test_get_uuid(self, *_): def test_get_uuid(self, *_):
"""uuid functionality""" """uuid functionality"""

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

@ -19,26 +19,25 @@ class Inbox(TestCase):
self.client = Client() self.client = Client()
self.factory = RequestFactory() self.factory = RequestFactory()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): local_user = models.User.objects.create_user(
local_user = models.User.objects.create_user( "mouse@example.com",
"mouse@example.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", )
local_user.remote_id = "https://example.com/user/mouse"
local_user.save(broadcast=False)
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
local_user.remote_id = "https://example.com/user/mouse"
local_user.save(broadcast=False)
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
self.create_json = { self.create_json = {
"id": "hi", "id": "hi",
"type": "Create", "type": "Create",
@ -47,8 +46,7 @@ class Inbox(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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"""

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

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

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

@ -13,34 +13,33 @@ class InboxActivities(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@example.com",
"mouse@example.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
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.user.set_remote_server.delay"): with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
self.remote_user = models.User.objects.create_user( self.status = models.Status.objects.create(
"rat", user=self.local_user,
"rat@rat.com", content="Test status",
"ratword", remote_id="https://example.com/status/1",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
self.status = models.Status.objects.create(
user=self.local_user,
content="Test status",
remote_id="https://example.com/status/1",
)
self.create_json = { self.create_json = {
"id": "hi", "id": "hi",
@ -50,8 +49,8 @@ class InboxActivities(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
@patch("bookwyrm.activitystreams.ActivityStream.add_status") @patch("bookwyrm.activitystreams.ActivityStream.add_status")
@patch("bookwyrm.activitystreams.ActivityStream.remove_object_from_related_stores") @patch("bookwyrm.activitystreams.ActivityStream.remove_object_from_related_stores")
@ -88,13 +87,12 @@ class InboxActivities(TestCase):
@patch("bookwyrm.activitystreams.ActivityStream.remove_object_from_related_stores") @patch("bookwyrm.activitystreams.ActivityStream.remove_object_from_related_stores")
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"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): work = models.Work.objects.create(title="work title")
work = models.Work.objects.create(title="work title") book = models.Edition.objects.create(
book = models.Edition.objects.create( title="Test",
title="Test", remote_id="https://bookwyrm.social/book/37292",
remote_id="https://bookwyrm.social/book/37292", parent_work=work,
parent_work=work, )
)
self.assertEqual(models.Notification.objects.count(), 0) self.assertEqual(models.Notification.objects.count(), 0)
activity = { activity = {
"type": "Announce", "type": "Announce",

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

@ -12,28 +12,27 @@ class InboxBlock(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@example.com",
"mouse@example.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
self.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.save(broadcast=False) models.SiteSettings.objects.create()
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
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"""

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

@ -10,38 +10,31 @@ from bookwyrm.activitypub import ActivitySerializerError
# pylint: disable=too-many-public-methods # pylint: disable=too-many-public-methods
@patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
class InboxCreate(TestCase): class InboxCreate(TestCase):
"""readthrough tests""" """readthrough tests"""
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@example.com",
"mouse@example.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
self.status = models.Status.objects.create(
user=self.local_user,
content="Test status",
remote_id="https://example.com/status/1",
)
self.create_json = { self.create_json = {
"id": "hi", "id": "hi",
@ -51,22 +44,18 @@ class InboxCreate(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
models.SiteSettings.objects.create()
def test_create_status(self): def test_create_status(self, _):
"""the "it justs works" mode""" """the "it justs works" mode"""
self.assertEqual(models.Status.objects.count(), 1)
datafile = pathlib.Path(__file__).parent.joinpath( datafile = pathlib.Path(__file__).parent.joinpath(
"../../data/ap_quotation.json" "../../data/ap_quotation.json"
) )
status_data = json.loads(datafile.read_bytes()) status_data = json.loads(datafile.read_bytes())
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): models.Edition.objects.create(
models.Edition.objects.create( title="Test Book", remote_id="https://example.com/book/1"
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
@ -81,15 +70,13 @@ class InboxCreate(TestCase):
self.assertEqual(status.quote, "quote body") self.assertEqual(status.quote, "quote body")
self.assertEqual(status.content, "commentary") self.assertEqual(status.content, "commentary")
self.assertEqual(status.user, self.local_user) self.assertEqual(status.user, self.local_user)
self.assertEqual(models.Status.objects.count(), 2)
# while we're here, lets ensure we avoid dupes # while we're here, lets ensure we avoid dupes
views.inbox.activity_task(activity) views.inbox.activity_task(activity)
self.assertEqual(models.Status.objects.count(), 2)
def test_create_status_remote_note_with_mention(self):
"""should only create it under the right circumstances"""
self.assertEqual(models.Status.objects.count(), 1) self.assertEqual(models.Status.objects.count(), 1)
def test_create_status_remote_note_with_mention(self, _):
"""should only create it under the right circumstances"""
self.assertFalse( self.assertFalse(
models.Notification.objects.filter(user=self.local_user).exists() models.Notification.objects.filter(user=self.local_user).exists()
) )
@ -110,15 +97,22 @@ class InboxCreate(TestCase):
) )
self.assertEqual(models.Notification.objects.get().notification_type, "MENTION") self.assertEqual(models.Notification.objects.get().notification_type, "MENTION")
def test_create_status_remote_note_with_reply(self): def test_create_status_remote_note_with_reply(self, _):
"""should only create it under the right circumstances""" """should only create it under the right circumstances"""
with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
parent_status = models.Status.objects.create(
user=self.local_user,
content="Test status",
remote_id="https://example.com/status/1",
)
self.assertEqual(models.Status.objects.count(), 1) self.assertEqual(models.Status.objects.count(), 1)
self.assertFalse(models.Notification.objects.filter(user=self.local_user)) self.assertFalse(models.Notification.objects.filter(user=self.local_user))
datafile = pathlib.Path(__file__).parent.joinpath("../../data/ap_note.json") datafile = pathlib.Path(__file__).parent.joinpath("../../data/ap_note.json")
status_data = json.loads(datafile.read_bytes()) status_data = json.loads(datafile.read_bytes())
del status_data["tag"] del status_data["tag"]
status_data["inReplyTo"] = self.status.remote_id status_data["inReplyTo"] = parent_status.remote_id
activity = self.create_json activity = self.create_json
activity["object"] = status_data activity["object"] = status_data
@ -127,16 +121,15 @@ class InboxCreate(TestCase):
self.assertTrue(redis_mock.called) self.assertTrue(redis_mock.called)
status = models.Status.objects.last() status = models.Status.objects.last()
self.assertEqual(status.content, "test content in note") self.assertEqual(status.content, "test content in note")
self.assertEqual(status.reply_parent, self.status) self.assertEqual(status.reply_parent, parent_status)
self.assertTrue(models.Notification.objects.filter(user=self.local_user)) self.assertTrue(models.Notification.objects.filter(user=self.local_user))
self.assertEqual(models.Notification.objects.get().notification_type, "REPLY") self.assertEqual(models.Notification.objects.get().notification_type, "REPLY")
def test_create_rating(self): def test_create_rating(self, _):
"""a remote rating activity""" """a remote rating activity"""
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): book = models.Edition.objects.create(
book = models.Edition.objects.create( title="Test Book", remote_id="https://example.com/book/1"
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",
@ -149,8 +142,8 @@ class InboxCreate(TestCase):
"id": "https://example.com/user/mouse/reviewrating/12/replies", "id": "https://example.com/user/mouse/reviewrating/12/replies",
"type": "OrderedCollection", "type": "OrderedCollection",
"totalItems": 0, "totalItems": 0,
"first": "https://example.com/user/mouse/reviewrating/12/replies?page=1", "first": "https://example.com/u/mouse/reviewrating/12/replies?page=1",
"last": "https://example.com/user/mouse/reviewrating/12/replies?page=1", "last": "https://example.com/u/mouse/reviewrating/12/replies?page=1",
"@context": "https://www.w3.org/ns/activitystreams", "@context": "https://www.w3.org/ns/activitystreams",
}, },
"inReplyTo": "", "inReplyTo": "",
@ -162,17 +155,14 @@ class InboxCreate(TestCase):
"rating": 3, "rating": 3,
"@context": "https://www.w3.org/ns/activitystreams", "@context": "https://www.w3.org/ns/activitystreams",
} }
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.activitystreams.ActivityStream.add_status") as redis_mock:
with patch( views.inbox.activity_task(activity)
"bookwyrm.activitystreams.ActivityStream.add_status" self.assertTrue(redis_mock.called)
) as redis_mock:
views.inbox.activity_task(activity)
self.assertTrue(redis_mock.called)
rating = models.ReviewRating.objects.first() rating = models.ReviewRating.objects.first()
self.assertEqual(rating.book, book) self.assertEqual(rating.book, book)
self.assertEqual(rating.rating, 3.0) self.assertEqual(rating.rating, 3.0)
def test_create_list(self): def test_create_list(self, _):
"""a new list""" """a new list"""
activity = self.create_json activity = self.create_json
activity["object"] = { activity["object"] = {
@ -196,7 +186,7 @@ class InboxCreate(TestCase):
self.assertEqual(book_list.description, "summary text") self.assertEqual(book_list.description, "summary text")
self.assertEqual(book_list.remote_id, "https://example.com/list/22") self.assertEqual(book_list.remote_id, "https://example.com/list/22")
def test_create_unsupported_type(self): def test_create_unsupported_type(self, _):
"""ignore activities we know we can't handle""" """ignore activities we know we can't handle"""
activity = self.create_json activity = self.create_json
activity["object"] = { activity["object"] = {
@ -206,7 +196,7 @@ class InboxCreate(TestCase):
# just observer how it doesn't throw an error # just observer how it doesn't throw an error
views.inbox.activity_task(activity) views.inbox.activity_task(activity)
def test_create_unknown_type(self): def test_create_unknown_type(self, _):
"""ignore activities we know we've never heard of""" """ignore activities we know we've never heard of"""
activity = self.create_json activity = self.create_json
activity["object"] = { activity["object"] = {

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

@ -13,26 +13,25 @@ class InboxActivities(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@example.com",
"mouse@example.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
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(
user=self.remote_user, user=self.remote_user,
@ -48,8 +47,7 @@ class InboxActivities(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
models.SiteSettings.objects.create()
def test_delete_status(self): def test_delete_status(self):
"""remove a status""" """remove a status"""
@ -119,8 +117,7 @@ class InboxActivities(TestCase):
"object": self.remote_user.remote_id, "object": self.remote_user.remote_id,
} }
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): views.inbox.activity_task(activity)
views.inbox.activity_task(activity)
self.assertFalse(models.User.objects.get(username="rat@example.com").is_active) self.assertFalse(models.User.objects.get(username="rat@example.com").is_active)
def test_delete_user_unknown(self): def test_delete_user_unknown(self):

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

@ -13,29 +13,27 @@ class InboxRelationships(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@example.com",
"mouse@example.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
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"""

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

@ -12,26 +12,25 @@ class InboxActivities(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@example.com",
"mouse@example.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
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"):
@ -50,8 +49,7 @@ class InboxActivities(TestCase):
"object": {}, "object": {},
} }
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
models.SiteSettings.objects.create()
def test_handle_favorite(self): def test_handle_favorite(self):
"""fav a status""" """fav a status"""

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

@ -12,37 +12,34 @@ class InboxRemove(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@example.com",
"mouse@example.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", )
) self.local_user.remote_id = "https://example.com/user/mouse"
self.local_user.remote_id = "https://example.com/user/mouse" self.local_user.save(broadcast=False)
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", "rat@rat.com",
"rat@rat.com", "ratword",
"ratword", local=False,
local=False, remote_id="https://example.com/users/rat",
remote_id="https://example.com/users/rat", 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_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"): self.work = models.Work.objects.create(title="work title")
models.SiteSettings.objects.create() self.book = models.Edition.objects.create(
title="Test",
remote_id="https://bookwyrm.social/book/37292",
parent_work=self.work,
)
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"""

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

@ -14,26 +14,25 @@ class InboxUpdate(TestCase):
def setUp(self): def setUp(self):
"""basic user and book data""" """basic user and book data"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@example.com",
"mouse@example.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
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"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
self.create_json = { self.create_json = {
"id": "hi", "id": "hi",
@ -43,8 +42,8 @@ class InboxUpdate(TestCase):
"cc": ["https://example.com/user/mouse/followers"], "cc": ["https://example.com/user/mouse/followers"],
"object": {}, "object": {},
} }
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
models.SiteSettings.objects.create() models.SiteSettings.objects.create()
def test_update_list(self): def test_update_list(self):
"""a new list""" """a new list"""
@ -99,17 +98,16 @@ class InboxUpdate(TestCase):
self.assertIsNone(self.remote_user.name) self.assertIsNone(self.remote_user.name)
self.assertFalse(self.remote_user.discoverable) self.assertFalse(self.remote_user.discoverable)
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): views.inbox.activity_task(
views.inbox.activity_task( {
{ "type": "Update",
"type": "Update", "to": [],
"to": [], "cc": [],
"cc": [], "actor": "hi",
"actor": "hi", "id": "sdkjf",
"id": "sdkjf", "object": userdata,
"object": userdata, }
} )
)
user = models.User.objects.get(id=self.remote_user.id) user = models.User.objects.get(id=self.remote_user.id)
self.assertEqual(user.name, "RAT???") self.assertEqual(user.name, "RAT???")
self.assertEqual(user.username, "rat@example.com") self.assertEqual(user.username, "rat@example.com")
@ -124,28 +122,27 @@ 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())
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): models.Work.objects.create(
models.Work.objects.create( title="Test Work", remote_id="https://bookwyrm.social/book/5988"
title="Test Work", remote_id="https://bookwyrm.social/book/5988" )
) book = models.Edition.objects.create(
book = models.Edition.objects.create( title="Test Book", remote_id="https://bookwyrm.social/book/5989"
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")
with patch("bookwyrm.activitypub.base_activity.set_related_field.delay"): with patch("bookwyrm.activitypub.base_activity.set_related_field.delay"):
views.inbox.activity_task( views.inbox.activity_task(
{ {
"type": "Update", "type": "Update",
"to": [], "to": [],
"cc": [], "cc": [],
"actor": "hi", "actor": "hi",
"id": "sdkjf", "id": "sdkjf",
"object": bookdata, "object": bookdata,
} }
) )
book = models.Edition.objects.get(id=book.id) book = models.Edition.objects.get(id=book.id)
self.assertEqual(book.title, "Piranesi") self.assertEqual(book.title, "Piranesi")
self.assertEqual(book.last_edited_by, self.remote_user) self.assertEqual(book.last_edited_by, self.remote_user)
@ -155,10 +152,9 @@ 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())
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): book = models.Work.objects.create(
book = models.Work.objects.create( title="Test Book", remote_id="https://bookwyrm.social/book/5988"
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")

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

@ -2,7 +2,6 @@
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
@ -13,16 +12,15 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
)
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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"""

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

@ -19,18 +19,17 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
)
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
self.settings = models.SiteSettings.objects.create(id=1) 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"""
@ -60,9 +59,8 @@ class AuthenticationViews(TestCase):
"email": "aa@bb.cccc", "email": "aa@bb.cccc",
}, },
) )
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.views.authentication.login"):
with patch("bookwyrm.views.authentication.login"): response = view(request)
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()
@ -77,9 +75,8 @@ class AuthenticationViews(TestCase):
"register/", "register/",
{"localname": "nutria ", "password": "mouseword", "email": "aa@bb.ccc"}, {"localname": "nutria ", "password": "mouseword", "email": "aa@bb.ccc"},
) )
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.views.authentication.login"):
with patch("bookwyrm.views.authentication.login"): response = view(request)
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()
@ -157,9 +154,8 @@ class AuthenticationViews(TestCase):
"invite_code": "testcode", "invite_code": "testcode",
}, },
) )
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.views.authentication.login"):
with patch("bookwyrm.views.authentication.login"): response = view(request)
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)

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

@ -17,15 +17,14 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
)
self.group = Group.objects.create(name="editor") self.group = Group.objects.create(name="editor")
self.group.permissions.add( self.group.permissions.add(
Permission.objects.create( Permission.objects.create(
@ -34,15 +33,14 @@ class AuthorViews(TestCase):
content_type=ContentType.objects.get_for_model(models.User), content_type=ContentType.objects.get_for_model(models.User),
).id ).id
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): self.work = models.Work.objects.create(title="Test Work")
self.work = models.Work.objects.create(title="Test Work") self.book = models.Edition.objects.create(
self.book = models.Edition.objects.create( title="Example Edition",
title="Example Edition", remote_id="https://example.com/book/1",
remote_id="https://example.com/book/1", parent_work=self.work,
parent_work=self.work, )
)
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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"""

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

@ -14,26 +14,25 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( models.SiteSettings.objects.create()
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
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"""

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

@ -23,15 +23,14 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
)
self.group = Group.objects.create(name="editor") self.group = Group.objects.create(name="editor")
self.group.permissions.add( self.group.permissions.add(
Permission.objects.create( Permission.objects.create(
@ -40,15 +39,14 @@ class BookViews(TestCase):
content_type=ContentType.objects.get_for_model(models.User), content_type=ContentType.objects.get_for_model(models.User),
).id ).id
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): self.work = models.Work.objects.create(title="Test Work")
self.work = models.Work.objects.create(title="Test Work") self.book = models.Edition.objects.create(
self.book = models.Edition.objects.create( title="Example Edition",
title="Example Edition", remote_id="https://example.com/book/1",
remote_id="https://example.com/book/1", parent_work=self.work,
parent_work=self.work, )
)
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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"""
@ -74,8 +72,7 @@ class BookViews(TestCase):
request = self.factory.get("") request = self.factory.get("")
request.user = self.local_user request.user = self.local_user
request.user.is_superuser = True request.user.is_superuser = True
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): result = view(request, self.book.id)
result = view(request, self.book.id)
self.assertIsInstance(result, TemplateResponse) self.assertIsInstance(result, TemplateResponse)
result.render() result.render()
self.assertEqual(result.status_code, 200) self.assertEqual(result.status_code, 200)
@ -90,9 +87,8 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): view(request, self.book.id)
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")
@ -108,9 +104,8 @@ 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.preview_images.generate_user_preview_image_task.delay"): result = view(request, self.book.id)
result = view(request, self.book.id) result.render()
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()
@ -128,9 +123,8 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): view(request, self.book.id)
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")
@ -150,9 +144,8 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): view(request, self.book.id)
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")
self.assertFalse(self.book.authors.exists()) self.assertFalse(self.book.authors.exists())
@ -167,8 +160,8 @@ 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.preview_images.generate_edition_preview_image_task.delay"): view(request)
view(request)
book = models.Edition.objects.get(title="New Title") book = models.Edition.objects.get(title="New Title")
self.assertEqual(book.parent_work.title, "New Title") self.assertEqual(book.parent_work.title, "New Title")
@ -183,8 +176,8 @@ 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.preview_images.generate_edition_preview_image_task.delay"): view(request)
view(request)
book = models.Edition.objects.get(title="New Title") book = models.Edition.objects.get(title="New Title")
self.assertEqual(book.parent_work, self.work) self.assertEqual(book.parent_work, self.work)
@ -200,8 +193,8 @@ 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.preview_images.generate_edition_preview_image_task.delay"): view(request)
view(request)
book = models.Edition.objects.get(title="New Title") book = models.Edition.objects.get(title="New Title")
self.assertEqual(book.parent_work.title, "New Title") self.assertEqual(book.parent_work.title, "New Title")
self.assertEqual(book.authors.first().name, "Sappho") self.assertEqual(book.authors.first().name, "Sappho")
@ -210,11 +203,8 @@ 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")
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): edition1 = models.Edition.objects.create(title="first 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)
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(
@ -267,12 +257,11 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch(
with patch( "bookwyrm.models.activitypub_mixin.broadcast_task.delay"
"bookwyrm.models.activitypub_mixin.broadcast_task.delay" ) as delay_mock:
) as delay_mock: views.upload_cover(request, self.book.id)
views.upload_cover(request, self.book.id) self.assertEqual(delay_mock.call_count, 1)
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)
@ -300,12 +289,11 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch(
with patch( "bookwyrm.models.activitypub_mixin.broadcast_task.delay"
"bookwyrm.models.activitypub_mixin.broadcast_task.delay" ) as delay_mock:
) as delay_mock: views.upload_cover(request, self.book.id)
views.upload_cover(request, self.book.id) self.assertEqual(delay_mock.call_count, 1)
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)

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

@ -2,7 +2,6 @@
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
@ -13,26 +12,25 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
) self.rat = models.User.objects.create_user(
self.rat = models.User.objects.create_user( "rat@local.com",
"rat@local.com", "rat@rat.com",
"rat@rat.com", "ratword",
"ratword", local=True,
local=True, localname="rat",
localname="rat", remote_id="https://example.com/users/rat",
remote_id="https://example.com/users/rat", discoverable=True,
discoverable=True, )
)
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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"""

61
bookwyrm/tests/views/test_edit_user.py
View file

@ -21,29 +21,26 @@ class EditUserViews(TestCase):
def setUp(self): def setUp(self):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
self.factory = RequestFactory() self.factory = RequestFactory()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
) self.rat = models.User.objects.create_user(
self.rat = models.User.objects.create_user( "rat@local.com", "rat@rat.rat", "password", local=True, localname="rat"
"rat@local.com", "rat@rat.rat", "password", local=True, localname="rat" )
self.book = models.Edition.objects.create(title="test")
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.ShelfBook.objects.create(
book=self.book,
user=self.local_user,
shelf=self.local_user.shelf_set.first(),
) )
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): models.SiteSettings.objects.create()
self.book = models.Edition.objects.create(title="test")
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.ShelfBook.objects.create(
book=self.book,
user=self.local_user,
shelf=self.local_user.shelf_set.first(),
)
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
@ -68,12 +65,11 @@ class EditUserViews(TestCase):
request.user = self.local_user request.user = self.local_user
self.assertIsNone(self.local_user.name) self.assertIsNone(self.local_user.name)
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch(
with patch( "bookwyrm.models.activitypub_mixin.broadcast_task.delay"
"bookwyrm.models.activitypub_mixin.broadcast_task.delay" ) as delay_mock:
) as delay_mock: view(request)
view(request) self.assertEqual(delay_mock.call_count, 1)
self.assertEqual(delay_mock.call_count, 1)
self.assertEqual(self.local_user.name, "New Name") self.assertEqual(self.local_user.name, "New Name")
self.assertEqual(self.local_user.email, "wow@email.com") self.assertEqual(self.local_user.email, "wow@email.com")
@ -93,12 +89,11 @@ class EditUserViews(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.preview_images.generate_user_preview_image_task.delay"): with patch(
with patch( "bookwyrm.models.activitypub_mixin.broadcast_task.delay"
"bookwyrm.models.activitypub_mixin.broadcast_task.delay" ) as delay_mock:
) as delay_mock: view(request)
view(request) self.assertEqual(delay_mock.call_count, 1)
self.assertEqual(delay_mock.call_count, 1)
self.assertEqual(self.local_user.name, "New Name") self.assertEqual(self.local_user.name, "New Name")
self.assertEqual(self.local_user.email, "wow@email.com") self.assertEqual(self.local_user.email, "wow@email.com")
self.assertIsNotNone(self.local_user.avatar) self.assertIsNotNone(self.local_user.avatar)

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

@ -15,26 +15,25 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user( models.SiteSettings.objects.create()
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
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,22 +22,19 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
) self.book = models.Edition.objects.create(
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): parent_work=models.Work.objects.create(title="hi"),
self.book = models.Edition.objects.create( title="Example Edition",
parent_work=models.Work.objects.create(title="hi"), remote_id="https://example.com/book/1",
title="Example Edition", )
remote_id="https://example.com/book/1", models.SiteSettings.objects.create()
)
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"""
@ -92,14 +89,11 @@ 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"):
with patch( status = models.Review.objects.create(
"bookwyrm.preview_images.generate_edition_preview_image_task.delay" content="hi",
): user=self.local_user,
status = models.Review.objects.create( book=self.book,
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"
) )
@ -152,13 +146,12 @@ 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.preview_images.generate_edition_preview_image_task.delay"): 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, user=self.local_user,
user=self.local_user, shelf=self.local_user.shelf_set.get(identifier="reading"),
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)

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

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

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

@ -13,25 +13,22 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
) self.book = models.Edition.objects.create(
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): parent_work=models.Work.objects.create(title="hi"),
self.book = models.Edition.objects.create( title="Example Edition",
parent_work=models.Work.objects.create(title="hi"), remote_id="https://example.com/book/1",
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
) )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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"""
@ -55,12 +52,11 @@ class GetStartedViews(TestCase):
request.user = self.local_user request.user = self.local_user
self.assertIsNone(self.local_user.name) self.assertIsNone(self.local_user.name)
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch(
with patch( "bookwyrm.models.activitypub_mixin.broadcast_task.delay"
"bookwyrm.models.activitypub_mixin.broadcast_task.delay" ) as delay_mock:
) as delay_mock: view(request)
view(request) self.assertEqual(delay_mock.call_count, 1)
self.assertEqual(delay_mock.call_count, 1)
self.assertEqual(self.local_user.name, "New Name") self.assertEqual(self.local_user.name, "New Name")
self.assertTrue(self.local_user.discoverable) self.assertTrue(self.local_user.discoverable)

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

@ -16,32 +16,29 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
) self.rat = models.User.objects.create_user(
self.rat = models.User.objects.create_user( "rat@local.com",
"rat@local.com", "rat@rat.com",
"rat@rat.com", "ratword",
"ratword", local=True,
local=True, localname="rat",
localname="rat", remote_id="https://example.com/users/rat",
remote_id="https://example.com/users/rat", )
) 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.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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"""

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

@ -19,34 +19,32 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, discoverable=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
discoverable=True, discoverable=True,
localname="mouse", inbox="https://example.com/users/rat/inbox",
remote_id="https://example.com/users/mouse", outbox="https://example.com/users/rat/outbox",
)
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@rat.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
discoverable=True,
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
self.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create(
title="Test Book",
remote_id="https://example.com/book/1",
parent_work=self.work,
) )
self.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create(
title="Test Book",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
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())
del self.userdata["icon"] del self.userdata["icon"]
@ -144,11 +142,10 @@ class ViewsHelpers(TestCase):
json=self.userdata, json=self.userdata,
status=200, status=200,
) )
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): with patch("bookwyrm.models.user.set_remote_server.delay"):
with patch("bookwyrm.models.user.set_remote_server.delay"): result = views.helpers.handle_remote_webfinger("@mouse@example.com")
result = views.helpers.handle_remote_webfinger("@mouse@example.com") self.assertIsInstance(result, models.User)
self.assertIsInstance(result, models.User) self.assertEqual(result.username, "mouse@example.com")
self.assertEqual(result.username, "mouse@example.com")
def test_user_on_blocked_server(self, _): def test_user_on_blocked_server(self, _):
"""find a remote user using webfinger""" """find a remote user using webfinger"""
@ -205,22 +202,21 @@ 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"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user_1 = models.User.objects.create_user(
user_1 = models.User.objects.create_user( "nutria@local.com",
"nutria@local.com", "nutria@nutria.com",
"nutria@nutria.com", "nutriaword",
"nutriaword", local=True,
local=True, localname="nutria",
localname="nutria", discoverable=True,
discoverable=True, )
) user_2 = models.User.objects.create_user(
user_2 = models.User.objects.create_user( "fish@local.com",
"fish@local.com", "fish@fish.com",
"fish@fish.com", "fishword",
"fishword", local=True,
local=True, localname="fish",
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)
@ -253,42 +249,39 @@ 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"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user_1 = models.User.objects.create_user(
user_1 = models.User.objects.create_user( "nutria@local.com",
"nutria@local.com", "nutria@nutria.com",
"nutria@nutria.com", "nutriaword",
"nutriaword", local=True,
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="nutria", localname=i,
discoverable=True,
) )
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user.following.add(user_1)
for i in range(3): user.followers.add(self.local_user)
user = models.User.objects.create_user(
"{:d}@local.com".format(i),
"{:d}@nutria.com".format(i),
"password",
local=True,
localname=i,
)
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"):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"): for i in range(3):
for i in range(3): book = models.Edition.objects.create(
book = models.Edition.objects.create( title=i,
title=i, parent_work=models.Work.objects.create(title=i),
parent_work=models.Work.objects.create(title=i), )
) models.ShelfBook.objects.create(
models.ShelfBook.objects.create( user=self.local_user,
user=self.local_user, book=book,
book=book, shelf=self.local_user.shelf_set.first(),
shelf=self.local_user.shelf_set.first(), )
) models.ShelfBook.objects.create(
models.ShelfBook.objects.create( user=user_1, book=book, shelf=user_1.shelf_set.first()
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,16 +14,14 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
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"""

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

@ -15,33 +15,31 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
with patch("bookwyrm.models.user.set_remote_server"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@email.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.models.user.set_remote_server"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@email.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): work = models.Work.objects.create(title="Test Work")
work = models.Work.objects.create(title="Test Work") self.book = models.Edition.objects.create(
self.book = models.Edition.objects.create( title="Example Edition",
title="Example Edition", remote_id="https://example.com/book/1",
remote_id="https://example.com/book/1", parent_work=work,
parent_work=work, )
)
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,16 +16,14 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
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,28 +16,25 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
) self.work = models.Work.objects.create(title="Test Work")
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="Test Book",
self.book = models.Edition.objects.create( isbn_13="1234567890123",
title="Test Book", remote_id="https://example.com/book/1",
isbn_13="1234567890123", parent_work=self.work,
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
) )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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,18 +15,16 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
)
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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"""

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

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

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

@ -15,49 +15,47 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
) self.rat = models.User.objects.create_user(
self.rat = models.User.objects.create_user( "rat@local.com",
"rat@local.com", "rat@rat.com",
"rat@rat.com", "ratword",
"ratword", local=True,
local=True, localname="rat",
localname="rat", remote_id="https://example.com/users/rat",
remote_id="https://example.com/users/rat", )
)
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): work = models.Work.objects.create(title="Work")
work = models.Work.objects.create(title="Work") self.book = models.Edition.objects.create(
self.book = models.Edition.objects.create( title="Example Edition",
title="Example Edition", remote_id="https://example.com/book/1",
remote_id="https://example.com/book/1", parent_work=work,
parent_work=work, )
) work_two = models.Work.objects.create(title="Labori")
work_two = models.Work.objects.create(title="Labori") self.book_two = models.Edition.objects.create(
self.book_two = models.Edition.objects.create( title="Example Edition 2",
title="Example Edition 2", remote_id="https://example.com/book/2",
remote_id="https://example.com/book/2", parent_work=work_two,
parent_work=work_two, )
) work_three = models.Work.objects.create(title="Trabajar")
work_three = models.Work.objects.create(title="Trabajar") self.book_three = models.Edition.objects.create(
self.book_three = models.Edition.objects.create( title="Example Edition 3",
title="Example Edition 3", remote_id="https://example.com/book/3",
remote_id="https://example.com/book/3", parent_work=work_three,
parent_work=work_three, )
) work_four = models.Work.objects.create(title="Travailler")
work_four = models.Work.objects.create(title="Travailler") self.book_four = models.Edition.objects.create(
self.book_four = models.Edition.objects.create( title="Example Edition 4",
title="Example Edition 4", remote_id="https://example.com/book/4",
remote_id="https://example.com/book/4", parent_work=work_four,
parent_work=work_four, )
)
with patch("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(
@ -65,8 +63,7 @@ class ListActionViews(TestCase):
) )
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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,7 +2,6 @@
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
@ -14,16 +13,14 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
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,22 +18,20 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
) 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_outbox(self, _): def test_outbox(self, _):
"""returns user's statuses""" """returns user's statuses"""
@ -81,16 +79,13 @@ 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"):
with patch( models.Review.objects.create(
"bookwyrm.preview_images.generate_edition_preview_image_task.delay" content="look at this",
): name="hi",
models.Review.objects.create( rating=1,
content="look at this", book=self.book,
name="hi", user=self.local_user,
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"})
@ -110,16 +105,13 @@ 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"):
with patch( models.Review.objects.create(
"bookwyrm.preview_images.generate_edition_preview_image_task.delay" name="hi",
): content="look at this",
models.Review.objects.create( user=self.local_user,
name="hi", book=self.book,
content="look at this", privacy="public",
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")
@ -131,16 +123,13 @@ 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"):
with patch( models.Review.objects.create(
"bookwyrm.preview_images.generate_edition_preview_image_task.delay" name="hi",
): content="look at this",
models.Review.objects.create( user=self.local_user,
name="hi", book=self.book,
content="look at this", privacy="public",
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,18 +15,16 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
)
self.anonymous_user = AnonymousUser self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False self.anonymous_user.is_authenticated = False
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create(id=1)
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"""

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

@ -15,32 +15,30 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/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", "rat@rat.com",
"rat@rat.com", "ratword",
"ratword", local=False,
local=False, remote_id="https://example.com/users/rat",
remote_id="https://example.com/users/rat", 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_edition_preview_image_task.delay"):
self.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create(
title="Test Book",
remote_id="https://example.com/book/1",
parent_work=self.work,
) )
self.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create(
title="Test Book",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
def test_start_reading(self, _): def test_start_reading(self, _):
"""begin a book""" """begin a book"""

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

@ -15,17 +15,15 @@ class ReadThrough(TestCase):
"""basic user and book data""" """basic user and book data"""
self.client = Client() self.client = Client()
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): self.work = models.Work.objects.create(title="Example Work")
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
) )
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.user = models.User.objects.create_user(
self.user = models.User.objects.create_user( "cinco", "cinco@example.com", "seissiete", local=True, localname="cinco"
"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,7 +2,6 @@
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
@ -13,23 +12,21 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
) self.rat = models.User.objects.create_user(
self.rat = models.User.objects.create_user( "rat@local.com",
"rat@local.com", "rat@mouse.mouse",
"rat@mouse.mouse", "password",
"password", local=True,
local=True, localname="rat",
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,45 +12,39 @@ class RssFeedView(TestCase):
def setUp(self): def setUp(self):
"""test data""" """test data"""
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): self.site = models.SiteSettings.objects.create()
self.site = models.SiteSettings.objects.create()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.user = models.User.objects.create_user(
self.user = models.User.objects.create_user( "rss_user", "rss@test.rss", "password", local=True
"rss_user", "rss@test.rss", "password", local=True )
)
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): work = models.Work.objects.create(title="Test Work")
work = models.Work.objects.create(title="Test Work") self.book = models.Edition.objects.create(
self.book = models.Edition.objects.create( title="Example Edition",
title="Example Edition", remote_id="https://example.com/book/1",
remote_id="https://example.com/book/1", parent_work=work,
parent_work=work, )
)
with patch("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"):
with patch( self.review = models.Review.objects.create(
"bookwyrm.preview_images.generate_edition_preview_image_task.delay" name="Review name",
): content="test content",
self.review = models.Review.objects.create( rating=3,
name="Review name", user=self.user,
content="test content", book=self.book,
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,27 +19,24 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
) self.work = models.Work.objects.create(title="Test Work")
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="Test Book",
self.book = models.Edition.objects.create( remote_id="https://example.com/book/1",
title="Test Book", parent_work=self.work,
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
) )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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,28 +16,25 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
) self.work = models.Work.objects.create(title="Test Work")
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,
)
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
) )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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"""

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

@ -16,35 +16,32 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.com",
"mouse@mouse.com", "mouseword",
"mouseword", local=True,
local=True, localname="mouse",
localname="mouse", remote_id="https://example.com/users/mouse",
remote_id="https://example.com/users/mouse", )
with patch("bookwyrm.models.user.set_remote_server"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@email.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.models.user.set_remote_server"):
self.remote_user = models.User.objects.create_user(
"rat",
"rat@email.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"): work = models.Work.objects.create(title="Test Work")
work = models.Work.objects.create(title="Test Work") self.book = models.Edition.objects.create(
self.book = models.Edition.objects.create( title="Example Edition",
title="Example Edition", remote_id="https://example.com/book/1",
remote_id="https://example.com/book/1", parent_work=work,
parent_work=work, )
) 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"""
@ -72,10 +69,9 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user = models.User.objects.create_user(
user = models.User.objects.create_user( "rat", "rat@rat.com", "password", local=True
"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
@ -103,14 +99,13 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user = models.User.objects.create_user(
user = models.User.objects.create_user( "rat@%s" % DOMAIN,
"rat@%s" % DOMAIN, "rat@rat.com",
"rat@rat.com", "password",
"password", local=True,
local=True, localname="rat",
localname="rat", )
)
form = forms.CommentForm( form = forms.CommentForm(
{ {
"content": "hi @rat", "content": "hi @rat",
@ -136,10 +131,9 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user = models.User.objects.create_user(
user = models.User.objects.create_user( "rat", "rat@rat.com", "password", local=True, localname="rat"
"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",
@ -204,11 +198,10 @@ 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.preview_images.generate_edition_preview_image_task.delay"): with patch("bookwyrm.activitystreams.ActivityStream.add_status"):
with patch("bookwyrm.activitystreams.ActivityStream.add_status"): status = models.ReviewRating.objects.create(
status = models.ReviewRating.objects.create( book=self.book, rating=2.0, user=self.local_user
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"
@ -242,14 +235,13 @@ 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"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): user = models.User.objects.create_user(
user = models.User.objects.create_user( "nutria@%s" % DOMAIN,
"nutria@%s" % DOMAIN, "nutria@nutria.com",
"nutria@nutria.com", "password",
"password", local=True,
local=True, localname="nutria",
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,17 +14,15 @@ class UpdateViews(TestCase):
def setUp(self): def setUp(self):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.factory = RequestFactory()
self.factory = RequestFactory() self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
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

@ -16,20 +16,18 @@ class UserViews(TestCase):
def setUp(self): def setUp(self):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.factory = RequestFactory()
self.factory = RequestFactory() self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
) self.rat = models.User.objects.create_user(
self.rat = models.User.objects.create_user( "rat@local.com", "rat@rat.rat", "password", local=True, localname="rat"
"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,
@ -37,8 +35,7 @@ class UserViews(TestCase):
shelf=self.local_user.shelf_set.first(), shelf=self.local_user.shelf_set.first(),
) )
with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"): models.SiteSettings.objects.create()
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,16 +14,14 @@ 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()
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
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"""

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

@ -15,30 +15,28 @@ class UserViews(TestCase):
def setUp(self): def setUp(self):
"""we need basic test data and mocks""" """we need basic test data and mocks"""
with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"): self.factory = RequestFactory()
self.factory = RequestFactory() self.local_user = models.User.objects.create_user(
self.local_user = models.User.objects.create_user( "mouse@local.com",
"mouse@local.com", "mouse@mouse.mouse",
"mouse@mouse.mouse", "password",
"password", local=True,
local=True, localname="mouse",
localname="mouse", )
) 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"):
models.User.objects.create_user( models.User.objects.create_user(
"rat@local.com", "rat@rat.rat", "password", local=True, localname="rat" "rat",
"rat@remote.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
) )
with patch("bookwyrm.models.user.set_remote_server.delay"): models.SiteSettings.objects.create()
models.User.objects.create_user(
"rat",
"rat@remote.com",
"ratword",
local=False,
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
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

2
bookwyrm/views/announcements.py
View file

@ -51,7 +51,7 @@ class Announcements(View):
form = forms.AnnouncementForm() form = forms.AnnouncementForm()
data = { data = {
"announcements": Paginator( "announcements": Paginator(
models.Announcement.objects.all(), PAGE_LENGTH models.Announcement.objects.order_by("-created_date"), PAGE_LENGTH
).get_page(request.GET.get("page")), ).get_page(request.GET.get("page")),
"form": form, "form": form,
} }

6
bookwyrm/views/directory.py
View file

@ -32,8 +32,12 @@ class Directory(View):
paginated = Paginator(users, 12) paginated = Paginator(users, 12)
page = paginated.get_page(request.GET.get("page"))
data = { data = {
"users": paginated.get_page(request.GET.get("page")), "page_range": paginated.get_elided_page_range(
page.number, on_each_side=2, on_ends=1
),
"users": page,
} }
return TemplateResponse(request, "directory/directory.html", data) return TemplateResponse(request, "directory/directory.html", data)

8
bookwyrm/views/user.py
View file

@ -88,7 +88,9 @@ class Followers(View):
if is_api_request(request): if is_api_request(request):
return ActivitypubResponse(user.to_followers_activity(**request.GET)) return ActivitypubResponse(user.to_followers_activity(**request.GET))
paginated = Paginator(user.followers.all(), PAGE_LENGTH) paginated = Paginator(
user.followers.order_by("-created_date").all(), PAGE_LENGTH
)
data = { data = {
"user": user, "user": user,
"is_self": request.user.id == user.id, "is_self": request.user.id == user.id,
@ -107,7 +109,9 @@ class Following(View):
if is_api_request(request): if is_api_request(request):
return ActivitypubResponse(user.to_following_activity(**request.GET)) return ActivitypubResponse(user.to_following_activity(**request.GET))
paginated = Paginator(user.following.all(), PAGE_LENGTH) paginated = Paginator(
user.following.order_by("-created_date").all(), PAGE_LENGTH
)
data = { data = {
"user": user, "user": user,
"is_self": request.user.id == user.id, "is_self": request.user.id == user.id,

16
pytest.ini
View file

@ -4,3 +4,19 @@ python_files = tests.py test_*.py *_tests.py
addopts = --cov=bookwyrm --cov-config=.coveragerc addopts = --cov=bookwyrm --cov-config=.coveragerc
markers = markers =
integration: marks tests as requiring external resources (deselect with '-m "not integration"') integration: marks tests as requiring external resources (deselect with '-m "not integration"')
env =
DEBUG = false
DOMAIN = your.domain.here
BOOKWYRM_DATABASE_BACKEND = postgres
MEDIA_ROOT = images/
CELERY_BROKER = ""
REDIS_BROKER_PORT = 6379
FLOWER_PORT = 8888
EMAIL_HOST = "smtp.mailgun.org"
EMAIL_PORT = 587
EMAIL_HOST_USER = ""
EMAIL_HOST_PASSWORD = ""
EMAIL_USE_TLS = true
ENABLE_PREVIEW_IMAGES = false
USE_S3 = false

2
requirements.txt
View file

@ -24,3 +24,5 @@ coverage==5.1
pytest-django==4.1.0 pytest-django==4.1.0
pytest==6.1.2 pytest==6.1.2
pytest-cov==2.10.1 pytest-cov==2.10.1
pytest-env==0.6.2
pytest-xdist==2.3.0