Merge branch 'production' into nix

.env.dev.example

@@ -2,7 +2,8 @@
 SECRET_KEY="7(2w1sedok=aznpq)ta1mc4i%4h=xx@hxwx*o57ctsuml0x%fr"
 
 # SECURITY WARNING: don't run with debug turned on in production!
-DEBUG=false
+DEBUG=true
+USE_HTTPS=false
 
 DOMAIN=your.domain.here
 #EMAIL=your@email.here
@@ -42,6 +43,21 @@ EMAIL_HOST_PASSWORD=emailpassword123
 EMAIL_USE_TLS=true
 EMAIL_USE_SSL=false
 
+# S3 configuration
+USE_S3=false
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+
+# Commented are example values if you use a non-AWS, S3-compatible service
+# AWS S3 should work with only AWS_STORAGE_BUCKET_NAME and AWS_S3_REGION_NAME
+# non-AWS S3-compatible services will need AWS_STORAGE_BUCKET_NAME,
+# along with both AWS_S3_CUSTOM_DOMAIN and AWS_S3_ENDPOINT_URL
+
+# AWS_STORAGE_BUCKET_NAME=        # "example-bucket-name"
+# AWS_S3_CUSTOM_DOMAIN=None       # "example-bucket-name.s3.fr-par.scw.cloud"
+# AWS_S3_REGION_NAME=None         # "fr-par"
+# AWS_S3_ENDPOINT_URL=None        # "https://s3.fr-par.scw.cloud"
+
 # Preview image generation can be computing and storage intensive
 # ENABLE_PREVIEW_IMAGES=True
 

.env.prod.example

@@ -3,6 +3,7 @@ SECRET_KEY="7(2w1sedok=aznpq)ta1mc4i%4h=xx@hxwx*o57ctsuml0x%fr"
 
 # SECURITY WARNING: don't run with debug turned on in production!
 DEBUG=false
+USE_HTTPS=true
 
 DOMAIN=your.domain.here
 EMAIL=your@email.here
@@ -42,6 +43,21 @@ EMAIL_HOST_PASSWORD=emailpassword123
 EMAIL_USE_TLS=true
 EMAIL_USE_SSL=false
 
+# S3 configuration
+USE_S3=false
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+
+# Commented are example values if you use a non-AWS, S3-compatible service
+# AWS S3 should work with only AWS_STORAGE_BUCKET_NAME and AWS_S3_REGION_NAME
+# non-AWS S3-compatible services will need AWS_STORAGE_BUCKET_NAME,
+# along with both AWS_S3_CUSTOM_DOMAIN and AWS_S3_ENDPOINT_URL
+
+# AWS_STORAGE_BUCKET_NAME=        # "example-bucket-name"
+# AWS_S3_CUSTOM_DOMAIN=None       # "example-bucket-name.s3.fr-par.scw.cloud"
+# AWS_S3_REGION_NAME=None         # "fr-par"
+# AWS_S3_ENDPOINT_URL=None        # "https://s3.fr-par.scw.cloud"
+
 # Preview image generation can be computing and storage intensive
 # ENABLE_PREVIEW_IMAGES=True
 

.github/workflows/black.yml

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

.github/workflows/django-tests.yml

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

.github/workflows/pylint.yml

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

bookwyrm/activitypub/base_activity.py

@@ -106,6 +106,7 @@ class ActivityObject:
                 value = field.default
             setattr(self, field.name, value)
 
+    # pylint: disable=too-many-locals,too-many-branches
     def to_model(self, model=None, instance=None, allow_create=True, save=True):
         """convert from an activity to a model instance"""
         model = model or get_model_from_type(self.type)
@@ -126,27 +127,36 @@ class ActivityObject:
             return None
         instance = instance or model()
 
+        # keep track of what we've changed
+        update_fields = []
         for field in instance.simple_fields:
             try:
-                field.set_field_from_activity(instance, self)
+                changed = field.set_field_from_activity(instance, self)
+                if changed:
+                    update_fields.append(field.name)
             except AttributeError as e:
                 raise ActivitySerializerError(e)
 
         # image fields have to be set after other fields because they can save
         # too early and jank up users
         for field in instance.image_fields:
-            field.set_field_from_activity(instance, self, save=save)
+            changed = field.set_field_from_activity(instance, self, save=save)
+            if changed:
+                update_fields.append(field.name)
 
         if not save:
             return instance
 
         with transaction.atomic():
+            # can't force an update on fields unless the object already exists in the db
+            if not instance.id:
+                update_fields = None
             # we can't set many to many and reverse fields on an unsaved object
             try:
                 try:
-                    instance.save(broadcast=False)
+                    instance.save(broadcast=False, update_fields=update_fields)
                 except TypeError:
-                    instance.save()
+                    instance.save(update_fields=update_fields)
             except IntegrityError as e:
                 raise ActivitySerializerError(e)
 

bookwyrm/activitystreams.py

@@ -4,11 +4,12 @@ from django.db.models import signals, Q
 
 from bookwyrm import models
 from bookwyrm.redis_store import RedisStore, r
+from bookwyrm.settings import STREAMS
 from bookwyrm.views.helpers import privacy_filter
 
 
 class ActivityStream(RedisStore):
-    """a category of activity stream (like home, local, federated)"""
+    """a category of activity stream (like home, local, books)"""
 
     def stream_id(self, user):
         """the redis key for this user's instance of this stream"""
@@ -155,29 +156,94 @@ class LocalStream(ActivityStream):
         )
 
 
-class FederatedStream(ActivityStream):
-    """users you follow"""
+class BooksStream(ActivityStream):
+    """books on your shelves"""
 
-    key = "federated"
+    key = "books"
 
     def get_audience(self, status):
-        # this stream wants no part in non-public statuses
-        if status.privacy != "public":
+        """anyone with the mentioned book on their shelves"""
+        # only show public statuses on the books feed,
+        # and only statuses that mention books
+        if status.privacy != "public" or not (
+            status.mention_books.exists() or hasattr(status, "book")
+        ):
             return []
-        return super().get_audience(status)
+
+        work = (
+            status.book.parent_work
+            if hasattr(status, "book")
+            else status.mention_books.first().parent_work
+        )
+
+        audience = super().get_audience(status)
+        if not audience:
+            return []
+        return audience.filter(shelfbook__book__parent_work=work).distinct()
 
     def get_statuses_for_user(self, user):
+        """any public status that mentions the user's books"""
+        books = user.shelfbook_set.values_list(
+            "book__parent_work__id", flat=True
+        ).distinct()
         return privacy_filter(
             user,
-            models.Status.objects.select_subclasses(),
+            models.Status.objects.select_subclasses()
+            .filter(
+                Q(comment__book__parent_work__id__in=books)
+                | Q(quotation__book__parent_work__id__in=books)
+                | Q(review__book__parent_work__id__in=books)
+                | Q(mention_books__parent_work__id__in=books)
+            )
+            .distinct(),
             privacy_levels=["public"],
         )
 
+    def add_book_statuses(self, user, book):
+        """add statuses about a book to a user's feed"""
+        work = book.parent_work
+        statuses = privacy_filter(
+            user,
+            models.Status.objects.select_subclasses()
+            .filter(
+                Q(comment__book__parent_work=work)
+                | Q(quotation__book__parent_work=work)
+                | Q(review__book__parent_work=work)
+                | Q(mention_books__parent_work=work)
+            )
+            .distinct(),
+            privacy_levels=["public"],
+        )
+        self.bulk_add_objects_to_store(statuses, self.stream_id(user))
 
+    def remove_book_statuses(self, user, book):
+        """add statuses about a book to a user's feed"""
+        work = book.parent_work
+        statuses = privacy_filter(
+            user,
+            models.Status.objects.select_subclasses()
+            .filter(
+                Q(comment__book__parent_work=work)
+                | Q(quotation__book__parent_work=work)
+                | Q(review__book__parent_work=work)
+                | Q(mention_books__parent_work=work)
+            )
+            .distinct(),
+            privacy_levels=["public"],
+        )
+        self.bulk_remove_objects_from_store(statuses, self.stream_id(user))
+
+
+# determine which streams are enabled in settings.py
+available_streams = [s["key"] for s in STREAMS]
 streams = {
-    "home": HomeStream(),
-    "local": LocalStream(),
-    "federated": FederatedStream(),
+    k: v
+    for (k, v) in {
+        "home": HomeStream(),
+        "local": LocalStream(),
+        "books": BooksStream(),
+    }.items()
+    if k in available_streams
 }
 
 
@@ -197,7 +263,6 @@ def add_status_on_create(sender, instance, created, *args, **kwargs):
     if not created:
         return
 
-    # iterates through Home, Local, Federated
     for stream in streams.values():
         stream.add_status(instance)
 
@@ -264,7 +329,7 @@ def remove_statuses_on_block(sender, instance, *args, **kwargs):
 # pylint: disable=unused-argument
 def add_statuses_on_unblock(sender, instance, *args, **kwargs):
     """remove statuses from all feeds on block"""
-    public_streams = [LocalStream(), FederatedStream()]
+    public_streams = [v for (k, v) in streams.items() if k != "home"]
     # add statuses back to streams with statuses from anyone
     if instance.user_subject.local:
         for stream in public_streams:
@@ -285,3 +350,33 @@ def populate_streams_on_account_create(sender, instance, created, *args, **kwarg
 
     for stream in streams.values():
         stream.populate_streams(instance)
+
+
+@receiver(signals.pre_save, sender=models.ShelfBook)
+# pylint: disable=unused-argument
+def add_statuses_on_shelve(sender, instance, *args, **kwargs):
+    """update books stream when user shelves a book"""
+    if not instance.user.local:
+        return
+    # check if the book is already on the user's shelves
+    if models.ShelfBook.objects.filter(
+        user=instance.user, book__in=instance.book.parent_work.editions.all()
+    ).exists():
+        return
+
+    BooksStream().add_book_statuses(instance.user, instance.book)
+
+
+@receiver(signals.post_delete, sender=models.ShelfBook)
+# pylint: disable=unused-argument
+def remove_statuses_on_shelve(sender, instance, *args, **kwargs):
+    """update books stream when user unshelves a book"""
+    if not instance.user.local:
+        return
+    # check if the book is actually unshelved, not just moved
+    if models.ShelfBook.objects.filter(
+        user=instance.user, book__in=instance.book.parent_work.editions.all()
+    ).exists():
+        return
+
+    BooksStream().remove_book_statuses(instance.user, instance.book)

bookwyrm/context_processors.py

@@ -11,10 +11,7 @@ def site_settings(request):  # pylint: disable=unused-argument
     return {
         "site": models.SiteSettings.objects.get(),
         "active_announcements": models.Announcement.active_announcements(),
-        "static_url": settings.STATIC_URL,
-        "media_url": settings.MEDIA_URL,
-        "static_path": settings.STATIC_PATH,
-        "media_path": settings.MEDIA_PATH,
+        "media_full_url": settings.MEDIA_FULL_URL,
         "preview_images_enabled": settings.ENABLE_PREVIEW_IMAGES,
         "request_protocol": request_protocol,
     }

bookwyrm/emailing.py

@@ -23,6 +23,14 @@ def email_data():
     }
 
 
+def email_confirmation_email(user):
+    """newly registered users confirm email address"""
+    data = email_data()
+    data["confirmation_code"] = user.confirmation_code
+    data["confirmation_link"] = user.confirmation_link
+    send_email.delay(user.email, *format_email("confirm", data))
+
+
 def invite_email(invite_request):
     """send out an invite code"""
     data = email_data()

bookwyrm/forms.py

@@ -132,6 +132,7 @@ class EditUserForm(CustomForm):
             "summary",
             "show_goal",
             "manually_approves_followers",
+            "default_post_privacy",
             "discoverable",
             "preferred_timezone",
         ]

bookwyrm/importers/importer.py

@@ -2,6 +2,8 @@
 import csv
 import logging
 
+from django.utils import timezone
+
 from bookwyrm import models
 from bookwyrm.models import ImportJob, ImportItem
 from bookwyrm.tasks import app
@@ -100,7 +102,10 @@ def handle_imported_book(source, user, item, include_reviews, privacy):
     # shelve the book if it hasn't been shelved already
     if item.shelf and not existing_shelf:
         desired_shelf = models.Shelf.objects.get(identifier=item.shelf, user=user)
-        models.ShelfBook.objects.create(book=item.book, shelf=desired_shelf, user=user)
+        shelved_date = item.date_added or timezone.now()
+        models.ShelfBook.objects.create(
+            book=item.book, shelf=desired_shelf, user=user, shelved_date=shelved_date
+        )
 
     for read in item.reads:
         # check for an existing readthrough with the same dates

bookwyrm/management/commands/populate_streams.py

@@ -1,16 +1,6 @@
 """ Re-create user streams """
 from django.core.management.base import BaseCommand
-import redis
-
-from bookwyrm import activitystreams, models, settings
-
-r = redis.Redis(
-    host=settings.REDIS_ACTIVITY_HOST,
-    port=settings.REDIS_ACTIVITY_PORT,
-    password=settings.REDIS_ACTIVITY_PASSWORD,
-    unix_socket_path=settings.REDIS_ACTIVITY_SOCKET,
-    db=0,
-)
+from bookwyrm import activitystreams, models
 
 
 def populate_streams():

bookwyrm/management/commands/populate_suggestions.py

@@ -0,0 +1,25 @@
+""" Populate suggested users """
+from django.core.management.base import BaseCommand
+
+from bookwyrm import models
+from bookwyrm.suggested_users import rerank_suggestions_task
+
+
+def populate_suggestions():
+    """build all the streams for all the users"""
+    users = models.User.objects.filter(
+        local=True,
+        is_active=True,
+    ).values_list("id", flat=True)
+    for user in users:
+        rerank_suggestions_task.delay(user)
+
+
+class Command(BaseCommand):
+    """start all over with user suggestions"""
+
+    help = "Populate suggested users for all users"
+    # pylint: disable=no-self-use,unused-argument
+    def handle(self, *args, **options):
+        """run builder"""
+        populate_suggestions()

bookwyrm/migrations/0046_user_default_post_privacy.py

@@ -0,0 +1,27 @@
+# Generated by Django 3.0.7 on 2021-02-14 00:39
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookwyrm", "0045_auto_20210210_2114"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="user",
+            name="default_post_privacy",
+            field=models.CharField(
+                choices=[
+                    ("public", "Public"),
+                    ("unlisted", "Unlisted"),
+                    ("followers", "Followers"),
+                    ("direct", "Direct"),
+                ],
+                default="public",
+                max_length=255,
+            ),
+        ),
+    ]

bookwyrm/migrations/0078_add_shelved_date.py

@@ -0,0 +1,34 @@
+# Generated by Django 3.2.4 on 2021-07-03 08:25
+
+from django.db import migrations, models
+import django.utils.timezone
+
+
+def copy_created_date(app_registry, schema_editor):
+    db_alias = schema_editor.connection.alias
+    ShelfBook = app_registry.get_model("bookwyrm", "ShelfBook")
+    ShelfBook.objects.all().update(shelved_date=models.F("created_date"))
+
+
+def do_nothing(app_registry, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookwyrm", "0077_auto_20210623_2155"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="shelfbook",
+            options={"ordering": ("-shelved_date",)},
+        ),
+        migrations.AddField(
+            model_name="shelfbook",
+            name="shelved_date",
+            field=models.DateTimeField(default=django.utils.timezone.now),
+        ),
+        migrations.RunPython(copy_created_date, reverse_code=do_nothing),
+    ]

bookwyrm/migrations/0079_merge_20210804_1746.py

@@ -0,0 +1,13 @@
+# Generated by Django 3.2.4 on 2021-08-04 17:46
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookwyrm", "0046_user_default_post_privacy"),
+        ("bookwyrm", "0078_add_shelved_date"),
+    ]
+
+    operations = []

bookwyrm/migrations/0080_alter_shelfbook_options.py

@@ -0,0 +1,17 @@
+# Generated by Django 3.2.4 on 2021-08-05 00:00
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookwyrm", "0079_merge_20210804_1746"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="shelfbook",
+            options={"ordering": ("-shelved_date", "-created_date", "-updated_date")},
+        ),
+    ]

bookwyrm/migrations/0081_alter_user_last_active_date.py

@@ -0,0 +1,19 @@
+# Generated by Django 3.2.4 on 2021-08-06 02:51
+
+from django.db import migrations, models
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookwyrm", "0080_alter_shelfbook_options"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="user",
+            name="last_active_date",
+            field=models.DateTimeField(default=django.utils.timezone.now),
+        ),
+    ]

bookwyrm/migrations/0082_auto_20210806_2324.py

@@ -0,0 +1,56 @@
+# Generated by Django 3.2.4 on 2021-08-06 23:24
+
+import bookwyrm.models.base_model
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookwyrm", "0081_alter_user_last_active_date"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="sitesettings",
+            name="require_confirm_email",
+            field=models.BooleanField(default=True),
+        ),
+        migrations.AddField(
+            model_name="user",
+            name="confirmation_code",
+            field=models.CharField(
+                default=bookwyrm.models.base_model.new_access_code, max_length=32
+            ),
+        ),
+        migrations.AlterField(
+            model_name="connector",
+            name="deactivation_reason",
+            field=models.CharField(
+                blank=True,
+                choices=[
+                    ("pending", "Pending"),
+                    ("self_deletion", "Self Deletion"),
+                    ("moderator_deletion", "Moderator Deletion"),
+                    ("domain_block", "Domain Block"),
+                ],
+                max_length=255,
+                null=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="user",
+            name="deactivation_reason",
+            field=models.CharField(
+                blank=True,
+                choices=[
+                    ("pending", "Pending"),
+                    ("self_deletion", "Self Deletion"),
+                    ("moderator_deletion", "Moderator Deletion"),
+                    ("domain_block", "Domain Block"),
+                ],
+                max_length=255,
+                null=True,
+            ),
+        ),
+    ]

bookwyrm/models/base_model.py

@@ -1,4 +1,6 @@
 """ base model with default fields """
+import base64
+from Crypto import Random
 from django.db import models
 from django.dispatch import receiver
 
@@ -9,6 +11,7 @@ from .fields import RemoteIdField
 DeactivationReason = models.TextChoices(
     "DeactivationReason",
     [
+        "pending",
         "self_deletion",
         "moderator_deletion",
         "domain_block",
@@ -16,6 +19,11 @@ DeactivationReason = models.TextChoices(
 )
 
 
+def new_access_code():
+    """the identifier for a user invite"""
+    return base64.b32encode(Random.get_random_bytes(5)).decode("ascii")
+
+
 class BookWyrmModel(models.Model):
     """shared fields"""
 

bookwyrm/models/favorite.py

@@ -30,7 +30,7 @@ class Favorite(ActivityMixin, BookWyrmModel):
     def save(self, *args, **kwargs):
         """update user active time"""
         self.user.last_active_date = timezone.now()
-        self.user.save(broadcast=False)
+        self.user.save(broadcast=False, update_fields=["last_active_date"])
         super().save(*args, **kwargs)
 
         if self.status.user.local and self.status.user != self.user:

bookwyrm/models/fields.py

@@ -13,6 +13,7 @@ from django.db import models
 from django.forms import ClearableFileInput, ImageField as DjangoImageField
 from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
+
 from bookwyrm import activitypub
 from bookwyrm.connectors import get_image
 from bookwyrm.sanitize_html import InputHtmlParser
@@ -66,7 +67,7 @@ class ActivitypubFieldMixin:
         super().__init__(*args, **kwargs)
 
     def set_field_from_activity(self, instance, data):
-        """helper function for assinging a value to the field"""
+        """helper function for assinging a value to the field. Returns if changed"""
         try:
             value = getattr(data, self.get_activitypub_field())
         except AttributeError:
@@ -76,8 +77,14 @@ class ActivitypubFieldMixin:
             value = getattr(data, "actor")
         formatted = self.field_from_activity(value)
         if formatted is None or formatted is MISSING or formatted == {}:
-            return
+            return False
+
+        # the field is unchanged
+        if hasattr(instance, self.name) and getattr(instance, self.name) == formatted:
+            return False
+
         setattr(instance, self.name, formatted)
+        return True
 
     def set_activity_from_field(self, activity, instance):
         """update the json object"""
@@ -204,6 +211,7 @@ class PrivacyField(ActivitypubFieldMixin, models.CharField):
 
     # pylint: disable=invalid-name
     def set_field_from_activity(self, instance, data):
+        original = getattr(instance, self.name)
         to = data.to
         cc = data.cc
         if to == [self.public]:
@@ -214,6 +222,7 @@ class PrivacyField(ActivitypubFieldMixin, models.CharField):
             setattr(instance, self.name, "unlisted")
         else:
             setattr(instance, self.name, "followers")
+        return original == getattr(instance, self.name)
 
     def set_activity_from_field(self, activity, instance):
         # explicitly to anyone mentioned (statuses only)
@@ -269,9 +278,10 @@ class ManyToManyField(ActivitypubFieldMixin, models.ManyToManyField):
         value = getattr(data, self.get_activitypub_field())
         formatted = self.field_from_activity(value)
         if formatted is None or formatted is MISSING:
-            return
+            return False
         getattr(instance, self.name).set(formatted)
         instance.save(broadcast=False)
+        return True
 
     def field_to_activity(self, value):
         if self.link_only:
@@ -354,7 +364,8 @@ def image_serializer(value, alt):
         url = value.url
     else:
         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)
 
 
@@ -371,8 +382,10 @@ class ImageField(ActivitypubFieldMixin, models.ImageField):
         value = getattr(data, self.get_activitypub_field())
         formatted = self.field_from_activity(value)
         if formatted is None or formatted is MISSING:
-            return
+            return False
+
         getattr(instance, self.name).save(*formatted, save=save)
+        return True
 
     def set_activity_from_field(self, activity, instance):
         value = getattr(instance, self.name)

bookwyrm/models/readthrough.py

@@ -30,7 +30,7 @@ class ReadThrough(BookWyrmModel):
     def save(self, *args, **kwargs):
         """update user active time"""
         self.user.last_active_date = timezone.now()
-        self.user.save(broadcast=False)
+        self.user.save(broadcast=False, update_fields=["last_active_date"])
         super().save(*args, **kwargs)
 
     def create_update(self):
@@ -55,5 +55,5 @@ class ProgressUpdate(BookWyrmModel):
     def save(self, *args, **kwargs):
         """update user active time"""
         self.user.last_active_date = timezone.now()
-        self.user.save(broadcast=False)
+        self.user.save(broadcast=False, update_fields=["last_active_date"])
         super().save(*args, **kwargs)

bookwyrm/models/shelf.py

@@ -1,6 +1,7 @@
 """ puttin' books on shelves """
 import re
 from django.db import models
+from django.utils import timezone
 
 from bookwyrm import activitypub
 from .activitypub_mixin import CollectionItemMixin, OrderedCollectionMixin
@@ -69,6 +70,7 @@ class ShelfBook(CollectionItemMixin, BookWyrmModel):
         "Edition", on_delete=models.PROTECT, activitypub_field="book"
     )
     shelf = models.ForeignKey("Shelf", on_delete=models.PROTECT)
+    shelved_date = models.DateTimeField(default=timezone.now)
     user = fields.ForeignKey(
         "User", on_delete=models.PROTECT, activitypub_field="actor"
     )
@@ -86,4 +88,4 @@ class ShelfBook(CollectionItemMixin, BookWyrmModel):
         you can't put a book on shelf twice"""
 
         unique_together = ("book", "shelf")
-        ordering = ("-created_date",)
+        ordering = ("-shelved_date", "-created_date", "-updated_date")

bookwyrm/models/site.py

@@ -1,8 +1,6 @@
 """ the particulars for this instance of BookWyrm """
-import base64
 import datetime
 
-from Crypto import Random
 from django.db import models, IntegrityError
 from django.dispatch import receiver
 from django.utils import timezone
@@ -10,7 +8,7 @@ from model_utils import FieldTracker
 
 from bookwyrm.preview_images import generate_site_preview_image_task
 from bookwyrm.settings import DOMAIN, ENABLE_PREVIEW_IMAGES
-from .base_model import BookWyrmModel
+from .base_model import BookWyrmModel, new_access_code
 from .user import User
 
 
@@ -33,6 +31,7 @@ class SiteSettings(models.Model):
     # registration
     allow_registration = models.BooleanField(default=True)
     allow_invite_requests = models.BooleanField(default=True)
+    require_confirm_email = models.BooleanField(default=True)
 
     # images
     logo = models.ImageField(upload_to="logos/", null=True, blank=True)
@@ -61,11 +60,6 @@ class SiteSettings(models.Model):
             return default_settings
 
 
-def new_access_code():
-    """the identifier for a user invite"""
-    return base64.b32encode(Random.get_random_bytes(5)).decode("ascii")
-
-
 class SiteInvite(models.Model):
     """gives someone access to create an account on the instance"""
 

bookwyrm/models/user.py

@@ -7,7 +7,7 @@ from django.contrib.auth.models import AbstractUser, Group
 from django.contrib.postgres.fields import CICharField
 from django.core.validators import MinValueValidator
 from django.dispatch import receiver
-from django.db import models
+from django.db import models, transaction
 from django.utils import timezone
 from model_utils import FieldTracker
 import pytz
@@ -17,16 +17,22 @@ from bookwyrm.connectors import get_data, ConnectorException
 from bookwyrm.models.shelf import Shelf
 from bookwyrm.models.status import Status, Review
 from bookwyrm.preview_images import generate_user_preview_image_task
-from bookwyrm.settings import DOMAIN, ENABLE_PREVIEW_IMAGES
+from bookwyrm.settings import DOMAIN, ENABLE_PREVIEW_IMAGES, USE_HTTPS
 from bookwyrm.signatures import create_key_pair
 from bookwyrm.tasks import app
 from bookwyrm.utils import regex
 from .activitypub_mixin import OrderedCollectionPageMixin, ActivitypubMixin
-from .base_model import BookWyrmModel, DeactivationReason
+from .base_model import BookWyrmModel, DeactivationReason, new_access_code
 from .federated_server import FederatedServer
 from . import fields, Review
 
 
+def site_link():
+    """helper for generating links to the site"""
+    protocol = "https" if USE_HTTPS else "http"
+    return f"{protocol}://{DOMAIN}"
+
+
 class User(OrderedCollectionPageMixin, AbstractUser):
     """a user who wants to read books"""
 
@@ -105,10 +111,13 @@ class User(OrderedCollectionPageMixin, AbstractUser):
         through_fields=("user", "status"),
         related_name="favorite_statuses",
     )
+    default_post_privacy = models.CharField(
+        max_length=255, default="public", choices=fields.PrivacyLevels.choices
+    )
     remote_id = fields.RemoteIdField(null=True, unique=True, activitypub_field="id")
     created_date = models.DateTimeField(auto_now_add=True)
     updated_date = models.DateTimeField(auto_now=True)
-    last_active_date = models.DateTimeField(auto_now=True)
+    last_active_date = models.DateTimeField(default=timezone.now)
     manually_approves_followers = fields.BooleanField(default=False)
     show_goal = models.BooleanField(default=True)
     discoverable = fields.BooleanField(default=False)
@@ -120,11 +129,18 @@ class User(OrderedCollectionPageMixin, AbstractUser):
     deactivation_reason = models.CharField(
         max_length=255, choices=DeactivationReason.choices, null=True, blank=True
     )
+    confirmation_code = models.CharField(max_length=32, default=new_access_code)
 
     name_field = "username"
     property_fields = [("following_link", "following")]
     field_tracker = FieldTracker(fields=["name", "avatar"])
 
+    @property
+    def confirmation_link(self):
+        """helper for generating confirmation links"""
+        link = site_link()
+        return f"{link}/confirm-email/{self.confirmation_code}"
+
     @property
     def following_link(self):
         """just how to find out the following info"""
@@ -204,7 +220,7 @@ class User(OrderedCollectionPageMixin, AbstractUser):
             self.following.order_by("-updated_date").all(),
             remote_id=remote_id,
             id_only=True,
-            **kwargs
+            **kwargs,
         )
 
     def to_followers_activity(self, **kwargs):
@@ -214,7 +230,7 @@ class User(OrderedCollectionPageMixin, AbstractUser):
             self.followers.order_by("-updated_date").all(),
             remote_id=remote_id,
             id_only=True,
-            **kwargs
+            **kwargs,
         )
 
     def to_activity(self, **kwargs):
@@ -243,7 +259,6 @@ class User(OrderedCollectionPageMixin, AbstractUser):
             # generate a username that uses the domain (webfinger format)
             actor_parts = urlparse(self.remote_id)
             self.username = "%s@%s" % (self.username, actor_parts.netloc)
-            super().save(*args, **kwargs)
 
         # this user already exists, no need to populate fields
         if not created:
@@ -253,13 +268,13 @@ class User(OrderedCollectionPageMixin, AbstractUser):
         # this is a new remote user, we need to set their remote server field
         if not self.local:
             super().save(*args, **kwargs)
-            set_remote_server.delay(self.id)
+            transaction.on_commit(lambda: set_remote_server.delay(self.id))
             return
 
         # populate fields for local users
-        self.remote_id = "https://%s/user/%s" % (DOMAIN, self.localname)
+        self.remote_id = "%s/user/%s" % (site_link(), self.localname)
         self.inbox = "%s/inbox" % self.remote_id
-        self.shared_inbox = "https://%s/inbox" % DOMAIN
+        self.shared_inbox = "%s/inbox" % site_link()
         self.outbox = "%s/outbox" % self.remote_id
 
         # an id needs to be set before we can proceed with related models
@@ -276,7 +291,7 @@ class User(OrderedCollectionPageMixin, AbstractUser):
         self.key_pair = KeyPair.objects.create(
             remote_id="%s/#main-key" % self.remote_id
         )
-        self.save(broadcast=False)
+        self.save(broadcast=False, update_fields=["key_pair"])
 
         shelves = [
             {
@@ -406,7 +421,7 @@ def set_remote_server(user_id):
     user = User.objects.get(id=user_id)
     actor_parts = urlparse(user.remote_id)
     user.federated_server = get_or_create_remote_server(actor_parts.netloc)
-    user.save(broadcast=False)
+    user.save(broadcast=False, update_fields=["federated_server"])
     if user.bookwyrm_user and user.outbox:
         get_remote_reviews.delay(user.outbox)
 

bookwyrm/preview_images.py

@@ -11,6 +11,7 @@ from PIL import Image, ImageDraw, ImageFont, ImageOps, ImageColor
 
 from django.core.files.base import ContentFile
 from django.core.files.uploadedfile import InMemoryUploadedFile
+from django.core.files.storage import default_storage
 from django.db.models import Avg
 
 from bookwyrm import models, settings
@@ -319,9 +320,9 @@ def save_and_cleanup(image, instance=None):
 
     try:
         try:
-            old_path = instance.preview_image.path
+            old_path = instance.preview_image.name
         except ValueError:
-            old_path = ""
+            old_path = None
 
         # Save
         image.save(image_buffer, format="jpeg", quality=75)
@@ -337,13 +338,13 @@ def save_and_cleanup(image, instance=None):
 
         save_without_broadcast = isinstance(instance, (models.Book, models.User))
         if save_without_broadcast:
-            instance.save(broadcast=False)
+            instance.save(broadcast=False, update_fields=["preview_image"])
         else:
-            instance.save()
+            instance.save(update_fields=["preview_image"])
 
         # Clean up old file after saving
-        if os.path.exists(old_path):
-            os.remove(old_path)
+        if old_path and default_storage.exists(old_path):
+            default_storage.delete(old_path)
 
     finally:
         image_buffer.close()

bookwyrm/redis_store.py

@@ -54,15 +54,15 @@ class RedisStore(ABC):
         pipeline.execute()
 
     def bulk_remove_objects_from_store(self, objs, store):
-        """remoev a list of objects from a given store"""
+        """remove a list of objects from a given store"""
         pipeline = r.pipeline()
         for obj in objs[: self.max_length]:
             pipeline.zrem(store, -1, obj.id)
         pipeline.execute()
 
-    def get_store(self, store):  # pylint: disable=no-self-use
+    def get_store(self, store, **kwargs):  # pylint: disable=no-self-use
         """load the values in a store"""
-        return r.zrevrange(store, 0, -1)
+        return r.zrevrange(store, 0, -1, **kwargs)
 
     def populate_store(self, store):
         """go from zero to a store"""

bookwyrm/settings.py

@@ -54,6 +54,7 @@ SECRET_KEY = env("SECRET_KEY")
 
 # SECURITY WARNING: don't run with debug turned on in production!
 DEBUG = env.bool("DEBUG", True)
+USE_HTTPS = env.bool("USE_HTTPS", False)
 
 ALLOWED_HOSTS = env.list("ALLOWED_HOSTS", ["*"])
 
@@ -70,6 +71,7 @@ INSTALLED_APPS = [
     "django_rename_app",
     "bookwyrm",
     "celery",
+    "storages",
 ]
 
 MIDDLEWARE = [
@@ -113,7 +115,11 @@ REDIS_ACTIVITY_PASSWORD = env("REDIS_ACTIVITY_PASSWORD", None)
 REDIS_ACTIVITY_SOCKET = env("REDIS_ACTIVITY_SOCKET", None)
 
 MAX_STREAM_LENGTH = int(env("MAX_STREAM_LENGTH", 200))
-STREAMS = ["home", "local", "federated"]
+
+STREAMS = [
+    {"key": "home", "name": _("Home Timeline"), "shortname": _("Home")},
+    {"key": "books", "name": _("Books Timeline"), "shortname": _("Books")},
+]
 
 # Database
 # https://docs.djangoproject.com/en/3.2/ref/settings/#databases
@@ -176,19 +182,51 @@ USE_L10N = True
 USE_TZ = True
 
 
-# Static files (CSS, JavaScript, Images)
-# https://docs.djangoproject.com/en/3.2/howto/static-files/
-
-PROJECT_DIR = os.path.dirname(os.path.abspath(__file__))
-STATIC_URL = "/static/"
-STATIC_PATH = "%s/%s" % (DOMAIN, env("STATIC_ROOT", "static"))
-STATIC_ROOT = os.path.join(BASE_DIR, env("STATIC_ROOT", "static"))
-MEDIA_URL = "/images/"
-MEDIA_PATH = "%s/%s" % (DOMAIN, env("MEDIA_ROOT", "images"))
-MEDIA_ROOT = os.path.join(BASE_DIR, env("MEDIA_ROOT", "images"))
-
 USER_AGENT = "%s (BookWyrm/%s; +https://%s/)" % (
     requests.utils.default_user_agent(),
     VERSION,
     DOMAIN,
 )
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/3.2/howto/static-files/
+
+PROJECT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# Storage
+
+PROTOCOL = "http"
+if USE_HTTPS:
+    PROTOCOL = "https"
+
+USE_S3 = env.bool("USE_S3", False)
+
+if USE_S3:
+    # AWS settings
+    AWS_ACCESS_KEY_ID = env("AWS_ACCESS_KEY_ID")
+    AWS_SECRET_ACCESS_KEY = env("AWS_SECRET_ACCESS_KEY")
+    AWS_STORAGE_BUCKET_NAME = env("AWS_STORAGE_BUCKET_NAME")
+    AWS_S3_CUSTOM_DOMAIN = env("AWS_S3_CUSTOM_DOMAIN")
+    AWS_S3_REGION_NAME = env("AWS_S3_REGION_NAME", "")
+    AWS_S3_ENDPOINT_URL = env("AWS_S3_ENDPOINT_URL")
+    AWS_DEFAULT_ACL = "public-read"
+    AWS_S3_OBJECT_PARAMETERS = {"CacheControl": "max-age=86400"}
+    # S3 Static settings
+    STATIC_LOCATION = "static"
+    STATIC_URL = "https://%s/%s/" % (AWS_S3_CUSTOM_DOMAIN, STATIC_LOCATION)
+    STATICFILES_STORAGE = "bookwyrm.storage_backends.StaticStorage"
+    # S3 Media settings
+    MEDIA_LOCATION = "images"
+    MEDIA_URL = "https://%s/%s/" % (AWS_S3_CUSTOM_DOMAIN, MEDIA_LOCATION)
+    MEDIA_FULL_URL = MEDIA_URL
+    DEFAULT_FILE_STORAGE = "bookwyrm.storage_backends.ImagesStorage"
+    # I don't know if it's used, but the site crashes without it
+    STATIC_ROOT = os.path.join(BASE_DIR, env("STATIC_ROOT", "static"))
+    MEDIA_ROOT = os.path.join(BASE_DIR, env("MEDIA_ROOT", "images"))
+else:
+    STATIC_URL = "/static/"
+    STATIC_ROOT = os.path.join(BASE_DIR, env("STATIC_ROOT", "static"))
+    MEDIA_URL = "/images/"
+    MEDIA_FULL_URL = "%s://%s%s" % (PROTOCOL, DOMAIN, MEDIA_URL)
+    MEDIA_ROOT = os.path.join(BASE_DIR, env("MEDIA_ROOT", "images"))

bookwyrm/static/css/bookwyrm.css

@@ -72,6 +72,14 @@ body {
     flex-grow: 1;
 }
 
+.preserve-whitespace p {
+    white-space: pre-wrap !important;
+}
+
+.display-inline p {
+    display: inline !important;
+}
+
 /** Shelving
  ******************************************************************************/
 

bookwyrm/storage_backends.py

@@ -0,0 +1,17 @@
+"""Handles backends for storages"""
+from storages.backends.s3boto3 import S3Boto3Storage
+
+
+class StaticStorage(S3Boto3Storage):  # pylint: disable=abstract-method
+    """Storage class for Static contents"""
+
+    location = "static"
+    default_acl = "public-read"
+
+
+class ImagesStorage(S3Boto3Storage):  # pylint: disable=abstract-method
+    """Storage class for Image files"""
+
+    location = "images"
+    default_acl = "public-read"
+    file_overwrite = False

bookwyrm/suggested_users.py

@@ -0,0 +1,221 @@
+""" store recommended follows in redis """
+import math
+import logging
+from django.dispatch import receiver
+from django.db.models import signals, Count, Q
+
+from bookwyrm import models
+from bookwyrm.redis_store import RedisStore, r
+from bookwyrm.tasks import app
+
+
+logger = logging.getLogger(__name__)
+
+
+class SuggestedUsers(RedisStore):
+    """suggested users for a user"""
+
+    max_length = 30
+
+    def get_rank(self, obj):
+        """get computed rank"""
+        return obj.mutuals  # + (1.0 - (1.0 / (obj.shared_books + 1)))
+
+    def store_id(self, user):  # pylint: disable=no-self-use
+        """the key used to store this user's recs"""
+        if isinstance(user, int):
+            return "{:d}-suggestions".format(user)
+        return "{:d}-suggestions".format(user.id)
+
+    def get_counts_from_rank(self, rank):  # pylint: disable=no-self-use
+        """calculate mutuals count and shared books count from rank"""
+        return {
+            "mutuals": math.floor(rank),
+            # "shared_books": int(1 / (-1 * (rank % 1 - 1))) - 1,
+        }
+
+    def get_objects_for_store(self, store):
+        """a list of potential follows for a user"""
+        user = models.User.objects.get(id=store.split("-")[0])
+
+        return get_annotated_users(
+            user,
+            ~Q(id=user.id),
+            ~Q(followers=user),
+            ~Q(follower_requests=user),
+            bookwyrm_user=True,
+        )
+
+    def get_stores_for_object(self, obj):
+        return [self.store_id(u) for u in self.get_users_for_object(obj)]
+
+    def get_users_for_object(self, obj):  # pylint: disable=no-self-use
+        """given a user, who might want to follow them"""
+        return models.User.objects.filter(local=True,).exclude(
+            Q(id=obj.id) | Q(followers=obj) | Q(id__in=obj.blocks.all()) | Q(blocks=obj)
+        )
+
+    def rerank_obj(self, obj, update_only=True):
+        """update all the instances of this user with new ranks"""
+        pipeline = r.pipeline()
+        for store_user in self.get_users_for_object(obj):
+            annotated_user = get_annotated_users(
+                store_user,
+                id=obj.id,
+            ).first()
+            if not annotated_user:
+                continue
+
+            pipeline.zadd(
+                self.store_id(store_user),
+                self.get_value(annotated_user),
+                xx=update_only,
+            )
+        pipeline.execute()
+
+    def rerank_user_suggestions(self, user):
+        """update the ranks of the follows suggested to a user"""
+        self.populate_store(self.store_id(user))
+
+    def remove_suggestion(self, user, suggested_user):
+        """take a user out of someone's suggestions"""
+        self.bulk_remove_objects_from_store([suggested_user], self.store_id(user))
+
+    def get_suggestions(self, user):
+        """get suggestions"""
+        values = self.get_store(self.store_id(user), withscores=True)
+        results = []
+        # annotate users with mutuals and shared book counts
+        for user_id, rank in values[:5]:
+            counts = self.get_counts_from_rank(rank)
+            try:
+                user = models.User.objects.get(id=user_id)
+            except models.User.DoesNotExist as err:
+                # if this happens, the suggestions are janked way up
+                logger.exception(err)
+                continue
+            user.mutuals = counts["mutuals"]
+            # user.shared_books = counts["shared_books"]
+            results.append(user)
+        return results
+
+
+def get_annotated_users(viewer, *args, **kwargs):
+    """Users, annotated with things they have in common"""
+    return (
+        models.User.objects.filter(discoverable=True, is_active=True, *args, **kwargs)
+        .exclude(Q(id__in=viewer.blocks.all()) | Q(blocks=viewer))
+        .annotate(
+            mutuals=Count(
+                "followers",
+                filter=Q(
+                    ~Q(id=viewer.id),
+                    ~Q(id__in=viewer.following.all()),
+                    followers__in=viewer.following.all(),
+                ),
+                distinct=True,
+            ),
+            #             shared_books=Count(
+            #                 "shelfbook",
+            #                 filter=Q(
+            #                     ~Q(id=viewer.id),
+            #                     shelfbook__book__parent_work__in=[
+            #                         s.book.parent_work for s in viewer.shelfbook_set.all()
+            #                     ],
+            #                 ),
+            #                 distinct=True,
+            #             ),
+        )
+    )
+
+
+suggested_users = SuggestedUsers()
+
+
+@receiver(signals.post_save, sender=models.UserFollows)
+# pylint: disable=unused-argument
+def update_suggestions_on_follow(sender, instance, created, *args, **kwargs):
+    """remove a follow from the recs and update the ranks"""
+    if not created or not instance.user_object.discoverable:
+        return
+
+    if instance.user_subject.local:
+        remove_suggestion_task.delay(instance.user_subject.id, instance.user_object.id)
+    rerank_user_task.delay(instance.user_object.id, update_only=False)
+
+
+@receiver(signals.post_save, sender=models.UserBlocks)
+# pylint: disable=unused-argument
+def update_suggestions_on_block(sender, instance, *args, **kwargs):
+    """remove blocked users from recs"""
+    if instance.user_subject.local and instance.user_object.discoverable:
+        remove_suggestion_task.delay(instance.user_subject.id, instance.user_object.id)
+    if instance.user_object.local and instance.user_subject.discoverable:
+        remove_suggestion_task.delay(instance.user_object.id, instance.user_subject.id)
+
+
+@receiver(signals.post_delete, sender=models.UserFollows)
+# pylint: disable=unused-argument
+def update_suggestions_on_unfollow(sender, instance, **kwargs):
+    """update rankings, but don't re-suggest because it was probably intentional"""
+    if instance.user_object.discoverable:
+        rerank_user_task.delay(instance.user_object.id, update_only=False)
+
+
+# @receiver(signals.post_save, sender=models.ShelfBook)
+# @receiver(signals.post_delete, sender=models.ShelfBook)
+# # pylint: disable=unused-argument
+# def update_rank_on_shelving(sender, instance, *args, **kwargs):
+#     """when a user shelves or unshelves a book, re-compute their rank"""
+#     # if it's a local user, re-calculate who is rec'ed to them
+#     if instance.user.local:
+#         rerank_suggestions_task.delay(instance.user.id)
+#
+#     # if the user is discoverable, update their rankings
+#     if instance.user.discoverable:
+#         rerank_user_task.delay(instance.user.id)
+
+
+@receiver(signals.post_save, sender=models.User)
+# pylint: disable=unused-argument, too-many-arguments
+def add_new_user(sender, instance, created, update_fields=None, **kwargs):
+    """a new user, wow how cool"""
+    # a new user is found, create suggestions for them
+    if created and instance.local:
+        rerank_suggestions_task.delay(instance.id)
+
+    if update_fields and not "discoverable" in update_fields:
+        return
+
+    # this happens on every save, not just when discoverability changes, annoyingly
+    if instance.discoverable:
+        rerank_user_task.delay(instance.id, update_only=False)
+    elif not created:
+        remove_user_task.delay(instance.id)
+
+
+@app.task
+def rerank_suggestions_task(user_id):
+    """do the hard work in celery"""
+    suggested_users.rerank_user_suggestions(user_id)
+
+
+@app.task
+def rerank_user_task(user_id, update_only=False):
+    """do the hard work in celery"""
+    user = models.User.objects.get(id=user_id)
+    suggested_users.rerank_obj(user, update_only=update_only)
+
+
+@app.task
+def remove_user_task(user_id):
+    """do the hard work in celery"""
+    user = models.User.objects.get(id=user_id)
+    suggested_users.remove_object_from_related_stores(user)
+
+
+@app.task
+def remove_suggestion_task(user_id, suggested_user_id):
+    """remove a specific user from a specific user's suggestions"""
+    suggested_user = models.User.objects.get(id=suggested_user_id)
+    suggested_users.remove_suggestion(user_id, suggested_user)

bookwyrm/templates/book/book.html

@@ -1,5 +1,10 @@
 {% extends 'layout.html' %}
-{% load i18n %}{% load bookwyrm_tags %}{% load humanize %}{% load utilities %}{% load layout %}
+{% load i18n %}
+{% load bookwyrm_tags %}
+{% load humanize %}
+{% load utilities %}
+{% load static %}
+{% load layout %}
 
 {% block title %}{{ book|book_title }}{% endblock %}
 
@@ -321,5 +326,5 @@
 {% endblock %}
 
 {% block scripts %}
-<script src="/static/js/vendor/tabs.js"></script>
+<script src="{% static "js/vendor/tabs.js" %}"></script>
 {% endblock %}

bookwyrm/templates/confirm_email/confirm_email.html

@@ -0,0 +1,44 @@
+{% extends "layout.html" %}
+{% load i18n %}
+
+{% block title %}{% trans "Confirm email" %}{% endblock %}
+
+{% block content %}
+<h1 class="title">{% trans "Confirm your email address" %}</h1>
+
+<div class="columns">
+    <div class="column">
+        <div class="block content">
+            <section class="block">
+                <p>{% trans "A confirmation code has been sent to the email address you used to register your account." %}</p>
+                {% if not valid %}
+                <p class="notification is-warning">{% trans "Sorry! We couldn't find that code." %}</p>
+                {% endif %}
+                <form name="confirm" method="post" action="{% url 'confirm-email' %}">
+                    {% csrf_token %}
+                    <label class="label" for="confirmation_code">{% trans "Confirmation code:" %}</label>
+                    <div class="field has-addons">
+                        <div class="control">
+                            <input class="input" type="text" name="code" id="confirmation_code" required>
+                        </div>
+                        <div class="control">
+                            <button class="button is-link" type="submit">{% trans "Submit" %}</button>
+                        </div>
+                    </div>
+                </form>
+            </section>
+
+            <section class="block">
+                {% trans "Can't find your code?" as button_text %}
+                {% include "snippets/toggle/open_button.html" with text=button_text controls_text="resend-form" focus="resend-form-header" %}
+                {% include "confirm_email/resend_form.html" with controls_text="resend-form" %}
+            </section>
+        </div>
+    </div>
+    <div class="column">
+        <div class="box">
+            {% include 'snippets/about.html' %}
+        </div>
+    </div>
+</div>
+{% endblock %}

bookwyrm/templates/confirm_email/resend_form.html

@@ -0,0 +1,20 @@
+{% extends "components/inline_form.html" %}
+{% load i18n %}
+{% block header %}
+{% trans "Resend confirmation link" %}
+{% endblock %}
+
+{% block form %}
+<form name="resend" method="post" action="{% url 'resend-link' %}">
+    {% csrf_token %}
+    <div class="field">
+        <label class="label" for="email">{% trans "Email address:" %}</label>
+        <div class="control">
+            <input type="text" name="email" class="input" required id="email">
+        </div>
+    </div>
+    <div class="control">
+        <button class="button is-link">{% trans "Resend link" %}</button>
+    </div>
+</form>
+{% endblock %}

bookwyrm/templates/directory/user_card.html

@@ -11,14 +11,21 @@
             </a>
             <div class="media-content">
                 <a href="{{ user.local_path }}" class="is-block mb-2">
-                    <span class="title is-4 is-block">{{ user.display_name }}</span>
+                    <span class="title is-4 is-block">
+                        {{ user.display_name }}
+                        {% if user.manually_approves_followers %}
+                        <span class="icon icon-lock is-size-7" title="{% trans 'Locked account' %}">
+                            <span class="is-sr-only">{% trans "Locked account" %}</span>
+                        </span>
+                        {% endif %}
+                    </span>
                     <span class="subtitle is-7 is-block">@{{ user|username }}</span>
                 </a>
                 {% include 'snippets/follow_button.html' with user=user %}
             </div>
         </div>
 
-        <div>
+        <div class="display-inline">
         {% if user.summary %}
             {{ user.summary|to_markdown|safe|truncatechars_html:40 }}
         {% else %}&nbsp;{% endif %}

bookwyrm/templates/email/confirm/html_content.html

@@ -0,0 +1,20 @@
+{% extends 'email/html_layout.html' %}
+{% load i18n %}
+
+{% block content %}
+<p>
+{% blocktrans trimmed %}
+One last step before you join {{ site_name }}! Please confirm your email address by clicking the link below:
+{% endblocktrans %}
+</p>
+
+{% trans "Confirm Email" as text %}
+{% include 'email/snippets/action.html' with path=confirmation_link text=text %}
+
+<p>
+{% blocktrans trimmed %}
+Or enter the code "<code>{{ confirmation_code }}</code>" at login.
+{% endblocktrans %}
+</p>
+
+{% endblock %}

bookwyrm/templates/email/confirm/subject.html

@@ -0,0 +1,4 @@
+{% load i18n %}
+{% blocktrans trimmed %}
+Please confirm your email
+{% endblocktrans %}

bookwyrm/templates/email/confirm/text_content.html

@@ -0,0 +1,14 @@
+{% extends 'email/text_layout.html' %}
+{% load i18n %}
+{% block content %}
+{% blocktrans trimmed %}
+One last step before you join {{ site_name }}! Please confirm your email address by clicking the link below:
+{% endblocktrans %}
+
+{{ confirmation_link }}
+
+{% blocktrans trimmed %}
+Or enter the code "{{ confirmation_code }}" at login.
+{% endblocktrans %}
+
+{% endblock %}

bookwyrm/templates/feed/direct_messages.html

@@ -1,4 +1,4 @@
-{% extends 'feed/feed_layout.html' %}
+{% extends 'feed/layout.html' %}
 {% load i18n %}
 {% block panel %}
 

bookwyrm/templates/feed/feed.html

@@ -1,38 +1,28 @@
-{% extends 'feed/feed_layout.html' %}
+{% extends 'feed/layout.html' %}
 {% load i18n %}
 
 {% block panel %}
 
 <h1 class="title">
-    {% if tab == 'home' %}
-    {% trans "Home Timeline" %}
-    {% elif tab == 'local' %}
-    {% trans "Local Timeline" %}
-    {% else %}
-    {% trans "Federated Timeline" %}
-    {% endif %}
+    {{ tab.name }}
 </h1>
 <div class="tabs">
     <ul>
-        <li class="{% if tab == 'home' %}is-active{% endif %}"{% if tab == 'home' %} aria-current="page"{% endif %}>
-            <a href="/#feed">{% trans "Home" %}</a>
-        </li>
-        <li class="{% if tab == 'local' %}is-active{% endif %}"{% if tab == 'local' %} aria-current="page"{% endif %}>
-            <a href="/local#feed">{% trans "Local" %}</a>
-        </li>
-        <li class="{% if tab == 'federated' %}is-active{% endif %}"{% if tab == 'federated' %} aria-current="page"{% endif %}>
-            <a href="/federated#feed">{% trans "Federated" %}</a>
+        {% for stream in streams %}
+        <li class="{% if tab.key == stream.key %}is-active{% endif %}"{% if tab.key == stream.key %} aria-current="page"{% endif %}>
+            <a href="/{{ stream.key }}#feed">{{ stream.shortname }}</a>
         </li>
+        {% endfor %}
     </ul>
 </div>
 
 {# announcements and system messages #}
 {% if not activities.number > 1 %}
 <a href="{{ request.path }}" class="transition-y is-hidden notification is-primary is-block" data-poll-wrapper>
-    {% blocktrans %}load <span data-poll="stream/{{ tab }}">0</span> unread status(es){% endblocktrans %}
+    {% blocktrans %}load <span data-poll="stream/{{ tab.key }}">0</span> unread status(es){% endblocktrans %}
 </a>
 
-{% if request.user.show_goal and not goal and tab == 'home' %}
+{% if request.user.show_goal and not goal and tab.key == streams.first.key %}
 {% now 'Y' as year %}
 <section class="block">
     {% include 'snippets/goal_card.html' with year=year %}
@@ -44,18 +34,22 @@
 
 {# activity feed #}
 {% if not activities %}
-<p>{% trans "There aren't any activities right now! Try following a user to get started" %}</p>
+<div class="block content">
+    <p>{% trans "There aren't any activities right now! Try following a user to get started" %}</p>
+
+    {% if suggested_users %}
+    {# suggested users for when things are very lonely #}
+    {% include 'feed/suggested_users.html' with suggested_users=suggested_users %}
+</div>
+{% endif %}
+
 {% endif %}
 
 {% for activity in activities %}
 
 {% if not activities.number > 1 and forloop.counter0 == 2 and suggested_users %}
 {# suggested users on the first page, two statuses down #}
-<section class="block">
-    <h2 class="title is-5">{% trans "Who to follow" %}</h2>
-    {% include 'feed/suggested_users.html' with suggested_users=suggested_users %}
-    <a class="help" href="{% url 'directory' %}">View directory <span class="icon icon-arrow-right"></a>
-</section>
+{% include 'feed/suggested_users.html' with suggested_users=suggested_users %}
 {% endif %}
 <div class="block">
     {% include 'snippets/status/status.html' with status=activity %}

bookwyrm/templates/feed/feed_layout.html

@@ -1,107 +0,0 @@
-{% extends 'layout.html' %}
-{% load i18n %}
-
-{% block title %}{% trans "Updates" %}{% endblock %}
-
-{% block content %}
-<div class="columns">
-    {% if user.is_authenticated %}
-    <div class="column is-one-third">
-        <h2 class="title is-5">{% trans "Your books" %}</h2>
-        {% if not suggested_books %}
-        <p>{% trans "There are no books here right now! Try searching for a book to get started" %}</p>
-        {% else %}
-        {% with active_book=request.GET.book %}
-        <div class="tab-group">
-            <div class="tabs is-small">
-                <ul role="tablist">
-                {% for shelf in suggested_books %}
-                {% if shelf.books %}
-                {% with shelf_counter=forloop.counter %}
-                    <li>
-                        <p>
-                            {% if shelf.identifier == 'to-read' %}{% trans "To Read" %}
-                            {% elif shelf.identifier == 'reading' %}{% trans "Currently Reading" %}
-                            {% elif shelf.identifier == 'read' %}{% trans "Read" %}
-                            {% else %}{{ shelf.name }}{% endif %}
-                        </p>
-                        <div class="tabs is-small is-toggle">
-                            <ul>
-                                {% for book in shelf.books %}
-                                <li class="{% if active_book == book.id|stringformat:'d' %}is-active{% elif not active_book and shelf_counter == 1 and forloop.first %}is-active{% endif %}">
-                                    <a
-                                        href="{{ request.path }}?book={{ book.id }}"
-                                        id="tab-book-{{ book.id }}"
-                                        role="tab"
-                                        aria-label="{{ book.title }}"
-                                        aria-selected="{% if active_book == book.id|stringformat:'d' %}true{% elif shelf_counter == 1 and forloop.first %}true{% else %}false{% endif %}"
-                                        aria-controls="book-{{ book.id }}">
-                                        {% include 'snippets/book_cover.html' with book=book cover_class='is-h-m' %}
-                                    </a>
-                                </li>
-                                {% endfor %}
-                            </ul>
-                        </div>
-                    </li>
-                {% endwith %}
-                {% endif %}
-                {% endfor %}
-                </ul>
-            </div>
-            {% for shelf in suggested_books %}
-            {% with shelf_counter=forloop.counter %}
-            {% for book in shelf.books %}
-            <div
-                class="suggested-tabs card"
-                role="tabpanel"
-                id="book-{{ book.id }}"
-                {% if active_book and active_book == book.id|stringformat:'d' %}{% elif not active_book and shelf_counter == 1 and forloop.first %}{% else %} hidden{% endif %}
-                aria-labelledby="tab-book-{{ book.id }}">
-
-                <div class="card-header">
-                    <div class="card-header-title">
-                        <div>
-                            <p class="mb-2">{% include 'snippets/book_titleby.html' with book=book %}</p>
-                            {% include 'snippets/shelve_button/shelve_button.html' with book=book %}
-                        </div>
-                    </div>
-                    <div class="card-header-icon is-hidden-tablet">
-                        {% trans "Close" as button_text %}
-                        {% include 'snippets/toggle/toggle_button.html' with label=button_text controls_text="book" controls_uid=book.id class="delete" nonbutton=True pressed=True %}
-                    </div>
-                </div>
-                <div class="card-content">
-                {% include 'snippets/create_status.html' with book=book %}
-                </div>
-            </div>
-            {% endfor %}
-            {% endwith %}
-            {% endfor %}
-        </div>
-        {% endwith %}
-        {% endif %}
-
-        {% if goal %}
-        <section class="section">
-            <div class="block">
-                <h3 class="title is-4">{% blocktrans with yar=goal.year %}{{ year }} Reading Goal{% endblocktrans %}</h3>
-                {% include 'snippets/goal_progress.html' with goal=goal %}
-            </div>
-        </section>
-        {% endif %}
-    </div>
-    {% endif %}
-
-    <div class="column is-two-thirds" id="feed">
-        {% block panel %}{% endblock %}
-
-        {% if activities %}
-        {% include 'snippets/pagination.html' with page=activities path=path anchor="#feed" %}
-        {% endif %}
-    </div>
-</div>
-{% endblock %}
-
-{% block scripts %}
-<script src="/static/js/vendor/tabs.js"></script>
-{% endblock %}

bookwyrm/templates/feed/layout.html

@@ -0,0 +1,110 @@
+{% extends 'layout.html' %}
+{% load i18n %}
+{% load static %}
+
+{% block title %}{% trans "Updates" %}{% endblock %}
+
+{% block content %}
+<div class="columns">
+    {% if user.is_authenticated %}
+    <div class="column is-one-third">
+        <section class="block">
+            <h2 class="title is-4">{% trans "Your books" %}</h2>
+            {% if not suggested_books %}
+            <p>{% trans "There are no books here right now! Try searching for a book to get started" %}</p>
+            {% else %}
+            {% with active_book=request.GET.book %}
+            <div class="tab-group">
+                <div class="tabs is-small">
+                    <ul role="tablist">
+                    {% for shelf in suggested_books %}
+                    {% if shelf.books %}
+                    {% with shelf_counter=forloop.counter %}
+                        <li>
+                            <p>
+                                {% if shelf.identifier == 'to-read' %}{% trans "To Read" %}
+                                {% elif shelf.identifier == 'reading' %}{% trans "Currently Reading" %}
+                                {% elif shelf.identifier == 'read' %}{% trans "Read" %}
+                                {% else %}{{ shelf.name }}{% endif %}
+                            </p>
+                            <div class="tabs is-small is-toggle">
+                                <ul>
+                                    {% for book in shelf.books %}
+                                    <li class="{% if active_book == book.id|stringformat:'d' %}is-active{% elif not active_book and shelf_counter == 1 and forloop.first %}is-active{% endif %}">
+                                        <a
+                                            href="{{ request.path }}?book={{ book.id }}"
+                                            id="tab-book-{{ book.id }}"
+                                            role="tab"
+                                            aria-label="{{ book.title }}"
+                                            aria-selected="{% if active_book == book.id|stringformat:'d' %}true{% elif shelf_counter == 1 and forloop.first %}true{% else %}false{% endif %}"
+                                            aria-controls="book-{{ book.id }}">
+                                            {% include 'snippets/book_cover.html' with book=book cover_class='is-h-m' %}
+                                        </a>
+                                    </li>
+                                    {% endfor %}
+                                </ul>
+                            </div>
+                        </li>
+                    {% endwith %}
+                    {% endif %}
+                    {% endfor %}
+                    </ul>
+                </div>
+                {% for shelf in suggested_books %}
+                {% with shelf_counter=forloop.counter %}
+                {% for book in shelf.books %}
+                <div
+                    class="suggested-tabs card"
+                    role="tabpanel"
+                    id="book-{{ book.id }}"
+                    {% if active_book and active_book == book.id|stringformat:'d' %}{% elif not active_book and shelf_counter == 1 and forloop.first %}{% else %} hidden{% endif %}
+                    aria-labelledby="tab-book-{{ book.id }}">
+
+                    <div class="card-header">
+                        <div class="card-header-title">
+                            <div>
+                                <p class="mb-2">{% include 'snippets/book_titleby.html' with book=book %}</p>
+                                {% include 'snippets/shelve_button/shelve_button.html' with book=book %}
+                            </div>
+                        </div>
+                        <div class="card-header-icon is-hidden-tablet">
+                            {% trans "Close" as button_text %}
+                            {% include 'snippets/toggle/toggle_button.html' with label=button_text controls_text="book" controls_uid=book.id class="delete" nonbutton=True pressed=True %}
+                        </div>
+                    </div>
+                    <div class="card-content">
+                    {% include 'snippets/create_status.html' with book=book %}
+                    </div>
+                </div>
+                {% endfor %}
+                {% endwith %}
+                {% endfor %}
+            </div>
+            {% endwith %}
+            {% endif %}
+        </section>
+
+        {% if goal %}
+        <section class="block">
+            <div class="block">
+                <h3 class="title is-4">{% blocktrans with yar=goal.year %}{{ year }} Reading Goal{% endblocktrans %}</h3>
+                {% include 'snippets/goal_progress.html' with goal=goal %}
+            </div>
+        </section>
+        {% endif %}
+    </div>
+    {% endif %}
+
+    <div class="column is-two-thirds" id="feed">
+        {% block panel %}{% endblock %}
+
+        {% if activities %}
+        {% include 'snippets/pagination.html' with page=activities path=path anchor="#feed" %}
+        {% endif %}
+    </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script src="{% static "js/vendor/tabs.js" %}"></script>
+{% endblock %}

bookwyrm/templates/feed/status.html

@@ -1,4 +1,4 @@
-{% extends 'feed/feed_layout.html' %}
+{% extends 'feed/layout.html' %}
 {% load i18n %}
 
 {% block panel %}

bookwyrm/templates/feed/suggested_users.html

@@ -1,25 +1,6 @@
 {% load i18n %}
-{% load utilities %}
-{% load humanize %}
-<div class="columns is-mobile scroll-x mb-0">
-    {% for user in suggested_users %}
-    <div class="column is-flex is-flex-grow-0">
-        <div class="box has-text-centered is-shadowless has-background-white-bis m-0">
-            <a href="{{ user.local_path }}" class="has-text-black">
-                {% include 'snippets/avatar.html' with user=user large=True %}
-                <span title="{{ user.display_name }}" class="is-block is-6 has-text-weight-bold">{{ user.display_name|truncatechars:10 }}</span>
-                <span title="@{{ user|username }}" class="is-block pb-3">@{{ user|username|truncatechars:8 }}</span>
-            </a>
-            {% include 'snippets/follow_button.html' with user=user minimal=True %}
-            {% if user.mutuals %}
-            <p class="help">
-            {% blocktrans with mutuals=user.mutuals|intcomma count counter=user.mutuals %}{{ mutuals }} follower you follow{% plural %}{{ mutuals }} followers you follow{% endblocktrans %}
-            </p>
-            {% elif user.shared_books %}
-            <p class="help">{% blocktrans with shared_books=user.shared_books|intcomma count counter=user.shared_books %}{{ shared_books }} book on your shelves{% plural %}{{ shared_books }} books on your shelves{% endblocktrans %}</p>
-            {% endif %}
-        </div>
-    </div>
-    {% endfor %}
-</div>
-
+<section class="block">
+    <h2 class="title is-5">{% trans "Who to follow" %}</h2>
+    {% include 'snippets/suggested_users.html' with suggested_users=suggested_users %}
+    <a class="help" href="{% url 'directory' %}">View directory <span class="icon icon-arrow-right"></a>
+</section>

bookwyrm/templates/get_started/layout.html

@@ -1,5 +1,6 @@
 {% extends 'layout.html' %}
 {% load i18n %}
+{% load static %}
 
 {% block title %}{% trans "Welcome" %}{% endblock %}
 
@@ -9,7 +10,7 @@
     <div class="modal-background"></div>
     <div class="modal-card is-fullwidth">
         <header class="modal-card-head">
-            <img class="image logo mr-2" src="{% if site.logo_small %}/images/{{ site.logo_small }}{% else %}/static/images/logo-small.png{% endif %}" aria-hidden="true">
+            <img class="image logo mr-2" src="{% if site.logo_small %}{% get_media_prefix %}{{ site.logo_small }}{% else %}{% static "images/logo-small.png" %}{% endif %}" aria-hidden="true">
             <h1 class="modal-card-title" id="get-started-header">
                 {% blocktrans %}Welcome to {{ site_name }}!{% endblocktrans %}
                 <span class="subtitle is-block">

bookwyrm/templates/get_started/users.html

@@ -9,7 +9,7 @@
     <form class="field has-addons" method="get" action="{% url 'get-started-users' %}">
         <div class="control">
             <input type="text" name="query" value="{{ request.GET.query }}" class="input" placeholder="{% trans 'Search for a user' %}" aria-label="{% trans 'Search for a user' %}">
-            {% if request.GET.query and not user_results %}
+            {% if request.GET.query and no_results %}
             <p class="help">{% blocktrans with query=request.GET.query %}No users found for "{{ query }}"{% endblocktrans %}</p>
             {% endif %}
         </div>
@@ -22,7 +22,7 @@
         </div>
     </form>
 
-    {% include 'feed/suggested_users.html' with suggested_users=suggested_users %}
+    {% include 'snippets/suggested_users.html' with suggested_users=suggested_users %}
 </div>
 {% endblock %}
 

bookwyrm/templates/goal.html

@@ -17,9 +17,9 @@
 
 {% block panel %}
 <section class="block">
-    {% if user == request.user %}
+    {% now 'Y' as current_year %}
+    {% if user == request.user and year == current_year %}
     <div class="block">
-        {% now 'Y' as year %}
         <section class="card {% if goal %}is-hidden{% endif %}" id="show-edit-goal">
             <header class="card-header">
                 <h2 class="card-header-title has-background-primary has-text-white" tabindex="0" id="edit-form-header">

bookwyrm/templates/import_status.html

@@ -1,6 +1,7 @@
 {% extends 'layout.html' %}
 {% load i18n %}
 {% load humanize %}
+{% load static %}
 
 {% block title %}{% trans "Import Status" %}{% endblock %}
 
@@ -156,5 +157,5 @@
 {% endspaceless %}{% endblock %}
 
 {% block scripts %}
-<script src="/static/js/check_all.js"></script>
+<script src="{% static "js/check_all.js" %}"></script>
 {% endblock %}

bookwyrm/templates/layout.html

@@ -1,14 +1,16 @@
-{% load layout %}{% load i18n %}
+{% load layout %}
+{% load i18n %}
+{% load static %}
 <!DOCTYPE html>
 <html lang="{% get_lang %}">
 <head>
     <title>{% block title %}BookWyrm{% endblock %} | {{ site.name }}</title>
     <meta name="viewport" content="width=device-width, initial-scale=1">
-    <link rel="stylesheet" href="/static/css/vendor/bulma.min.css">
-    <link rel="stylesheet" href="/static/css/vendor/icons.css">
-    <link rel="stylesheet" href="/static/css/bookwyrm.css">
+    <link rel="stylesheet" href="{% static "css/vendor/bulma.min.css" %}">
+    <link rel="stylesheet" href="{% static "css/vendor/icons.css" %}">
+    <link rel="stylesheet" href="{% static "css/bookwyrm.css" %}">
 
-    <link rel="shortcut icon" type="image/x-icon" href="{% if site.favicon %}{{ media_url }}{{ site.favicon }}{% else %}/static/images/favicon.ico{% endif %}">
+    <link rel="shortcut icon" type="image/x-icon" href="{% if site.favicon %}{% get_media_prefix %}{{ site.favicon }}{% else %}{% static "images/favicon.ico" %}{% endif %}">
 
     {% if preview_images_enabled is True %}
     <meta name="twitter:card" content="summary_large_image">
@@ -30,7 +32,7 @@
     <div class="container">
         <div class="navbar-brand">
             <a class="navbar-item" href="/">
-                <img class="image logo" src="{% if site.logo_small %}{{ media_url }}{{ site.logo_small }}{% else %}/static/images/logo-small.png{% endif %}" alt="Home page">
+                <img class="image logo" src="{% if site.logo_small %}{% get_media_prefix %}{{ site.logo_small }}{% else %}{% static "images/logo-small.png" %}{% endif %}" alt="Home page">
             </a>
             <form class="navbar-item column" action="/search/">
                 <div class="field has-addons">
@@ -149,7 +151,7 @@
                     {% if request.path != '/login' and request.path != '/login/' %}
                     <div class="columns">
                         <div class="column">
-                            <form name="login" method="post" action="/login">
+                            <form name="login" method="post" action="{% url 'login' %}?next={{ request.path }}">
                                 {% csrf_token %}
                                 <div class="columns is-variable is-1">
                                     <div class="column">
@@ -242,8 +244,8 @@
 <script>
     var csrf_token = '{{ csrf_token }}';
 </script>
-<script src="/static/js/bookwyrm.js"></script>
-<script src="/static/js/localstorage.js"></script>
+<script src="{% static "js/bookwyrm.js" %}"></script>
+<script src="{% static "js/localstorage.js" %}"></script>
 {% block scripts %}{% endblock %}
 </body>
 </html>

bookwyrm/templates/login.html

@@ -11,8 +11,13 @@
             {% if login_form.non_field_errors %}
             <p class="notification is-danger">{{ login_form.non_field_errors }}</p>
             {% endif %}
+
+            {% if show_confirmed_email %}
+            <p class="notification is-success">{% trans "Success! Email address confirmed." %}</p>
+            {% endif %}
             <form name="login" method="post" action="/login">
                 {% csrf_token %}
+                {% if show_confirmed_email %}<input type="hidden" name="first_login" value="true">{% endif %}
                 <div class="field">
                     <label class="label" for="id_localname">{% trans "Username:" %}</label>
                     <div class="control">

bookwyrm/templates/preferences/edit_user.html

@@ -53,6 +53,14 @@
             {{ form.manually_approves_followers }}
         </label>
     </div>
+    <div class="block">
+        <label class="label" for="id_default_post_privacy">
+            {% trans "Default post privacy:" %}
+        </label>
+        <div class="select">
+            {{ form.default_post_privacy }}
+        </div>
+    </div>
     <div class="block">
         <label class="checkbox label" for="id_discoverable">
             {% trans "Show this account in suggested users:" %}

bookwyrm/templates/settings/site.html

@@ -91,6 +91,13 @@
                 {% trans "Allow invite requests" %}
             </label>
         </div>
+        <div class="field">
+            <label class="label mb-0" for="id_allow_invite_requests">
+                {{ site_form.require_confirm_email }}
+                {% trans "Require users to confirm email address" %}
+            </label>
+            <p class="help">{% trans "(Recommended if registration is open)" %}</p>
+        </div>
         <div class="field">
             <label class="label" for="id_registration_closed_text">{% trans "Registration closed text:" %}</label>
             {{ site_form.registration_closed_text }}

bookwyrm/templates/snippets/about.html

@@ -1,7 +1,9 @@
+{% load static %}
+
 <div class="columns">
     <div class="column is-narrow is-hidden-mobile">
         <figure class="block is-w-xl">
-            <img src="{% if site.logo %}/images/{{ site.logo }}{% else %}/static/images/logo.png{% endif %}" alt="BookWyrm logo">
+            <img src="{% if site.logo %}/images/{{ site.logo }}{% else %}{% static "images/logo.png" %}{% endif %}" alt="BookWyrm logo">
         </figure>
     </div>
     <div class="content">

bookwyrm/templates/snippets/authors.html

@@ -1,9 +1,16 @@
 {% spaceless %}
+{% load i18n %}
+{% load humanize %}
 {% comment %}
     @todo The author property needs to be an Organization or a Person. We’ll be using Thing which is the more generic ancestor.
     @see https://schema.org/Author
 {% endcomment %}
-{% for author in book.authors.all %}
+{% firstof limit None as limit %}
+{% with subtraction_value='-'|add:limit %}
+{% with remainder_count=book.authors.count|add:subtraction_value %}
+{% with remainder_count_display=remainder_count|intcomma %}
+
+{% for author in book.authors.all|slice:limit %}
     <a
         href="{{ author.local_path }}"
         class="author"
@@ -12,6 +19,14 @@
         itemtype="https://schema.org/Thing"
     ><span
         itemprop="name"
-    >{{ author.name }}<span></a>{% if not forloop.last %}, {% endif %}
+        >{{ author.name }}<span></a>{% if not forloop.last %}, {% elif remainder_count > 0 %}, {% blocktrans trimmed count counter=remainder_count %}
+and {{ remainder_count_display }} other
+{% plural %}
+and {{ remainder_count_display }} others
+{% endblocktrans %}{% endif %}
 {% endfor %}
+
+{% endwith %}
+{% endwith %}
+{% endwith %}
 {% endspaceless %}

bookwyrm/templates/snippets/avatar.html

@@ -1,2 +1,4 @@
-<img class="avatar image {% if large %}is-96x96{% elif medium %}is-48x48{% else %}is-32x32{% endif %}" src="{% if user.avatar %}/images/{{ user.avatar }}{% else %}/static/images/default_avi.jpg{% endif %}" {% if ariaHide %}aria-hidden="true"{% endif %} alt="{{ user.alt_text }}">
+{% load static %}
+
+<img class="avatar image {% if large %}is-96x96{% elif medium %}is-48x48{% else %}is-32x32{% endif %}" src="{% if user.avatar %}{% get_media_prefix %}{{ user.avatar }}{% else %}{% static "images/default_avi.jpg" %}{% endif %}" {% if ariaHide %}aria-hidden="true"{% endif %} alt="{{ user.alt_text }}">
 

bookwyrm/templates/snippets/book_cover.html

@@ -1,6 +1,7 @@
 {% spaceless %}
 
 {% load i18n %}
+{% load static %}
 
 <figure
     class="
@@ -20,14 +21,14 @@
         class="book-cover"
 
         {% if book.cover %}
-            src="{% if img_path is None %}/images/{% else %}{{ img_path }}{% endif %}{{ book.cover }}"
+            src="{% if img_path is None %}{% get_media_prefix %}{% else %}{{ img_path }}{% endif %}{{ book.cover }}"
             itemprop="thumbnailUrl"
 
             {% if book.alt_text %}
                 alt="{{ book.alt_text }}"
             {% endif %}
         {% else %}
-            src="/static/images/no_cover.jpg"
+            src="{% static "images/no_cover.jpg" %}"
             alt="{% trans "No cover" %}"
         {% endif %}
     >

bookwyrm/templates/snippets/book_titleby.html

@@ -1,8 +1,15 @@
 {% load i18n %}
 {% load utilities %}
+{% spaceless %}
+
 {% if book.authors %}
-{% blocktrans with path=book.local_path title=book|book_title %}<a href="{{ path }}">{{ title }}</a> by {% endblocktrans %}{% include 'snippets/authors.html' with book=book %}
+{% blocktrans trimmed with path=book.local_path title=book|book_title %}
+<a href="{{ path }}">{{ title }}</a> by
+{% endblocktrans %}
+{% include 'snippets/authors.html' with book=book limit=3 %}
+
 {% else %}
 <a href="{{ book.local_path }}">{{ book|book_title }}</a>
 {% endif %}
 
+{% endspaceless %}

bookwyrm/templates/snippets/opengraph_images.html

@@ -1,12 +1,14 @@
+{% load static %}
+
 {% if preview_images_enabled is True %}
     {% if image %}
-        <meta name="twitter:image" content="{{ request.scheme }}://{{ media_path }}{{ image }}">
-        <meta name="og:image" content="{{ request.scheme }}://{{ media_path }}{{ image }}">
+        <meta name="twitter:image" content="{{ media_full_url }}{{ image }}">
+        <meta name="og:image" content="{{ media_full_url }}{{ image }}">
     {% else %}
-        <meta name="twitter:image" content="{{ request.scheme }}://{{ media_path }}{{ site.preview_image }}">
-        <meta name="og:image" content="{{ request.scheme }}://{{ media_path }}{{ site.preview_image }}">
+        <meta name="twitter:image" content="{{ media_full_url }}{{ site.preview_image }}">
+        <meta name="og:image" content="{{ media_full_url }}{{ site.preview_image }}">
     {% endif %}
 {% else %}
-    <meta name="twitter:image" content="{{ request.scheme }}://{% if site.logo %}{{ media_path }}{{ site.logo }}{% else %}{{ static_path }}/images/logo.png{% endif %}">
-    <meta name="og:image" content="{{ request.scheme }}://{% if site.logo %}{{ media_path }}{{ site.logo }}{% else %}{{ static_path }}/images/logo.png{% endif %}">
+    <meta name="twitter:image" content="{% if site.logo %}{{ media_full_url }}{{ site.logo }}{% else %}{% static "images/logo.png" %}{% endif %}">
+    <meta name="og:image" content="{% if site.logo %}{{ media_full_url }}{{ site.logo }}{% else %}{% static "images/logo.png" %}{% endif %}">
 {% endif %}

bookwyrm/templates/snippets/privacy_select.html

@@ -5,17 +5,18 @@
     {% if not no_label %}
     <label class="is-sr-only" for="privacy-{{ uuid }}">{% trans "Post privacy" %}</label>
     {% endif %}
+    {% firstof current user.default_post_privacy "public" as privacy %}
     <select name="privacy" id="privacy-{{ uuid }}">
-        <option value="public" {% if not current or current == 'public' %}selected{% endif %}>
+        <option value="public" {% if privacy == 'public' %}selected{% endif %}>
             {% trans "Public" %}
         </option>
-        <option value="unlisted" {% if current == 'unlisted' %}selected{% endif %}>
+        <option value="unlisted" {% if privacy == 'unlisted' %}selected{% endif %}>
             {% trans "Unlisted" %}
         </option>
-        <option value="followers" {% if current == 'followers' %}selected{% endif %}>
+        <option value="followers" {% if privacy == 'followers' %}selected{% endif %}>
             {% trans "Followers" %}
         </option>
-        <option value="direct" {% if current == 'direct' %}selected{% endif %}>
+        <option value="direct" {% if privacy == 'direct' %}selected{% endif %}>
             {% trans "Private" %}
         </option>
     </select>

bookwyrm/templates/snippets/register_form.html

@@ -12,7 +12,7 @@
 <div class="field">
     <label class="label" for="id_email_register">{% trans "Email address:" %}</label>
     <div class="control">
-        <input type="email" name="email" maxlength="254" class="input" id="id_email_register" value="{% if register_form.email.value %}{{ register_form.email.value }}{% endif %}">
+        <input type="email" name="email" maxlength="254" class="input" id="id_email_register" value="{% if register_form.email.value %}{{ register_form.email.value }}{% endif %}" required>
     {% for error in register_form.email.errors %}
     <p class="help is-danger">{{ error | escape }}</p>
     {% endfor %}

bookwyrm/templates/snippets/status/content_status.html

@@ -1,6 +1,7 @@
 {% load bookwyrm_tags %}
 {% load markdown %}
 {% load i18n %}
+{% load static %}
 
 {% with status_type=status.status_type %}
 <div
@@ -111,12 +112,12 @@
                                 <div class="column is-narrow">
                                     <figure class="image is-128x128">
                                         <a
-                                            href="/images/{{ attachment.image }}"
+                                            href="{% get_media_prefix %}{{ attachment.image }}"
                                             target="_blank"
                                             aria-label="{% trans 'Open image in new window' %}"
                                         >
                                             <img
-                                                src="/images/{{ attachment.image }}"
+                                                src="{% get_media_prefix %}{{ attachment.image }}"
 
                                                 {% if attachment.caption %}
                                                     alt="{{ attachment.caption }}"

bookwyrm/templates/snippets/status/status_header.html

@@ -2,6 +2,7 @@
 {% load status_display %}
 {% load i18n %}
 {% load humanize %}
+{% load static %}
 
 <div class="media">
     <figure class="media-left" aria-hidden="true">
@@ -18,7 +19,7 @@
                 itemtype="https://schema.org/Person"
             >
                 {% if status.user.avatar %}
-                    <meta itemprop="image" content="/images/{{ status.user.avatar }}">
+                    <meta itemprop="image" content="{% get_media_prefix %}{{ status.user.avatar }}">
                 {% endif %}
 
                 <a

bookwyrm/templates/snippets/suggested_users.html

@@ -0,0 +1,38 @@
+{% load i18n %}
+{% load utilities %}
+{% load humanize %}
+<div class="columns is-mobile scroll-x mb-0">
+    {% for user in suggested_users %}
+    <div class="column is-flex is-flex-grow-0">
+        <div class="box has-text-centered is-shadowless has-background-white-bis m-0">
+            <a href="{{ user.local_path }}" class="has-text-black">
+                {% include 'snippets/avatar.html' with user=user large=True %}
+                <span title="{{ user.display_name }}" class="is-block is-6 has-text-weight-bold">{{ user.display_name|truncatechars:10 }}</span>
+                <span title="@{{ user|username }}" class="is-block pb-3">@{{ user|username|truncatechars:8 }}</span>
+            </a>
+            {% include 'snippets/follow_button.html' with user=user minimal=True %}
+            {% if user.mutuals %}
+            <p class="help">
+                {% blocktrans trimmed with mutuals=user.mutuals|intcomma count counter=user.mutuals %}
+                {{ mutuals }} follower you follow
+                {% plural %}
+                {{ mutuals }} followers you follow{% endblocktrans %}
+            </p>
+            {% elif user.shared_books %}
+            <p class="help">
+                {% blocktrans trimmed with shared_books=user.shared_books|intcomma count counter=user.shared_books %}
+                {{ shared_books }} book on your shelves
+                {% plural %}
+                {{ shared_books }} books on your shelves
+                {% endblocktrans %}
+            </p>
+            {% elif request.user in user.following.all %}
+            <p class="help">
+                {% trans "Follows you" %}
+            </p>
+            {% endif %}
+        </div>
+    </div>
+    {% endfor %}
+</div>
+

bookwyrm/templates/user/layout.html

@@ -28,8 +28,10 @@
         </div>
 
         {% if user.summary %}
-        <div class="column box has-background-white-bis content">
+        {% spaceless %}
+        <div class="column box has-background-white-bis content preserve-whitespace">
             {{ user.summary|to_markdown|safe }}
+        {% endspaceless %}
         </div>
         {% endif %}
     </div>

bookwyrm/templates/user/relationships/following.html

@@ -12,3 +12,4 @@
     {% blocktrans with username=user.display_name %}{{ username }} isn't following any users{% endblocktrans %}
 </div>
 {% endblock %}
+

bookwyrm/templates/user/shelf/shelf.html

@@ -103,7 +103,7 @@
                         {% include 'snippets/authors.html' %}
                     </td>
                     <td data-title="{% trans "Shelved" %}">
-                        {{ book.created_date|naturalday }}
+                        {{ book.shelved_date|naturalday }}
                     </td>
                     {% latest_read_through book user as read_through %}
                     <td data-title="{% trans "Started" %}">

bookwyrm/templates/user/user_preview.html

@@ -10,7 +10,14 @@
         </a>
     </div>
     <div class="media-content">
-        <p>{% if user.name %}{{ user.name }}{% else %}{{ user.localname }}{% endif %}</p>
+        <p>
+            {% if user.name %}{{ user.name }}{% else %}{{ user.localname }}{% endif %}
+            {% if user.manually_approves_followers %}
+            <span class="icon icon-lock is-size-7" title="{% trans 'Locked account' %}">
+                <span class="is-sr-only">{% trans "Locked account" %}</span>
+            </span>
+            {% endif %}
+        </p>
         <p><a href="{{ user.remote_id }}">{{ user.username }}</a></p>
         <p>{% blocktrans with date=user.created_date|naturaltime %}Joined {{ date }}{% endblocktrans %}</p>
         <p>
@@ -23,7 +30,13 @@
 
             {% mutuals_count user as mutuals %}
             <a href="{% url 'user-followers' user|username %}">
+            {% if mutuals %}
                 {% blocktrans with mutuals_display=mutuals|intcomma count counter=mutuals %}{{ mutuals_display }} follower you follow{% plural %}{{ mutuals_display }} followers you follow{% endblocktrans %}
+            {% elif request.user in user.following.all %}
+            {% trans "Follows you" %}
+            {% else %}
+            {% trans "No followers you follow" %}
+            {% endif %}
             </a>
 
             {% endif %}

bookwyrm/templatetags/bookwyrm_tags.py

@@ -12,7 +12,7 @@ register = template.Library()
 def get_rating(book, user):
     """get the overall rating of a book"""
     queryset = views.helpers.privacy_filter(
-        user, models.Review.objects.filter(book=book)
+        user, models.Review.objects.filter(book__in=book.parent_work.editions.all())
     )
     return queryset.aggregate(Avg("rating"))["rating__avg"]
 

bookwyrm/tests/activitypub/test_author.py

@@ -1,17 +1,14 @@
-import datetime
-
-from unittest.mock import patch
+"""test author serializer"""
 from django.test import TestCase
 from bookwyrm import models
 
 
 class Author(TestCase):
     def setUp(self):
-        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",
+        )
         self.author = models.Author.objects.create(
             name="Author fullname",
             aliases=["One", "Two"],

bookwyrm/tests/activitypub/test_base_activity.py

@@ -20,49 +20,52 @@ from bookwyrm import models
 
 
 @patch("bookwyrm.activitystreams.ActivityStream.add_status")
+@patch("bookwyrm.suggested_users.rerank_user_task.delay")
+@patch("bookwyrm.suggested_users.remove_user_task.delay")
+@patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
 class BaseActivity(TestCase):
     """the super class for model-linked activitypub dataclasses"""
 
     def setUp(self):
         """we're probably going to re-use this so why copy/paste"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
             )
-            self.user.remote_id = "http://example.com/a/b"
-            self.user.save(broadcast=False)
+        self.user.remote_id = "http://example.com/a/b"
+        self.user.save(broadcast=False, update_fields=["remote_id"])
 
-            datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json")
-            self.userdata = json.loads(datafile.read_bytes())
-            # don't try to load the user icon
-            del self.userdata["icon"]
+        datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json")
+        self.userdata = json.loads(datafile.read_bytes())
+        # don't try to load the user icon
+        del self.userdata["icon"]
 
-            image_file = pathlib.Path(__file__).parent.joinpath(
-                "../../static/images/default_avi.jpg"
-            )
-            image = Image.open(image_file)
-            output = BytesIO()
-            image.save(output, format=image.format)
-            self.image_data = output.getvalue()
+        image_file = pathlib.Path(__file__).parent.joinpath(
+            "../../static/images/default_avi.jpg"
+        )
+        image = Image.open(image_file)
+        output = BytesIO()
+        image.save(output, format=image.format)
+        self.image_data = output.getvalue()
 
-    def test_init(self, _):
+    def test_init(self, *_):
         """simple successfuly init"""
         instance = ActivityObject(id="a", type="b")
         self.assertTrue(hasattr(instance, "id"))
         self.assertTrue(hasattr(instance, "type"))
 
-    def test_init_missing(self, _):
+    def test_init_missing(self, *_):
         """init with missing required params"""
         with self.assertRaises(ActivitySerializerError):
             ActivityObject()
 
-    def test_init_extra_fields(self, _):
+    def test_init_extra_fields(self, *_):
         """init ignoring additional fields"""
         instance = ActivityObject(id="a", type="b", fish="c")
         self.assertTrue(hasattr(instance, "id"))
         self.assertTrue(hasattr(instance, "type"))
 
-    def test_init_default_field(self, _):
+    def test_init_default_field(self, *_):
         """replace an existing required field with a default field"""
 
         @dataclass(init=False)
@@ -75,7 +78,7 @@ class BaseActivity(TestCase):
         self.assertEqual(instance.id, "a")
         self.assertEqual(instance.type, "TestObject")
 
-    def test_serialize(self, _):
+    def test_serialize(self, *_):
         """simple function for converting dataclass to dict"""
         instance = ActivityObject(id="a", type="b")
         serialized = instance.serialize()
@@ -84,7 +87,7 @@ class BaseActivity(TestCase):
         self.assertEqual(serialized["type"], "b")
 
     @responses.activate
-    def test_resolve_remote_id(self, _):
+    def test_resolve_remote_id(self, *_):
         """look up or load remote data"""
         # existing item
         result = resolve_remote_id("http://example.com/a/b", model=models.User)
@@ -98,23 +101,22 @@ class BaseActivity(TestCase):
             status=200,
         )
 
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
-            with patch("bookwyrm.models.user.set_remote_server.delay"):
-                result = resolve_remote_id(
-                    "https://example.com/user/mouse", model=models.User
-                )
+        with patch("bookwyrm.models.user.set_remote_server.delay"):
+            result = resolve_remote_id(
+                "https://example.com/user/mouse", model=models.User
+            )
         self.assertIsInstance(result, models.User)
         self.assertEqual(result.remote_id, "https://example.com/user/mouse")
         self.assertEqual(result.name, "MOUSE?? MOUSE!!")
 
-    def test_to_model_invalid_model(self, _):
+    def test_to_model_invalid_model(self, *_):
         """catch mismatch between activity type and model type"""
         instance = ActivityObject(id="a", type="b")
         with self.assertRaises(ActivitySerializerError):
             instance.to_model(model=models.User)
 
     @responses.activate
-    def test_to_model_image(self, _):
+    def test_to_model_image(self, *_):
         """update an image field"""
         activity = activitypub.Person(
             id=self.user.remote_id,
@@ -141,24 +143,22 @@ class BaseActivity(TestCase):
             self.user.avatar.file  # pylint: disable=pointless-statement
 
         # 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"):
-                activity.to_model(model=models.User, instance=self.user)
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            activity.to_model(model=models.User, instance=self.user)
         self.assertIsNotNone(self.user.avatar.file)
         self.assertEqual(self.user.name, "New Name")
         self.assertEqual(self.user.key_pair.public_key, "hi")
 
-    def test_to_model_many_to_many(self, _):
+    def test_to_model_many_to_many(self, *_):
         """annoying that these all need special handling"""
         with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
             status = models.Status.objects.create(
                 content="test status",
                 user=self.user,
             )
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            book = models.Edition.objects.create(
-                title="Test Edition", remote_id="http://book.com/book"
-            )
+        book = models.Edition.objects.create(
+            title="Test Edition", remote_id="http://book.com/book"
+        )
         update_data = activitypub.Note(
             id=status.remote_id,
             content=status.content,
@@ -180,7 +180,7 @@ class BaseActivity(TestCase):
         self.assertEqual(status.mention_books.first(), book)
 
     @responses.activate
-    def test_to_model_one_to_many(self, _):
+    def test_to_model_one_to_many(self, *_):
         """these are reversed relationships, where the secondary object
         keys the primary object but not vice versa"""
         with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
@@ -219,7 +219,7 @@ class BaseActivity(TestCase):
         self.assertIsNone(status.attachments.first())
 
     @responses.activate
-    def test_set_related_field(self, _):
+    def test_set_related_field(self, *_):
         """celery task to add back-references to created objects"""
         with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
             status = models.Status.objects.create(

bookwyrm/tests/activitypub/test_person.py

@@ -20,9 +20,8 @@ class Person(TestCase):
 
     def test_user_to_model(self):
         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"):
-                user = activity.to_model(model=models.User)
+        with patch("bookwyrm.models.user.set_remote_server.delay"):
+            user = activity.to_model(model=models.User)
         self.assertEqual(user.username, "mouse@example.com")
         self.assertEqual(user.remote_id, "https://example.com/user/mouse")
         self.assertFalse(user.local)

bookwyrm/tests/activitypub/test_quotation.py

@@ -12,22 +12,20 @@ class Quotation(TestCase):
 
     def setUp(self):
         """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"):
-                self.user = models.User.objects.create_user(
-                    "mouse",
-                    "mouse@mouse.mouse",
-                    "mouseword",
-                    local=False,
-                    inbox="https://example.com/user/mouse/inbox",
-                    outbox="https://example.com/user/mouse/outbox",
-                    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",
+        with patch("bookwyrm.models.user.set_remote_server.delay"):
+            self.user = models.User.objects.create_user(
+                "mouse",
+                "mouse@mouse.mouse",
+                "mouseword",
+                local=False,
+                inbox="https://example.com/user/mouse/inbox",
+                outbox="https://example.com/user/mouse/outbox",
+                remote_id="https://example.com/user/mouse",
             )
+        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")
         self.status_data = json.loads(datafile.read_bytes())
 

bookwyrm/tests/connectors/test_abstract_connector.py

@@ -74,12 +74,11 @@ class AbstractConnector(TestCase):
             Mapping("openlibraryKey"),
         ]
 
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            self.book = models.Edition.objects.create(
-                title="Test Book",
-                remote_id="https://example.com/book/1234",
-                openlibrary_key="OL1234M",
-            )
+        self.book = models.Edition.objects.create(
+            title="Test Book",
+            remote_id="https://example.com/book/1234",
+            openlibrary_key="OL1234M",
+        )
 
     def test_abstract_connector_init(self):
         """barebones connector for search with defaults"""
@@ -111,11 +110,8 @@ class AbstractConnector(TestCase):
         responses.add(
             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"):
-                result = self.connector.get_or_create_book(
-                    "https://example.com/book/abcd"
-                )
+        with patch("bookwyrm.connectors.abstract_connector.load_more_data.delay"):
+            result = self.connector.get_or_create_book("https://example.com/book/abcd")
         self.assertEqual(result, self.book)
         self.assertEqual(models.Edition.objects.count(), 1)
         self.assertEqual(models.Edition.objects.count(), 1)
@@ -123,10 +119,12 @@ class AbstractConnector(TestCase):
     @responses.activate
     def test_get_or_create_author(self):
         """load an author"""
-        self.connector.author_mappings = [
-            Mapping("id"),
-            Mapping("name"),
-        ]
+        self.connector.author_mappings = (
+            [  # pylint: disable=attribute-defined-outside-init
+                Mapping("id"),
+                Mapping("name"),
+            ]
+        )
 
         responses.add(
             responses.GET,

bookwyrm/tests/connectors/test_bookwyrm_connector.py

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

bookwyrm/tests/connectors/test_connector_manager.py

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

bookwyrm/tests/connectors/test_inventaire_connector.py

@@ -171,3 +171,15 @@ class Inventaire(TestCase):
         }
         self.assertEqual(get_language_code(options), "there")
         self.assertIsNone(get_language_code({}))
+
+    @responses.activate
+    def test_get_description(self):
+        """extract a wikipedia excerpt"""
+        responses.add(
+            responses.GET,
+            "https://inventaire.io/api/data?action=wp-extract&lang=en&title=test_path",
+            json={"extract": "hi hi"},
+        )
+
+        extract = self.connector.get_description({"enwiki": "test_path"})
+        self.assertEqual(extract, "hi hi")

bookwyrm/tests/connectors/test_openlibrary_connector.py

@@ -178,26 +178,20 @@ class Openlibrary(TestCase):
     @responses.activate
     def test_expand_book_data(self):
         """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"
-            )
-            edition = models.Edition.objects.create(
-                title="Test Edition", parent_work=work
-            )
+        work = models.Work.objects.create(title="Test Work", openlibrary_key="OL1234W")
+        edition = models.Edition.objects.create(title="Test Edition", parent_work=work)
 
         responses.add(
             responses.GET,
             "https://openlibrary.org/works/OL1234W/editions",
             json={"entries": []},
         )
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
-            with patch(
-                "bookwyrm.connectors.abstract_connector.AbstractConnector."
-                "create_edition_from_data"
-            ):
-                self.connector.expand_book_data(edition)
-                self.connector.expand_book_data(work)
+        with patch(
+            "bookwyrm.connectors.abstract_connector.AbstractConnector."
+            "create_edition_from_data"
+        ):
+            self.connector.expand_book_data(edition)
+            self.connector.expand_book_data(work)
 
     def test_get_description(self):
         """should do some cleanup on the description data"""
@@ -230,14 +224,11 @@ class Openlibrary(TestCase):
             json={"hi": "there"},
             status=200,
         )
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            with patch(
-                "bookwyrm.connectors.openlibrary.Connector." "get_authors_from_data"
-            ) as mock:
-                mock.return_value = []
-                result = self.connector.create_edition_from_data(
-                    work, self.edition_data
-                )
+        with patch(
+            "bookwyrm.connectors.openlibrary.Connector." "get_authors_from_data"
+        ) as mock:
+            mock.return_value = []
+            result = self.connector.create_edition_from_data(work, self.edition_data)
         self.assertEqual(result.parent_work, work)
         self.assertEqual(result.title, "Sabriel")
         self.assertEqual(result.isbn_10, "0060273224")

bookwyrm/tests/connectors/test_self_connector.py

@@ -1,5 +1,4 @@
 """ testing book data connectors """
-from unittest.mock import patch
 import datetime
 from django.test import TestCase
 from django.utils import timezone
@@ -30,21 +29,19 @@ class SelfConnector(TestCase):
     def test_format_search_result(self):
         """create a SearchResult"""
         author = models.Author.objects.create(name="Anonymous")
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            edition = models.Edition.objects.create(
-                title="Edition of Example Work",
-                published_date=datetime.datetime(1980, 5, 10, tzinfo=timezone.utc),
-            )
-            edition.authors.add(author)
-            result = self.connector.search("Edition of Example")[0]
+        edition = models.Edition.objects.create(
+            title="Edition of Example Work",
+            published_date=datetime.datetime(1980, 5, 10, tzinfo=timezone.utc),
+        )
+        edition.authors.add(author)
+        result = self.connector.search("Edition of Example")[0]
         self.assertEqual(result.title, "Edition of Example Work")
         self.assertEqual(result.key, edition.remote_id)
         self.assertEqual(result.author, "Anonymous")
         self.assertEqual(result.year, 1980)
         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"""
         author = models.Author.objects.create(name="Anonymous")
         edition = models.Edition.objects.create(
@@ -81,8 +78,7 @@ class SelfConnector(TestCase):
         self.assertEqual(results[2].title, "Edition of Example Work")
         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"""
         work = models.Work.objects.create(title="Work Title")
         edition_1 = models.Edition.objects.create(

bookwyrm/tests/data/ap_user.json

@@ -28,7 +28,7 @@
     },
     "bookwyrmUser": true,
     "manuallyApprovesFollowers": false,
-    "discoverable": true,
+    "discoverable": false,
     "devices": "https://friend.camp/users/tripofmice/collections/devices",
     "tag": [],
     "icon": {

bookwyrm/tests/importers/test_goodreads_import.py

@@ -3,6 +3,8 @@ from collections import namedtuple
 import csv
 import pathlib
 from unittest.mock import patch
+import datetime
+import pytz
 
 from django.test import TestCase
 import responses
@@ -13,6 +15,13 @@ from bookwyrm.importers.importer import import_data, handle_imported_book
 from bookwyrm.settings import DOMAIN
 
 
+def make_date(*args):
+    """helper function to easily generate a date obj"""
+    return datetime.datetime(*args, tzinfo=pytz.UTC)
+
+
+# pylint: disable=consider-using-with
+@patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
 class GoodreadsImport(TestCase):
     """importing from goodreads csv"""
 
@@ -21,7 +30,7 @@ class GoodreadsImport(TestCase):
         self.importer = GoodreadsImporter()
         datafile = pathlib.Path(__file__).parent.joinpath("../data/goodreads.csv")
         self.csv = open(datafile, "r", encoding=self.importer.encoding)
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.mouse", "password", local=True
             )
@@ -37,15 +46,14 @@ class GoodreadsImport(TestCase):
             search_url="https://%s/search?q=" % DOMAIN,
             priority=1,
         )
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            work = models.Work.objects.create(title="Test Work")
-            self.book = models.Edition.objects.create(
-                title="Example Edition",
-                remote_id="https://example.com/book/1",
-                parent_work=work,
-            )
+        work = models.Work.objects.create(title="Test Work")
+        self.book = models.Edition.objects.create(
+            title="Example Edition",
+            remote_id="https://example.com/book/1",
+            parent_work=work,
+        )
 
-    def test_create_job(self):
+    def test_create_job(self, _):
         """creates the import job entry and checks csv"""
         import_job = self.importer.create_job(self.user, self.csv, False, "public")
         self.assertEqual(import_job.user, self.user)
@@ -61,7 +69,7 @@ class GoodreadsImport(TestCase):
         self.assertEqual(import_items[2].index, 2)
         self.assertEqual(import_items[2].data["Book Id"], "28694510")
 
-    def test_create_retry_job(self):
+    def test_create_retry_job(self, _):
         """trying again with items that didn't import"""
         import_job = self.importer.create_job(self.user, self.csv, False, "unlisted")
         import_items = models.ImportItem.objects.filter(job=import_job).all()[:2]
@@ -79,7 +87,7 @@ class GoodreadsImport(TestCase):
         self.assertEqual(retry_items[1].index, 1)
         self.assertEqual(retry_items[1].data["Book Id"], "52691223")
 
-    def test_start_import(self):
+    def test_start_import(self, _):
         """begin loading books"""
         import_job = self.importer.create_job(self.user, self.csv, False, "unlisted")
         MockTask = namedtuple("Task", ("id"))
@@ -91,11 +99,10 @@ class GoodreadsImport(TestCase):
         self.assertEqual(import_job.task_id, "7")
 
     @responses.activate
-    def test_import_data(self):
+    def test_import_data(self, _):
         """resolve entry"""
         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(
             "bookwyrm.models.import_job.ImportItem.get_book_from_isbn"
@@ -107,46 +114,11 @@ class GoodreadsImport(TestCase):
         import_item = models.ImportItem.objects.get(job=import_job, index=0)
         self.assertEqual(import_item.book.id, book.id)
 
-    def test_handle_imported_book(self):
+    def test_handle_imported_book(self, _):
         """goodreads import added a book, this adds related connections"""
         shelf = self.user.shelf_set.filter(identifier="read").first()
         self.assertIsNone(shelf.books.first())
 
-        import_job = models.ImportJob.objects.create(user=self.user)
-        datafile = pathlib.Path(__file__).parent.joinpath("../data/goodreads.csv")
-        csv_file = open(datafile, "r")
-        for index, entry in enumerate(list(csv.DictReader(csv_file))):
-            entry = self.importer.parse_fields(entry)
-            import_item = models.ImportItem.objects.create(
-                job_id=import_job.id, index=index, data=entry, book=self.book
-            )
-            break
-
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, False, "public"
-                )
-
-        shelf.refresh_from_db()
-        self.assertEqual(shelf.books.first(), self.book)
-
-        readthrough = models.ReadThrough.objects.get(user=self.user)
-        self.assertEqual(readthrough.book, self.book)
-        # I can't remember how to create dates and I don't want to look it up.
-        self.assertEqual(readthrough.start_date.year, 2020)
-        self.assertEqual(readthrough.start_date.month, 10)
-        self.assertEqual(readthrough.start_date.day, 21)
-        self.assertEqual(readthrough.finish_date.year, 2020)
-        self.assertEqual(readthrough.finish_date.month, 10)
-        self.assertEqual(readthrough.finish_date.day, 25)
-
-    def test_handle_imported_book_already_shelved(self):
-        """goodreads import added a book, this adds related connections"""
-        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
-            shelf = self.user.shelf_set.filter(identifier="to-read").first()
-            models.ShelfBook.objects.create(shelf=shelf, user=self.user, book=self.book)
-
         import_job = models.ImportJob.objects.create(user=self.user)
         datafile = pathlib.Path(__file__).parent.joinpath("../data/goodreads.csv")
         csv_file = open(datafile, "r")
@@ -164,17 +136,54 @@ class GoodreadsImport(TestCase):
 
         shelf.refresh_from_db()
         self.assertEqual(shelf.books.first(), self.book)
-        self.assertIsNone(self.user.shelf_set.get(identifier="read").books.first())
+        self.assertEqual(
+            shelf.shelfbook_set.first().shelved_date, make_date(2020, 10, 21)
+        )
+
         readthrough = models.ReadThrough.objects.get(user=self.user)
         self.assertEqual(readthrough.book, self.book)
-        self.assertEqual(readthrough.start_date.year, 2020)
-        self.assertEqual(readthrough.start_date.month, 10)
-        self.assertEqual(readthrough.start_date.day, 21)
-        self.assertEqual(readthrough.finish_date.year, 2020)
-        self.assertEqual(readthrough.finish_date.month, 10)
-        self.assertEqual(readthrough.finish_date.day, 25)
+        self.assertEqual(readthrough.start_date, make_date(2020, 10, 21))
+        self.assertEqual(readthrough.finish_date, make_date(2020, 10, 25))
 
-    def test_handle_import_twice(self):
+    def test_handle_imported_book_already_shelved(self, _):
+        """goodreads import added a book, this adds related connections"""
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            shelf = self.user.shelf_set.filter(identifier="to-read").first()
+            models.ShelfBook.objects.create(
+                shelf=shelf,
+                user=self.user,
+                book=self.book,
+                shelved_date=make_date(2020, 2, 2),
+            )
+
+        import_job = models.ImportJob.objects.create(user=self.user)
+        datafile = pathlib.Path(__file__).parent.joinpath("../data/goodreads.csv")
+        csv_file = open(datafile, "r")
+        for index, entry in enumerate(list(csv.DictReader(csv_file))):
+            entry = self.importer.parse_fields(entry)
+            import_item = models.ImportItem.objects.create(
+                job_id=import_job.id, index=index, data=entry, book=self.book
+            )
+            break
+
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            handle_imported_book(
+                self.importer.service, self.user, import_item, False, "public"
+            )
+
+        shelf.refresh_from_db()
+        self.assertEqual(shelf.books.first(), self.book)
+        self.assertEqual(
+            shelf.shelfbook_set.first().shelved_date, make_date(2020, 2, 2)
+        )
+        self.assertIsNone(self.user.shelf_set.get(identifier="read").books.first())
+
+        readthrough = models.ReadThrough.objects.get(user=self.user)
+        self.assertEqual(readthrough.book, self.book)
+        self.assertEqual(readthrough.start_date, make_date(2020, 10, 21))
+        self.assertEqual(readthrough.finish_date, make_date(2020, 10, 25))
+
+    def test_handle_import_twice(self, _):
         """re-importing books"""
         shelf = self.user.shelf_set.filter(identifier="read").first()
         import_job = models.ImportJob.objects.create(user=self.user)
@@ -187,30 +196,27 @@ class GoodreadsImport(TestCase):
             )
             break
 
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, False, "public"
-                )
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, False, "public"
-                )
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            handle_imported_book(
+                self.importer.service, self.user, import_item, False, "public"
+            )
+            handle_imported_book(
+                self.importer.service, self.user, import_item, False, "public"
+            )
 
         shelf.refresh_from_db()
         self.assertEqual(shelf.books.first(), self.book)
+        self.assertEqual(
+            shelf.shelfbook_set.first().shelved_date, make_date(2020, 10, 21)
+        )
 
         readthrough = models.ReadThrough.objects.get(user=self.user)
         self.assertEqual(readthrough.book, self.book)
-        # I can't remember how to create dates and I don't want to look it up.
-        self.assertEqual(readthrough.start_date.year, 2020)
-        self.assertEqual(readthrough.start_date.month, 10)
-        self.assertEqual(readthrough.start_date.day, 21)
-        self.assertEqual(readthrough.finish_date.year, 2020)
-        self.assertEqual(readthrough.finish_date.month, 10)
-        self.assertEqual(readthrough.finish_date.day, 25)
+        self.assertEqual(readthrough.start_date, make_date(2020, 10, 21))
+        self.assertEqual(readthrough.finish_date, make_date(2020, 10, 25))
 
     @patch("bookwyrm.activitystreams.ActivityStream.add_status")
-    def test_handle_imported_book_review(self, _):
+    def test_handle_imported_book_review(self, *_):
         """goodreads review import"""
         import_job = models.ImportJob.objects.create(user=self.user)
         datafile = pathlib.Path(__file__).parent.joinpath("../data/goodreads.csv")
@@ -221,21 +227,18 @@ class GoodreadsImport(TestCase):
             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"):
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, True, "unlisted"
-                )
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            handle_imported_book(
+                self.importer.service, self.user, import_item, True, "unlisted"
+            )
         review = models.Review.objects.get(book=self.book, user=self.user)
         self.assertEqual(review.content, "mixed feelings")
         self.assertEqual(review.rating, 2)
-        self.assertEqual(review.published_date.year, 2019)
-        self.assertEqual(review.published_date.month, 7)
-        self.assertEqual(review.published_date.day, 8)
+        self.assertEqual(review.published_date, make_date(2019, 7, 8))
         self.assertEqual(review.privacy, "unlisted")
 
     @patch("bookwyrm.activitystreams.ActivityStream.add_status")
-    def test_handle_imported_book_rating(self, _):
+    def test_handle_imported_book_rating(self, *_):
         """goodreads rating import"""
         import_job = models.ImportJob.objects.create(user=self.user)
         datafile = pathlib.Path(__file__).parent.joinpath(
@@ -248,20 +251,17 @@ class GoodreadsImport(TestCase):
             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"):
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, True, "unlisted"
-                )
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            handle_imported_book(
+                self.importer.service, self.user, import_item, True, "unlisted"
+            )
         review = models.ReviewRating.objects.get(book=self.book, user=self.user)
         self.assertIsInstance(review, models.ReviewRating)
         self.assertEqual(review.rating, 2)
-        self.assertEqual(review.published_date.year, 2019)
-        self.assertEqual(review.published_date.month, 7)
-        self.assertEqual(review.published_date.day, 8)
+        self.assertEqual(review.published_date, make_date(2019, 7, 8))
         self.assertEqual(review.privacy, "unlisted")
 
-    def test_handle_imported_book_reviews_disabled(self):
+    def test_handle_imported_book_reviews_disabled(self, _):
         """goodreads review import"""
         import_job = models.ImportJob.objects.create(user=self.user)
         datafile = pathlib.Path(__file__).parent.joinpath("../data/goodreads.csv")
@@ -272,11 +272,10 @@ class GoodreadsImport(TestCase):
             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"):
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, False, "unlisted"
-                )
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            handle_imported_book(
+                self.importer.service, self.user, import_item, False, "unlisted"
+            )
         self.assertFalse(
             models.Review.objects.filter(book=self.book, user=self.user).exists()
         )

bookwyrm/tests/importers/test_librarything_import.py

@@ -2,6 +2,8 @@
 import csv
 import pathlib
 from unittest.mock import patch
+import datetime
+import pytz
 
 from django.test import TestCase
 import responses
@@ -12,6 +14,13 @@ from bookwyrm.importers.importer import import_data, handle_imported_book
 from bookwyrm.settings import DOMAIN
 
 
+def make_date(*args):
+    """helper function to easily generate a date obj"""
+    return datetime.datetime(*args, tzinfo=pytz.UTC)
+
+
+# pylint: disable=consider-using-with
+@patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
 class LibrarythingImport(TestCase):
     """importing from librarything tsv"""
 
@@ -22,7 +31,7 @@ class LibrarythingImport(TestCase):
 
         # Librarything generates latin encoded exports...
         self.csv = open(datafile, "r", encoding=self.importer.encoding)
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.user = models.User.objects.create_user(
                 "mmai", "mmai@mmai.mmai", "password", local=True
             )
@@ -38,15 +47,14 @@ class LibrarythingImport(TestCase):
             search_url="https://%s/search?q=" % DOMAIN,
             priority=1,
         )
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            work = models.Work.objects.create(title="Test Work")
-            self.book = models.Edition.objects.create(
-                title="Example Edition",
-                remote_id="https://example.com/book/1",
-                parent_work=work,
-            )
+        work = models.Work.objects.create(title="Test Work")
+        self.book = models.Edition.objects.create(
+            title="Example Edition",
+            remote_id="https://example.com/book/1",
+            parent_work=work,
+        )
 
-    def test_create_job(self):
+    def test_create_job(self, _):
         """creates the import job entry and checks csv"""
         import_job = self.importer.create_job(self.user, self.csv, False, "public")
         self.assertEqual(import_job.user, self.user)
@@ -62,7 +70,7 @@ class LibrarythingImport(TestCase):
         self.assertEqual(import_items[2].index, 2)
         self.assertEqual(import_items[2].data["Book Id"], "5015399")
 
-    def test_create_retry_job(self):
+    def test_create_retry_job(self, _):
         """trying again with items that didn't import"""
         import_job = self.importer.create_job(self.user, self.csv, False, "unlisted")
         import_items = models.ImportItem.objects.filter(job=import_job).all()[:2]
@@ -81,11 +89,10 @@ class LibrarythingImport(TestCase):
         self.assertEqual(retry_items[1].data["Book Id"], "5015319")
 
     @responses.activate
-    def test_import_data(self):
+    def test_import_data(self, _):
         """resolve entry"""
         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(
             "bookwyrm.models.import_job.ImportItem.get_book_from_isbn"
@@ -97,7 +104,7 @@ class LibrarythingImport(TestCase):
         import_item = models.ImportItem.objects.get(job=import_job, index=0)
         self.assertEqual(import_item.book.id, book.id)
 
-    def test_handle_imported_book(self):
+    def test_handle_imported_book(self, _):
         """librarything import added a book, this adds related connections"""
         shelf = self.user.shelf_set.filter(identifier="read").first()
         self.assertIsNone(shelf.books.first())
@@ -114,26 +121,20 @@ class LibrarythingImport(TestCase):
             )
             break
 
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, False, "public"
-                )
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            handle_imported_book(
+                self.importer.service, self.user, import_item, False, "public"
+            )
 
         shelf.refresh_from_db()
         self.assertEqual(shelf.books.first(), self.book)
 
         readthrough = models.ReadThrough.objects.get(user=self.user)
         self.assertEqual(readthrough.book, self.book)
-        # I can't remember how to create dates and I don't want to look it up.
-        self.assertEqual(readthrough.start_date.year, 2007)
-        self.assertEqual(readthrough.start_date.month, 4)
-        self.assertEqual(readthrough.start_date.day, 16)
-        self.assertEqual(readthrough.finish_date.year, 2007)
-        self.assertEqual(readthrough.finish_date.month, 5)
-        self.assertEqual(readthrough.finish_date.day, 8)
+        self.assertEqual(readthrough.start_date, make_date(2007, 4, 16))
+        self.assertEqual(readthrough.finish_date, make_date(2007, 5, 8))
 
-    def test_handle_imported_book_already_shelved(self):
+    def test_handle_imported_book_already_shelved(self, _):
         """librarything import added a book, this adds related connections"""
         with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
             shelf = self.user.shelf_set.filter(identifier="to-read").first()
@@ -151,25 +152,21 @@ class LibrarythingImport(TestCase):
             )
             break
 
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, False, "public"
-                )
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            handle_imported_book(
+                self.importer.service, self.user, import_item, False, "public"
+            )
 
         shelf.refresh_from_db()
         self.assertEqual(shelf.books.first(), self.book)
         self.assertIsNone(self.user.shelf_set.get(identifier="read").books.first())
+
         readthrough = models.ReadThrough.objects.get(user=self.user)
         self.assertEqual(readthrough.book, self.book)
-        self.assertEqual(readthrough.start_date.year, 2007)
-        self.assertEqual(readthrough.start_date.month, 4)
-        self.assertEqual(readthrough.start_date.day, 16)
-        self.assertEqual(readthrough.finish_date.year, 2007)
-        self.assertEqual(readthrough.finish_date.month, 5)
-        self.assertEqual(readthrough.finish_date.day, 8)
+        self.assertEqual(readthrough.start_date, make_date(2007, 4, 16))
+        self.assertEqual(readthrough.finish_date, make_date(2007, 5, 8))
 
-    def test_handle_import_twice(self):
+    def test_handle_import_twice(self, _):
         """re-importing books"""
         shelf = self.user.shelf_set.filter(identifier="read").first()
         import_job = models.ImportJob.objects.create(user=self.user)
@@ -184,30 +181,24 @@ class LibrarythingImport(TestCase):
             )
             break
 
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, False, "public"
-                )
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, False, "public"
-                )
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            handle_imported_book(
+                self.importer.service, self.user, import_item, False, "public"
+            )
+            handle_imported_book(
+                self.importer.service, self.user, import_item, False, "public"
+            )
 
         shelf.refresh_from_db()
         self.assertEqual(shelf.books.first(), self.book)
 
         readthrough = models.ReadThrough.objects.get(user=self.user)
         self.assertEqual(readthrough.book, self.book)
-        # I can't remember how to create dates and I don't want to look it up.
-        self.assertEqual(readthrough.start_date.year, 2007)
-        self.assertEqual(readthrough.start_date.month, 4)
-        self.assertEqual(readthrough.start_date.day, 16)
-        self.assertEqual(readthrough.finish_date.year, 2007)
-        self.assertEqual(readthrough.finish_date.month, 5)
-        self.assertEqual(readthrough.finish_date.day, 8)
+        self.assertEqual(readthrough.start_date, make_date(2007, 4, 16))
+        self.assertEqual(readthrough.finish_date, make_date(2007, 5, 8))
 
     @patch("bookwyrm.activitystreams.ActivityStream.add_status")
-    def test_handle_imported_book_review(self, _):
+    def test_handle_imported_book_review(self, *_):
         """librarything review import"""
         import_job = models.ImportJob.objects.create(user=self.user)
         datafile = pathlib.Path(__file__).parent.joinpath("../data/librarything.tsv")
@@ -218,20 +209,17 @@ class LibrarythingImport(TestCase):
             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"):
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, True, "unlisted"
-                )
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            handle_imported_book(
+                self.importer.service, self.user, import_item, True, "unlisted"
+            )
         review = models.Review.objects.get(book=self.book, user=self.user)
         self.assertEqual(review.content, "chef d'oeuvre")
         self.assertEqual(review.rating, 5)
-        self.assertEqual(review.published_date.year, 2007)
-        self.assertEqual(review.published_date.month, 5)
-        self.assertEqual(review.published_date.day, 8)
+        self.assertEqual(review.published_date, make_date(2007, 5, 8))
         self.assertEqual(review.privacy, "unlisted")
 
-    def test_handle_imported_book_reviews_disabled(self):
+    def test_handle_imported_book_reviews_disabled(self, _):
         """librarything review import"""
         import_job = models.ImportJob.objects.create(user=self.user)
         datafile = pathlib.Path(__file__).parent.joinpath("../data/librarything.tsv")
@@ -242,11 +230,10 @@ class LibrarythingImport(TestCase):
             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"):
-                handle_imported_book(
-                    self.importer.service, self.user, import_item, False, "unlisted"
-                )
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
+            handle_imported_book(
+                self.importer.service, self.user, import_item, False, "unlisted"
+            )
         self.assertFalse(
             models.Review.objects.filter(book=self.book, user=self.user).exists()
         )

bookwyrm/tests/management/test_populate_streams.py

@@ -12,7 +12,7 @@ class Activitystreams(TestCase):
 
     def setUp(self):
         """we need some stuff"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.local_user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
             )
@@ -23,18 +23,17 @@ class Activitystreams(TestCase):
                 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")
+        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.book = models.Edition.objects.create(title="test book")
 
     def test_populate_streams(self, _):
         """make sure the function on the redis manager gets called"""
@@ -47,4 +46,4 @@ class Activitystreams(TestCase):
             "bookwyrm.activitystreams.ActivityStream.populate_store"
         ) as redis_mock:
             populate_streams()
-        self.assertEqual(redis_mock.call_count, 6)  # 2 users x 3 streams
+        self.assertEqual(redis_mock.call_count, 4)  # 2 users x 2 streams

bookwyrm/tests/models/test_activitypub_mixin.py

@@ -21,28 +21,28 @@ from bookwyrm.settings import PAGE_LENGTH
 
 # pylint: disable=invalid-name
 @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):
     """functionality shared across models"""
 
     def setUp(self):
         """shared data"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.local_user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
             )
-            self.local_user.remote_id = "http://example.com/a/b"
-            self.local_user.save(broadcast=False)
-            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, update_fields=["remote_id"])
+        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 = {
             "to": "to field",
@@ -78,22 +78,20 @@ class ActivitypubMixins(TestCase):
         """attempt to match a remote id to an object in the db"""
         # uses a different remote id scheme
         # 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(
-                title="Test Edition", remote_id="http://book.com/book"
-            )
+        book = models.Edition.objects.create(
+            title="Test Edition", remote_id="http://book.com/book"
+        )
 
         self.assertEqual(book.origin_id, "http://book.com/book")
         self.assertNotEqual(book.remote_id, "http://book.com/book")
 
         # uses subclasses
-        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
-            models.Comment.objects.create(
-                user=self.local_user,
-                content="test status",
-                book=book,
-                remote_id="https://comment.net",
-            )
+        models.Comment.objects.create(
+            user=self.local_user,
+            content="test status",
+            book=book,
+            remote_id="https://comment.net",
+        )
 
         result = models.User.find_existing_by_remote_id("hi")
         self.assertIsNone(result)
@@ -110,11 +108,10 @@ class ActivitypubMixins(TestCase):
 
     def test_find_existing(self, *_):
         """match a blob of data to a model"""
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            book = models.Edition.objects.create(
-                title="Test edition",
-                openlibrary_key="OL1234",
-            )
+        book = models.Edition.objects.create(
+            title="Test edition",
+            openlibrary_key="OL1234",
+        )
 
         result = models.Edition.find_existing({"openlibraryKey": "OL1234"})
         self.assertEqual(result, book)
@@ -193,7 +190,7 @@ class ActivitypubMixins(TestCase):
     def test_get_recipients_combine_inboxes(self, *_):
         """should combine users with the same shared_inbox"""
         self.remote_user.shared_inbox = "http://example.com/inbox"
-        self.remote_user.save(broadcast=False)
+        self.remote_user.save(broadcast=False, update_fields=["shared_inbox"])
         with patch("bookwyrm.models.user.set_remote_server.delay"):
             another_remote_user = models.User.objects.create_user(
                 "nutria",
@@ -369,7 +366,6 @@ class ActivitypubMixins(TestCase):
         self.assertEqual(activity["type"], "Undo")
         self.assertIsInstance(activity["object"], dict)
 
-    @patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
     def test_to_ordered_collection_page(self, *_):
         """make sure the paged results of an ordered collection work"""
         self.assertEqual(PAGE_LENGTH, 15)
@@ -395,7 +391,6 @@ class ActivitypubMixins(TestCase):
         self.assertEqual(page_2.orderedItems[0]["content"], "test status 14")
         self.assertEqual(page_2.orderedItems[-1]["content"], "test status 0")
 
-    @patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
     def test_to_ordered_collection(self, *_):
         """convert a queryset into an ordered collection object"""
         self.assertEqual(PAGE_LENGTH, 15)

bookwyrm/tests/models/test_base_model.py

@@ -7,25 +7,26 @@ from bookwyrm.models import base_model
 from bookwyrm.settings import DOMAIN
 
 
+# pylint: disable=attribute-defined-outside-init
 class BaseModel(TestCase):
     """functionality shared across models"""
 
     def setUp(self):
         """shared data"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.local_user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
             )
-            with patch("bookwyrm.models.user.set_remote_server.delay"):
-                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):
             """just making it not abstract"""

bookwyrm/tests/models/test_book_model.py

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

bookwyrm/tests/models/test_federated_server.py

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

bookwyrm/tests/models/test_fields.py

@@ -24,10 +24,11 @@ from bookwyrm.models.base_model import BookWyrmModel
 from bookwyrm.models.activitypub_mixin import ActivitypubMixin
 
 # pylint: disable=too-many-public-methods
-class ActivitypubFields(TestCase):
+@patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
+class ModelFields(TestCase):
     """overwrites standard model feilds to work with activitypub"""
 
-    def test_validate_remote_id(self):
+    def test_validate_remote_id(self, _):
         """should look like a url"""
         self.assertIsNone(fields.validate_remote_id("http://www.example.com"))
         self.assertIsNone(fields.validate_remote_id("https://www.example.com"))
@@ -44,7 +45,7 @@ class ActivitypubFields(TestCase):
             "http://www.example.com/dlfjg 23/x",
         )
 
-    def test_activitypub_field_mixin(self):
+    def test_activitypub_field_mixin(self, _):
         """generic mixin with super basic to and from functionality"""
         instance = fields.ActivitypubFieldMixin()
         self.assertEqual(instance.field_to_activity("fish"), "fish")
@@ -62,7 +63,7 @@ class ActivitypubFields(TestCase):
         instance.name = "snake_case_name"
         self.assertEqual(instance.get_activitypub_field(), "snakeCaseName")
 
-    def test_set_field_from_activity(self):
+    def test_set_field_from_activity(self, _):
         """setter from entire json blob"""
 
         @dataclass
@@ -81,7 +82,7 @@ class ActivitypubFields(TestCase):
         instance.set_field_from_activity(mock_model, data)
         self.assertEqual(mock_model.field_name, "hi")
 
-    def test_set_activity_from_field(self):
+    def test_set_activity_from_field(self, _):
         """set json field given entire model"""
 
         @dataclass
@@ -99,7 +100,7 @@ class ActivitypubFields(TestCase):
         instance.set_activity_from_field(data, mock_model)
         self.assertEqual(data["fieldName"], "bip")
 
-    def test_remote_id_field(self):
+    def test_remote_id_field(self, _):
         """just sets some defaults on charfield"""
         instance = fields.RemoteIdField()
         self.assertEqual(instance.max_length, 255)
@@ -108,7 +109,7 @@ class ActivitypubFields(TestCase):
         with self.assertRaises(ValidationError):
             instance.run_validators("http://www.example.com/dlfjg 23/x")
 
-    def test_username_field(self):
+    def test_username_field(self, _):
         """again, just setting defaults on username field"""
         instance = fields.UsernameField()
         self.assertEqual(instance.activitypub_field, "preferredUsername")
@@ -129,7 +130,7 @@ class ActivitypubFields(TestCase):
 
         self.assertEqual(instance.field_to_activity("test@example.com"), "test")
 
-    def test_privacy_field_defaults(self):
+    def test_privacy_field_defaults(self, _):
         """post privacy field's many default values"""
         instance = fields.PrivacyField()
         self.assertEqual(instance.max_length, 255)
@@ -142,7 +143,7 @@ class ActivitypubFields(TestCase):
             instance.public, "https://www.w3.org/ns/activitystreams#Public"
         )
 
-    def test_privacy_field_set_field_from_activity(self):
+    def test_privacy_field_set_field_from_activity(self, _):
         """translate between to/cc fields and privacy"""
 
         @dataclass(init=False)
@@ -188,10 +189,9 @@ class ActivitypubFields(TestCase):
     @patch("bookwyrm.activitystreams.ActivityStream.add_status")
     def test_privacy_field_set_activity_from_field(self, *_):
         """translate between to/cc fields and privacy"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
-            user = User.objects.create_user(
-                "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
-            )
+        user = User.objects.create_user(
+            "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
+        )
         public = "https://www.w3.org/ns/activitystreams#Public"
         followers = "%s/followers" % user.remote_id
 
@@ -231,7 +231,7 @@ class ActivitypubFields(TestCase):
         self.assertEqual(activity["to"], [user.remote_id])
         self.assertEqual(activity["cc"], [])
 
-    def test_foreign_key(self):
+    def test_foreign_key(self, _):
         """should be able to format a related model"""
         instance = fields.ForeignKey("User", on_delete=models.CASCADE)
         Serializable = namedtuple("Serializable", ("to_activity", "remote_id"))
@@ -240,7 +240,7 @@ class ActivitypubFields(TestCase):
         self.assertEqual(instance.field_to_activity(item), "https://e.b/c")
 
     @responses.activate
-    def test_foreign_key_from_activity_str(self):
+    def test_foreign_key_from_activity_str(self, _):
         """create a new object from a foreign key"""
         instance = fields.ForeignKey(User, on_delete=models.CASCADE)
         datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json")
@@ -249,26 +249,25 @@ class ActivitypubFields(TestCase):
         del userdata["icon"]
 
         # 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(
-                "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
-            )
+        unrelated_user = User.objects.create_user(
+            "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
+        )
 
-            # test receiving an unknown remote id and loading data
-            responses.add(
-                responses.GET,
-                "https://example.com/user/mouse",
-                json=userdata,
-                status=200,
-            )
-            with patch("bookwyrm.models.user.set_remote_server.delay"):
-                value = instance.field_from_activity("https://example.com/user/mouse")
+        # test receiving an unknown remote id and loading data
+        responses.add(
+            responses.GET,
+            "https://example.com/user/mouse",
+            json=userdata,
+            status=200,
+        )
+        with patch("bookwyrm.models.user.set_remote_server.delay"):
+            value = instance.field_from_activity("https://example.com/user/mouse")
         self.assertIsInstance(value, User)
         self.assertNotEqual(value, unrelated_user)
         self.assertEqual(value.remote_id, "https://example.com/user/mouse")
         self.assertEqual(value.name, "MOUSE?? MOUSE!!")
 
-    def test_foreign_key_from_activity_dict(self):
+    def test_foreign_key_from_activity_dict(self, *_):
         """test recieving activity json"""
         instance = fields.ForeignKey(User, on_delete=models.CASCADE)
         datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json")
@@ -277,60 +276,57 @@ class ActivitypubFields(TestCase):
         del userdata["icon"]
 
         # 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(
-                "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
-            )
-            with patch("bookwyrm.models.user.set_remote_server.delay"):
-                value = instance.field_from_activity(activitypub.Person(**userdata))
+        unrelated_user = User.objects.create_user(
+            "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
+        )
+        with patch("bookwyrm.models.user.set_remote_server.delay"):
+            value = instance.field_from_activity(activitypub.Person(**userdata))
         self.assertIsInstance(value, User)
         self.assertNotEqual(value, unrelated_user)
         self.assertEqual(value.remote_id, "https://example.com/user/mouse")
         self.assertEqual(value.name, "MOUSE?? MOUSE!!")
         # et cetera but we're not testing serializing user json
 
-    def test_foreign_key_from_activity_dict_existing(self):
+    def test_foreign_key_from_activity_dict_existing(self, _):
         """test receiving a dict of an existing object in the db"""
         instance = fields.ForeignKey(User, on_delete=models.CASCADE)
         datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json")
         userdata = json.loads(datafile.read_bytes())
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
-            user = User.objects.create_user(
-                "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
-            )
-            user.remote_id = "https://example.com/user/mouse"
-            user.save(broadcast=False)
+        user = User.objects.create_user(
+            "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
+        )
+        user.remote_id = "https://example.com/user/mouse"
+        user.save(broadcast=False, update_fields=["remote_id"])
 
-            User.objects.create_user(
-                "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
-            )
+        User.objects.create_user(
+            "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
+        )
 
-            with patch("bookwyrm.models.activitypub_mixin.ObjectMixin.broadcast"):
-                value = instance.field_from_activity(activitypub.Person(**userdata))
+        with patch("bookwyrm.models.activitypub_mixin.ObjectMixin.broadcast"):
+            value = instance.field_from_activity(activitypub.Person(**userdata))
         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"""
         instance = fields.ForeignKey(User, on_delete=models.CASCADE)
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
-            user = User.objects.create_user(
-                "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
-            )
-            User.objects.create_user(
-                "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
-            )
+        user = User.objects.create_user(
+            "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
+        )
+        User.objects.create_user(
+            "rat", "rat@rat.rat", "ratword", local=True, localname="rat"
+        )
 
         value = instance.field_from_activity(user.remote_id)
         self.assertEqual(value, user)
 
-    def test_one_to_one_field(self):
+    def test_one_to_one_field(self, _):
         """a gussied up foreign key"""
         instance = fields.OneToOneField("User", on_delete=models.CASCADE)
         Serializable = namedtuple("Serializable", ("to_activity", "remote_id"))
         item = Serializable(lambda: {"a": "b"}, "https://e.b/c")
         self.assertEqual(instance.field_to_activity(item), {"a": "b"})
 
-    def test_many_to_many_field(self):
+    def test_many_to_many_field(self, _):
         """lists!"""
         instance = fields.ManyToManyField("User")
 
@@ -348,7 +344,7 @@ class ActivitypubFields(TestCase):
         self.assertEqual(instance.field_to_activity(items), "example.com/snake_case")
 
     @responses.activate
-    def test_many_to_many_field_from_activity(self):
+    def test_many_to_many_field_from_activity(self, _):
         """resolve related fields for a list, takes a list of remote ids"""
         instance = fields.ManyToManyField(User)
         datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json")
@@ -360,16 +356,15 @@ class ActivitypubFields(TestCase):
         responses.add(
             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"):
-                value = instance.field_from_activity(
-                    ["https://example.com/user/mouse", "bleh"]
-                )
+        with patch("bookwyrm.models.user.set_remote_server.delay"):
+            value = instance.field_from_activity(
+                ["https://example.com/user/mouse", "bleh"]
+            )
         self.assertIsInstance(value, list)
         self.assertEqual(len(value), 1)
         self.assertIsInstance(value[0], User)
 
-    def test_tag_field(self):
+    def test_tag_field(self, _):
         """a special type of many to many field"""
         instance = fields.TagField("User")
 
@@ -388,25 +383,25 @@ class ActivitypubFields(TestCase):
         self.assertEqual(result[0].name, "Name")
         self.assertEqual(result[0].type, "Serializable")
 
-    def test_tag_field_from_activity(self):
+    def test_tag_field_from_activity(self, _):
         """loadin' a list of items from Links"""
         # TODO
 
     @responses.activate
     @patch("bookwyrm.models.activitypub_mixin.ObjectMixin.broadcast")
-    def test_image_field(self, _):
+    @patch("bookwyrm.suggested_users.remove_user_task.delay")
+    def test_image_field(self, *_):
         """storing images"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
-            user = User.objects.create_user(
-                "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
-            )
-            image_file = pathlib.Path(__file__).parent.joinpath(
-                "../../static/images/default_avi.jpg"
-            )
-            image = Image.open(image_file)
-            output = BytesIO()
-            image.save(output, format=image.format)
-            user.avatar.save("test.jpg", ContentFile(output.getvalue()))
+        user = User.objects.create_user(
+            "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
+        )
+        image_file = pathlib.Path(__file__).parent.joinpath(
+            "../../static/images/default_avi.jpg"
+        )
+        image = Image.open(image_file)
+        output = BytesIO()
+        image.save(output, format=image.format)
+        user.avatar.save("test.jpg", ContentFile(output.getvalue()))
 
         output = fields.image_serializer(user.avatar, alt="alt text")
         self.assertIsNotNone(
@@ -433,7 +428,16 @@ class ActivitypubFields(TestCase):
         self.assertIsInstance(loaded_image, list)
         self.assertIsInstance(loaded_image[1], ContentFile)
 
-    def test_datetime_field(self):
+    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, _):
         """this one is pretty simple, it just has to use isoformat"""
         instance = fields.DateTimeField()
         now = timezone.now()
@@ -441,12 +445,12 @@ class ActivitypubFields(TestCase):
         self.assertEqual(instance.field_from_activity(now.isoformat()), now)
         self.assertEqual(instance.field_from_activity("bip"), None)
 
-    def test_array_field(self):
+    def test_array_field(self, _):
         """idk why it makes them strings but probably for a good reason"""
         instance = fields.ArrayField(fields.IntegerField)
         self.assertEqual(instance.field_to_activity([0, 1]), ["0", "1"])
 
-    def test_html_field(self):
+    def test_html_field(self, _):
         """sanitizes html, the sanitizer has its own tests"""
         instance = fields.HtmlField()
         self.assertEqual(

bookwyrm/tests/models/test_import_model.py

@@ -59,7 +59,7 @@ class ImportJob(TestCase):
         unknown_read_data["Exclusive Shelf"] = "read"
         unknown_read_data["Date Read"] = ""
 
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
             )
@@ -175,9 +175,6 @@ class ImportJob(TestCase):
                 with patch(
                     "bookwyrm.connectors.openlibrary.Connector." "get_authors_from_data"
                 ):
-                    with patch(
-                        "bookwyrm.preview_images.generate_edition_preview_image_task.delay"
-                    ):
-                        book = self.item_1.get_book_from_isbn()
+                    book = self.item_1.get_book_from_isbn()
 
         self.assertEqual(book.title, "Sabriel")

bookwyrm/tests/models/test_list.py

@@ -11,13 +11,12 @@ class List(TestCase):
 
     def setUp(self):
         """look, a list"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.local_user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
             )
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            work = models.Work.objects.create(title="hello")
-            self.book = models.Edition.objects.create(title="hi", parent_work=work)
+        work = models.Work.objects.create(title="hello")
+        self.book = models.Edition.objects.create(title="hi", parent_work=work)
 
     def test_remote_id(self, _):
         """shelves use custom remote ids"""

bookwyrm/tests/models/test_readthrough_model.py

@@ -1,7 +1,7 @@
 """ testing models """
+from unittest.mock import patch
 from django.test import TestCase
 from django.core.exceptions import ValidationError
-from unittest.mock import patch
 
 from bookwyrm import models
 
@@ -11,16 +11,15 @@ class ReadThrough(TestCase):
 
     def setUp(self):
         """look, a shelf"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.user = models.User.objects.create_user(
                 "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.edition = models.Edition.objects.create(
-                title="Example Edition", parent_work=self.work
-            )
+        self.work = models.Work.objects.create(title="Example Work")
+        self.edition = models.Edition.objects.create(
+            title="Example Edition", parent_work=self.work
+        )
 
         self.readthrough = models.ReadThrough.objects.create(
             user=self.user, book=self.edition

bookwyrm/tests/models/test_relationship_models.py

@@ -1,4 +1,5 @@
 """ testing models """
+import json
 from unittest.mock import patch
 from django.test import TestCase
 
@@ -10,36 +11,31 @@ class Relationship(TestCase):
 
     def setUp(self):
         """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"):
-                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",
+            )
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.local_user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.com", "mouseword", local=True, localname="mouse"
             )
-            self.local_user.remote_id = "http://local.com/user/mouse"
-            self.local_user.save(broadcast=False)
+        self.local_user.remote_id = "http://local.com/user/mouse"
+        self.local_user.save(broadcast=False, update_fields=["remote_id"])
 
     def test_user_follows_from_request(self):
         """convert a follow request into a follow"""
-        real_broadcast = models.UserFollowRequest.broadcast
-
-        def mock_broadcast(_, activity, user):
-            """introspect what's being sent out"""
-            self.assertEqual(user.remote_id, self.local_user.remote_id)
-            self.assertEqual(activity["type"], "Follow")
-
-        models.UserFollowRequest.broadcast = mock_broadcast
-        request = models.UserFollowRequest.objects.create(
-            user_subject=self.local_user, user_object=self.remote_user
-        )
+        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay") as mock:
+            request = models.UserFollowRequest.objects.create(
+                user_subject=self.local_user, user_object=self.remote_user
+            )
+        activity = json.loads(mock.call_args[0][1])
+        self.assertEqual(activity["type"], "Follow")
         self.assertEqual(
             request.remote_id, "http://local.com/user/mouse#follows/%d" % request.id
         )
@@ -52,7 +48,6 @@ class Relationship(TestCase):
         self.assertEqual(rel.status, "follows")
         self.assertEqual(rel.user_subject, self.local_user)
         self.assertEqual(rel.user_object, self.remote_user)
-        models.UserFollowRequest.broadcast = real_broadcast
 
     def test_user_follows_from_request_custom_remote_id(self):
         """store a specific remote id for a relationship provided by remote"""
@@ -71,36 +66,26 @@ class Relationship(TestCase):
         self.assertEqual(rel.user_subject, self.local_user)
         self.assertEqual(rel.user_object, self.remote_user)
 
-    def test_follow_request_activity(self):
+    @patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
+    def test_follow_request_activity(self, broadcast_mock):
         """accept a request and make it a relationship"""
-        real_broadcast = models.UserFollowRequest.broadcast
-
-        def mock_broadcast(_, activity, user):
-            self.assertEqual(user.remote_id, self.local_user.remote_id)
-            self.assertEqual(activity["actor"], self.local_user.remote_id)
-            self.assertEqual(activity["object"], self.remote_user.remote_id)
-            self.assertEqual(activity["type"], "Follow")
-
-        models.UserFollowRequest.broadcast = mock_broadcast
         models.UserFollowRequest.objects.create(
             user_subject=self.local_user,
             user_object=self.remote_user,
         )
-        models.UserFollowRequest.broadcast = real_broadcast
+        activity = json.loads(broadcast_mock.call_args[0][1])
+        self.assertEqual(activity["actor"], self.local_user.remote_id)
+        self.assertEqual(activity["object"], self.remote_user.remote_id)
+        self.assertEqual(activity["type"], "Follow")
 
-    def test_follow_request_accept(self):
+    @patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
+    def test_follow_request_accept(self, broadcast_mock):
         """accept a request and make it a relationship"""
-        real_broadcast = models.UserFollowRequest.broadcast
-
-        def mock_broadcast(_, activity, user):
-            self.assertEqual(user.remote_id, self.local_user.remote_id)
-            self.assertEqual(activity["type"], "Accept")
-            self.assertEqual(activity["actor"], self.local_user.remote_id)
-            self.assertEqual(activity["object"]["id"], "https://www.hi.com/")
-
         self.local_user.manually_approves_followers = True
-        self.local_user.save(broadcast=False)
-        models.UserFollowRequest.broadcast = mock_broadcast
+        self.local_user.save(
+            broadcast=False, update_fields=["manually_approves_followers"]
+        )
+
         request = models.UserFollowRequest.objects.create(
             user_subject=self.remote_user,
             user_object=self.local_user,
@@ -108,32 +93,34 @@ class Relationship(TestCase):
         )
         request.accept()
 
+        activity = json.loads(broadcast_mock.call_args[0][1])
+        self.assertEqual(activity["type"], "Accept")
+        self.assertEqual(activity["actor"], self.local_user.remote_id)
+        self.assertEqual(activity["object"]["id"], "https://www.hi.com/")
+
         self.assertFalse(models.UserFollowRequest.objects.exists())
         self.assertTrue(models.UserFollows.objects.exists())
         rel = models.UserFollows.objects.get()
         self.assertEqual(rel.user_subject, self.remote_user)
         self.assertEqual(rel.user_object, self.local_user)
-        models.UserFollowRequest.broadcast = real_broadcast
 
-    def test_follow_request_reject(self):
+    @patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
+    def test_follow_request_reject(self, broadcast_mock):
         """accept a request and make it a relationship"""
-        real_broadcast = models.UserFollowRequest.broadcast
-
-        def mock_reject(_, activity, user):
-            self.assertEqual(user.remote_id, self.local_user.remote_id)
-            self.assertEqual(activity["type"], "Reject")
-            self.assertEqual(activity["actor"], self.local_user.remote_id)
-            self.assertEqual(activity["object"]["id"], request.remote_id)
-
-        models.UserFollowRequest.broadcast = mock_reject
         self.local_user.manually_approves_followers = True
-        self.local_user.save(broadcast=False)
+        self.local_user.save(
+            broadcast=False, update_fields=["manually_approves_followers"]
+        )
         request = models.UserFollowRequest.objects.create(
             user_subject=self.remote_user,
             user_object=self.local_user,
         )
         request.reject()
 
+        activity = json.loads(broadcast_mock.call_args[0][1])
+        self.assertEqual(activity["type"], "Reject")
+        self.assertEqual(activity["actor"], self.local_user.remote_id)
+        self.assertEqual(activity["object"]["id"], request.remote_id)
+
         self.assertFalse(models.UserFollowRequest.objects.exists())
         self.assertFalse(models.UserFollows.objects.exists())
-        models.UserFollowRequest.broadcast = real_broadcast

bookwyrm/tests/models/test_shelf_model.py

@@ -7,22 +7,20 @@ from bookwyrm import models, settings
 
 
 # pylint: disable=unused-argument
+@patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
 class Shelf(TestCase):
     """some activitypub oddness ahead"""
 
     def setUp(self):
         """look, a shelf"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.local_user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
             )
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            work = models.Work.objects.create(title="Test Work")
-            self.book = models.Edition.objects.create(
-                title="test book", parent_work=work
-            )
+        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"""
         with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
             shelf = models.Shelf.objects.create(
@@ -31,7 +29,7 @@ class Shelf(TestCase):
         expected_id = "https://%s/user/mouse/books/test-shelf" % settings.DOMAIN
         self.assertEqual(shelf.get_remote_id(), expected_id)
 
-    def test_to_activity(self):
+    def test_to_activity(self, _):
         """jsonify it"""
         with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
             shelf = models.Shelf.objects.create(
@@ -45,7 +43,7 @@ class Shelf(TestCase):
         self.assertEqual(activity_json["name"], "Test Shelf")
         self.assertEqual(activity_json["owner"], self.local_user.remote_id)
 
-    def test_create_update_shelf(self):
+    def test_create_update_shelf(self, _):
         """create and broadcast shelf creation"""
 
         with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay") as mock:
@@ -66,7 +64,7 @@ class Shelf(TestCase):
         self.assertEqual(activity["object"]["name"], "arthur russel")
         self.assertEqual(shelf.name, "arthur russel")
 
-    def test_shelve(self):
+    def test_shelve(self, _):
         """create and broadcast shelf creation"""
         with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
             shelf = models.Shelf.objects.create(

bookwyrm/tests/models/test_status_model.py

@@ -22,31 +22,30 @@ class Status(TestCase):
 
     def setUp(self):
         """useful things for creating a status"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.local_user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
             )
-            with patch("bookwyrm.models.user.set_remote_server.delay"):
-                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(
-                "../../static/images/default_avi.jpg"
+        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",
             )
-            image = Image.open(image_file)
-            output = BytesIO()
-            with patch("bookwyrm.models.Status.broadcast"):
-                image.save(output, format=image.format)
-                self.book.cover.save("test.jpg", ContentFile(output.getvalue()))
+        self.book = models.Edition.objects.create(title="Test Edition")
+
+        image_file = pathlib.Path(__file__).parent.joinpath(
+            "../../static/images/default_avi.jpg"
+        )
+        image = Image.open(image_file)
+        output = BytesIO()
+        with patch("bookwyrm.models.Status.broadcast"):
+            image.save(output, format=image.format)
+            self.book.cover.save("test.jpg", ContentFile(output.getvalue()))
 
     def test_status_generated_fields(self, *_):
         """setting remote id"""
@@ -61,10 +60,9 @@ class Status(TestCase):
         child = models.Status.objects.create(
             content="hello", reply_parent=parent, user=self.local_user
         )
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            models.Review.objects.create(
-                content="hey", reply_parent=parent, user=self.local_user, book=self.book
-            )
+        models.Review.objects.create(
+            content="hey", reply_parent=parent, user=self.local_user, book=self.book
+        )
         models.Status.objects.create(
             content="hi hello", reply_parent=child, user=self.local_user
         )
@@ -96,10 +94,9 @@ class Status(TestCase):
         child = models.Status.objects.create(
             content="hello", reply_parent=parent, user=self.local_user
         )
-        with patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay"):
-            models.Review.objects.create(
-                content="hey", reply_parent=parent, user=self.local_user, book=self.book
-            )
+        models.Review.objects.create(
+            content="hey", reply_parent=parent, user=self.local_user, book=self.book
+        )
         models.Status.objects.create(
             content="hi hello", reply_parent=child, user=self.local_user
         )
@@ -256,15 +253,14 @@ class Status(TestCase):
 
     def test_review_to_activity(self, *_):
         """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(
-                name="Review name",
-                content="test content",
-                rating=3.0,
-                user=self.local_user,
-                book=self.book,
-            )
-            activity = status.to_activity()
+        status = models.Review.objects.create(
+            name="Review name",
+            content="test content",
+            rating=3.0,
+            user=self.local_user,
+            book=self.book,
+        )
+        activity = status.to_activity()
         self.assertEqual(activity["id"], status.remote_id)
         self.assertEqual(activity["type"], "Review")
         self.assertEqual(activity["rating"], 3)
@@ -274,15 +270,14 @@ class Status(TestCase):
 
     def test_review_to_pure_activity(self, *_):
         """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(
-                name="Review's name",
-                content="test content",
-                rating=3.0,
-                user=self.local_user,
-                book=self.book,
-            )
-            activity = status.to_activity(pure=True)
+        status = models.Review.objects.create(
+            name="Review's name",
+            content="test content",
+            rating=3.0,
+            user=self.local_user,
+            book=self.book,
+        )
+        activity = status.to_activity(pure=True)
         self.assertEqual(activity["id"], status.remote_id)
         self.assertEqual(activity["type"], "Article")
         self.assertEqual(
@@ -299,14 +294,13 @@ class Status(TestCase):
 
     def test_review_to_pure_activity_no_rating(self, *_):
         """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(
-                name="Review name",
-                content="test content",
-                user=self.local_user,
-                book=self.book,
-            )
-            activity = status.to_activity(pure=True)
+        status = models.Review.objects.create(
+            name="Review name",
+            content="test content",
+            user=self.local_user,
+            book=self.book,
+        )
+        activity = status.to_activity(pure=True)
         self.assertEqual(activity["id"], status.remote_id)
         self.assertEqual(activity["type"], "Article")
         self.assertEqual(
@@ -322,13 +316,12 @@ class Status(TestCase):
 
     def test_reviewrating_to_pure_activity(self, *_):
         """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(
-                rating=3.0,
-                user=self.local_user,
-                book=self.book,
-            )
-            activity = status.to_activity(pure=True)
+        status = models.ReviewRating.objects.create(
+            rating=3.0,
+            user=self.local_user,
+            book=self.book,
+        )
+        activity = status.to_activity(pure=True)
         self.assertEqual(activity["id"], status.remote_id)
         self.assertEqual(activity["type"], "Note")
         self.assertEqual(
@@ -357,12 +350,11 @@ class Status(TestCase):
         status = models.Status.objects.create(
             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
-            with self.assertRaises(IntegrityError):
-                models.Favorite.objects.create(status=status, user=self.local_user)
+        # can't fav a status twice
+        with self.assertRaises(IntegrityError):
+            models.Favorite.objects.create(status=status, user=self.local_user)
 
         activity = fav.to_activity()
         self.assertEqual(activity["type"], "Like")

bookwyrm/tests/models/test_user_model.py

@@ -11,7 +11,7 @@ from bookwyrm.settings import DOMAIN
 # pylint: disable=missing-function-docstring
 class User(TestCase):
     def setUp(self):
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.user = models.User.objects.create_user(
                 "mouse@%s" % DOMAIN,
                 "mouse@mouse.mouse",
@@ -35,16 +35,15 @@ class User(TestCase):
         self.assertIsNotNone(self.user.key_pair.public_key)
 
     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"):
-                user = models.User.objects.create_user(
-                    "rat",
-                    "rat@rat.rat",
-                    "ratword",
-                    local=False,
-                    remote_id="https://example.com/dfjkg",
-                    bookwyrm_user=False,
-                )
+        with patch("bookwyrm.models.user.set_remote_server.delay"):
+            user = models.User.objects.create_user(
+                "rat",
+                "rat@rat.rat",
+                "ratword",
+                local=False,
+                remote_id="https://example.com/dfjkg",
+                bookwyrm_user=False,
+            )
         self.assertEqual(user.username, "rat@example.com")
 
     def test_user_shelves(self):
@@ -156,7 +155,8 @@ class User(TestCase):
         self.assertIsNone(server.application_type)
         self.assertIsNone(server.application_version)
 
-    def test_delete_user(self):
+    @patch("bookwyrm.suggested_users.remove_user_task.delay")
+    def test_delete_user(self, _):
         """deactivate a user"""
         self.assertTrue(self.user.is_active)
         with patch(

bookwyrm/tests/test_activitystreams.py

@@ -6,12 +6,14 @@ from bookwyrm import activitystreams, models
 
 @patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
 @patch("bookwyrm.activitystreams.ActivityStream.add_status")
+@patch("bookwyrm.activitystreams.BooksStream.add_book_statuses")
+@patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
 class Activitystreams(TestCase):
     """using redis to build activity streams"""
 
     def setUp(self):
         """use a test csv"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.local_user = models.User.objects.create_user(
                 "mouse", "mouse@mouse.mouse", "password", local=True, localname="mouse"
             )
@@ -22,18 +24,18 @@ class Activitystreams(TestCase):
                 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")
+        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",
+            )
+        work = models.Work.objects.create(title="test work")
+        self.book = models.Edition.objects.create(title="test book", parent_work=work)
 
         class TestStream(activitystreams.ActivityStream):
             """test stream, don't have to do anything here"""
@@ -192,19 +194,95 @@ class Activitystreams(TestCase):
         users = activitystreams.LocalStream().get_audience(status)
         self.assertEqual(users, [])
 
-    def test_federatedstream_get_audience(self, *_):
+    def test_localstream_get_audience_books_no_book(self, *_):
         """get a list of users that should see a status"""
         status = models.Status.objects.create(
-            user=self.remote_user, content="hi", privacy="public"
+            user=self.local_user, content="hi", privacy="public"
         )
-        users = activitystreams.FederatedStream().get_audience(status)
-        self.assertTrue(self.local_user in users)
-        self.assertTrue(self.another_user in users)
+        audience = activitystreams.BooksStream().get_audience(status)
+        # no books, no audience
+        self.assertEqual(audience, [])
 
-    def test_federatedstream_get_audience_unlisted(self, *_):
+    def test_localstream_get_audience_books_mention_books(self, *_):
         """get a list of users that should see a status"""
         status = models.Status.objects.create(
-            user=self.remote_user, content="hi", privacy="unlisted"
+            user=self.local_user, content="hi", privacy="public"
         )
-        users = activitystreams.FederatedStream().get_audience(status)
-        self.assertEqual(users, [])
+        status.mention_books.add(self.book)
+        status.save(broadcast=False)
+        models.ShelfBook.objects.create(
+            user=self.local_user,
+            shelf=self.local_user.shelf_set.first(),
+            book=self.book,
+        )
+        # yes book, yes audience
+        audience = activitystreams.BooksStream().get_audience(status)
+        self.assertTrue(self.local_user in audience)
+
+    def test_localstream_get_audience_books_book_field(self, *_):
+        """get a list of users that should see a status"""
+        status = models.Comment.objects.create(
+            user=self.local_user, content="hi", privacy="public", book=self.book
+        )
+        models.ShelfBook.objects.create(
+            user=self.local_user,
+            shelf=self.local_user.shelf_set.first(),
+            book=self.book,
+        )
+        # yes book, yes audience
+        audience = activitystreams.BooksStream().get_audience(status)
+        self.assertTrue(self.local_user in audience)
+
+    def test_localstream_get_audience_books_alternate_edition(self, *_):
+        """get a list of users that should see a status"""
+        alt_book = models.Edition.objects.create(
+            title="hi", parent_work=self.book.parent_work
+        )
+        status = models.Comment.objects.create(
+            user=self.remote_user, content="hi", privacy="public", book=alt_book
+        )
+        models.ShelfBook.objects.create(
+            user=self.local_user,
+            shelf=self.local_user.shelf_set.first(),
+            book=self.book,
+        )
+        # yes book, yes audience
+        audience = activitystreams.BooksStream().get_audience(status)
+        self.assertTrue(self.local_user in audience)
+
+    def test_localstream_get_audience_books_non_public(self, *_):
+        """get a list of users that should see a status"""
+        alt_book = models.Edition.objects.create(
+            title="hi", parent_work=self.book.parent_work
+        )
+        status = models.Comment.objects.create(
+            user=self.remote_user, content="hi", privacy="unlisted", book=alt_book
+        )
+        models.ShelfBook.objects.create(
+            user=self.local_user,
+            shelf=self.local_user.shelf_set.first(),
+            book=self.book,
+        )
+        # yes book, yes audience
+        audience = activitystreams.BooksStream().get_audience(status)
+        self.assertEqual(audience, [])
+
+    def test_get_statuses_for_user_books(self, *_):
+        """create a stream for a user"""
+        alt_book = models.Edition.objects.create(
+            title="hi", parent_work=self.book.parent_work
+        )
+        status = models.Status.objects.create(
+            user=self.local_user, content="hi", privacy="public"
+        )
+        status = models.Comment.objects.create(
+            user=self.remote_user, content="hi", privacy="public", book=alt_book
+        )
+        models.ShelfBook.objects.create(
+            user=self.local_user,
+            shelf=self.local_user.shelf_set.first(),
+            book=self.book,
+        )
+        # yes book, yes audience
+        result = activitystreams.BooksStream().get_statuses_for_user(self.local_user)
+        self.assertEqual(list(result), [status])

bookwyrm/tests/test_emailing.py

@@ -3,7 +3,6 @@ from unittest.mock import patch
 
 from django.test import TestCase
 from django.test.client import RequestFactory
-import responses
 
 from bookwyrm import emailing, models
 
@@ -15,7 +14,7 @@ class Emailing(TestCase):
     def setUp(self):
         """we need basic test data and mocks"""
         self.factory = RequestFactory()
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.local_user = models.User.objects.create_user(
                 "mouse@local.com",
                 "mouse@mouse.mouse",
@@ -23,8 +22,7 @@ class Emailing(TestCase):
                 local=True,
                 localname="mouse",
             )
-        with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
-            models.SiteSettings.objects.create()
+        models.SiteSettings.objects.create()
 
     def test_invite_email(self, email_mock):
         """load the invite email"""

bookwyrm/tests/test_postgres.py

@@ -6,17 +6,16 @@ from bookwyrm import models
 
 
 @patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
-@patch("bookwyrm.preview_images.generate_edition_preview_image_task.delay")
 class PostgresTriggers(TestCase):
     """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"""
         book = models.Edition.objects.create(title="The Long Goodbye")
         book.refresh_from_db()
         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"""
         book = models.Edition.objects.create(title="The Long Goodbye")
         book.title = "The Even Longer Goodbye"
@@ -24,7 +23,7 @@ class PostgresTriggers(TestCase):
         book.refresh_from_db()
         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"""
         author = models.Author.objects.create(name="The Rays")
         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",
         )
 
-    def test_seach_vector_on_author_update(self, *_):
+    def test_seach_vector_on_author_update(self, _):
         """update search when an author name changes"""
         author = models.Author.objects.create(name="The Rays")
         book = models.Edition.objects.create(
@@ -53,7 +52,7 @@ class PostgresTriggers(TestCase):
 
         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"""
         author = models.Author.objects.create(name="Jeremy")
         book = models.Edition.objects.create(
@@ -68,7 +67,7 @@ class PostgresTriggers(TestCase):
         book.refresh_from_db()
         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"""
         book = models.Edition.objects.create(
             title="there there",

bookwyrm/tests/test_preview_images.py

@@ -9,7 +9,6 @@ from django.core.files.uploadedfile import SimpleUploadedFile
 from django.db.models.fields.files import ImageFieldFile
 
 from bookwyrm import models, settings
-
 from bookwyrm.preview_images import (
     generate_site_preview_image_task,
     generate_edition_preview_image_task,
@@ -27,10 +26,10 @@ class PreviewImages(TestCase):
     def setUp(self):
         """we need basic test data and mocks"""
         self.factory = RequestFactory()
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
-            avatar_file = pathlib.Path(__file__).parent.joinpath(
-                "../static/images/no_cover.jpg"
-            )
+        avatar_file = pathlib.Path(__file__).parent.joinpath(
+            "../static/images/no_cover.jpg"
+        )
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.local_user = models.User.objects.create_user(
                 "possum@local.com",
                 "possum@possum.possum",
@@ -43,15 +42,17 @@ class PreviewImages(TestCase):
                     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.edition = models.Edition.objects.create(
-                title="Example Edition",
-                remote_id="https://example.com/book/1",
-                parent_work=self.work,
-            )
-        with patch("bookwyrm.preview_images.generate_site_preview_image_task.delay"):
-            self.site = models.SiteSettings.objects.create()
+
+        self.work = models.Work.objects.create(title="Test Work")
+        self.edition = models.Edition.objects.create(
+            title="Example Edition",
+            remote_id="https://example.com/book/1",
+            parent_work=self.work,
+        )
+
+        self.site = models.SiteSettings.objects.create()
+
+        settings.ENABLE_PREVIEW_IMAGES = True
 
     def test_generate_preview_image(self, *args, **kwargs):
         image_file = pathlib.Path(__file__).parent.joinpath(

bookwyrm/tests/test_signing.py

@@ -37,7 +37,7 @@ class Signature(TestCase):
 
     def setUp(self):
         """create users and test data"""
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
+        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"):
             self.mouse = models.User.objects.create_user(
                 "mouse@%s" % DOMAIN,
                 "mouse@example.com",
@@ -58,8 +58,7 @@ class Signature(TestCase):
             "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):
         """test request"""
@@ -119,10 +118,9 @@ class Signature(TestCase):
             status=200,
         )
 
-        with patch("bookwyrm.preview_images.generate_user_preview_image_task.delay"):
-            with patch("bookwyrm.models.user.get_remote_reviews.delay"):
-                response = self.send_test_request(sender=self.fake_remote)
-                self.assertEqual(response.status_code, 200)
+        with patch("bookwyrm.models.user.get_remote_reviews.delay"):
+            response = self.send_test_request(sender=self.fake_remote)
+            self.assertEqual(response.status_code, 200)
 
     @responses.activate
     def test_key_needs_refresh(self):
@@ -143,23 +141,22 @@ class Signature(TestCase):
         data["publicKey"]["publicKeyPem"] = key_pair.public_key
         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"):
-                # Key correct:
-                response = self.send_test_request(sender=self.fake_remote)
-                self.assertEqual(response.status_code, 200)
+        with patch("bookwyrm.models.user.get_remote_reviews.delay"):
+            # Key correct:
+            response = self.send_test_request(sender=self.fake_remote)
+            self.assertEqual(response.status_code, 200)
 
-                # Old key is cached, so still works:
-                response = self.send_test_request(sender=self.fake_remote)
-                self.assertEqual(response.status_code, 200)
+            # Old key is cached, so still works:
+            response = self.send_test_request(sender=self.fake_remote)
+            self.assertEqual(response.status_code, 200)
 
-                # Try with new key:
-                response = self.send_test_request(sender=new_sender)
-                self.assertEqual(response.status_code, 200)
+            # Try with new key:
+            response = self.send_test_request(sender=new_sender)
+            self.assertEqual(response.status_code, 200)
 
-                # Now the old key will fail:
-                response = self.send_test_request(sender=self.fake_remote)
-                self.assertEqual(response.status_code, 401)
+            # Now the old key will fail:
+            response = self.send_test_request(sender=self.fake_remote)
+            self.assertEqual(response.status_code, 401)
 
     @responses.activate
     def test_nonexistent_signer(self):