yul/bookwyrm-mastodon
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'main' into create-book

Browse Source
This commit is contained in:
Mouse Reeve
2021-03-08 10:07:02 -08:00
committed by GitHub
parent a5baa1f5c6 a8b29b213d
commit 01a2a77cbb
201 changed files with 10253 additions and 8555 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
bookwyrm/tests/views/test_authentication.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.contrib.auth.models import AnonymousUser
@ -14,21 +14,26 @@ from bookwyrm.settings import DOMAIN
# pylint: disable=too-many-public-methods
class AuthenticationViews(TestCase):
''' login and password management '''
""" login and password management """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'password',
local=True, localname='mouse')
"mouse@local.com",
"mouse@mouse.com",
"password",
local=True,
localname="mouse",
)
self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False
self.settings = models.SiteSettings.objects.create(id=1)
def test_login_get(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
login = views.Login.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.anonymous_user
result = login(request)
@ -38,135 +43,117 @@ class AuthenticationViews(TestCase):
request.user = self.local_user
result = login(request)
self.assertEqual(result.url, '/')
self.assertEqual(result.url, "/")
self.assertEqual(result.status_code, 302)
def test_register(self):
''' create a user '''
""" create a user """
view = views.Register.as_view()
self.assertEqual(models.User.objects.count(), 1)
request = self.factory.post(
'register/',
"register/",
{
'localname': 'nutria-user.user_nutria',
'password': 'mouseword',
'email': 'aa@bb.cccc'
})
with patch('bookwyrm.views.authentication.login'):
"localname": "nutria-user.user_nutria",
"password": "mouseword",
"email": "aa@bb.cccc",
},
)
with patch("bookwyrm.views.authentication.login"):
response = view(request)
self.assertEqual(models.User.objects.count(), 2)
self.assertEqual(response.status_code, 302)
nutria = models.User.objects.last()
self.assertEqual(nutria.username, 'nutria-user.user_nutria@%s' % DOMAIN)
self.assertEqual(nutria.localname, 'nutria-user.user_nutria')
self.assertEqual(nutria.username, "nutria-user.user_nutria@%s" % DOMAIN)
self.assertEqual(nutria.localname, "nutria-user.user_nutria")
self.assertEqual(nutria.local, True)
def test_register_trailing_space(self):
''' django handles this so weirdly '''
""" django handles this so weirdly """
view = views.Register.as_view()
request = self.factory.post(
'register/',
{
'localname': 'nutria ',
'password': 'mouseword',
'email': 'aa@bb.ccc'
})
with patch('bookwyrm.views.authentication.login'):
"register/",
{"localname": "nutria ", "password": "mouseword", "email": "aa@bb.ccc"},
)
with patch("bookwyrm.views.authentication.login"):
response = view(request)
self.assertEqual(models.User.objects.count(), 2)
self.assertEqual(response.status_code, 302)
nutria = models.User.objects.last()
self.assertEqual(nutria.username, 'nutria@%s' % DOMAIN)
self.assertEqual(nutria.localname, 'nutria')
self.assertEqual(nutria.username, "nutria@%s" % DOMAIN)
self.assertEqual(nutria.localname, "nutria")
self.assertEqual(nutria.local, True)
def test_register_invalid_email(self):
''' gotta have an email '''
""" gotta have an email """
view = views.Register.as_view()
self.assertEqual(models.User.objects.count(), 1)
request = self.factory.post(
'register/',
{
'localname': 'nutria',
'password': 'mouseword',
'email': 'aa'
})
"register/", {"localname": "nutria", "password": "mouseword", "email": "aa"}
)
response = view(request)
self.assertEqual(models.User.objects.count(), 1)
response.render()
def test_register_invalid_username(self):
''' gotta have an email '''
""" gotta have an email """
view = views.Register.as_view()
self.assertEqual(models.User.objects.count(), 1)
request = self.factory.post(
'register/',
{
'localname': 'nut@ria',
'password': 'mouseword',
'email': 'aa@bb.ccc'
})
"register/",
{"localname": "nut@ria", "password": "mouseword", "email": "aa@bb.ccc"},
)
response = view(request)
self.assertEqual(models.User.objects.count(), 1)
response.render()
request = self.factory.post(
'register/',
{
'localname': 'nutr ia',
'password': 'mouseword',
'email': 'aa@bb.ccc'
})
"register/",
{"localname": "nutr ia", "password": "mouseword", "email": "aa@bb.ccc"},
)
response = view(request)
self.assertEqual(models.User.objects.count(), 1)
response.render()
request = self.factory.post(
'register/',
{
'localname': 'nut@ria',
'password': 'mouseword',
'email': 'aa@bb.ccc'
})
"register/",
{"localname": "nut@ria", "password": "mouseword", "email": "aa@bb.ccc"},
)
response = view(request)
self.assertEqual(models.User.objects.count(), 1)
response.render()
def test_register_closed_instance(self):
''' you can't just register '''
""" you can't just register """
view = views.Register.as_view()
self.settings.allow_registration = False
self.settings.save()
request = self.factory.post(
'register/',
{
'localname': 'nutria ',
'password': 'mouseword',
'email': 'aa@bb.ccc'
})
"register/",
{"localname": "nutria ", "password": "mouseword", "email": "aa@bb.ccc"},
)
with self.assertRaises(PermissionDenied):
view(request)
def test_register_invite(self):
''' you can't just register '''
""" you can't just register """
view = views.Register.as_view()
self.settings.allow_registration = False
self.settings.save()
models.SiteInvite.objects.create(
code='testcode', user=self.local_user, use_limit=1)
code="testcode", user=self.local_user, use_limit=1
)
self.assertEqual(models.SiteInvite.objects.get().times_used, 0)
request = self.factory.post(
'register/',
"register/",
{
'localname': 'nutria',
'password': 'mouseword',
'email': 'aa@bb.ccc',
'invite_code': 'testcode'
})
with patch('bookwyrm.views.authentication.login'):
"localname": "nutria",
"password": "mouseword",
"email": "aa@bb.ccc",
"invite_code": "testcode",
},
)
with patch("bookwyrm.views.authentication.login"):
response = view(request)
self.assertEqual(models.User.objects.count(), 2)
self.assertEqual(response.status_code, 302)
@ -174,26 +161,28 @@ class AuthenticationViews(TestCase):
# invite already used to max capacity
request = self.factory.post(
'register/',
"register/",
{
'localname': 'nutria2',
'password': 'mouseword',
'email': 'aa@bb.ccc',
'invite_code': 'testcode'
})
"localname": "nutria2",
"password": "mouseword",
"email": "aa@bb.ccc",
"invite_code": "testcode",
},
)
with self.assertRaises(PermissionDenied):
response = view(request)
self.assertEqual(models.User.objects.count(), 2)
# bad invite code
request = self.factory.post(
'register/',
"register/",
{
'localname': 'nutria3',
'password': 'mouseword',
'email': 'aa@bb.ccc',
'invite_code': 'dkfkdjgdfkjgkdfj'
})
"localname": "nutria3",
"password": "mouseword",
"email": "aa@bb.ccc",
"invite_code": "dkfkdjgdfkjgkdfj",
},
)
with self.assertRaises(Http404):
response = view(request)
self.assertEqual(models.User.objects.count(), 2)

92
bookwyrm/tests/views/test_author.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.contrib.auth.models import Group, Permission
from django.contrib.contenttypes.models import ContentType
@ -12,37 +12,41 @@ from bookwyrm.activitypub import ActivitypubResponse
class AuthorViews(TestCase):
''' author views'''
""" author views"""
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
self.group = Group.objects.create(name='editor')
self.group = Group.objects.create(name="editor")
self.group.permissions.add(
Permission.objects.create(
name='edit_book',
codename='edit_book',
content_type=ContentType.objects.get_for_model(models.User)).id
name="edit_book",
codename="edit_book",
content_type=ContentType.objects.get_for_model(models.User),
).id
)
self.work = models.Work.objects.create(title='Test Work')
self.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=self.work
title="Example Edition",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
models.SiteSettings.objects.create()
def test_author_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Author.as_view()
author = models.Author.objects.create(name='Jessica')
request = self.factory.get('')
with patch('bookwyrm.views.author.is_api_request') as is_api:
author = models.Author.objects.create(name="Jessica")
request = self.factory.get("")
with patch("bookwyrm.views.author.is_api_request") as is_api:
is_api.return_value = False
result = view(request, author.id)
self.assertIsInstance(result, TemplateResponse)
@ -50,19 +54,18 @@ class AuthorViews(TestCase):
self.assertEqual(result.status_code, 200)
self.assertEqual(result.status_code, 200)
request = self.factory.get('')
with patch('bookwyrm.views.author.is_api_request') as is_api:
request = self.factory.get("")
with patch("bookwyrm.views.author.is_api_request") as is_api:
is_api.return_value = True
result = view(request, author.id)
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_edit_author_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.EditAuthor.as_view()
author = models.Author.objects.create(name='Test Author')
request = self.factory.get('')
author = models.Author.objects.create(name="Test Author")
request = self.factory.get("")
request.user = self.local_user
request.user.is_superuser = True
@ -72,52 +75,51 @@ class AuthorViews(TestCase):
self.assertEqual(result.status_code, 200)
self.assertEqual(result.status_code, 200)
def test_edit_author(self):
''' edit an author '''
""" edit an author """
view = views.EditAuthor.as_view()
author = models.Author.objects.create(name='Test Author')
author = models.Author.objects.create(name="Test Author")
self.local_user.groups.add(self.group)
form = forms.AuthorForm(instance=author)
form.data['name'] = 'New Name'
form.data['last_edited_by'] = self.local_user.id
request = self.factory.post('', form.data)
form.data["name"] = "New Name"
form.data["last_edited_by"] = self.local_user.id
request = self.factory.post("", form.data)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, author.id)
author.refresh_from_db()
self.assertEqual(author.name, 'New Name')
self.assertEqual(author.name, "New Name")
self.assertEqual(author.last_edited_by, self.local_user)
def test_edit_author_non_editor(self):
''' edit an author with invalid post data'''
""" edit an author with invalid post data"""
view = views.EditAuthor.as_view()
author = models.Author.objects.create(name='Test Author')
author = models.Author.objects.create(name="Test Author")
form = forms.AuthorForm(instance=author)
form.data['name'] = 'New Name'
form.data['last_edited_by'] = self.local_user.id
request = self.factory.post('', form.data)
form.data["name"] = "New Name"
form.data["last_edited_by"] = self.local_user.id
request = self.factory.post("", form.data)
request.user = self.local_user
with self.assertRaises(PermissionDenied):
view(request, author.id)
author.refresh_from_db()
self.assertEqual(author.name, 'Test Author')
self.assertEqual(author.name, "Test Author")
def test_edit_author_invalid_form(self):
''' edit an author with invalid post data'''
""" edit an author with invalid post data"""
view = views.EditAuthor.as_view()
author = models.Author.objects.create(name='Test Author')
author = models.Author.objects.create(name="Test Author")
self.local_user.groups.add(self.group)
form = forms.AuthorForm(instance=author)
form.data['name'] = ''
form.data['last_edited_by'] = self.local_user.id
request = self.factory.post('', form.data)
form.data["name"] = ""
form.data["last_edited_by"] = self.local_user.id
request = self.factory.post("", form.data)
request.user = self.local_user
resp = view(request, author.id)
author.refresh_from_db()
self.assertEqual(author.name, 'Test Author')
self.assertEqual(author.name, "Test Author")
resp.render()
self.assertEqual(resp.status_code, 200)

50
bookwyrm/tests/views/test_block.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.template.response import TemplateResponse
from django.test import TestCase
@ -8,28 +8,34 @@ from bookwyrm import models, views
class BlockViews(TestCase):
''' view user and edit profile '''
""" view user and edit profile """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.mouse', 'password',
local=True, localname='mouse')
with patch('bookwyrm.models.user.set_remote_server.delay'):
"mouse@local.com",
"mouse@mouse.mouse",
"password",
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',
"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',
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
models.SiteSettings.objects.create()
def test_block_get(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Block.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request)
self.assertIsInstance(result, TemplateResponse)
@ -37,19 +43,19 @@ class BlockViews(TestCase):
self.assertEqual(result.status_code, 200)
def test_block_post(self):
''' create a "block" database entry from an activity '''
""" create a "block" database entry from an activity """
view = views.Block.as_view()
self.local_user.followers.add(self.remote_user)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.UserFollowRequest.objects.create(
user_subject=self.local_user,
user_object=self.remote_user)
user_subject=self.local_user, user_object=self.remote_user
)
self.assertTrue(models.UserFollows.objects.exists())
self.assertTrue(models.UserFollowRequest.objects.exists())
request = self.factory.post('')
request = self.factory.post("")
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, self.remote_user.id)
block = models.UserBlocks.objects.get()
self.assertEqual(block.user_subject, self.local_user)
@ -59,12 +65,12 @@ class BlockViews(TestCase):
self.assertFalse(models.UserFollowRequest.objects.exists())
def test_unblock(self):
''' undo a block '''
""" undo a block """
self.local_user.blocks.add(self.remote_user)
request = self.factory.post('')
request = self.factory.post("")
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.block.unblock(request, self.remote_user.id)
self.assertFalse(models.UserBlocks.objects.exists())

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

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.contrib.auth.models import Group, Permission
from django.contrib.contenttypes.models import ContentType
@ -11,55 +11,58 @@ from bookwyrm.activitypub import ActivitypubResponse
class BookViews(TestCase):
''' books books books '''
""" books books books """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
self.group = Group.objects.create(name='editor')
self.group = Group.objects.create(name="editor")
self.group.permissions.add(
Permission.objects.create(
name='edit_book',
codename='edit_book',
content_type=ContentType.objects.get_for_model(models.User)).id
name="edit_book",
codename="edit_book",
content_type=ContentType.objects.get_for_model(models.User),
).id
)
self.work = models.Work.objects.create(title='Test Work')
self.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=self.work
title="Example Edition",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
models.SiteSettings.objects.create()
def test_book_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Book.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
with patch('bookwyrm.views.books.is_api_request') as is_api:
with patch("bookwyrm.views.books.is_api_request") as is_api:
is_api.return_value = False
result = view(request, self.book.id)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
request = self.factory.get('')
with patch('bookwyrm.views.books.is_api_request') as is_api:
request = self.factory.get("")
with patch("bookwyrm.views.books.is_api_request") as is_api:
is_api.return_value = True
result = view(request, self.book.id)
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_edit_book_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.EditBook.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
request.user.is_superuser = True
result = view(request, self.book.id)
@ -67,21 +70,19 @@ class BookViews(TestCase):
result.render()
self.assertEqual(result.status_code, 200)
def test_edit_book(self):
''' lets a user edit a book '''
""" lets a user edit a book """
view = views.EditBook.as_view()
self.local_user.groups.add(self.group)
form = forms.EditionForm(instance=self.book)
form.data['title'] = 'New Title'
form.data['last_edited_by'] = self.local_user.id
request = self.factory.post('', form.data)
form.data["title"] = "New Title"
form.data["last_edited_by"] = self.local_user.id
request = self.factory.post("", form.data)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, self.book.id)
self.book.refresh_from_db()
self.assertEqual(self.book.title, 'New Title')
self.assertEqual(self.book.title, "New Title")
def test_edit_book_add_author(self):
''' lets a user edit a book with new authors '''
@ -141,49 +142,42 @@ class BookViews(TestCase):
def test_switch_edition(self):
''' updates user's relationships to a book '''
work = models.Work.objects.create(title='test work')
edition1 = models.Edition.objects.create(
title='first ed', parent_work=work)
edition2 = models.Edition.objects.create(
title='second ed', parent_work=work)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
shelf = models.Shelf.objects.create(
name='Test Shelf', user=self.local_user)
""" updates user's relationships to a book """
work = models.Work.objects.create(title="test work")
edition1 = models.Edition.objects.create(title="first ed", parent_work=work)
edition2 = models.Edition.objects.create(title="second ed", parent_work=work)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
shelf = models.Shelf.objects.create(name="Test Shelf", user=self.local_user)
models.ShelfBook.objects.create(
book=edition1,
user=self.local_user,
shelf=shelf,
)
models.ReadThrough.objects.create(
user=self.local_user, book=edition1)
models.ReadThrough.objects.create(user=self.local_user, book=edition1)
self.assertEqual(models.ShelfBook.objects.get().book, edition1)
self.assertEqual(models.ReadThrough.objects.get().book, edition1)
request = self.factory.post('', {
'edition': edition2.id
})
request = self.factory.post("", {"edition": edition2.id})
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.switch_edition(request)
self.assertEqual(models.ShelfBook.objects.get().book, edition2)
self.assertEqual(models.ReadThrough.objects.get().book, edition2)
def test_editions_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Editions.as_view()
request = self.factory.get('')
with patch('bookwyrm.views.books.is_api_request') as is_api:
request = self.factory.get("")
with patch("bookwyrm.views.books.is_api_request") as is_api:
is_api.return_value = False
result = view(request, self.work.id)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
request = self.factory.get('')
with patch('bookwyrm.views.books.is_api_request') as is_api:
request = self.factory.get("")
with patch("bookwyrm.views.books.is_api_request") as is_api:
is_api.return_value = True
result = view(request, self.work.id)
self.assertIsInstance(result, ActivitypubResponse)

20
bookwyrm/tests/views/test_federation.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from django.template.response import TemplateResponse
from django.test import TestCase
from django.test.client import RequestFactory
@ -8,20 +8,24 @@ from bookwyrm import views
class FederationViews(TestCase):
''' every response to a get request, html or json '''
""" every response to a get request, html or json """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.mouse', 'password',
local=True, localname='mouse')
"mouse@local.com",
"mouse@mouse.mouse",
"password",
local=True,
localname="mouse",
)
models.SiteSettings.objects.create()
def test_federation_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Federation.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
request.user.is_superuser = True
result = view(request)

80
bookwyrm/tests/views/test_feed.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.template.response import TemplateResponse
from django.test import TestCase
@ -10,95 +10,93 @@ from bookwyrm.activitypub import ActivitypubResponse
class FeedMessageViews(TestCase):
''' dms '''
""" dms """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.mouse', 'password',
local=True, localname='mouse')
"mouse@local.com",
"mouse@mouse.mouse",
"password",
local=True,
localname="mouse",
)
self.book = models.Edition.objects.create(
parent_work=models.Work.objects.create(title='hi'),
title='Example Edition',
remote_id='https://example.com/book/1',
parent_work=models.Work.objects.create(title="hi"),
title="Example Edition",
remote_id="https://example.com/book/1",
)
models.SiteSettings.objects.create()
def test_feed(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Feed.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request, 'local')
result = view(request, "local")
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
def test_status_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Status.as_view()
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
status = models.Status.objects.create(
content='hi', user=self.local_user)
request = self.factory.get('')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Status.objects.create(content="hi", user=self.local_user)
request = self.factory.get("")
request.user = self.local_user
with patch('bookwyrm.views.feed.is_api_request') as is_api:
with patch("bookwyrm.views.feed.is_api_request") as is_api:
is_api.return_value = False
result = view(request, 'mouse', status.id)
result = view(request, "mouse", status.id)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
with patch('bookwyrm.views.feed.is_api_request') as is_api:
with patch("bookwyrm.views.feed.is_api_request") as is_api:
is_api.return_value = True
result = view(request, 'mouse', status.id)
result = view(request, "mouse", status.id)
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_replies_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Replies.as_view()
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
status = models.Status.objects.create(
content='hi', user=self.local_user)
request = self.factory.get('')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Status.objects.create(content="hi", user=self.local_user)
request = self.factory.get("")
request.user = self.local_user
with patch('bookwyrm.views.feed.is_api_request') as is_api:
with patch("bookwyrm.views.feed.is_api_request") as is_api:
is_api.return_value = False
result = view(request, 'mouse', status.id)
result = view(request, "mouse", status.id)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
with patch('bookwyrm.views.feed.is_api_request') as is_api:
with patch("bookwyrm.views.feed.is_api_request") as is_api:
is_api.return_value = True
result = view(request, 'mouse', status.id)
result = view(request, "mouse", status.id)
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_direct_messages_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.DirectMessage.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
def test_get_suggested_book(self):
''' gets books the ~*~ algorithm ~*~ thinks you want to post about '''
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" gets books the ~*~ algorithm ~*~ thinks you want to post about """
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.ShelfBook.objects.create(
book=self.book,
user=self.local_user,
shelf=self.local_user.shelf_set.get(identifier='reading')
shelf=self.local_user.shelf_set.get(identifier="reading"),
)
suggestions = views.feed.get_suggested_books(self.local_user)
self.assertEqual(suggestions[0]['name'], 'Currently Reading')
self.assertEqual(suggestions[0]['books'][0], self.book)
self.assertEqual(suggestions[0]["name"], "Currently Reading")
self.assertEqual(suggestions[0]["books"][0], self.book)

129
bookwyrm/tests/views/test_follow.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.contrib.auth.models import Group, Permission
from django.contrib.contenttypes.models import ContentType
@ -9,148 +9,147 @@ from bookwyrm import models, views
class BookViews(TestCase):
''' books books books '''
""" books books books """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
with patch('bookwyrm.models.user.set_remote_server'):
with patch("bookwyrm.models.user.set_remote_server"):
self.remote_user = models.User.objects.create_user(
'rat', 'rat@email.com', 'ratword',
"rat",
"rat@email.com",
"ratword",
local=False,
remote_id='https://example.com/users/rat',
inbox='https://example.com/users/rat/inbox',
outbox='https://example.com/users/rat/outbox',
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
self.group = Group.objects.create(name='editor')
self.group = Group.objects.create(name="editor")
self.group.permissions.add(
Permission.objects.create(
name='edit_book',
codename='edit_book',
content_type=ContentType.objects.get_for_model(models.User)).id
name="edit_book",
codename="edit_book",
content_type=ContentType.objects.get_for_model(models.User),
).id
)
self.work = models.Work.objects.create(title='Test Work')
self.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=self.work
title="Example Edition",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
def test_handle_follow_remote(self):
''' send a follow request '''
request = self.factory.post('', {'user': self.remote_user.username})
""" send a follow request """
request = self.factory.post("", {"user": self.remote_user.username})
request.user = self.local_user
self.assertEqual(models.UserFollowRequest.objects.count(), 0)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.follow(request)
rel = models.UserFollowRequest.objects.get()
self.assertEqual(rel.user_subject, self.local_user)
self.assertEqual(rel.user_object, self.remote_user)
self.assertEqual(rel.status, 'follow_request')
self.assertEqual(rel.status, "follow_request")
def test_handle_follow_local_manually_approves(self):
''' send a follow request '''
""" send a follow request """
rat = models.User.objects.create_user(
'rat@local.com', 'rat@rat.com', 'ratword',
local=True, localname='rat',
remote_id='https://example.com/users/rat',
"rat@local.com",
"rat@rat.com",
"ratword",
local=True,
localname="rat",
remote_id="https://example.com/users/rat",
manually_approves_followers=True,
)
request = self.factory.post('', {'user': rat})
request = self.factory.post("", {"user": rat})
request.user = self.local_user
self.assertEqual(models.UserFollowRequest.objects.count(), 0)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.follow(request)
rel = models.UserFollowRequest.objects.get()
self.assertEqual(rel.user_subject, self.local_user)
self.assertEqual(rel.user_object, rat)
self.assertEqual(rel.status, 'follow_request')
self.assertEqual(rel.status, "follow_request")
def test_handle_follow_local(self):
''' send a follow request '''
""" send a follow request """
rat = models.User.objects.create_user(
'rat@local.com', 'rat@rat.com', 'ratword',
local=True, localname='rat',
remote_id='https://example.com/users/rat',
"rat@local.com",
"rat@rat.com",
"ratword",
local=True,
localname="rat",
remote_id="https://example.com/users/rat",
)
request = self.factory.post('', {'user': rat})
request = self.factory.post("", {"user": rat})
request.user = self.local_user
self.assertEqual(models.UserFollowRequest.objects.count(), 0)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.follow(request)
rel = models.UserFollows.objects.get()
self.assertEqual(rel.user_subject, self.local_user)
self.assertEqual(rel.user_object, rat)
self.assertEqual(rel.status, 'follows')
self.assertEqual(rel.status, "follows")
def test_handle_unfollow(self):
''' send an unfollow '''
request = self.factory.post('', {'user': self.remote_user.username})
""" send an unfollow """
request = self.factory.post("", {"user": self.remote_user.username})
request.user = self.local_user
self.remote_user.followers.add(self.local_user)
self.assertEqual(self.remote_user.followers.count(), 1)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay') \
as mock:
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay") as mock:
views.unfollow(request)
self.assertEqual(mock.call_count, 1)
self.assertEqual(self.remote_user.followers.count(), 0)
def test_handle_accept(self):
''' accept a follow request '''
""" accept a follow request """
self.local_user.manually_approves_followers = True
self.local_user.save(broadcast=False)
request = self.factory.post('', {'user': self.remote_user.username})
request = self.factory.post("", {"user": self.remote_user.username})
request.user = self.local_user
rel = models.UserFollowRequest.objects.create(
user_subject=self.remote_user,
user_object=self.local_user
user_subject=self.remote_user, user_object=self.local_user
)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.accept_follow_request(request)
# request should be deleted
self.assertEqual(
models.UserFollowRequest.objects.filter(id=rel.id).count(), 0
)
self.assertEqual(models.UserFollowRequest.objects.filter(id=rel.id).count(), 0)
# follow relationship should exist
self.assertEqual(self.local_user.followers.first(), self.remote_user)
def test_handle_reject(self):
''' reject a follow request '''
""" reject a follow request """
self.local_user.manually_approves_followers = True
self.local_user.save(broadcast=False)
request = self.factory.post('', {'user': self.remote_user.username})
request = self.factory.post("", {"user": self.remote_user.username})
request.user = self.local_user
rel = models.UserFollowRequest.objects.create(
user_subject=self.remote_user,
user_object=self.local_user
user_subject=self.remote_user, user_object=self.local_user
)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.delete_follow_request(request)
# request should be deleted
self.assertEqual(
models.UserFollowRequest.objects.filter(id=rel.id).count(), 0
)
self.assertEqual(models.UserFollowRequest.objects.filter(id=rel.id).count(), 0)
# follow relationship should not exist
self.assertEqual(
models.UserFollows.objects.filter(id=rel.id).count(), 0
)
self.assertEqual(models.UserFollows.objects.filter(id=rel.id).count(), 0)

86
bookwyrm/tests/views/test_goal.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.utils import timezone
@ -11,60 +11,65 @@ from bookwyrm import models, views
class GoalViews(TestCase):
''' viewing and creating statuses '''
""" viewing and creating statuses """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
self.rat = models.User.objects.create_user(
'rat@local.com', 'rat@rat.com', 'ratword',
local=True, localname='rat',
remote_id='https://example.com/users/rat',
"rat@local.com",
"rat@rat.com",
"ratword",
local=True,
localname="rat",
remote_id="https://example.com/users/rat",
)
self.book = models.Edition.objects.create(
title='Example Edition',
remote_id='https://example.com/book/1',
title="Example Edition",
remote_id="https://example.com/book/1",
)
self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False
models.SiteSettings.objects.create()
def test_goal_page_no_goal(self):
''' view a reading goal page for another's unset goal '''
""" view a reading goal page for another's unset goal """
view = views.Goal.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.rat
result = view(request, self.local_user.localname, 2020)
self.assertEqual(result.status_code, 404)
def test_goal_page_no_goal_self(self):
''' view a reading goal page for your own unset goal '''
""" view a reading goal page for your own unset goal """
view = views.Goal.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request, self.local_user.localname, 2020)
result.render()
self.assertIsInstance(result, TemplateResponse)
def test_goal_page_anonymous(self):
''' can't view it without login '''
""" can't view it without login """
view = views.Goal.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.anonymous_user
result = view(request, self.local_user.localname, 2020)
self.assertEqual(result.status_code, 302)
def test_goal_page_public(self):
''' view a user's public goal '''
""" view a user's public goal """
models.ReadThrough.objects.create(
finish_date=timezone.now(),
user=self.local_user,
@ -75,9 +80,10 @@ class GoalViews(TestCase):
user=self.local_user,
year=timezone.now().year,
goal=128937123,
privacy='public')
privacy="public",
)
view = views.Goal.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.rat
result = view(request, self.local_user.localname, timezone.now().year)
@ -85,40 +91,40 @@ class GoalViews(TestCase):
self.assertIsInstance(result, TemplateResponse)
def test_goal_page_private(self):
''' view a user's private goal '''
""" view a user's private goal """
models.AnnualGoal.objects.create(
user=self.local_user,
year=2020,
goal=15,
privacy='followers')
user=self.local_user, year=2020, goal=15, privacy="followers"
)
view = views.Goal.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.rat
result = view(request, self.local_user.localname, 2020)
self.assertEqual(result.status_code, 404)
def test_create_goal(self):
''' create a new goal '''
""" create a new goal """
view = views.Goal.as_view()
request = self.factory.post('', {
'user': self.local_user.id,
'goal': 10,
'year': 2020,
'privacy': 'unlisted',
'post-status': True
})
request = self.factory.post(
"",
{
"user": self.local_user.id,
"goal": 10,
"year": 2020,
"privacy": "unlisted",
"post-status": True,
},
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, self.local_user.localname, 2020)
goal = models.AnnualGoal.objects.get()
self.assertEqual(goal.user, self.local_user)
self.assertEqual(goal.goal, 10)
self.assertEqual(goal.year, 2020)
self.assertEqual(goal.privacy, 'unlisted')
self.assertEqual(goal.privacy, "unlisted")
status = models.GeneratedNote.objects.get()
self.assertEqual(status.user, self.local_user)
self.assertEqual(status.privacy, 'unlisted')
self.assertEqual(status.privacy, "unlisted")

324
bookwyrm/tests/views/test_helpers.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
import json
from unittest.mock import patch
import pathlib
@ -9,127 +9,129 @@ import responses
from bookwyrm import models, views
from bookwyrm.settings import USER_AGENT
class ViewsHelpers(TestCase):
''' viewing and creating statuses '''
""" viewing and creating statuses """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
self.work = models.Work.objects.create(title='Test Work')
self.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create(
title='Test Book',
remote_id='https://example.com/book/1',
parent_work=self.work
title="Test Book",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
with patch('bookwyrm.models.user.set_remote_server.delay'):
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
'rat', 'rat@rat.com', 'ratword',
"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',
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
datafile = pathlib.Path(__file__).parent.joinpath(
'../data/ap_user.json'
)
datafile = pathlib.Path(__file__).parent.joinpath("../data/ap_user.json")
self.userdata = json.loads(datafile.read_bytes())
del self.userdata['icon']
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
del self.userdata["icon"]
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.shelf = models.Shelf.objects.create(
name='Test Shelf',
identifier='test-shelf',
user=self.local_user
name="Test Shelf", identifier="test-shelf", user=self.local_user
)
def test_get_edition(self):
''' given an edition or a work, returns an edition '''
self.assertEqual(
views.helpers.get_edition(self.book.id), self.book)
self.assertEqual(
views.helpers.get_edition(self.work.id), self.book)
""" given an edition or a work, returns an edition """
self.assertEqual(views.helpers.get_edition(self.book.id), self.book)
self.assertEqual(views.helpers.get_edition(self.work.id), self.book)
def test_get_user_from_username(self):
''' works for either localname or username '''
""" works for either localname or username """
self.assertEqual(
views.helpers.get_user_from_username(
self.local_user, 'mouse'), self.local_user)
views.helpers.get_user_from_username(self.local_user, "mouse"),
self.local_user,
)
self.assertEqual(
views.helpers.get_user_from_username(
self.local_user, 'mouse@local.com'), self.local_user)
views.helpers.get_user_from_username(self.local_user, "mouse@local.com"),
self.local_user,
)
with self.assertRaises(models.User.DoesNotExist):
views.helpers.get_user_from_username(
self.local_user, 'mojfse@example.com')
views.helpers.get_user_from_username(self.local_user, "mojfse@example.com")
def test_is_api_request(self):
''' should it return html or json '''
request = self.factory.get('/path')
request.headers = {'Accept': 'application/json'}
""" should it return html or json """
request = self.factory.get("/path")
request.headers = {"Accept": "application/json"}
self.assertTrue(views.helpers.is_api_request(request))
request = self.factory.get('/path.json')
request.headers = {'Accept': 'Praise'}
request = self.factory.get("/path.json")
request.headers = {"Accept": "Praise"}
self.assertTrue(views.helpers.is_api_request(request))
request = self.factory.get('/path')
request.headers = {'Accept': 'Praise'}
request = self.factory.get("/path")
request.headers = {"Accept": "Praise"}
self.assertFalse(views.helpers.is_api_request(request))
def test_get_activity_feed(self):
''' loads statuses '''
""" loads statuses """
rat = models.User.objects.create_user(
'rat', 'rat@rat.rat', 'password', local=True)
"rat", "rat@rat.rat", "password", local=True
)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
public_status = models.Comment.objects.create(
content='public status', book=self.book, user=self.local_user)
content="public status", book=self.book, user=self.local_user
)
direct_status = models.Status.objects.create(
content='direct', user=self.local_user, privacy='direct')
content="direct", user=self.local_user, privacy="direct"
)
rat_public = models.Status.objects.create(
content='blah blah', user=rat)
rat_public = models.Status.objects.create(content="blah blah", user=rat)
rat_unlisted = models.Status.objects.create(
content='blah blah', user=rat, privacy='unlisted')
content="blah blah", user=rat, privacy="unlisted"
)
remote_status = models.Status.objects.create(
content='blah blah', user=self.remote_user)
content="blah blah", user=self.remote_user
)
followers_status = models.Status.objects.create(
content='blah', user=rat, privacy='followers')
content="blah", user=rat, privacy="followers"
)
rat_mention = models.Status.objects.create(
content='blah blah blah', user=rat, privacy='followers')
content="blah blah blah", user=rat, privacy="followers"
)
rat_mention.mention_users.set([self.local_user])
statuses = views.helpers.get_activity_feed(
self.local_user,
privacy=['public', 'unlisted', 'followers'],
privacy=["public", "unlisted", "followers"],
following_only=True,
queryset=models.Comment.objects
queryset=models.Comment.objects,
)
self.assertEqual(len(statuses), 1)
self.assertEqual(statuses[0], public_status)
statuses = views.helpers.get_activity_feed(
self.local_user,
privacy=['public', 'followers'],
local_only=True
self.local_user, privacy=["public", "followers"], local_only=True
)
self.assertEqual(len(statuses), 2)
self.assertEqual(statuses[1], public_status)
self.assertEqual(statuses[0], rat_public)
statuses = views.helpers.get_activity_feed(
self.local_user, privacy=['direct'])
statuses = views.helpers.get_activity_feed(self.local_user, privacy=["direct"])
self.assertEqual(len(statuses), 1)
self.assertEqual(statuses[0], direct_status)
statuses = views.helpers.get_activity_feed(
self.local_user,
privacy=['public', 'followers'],
privacy=["public", "followers"],
)
self.assertEqual(len(statuses), 3)
self.assertEqual(statuses[2], public_status)
@ -138,8 +140,8 @@ class ViewsHelpers(TestCase):
statuses = views.helpers.get_activity_feed(
self.local_user,
privacy=['public', 'unlisted', 'followers'],
following_only=True
privacy=["public", "unlisted", "followers"],
following_only=True,
)
self.assertEqual(len(statuses), 2)
self.assertEqual(statuses[1], public_status)
@ -148,8 +150,8 @@ class ViewsHelpers(TestCase):
rat.followers.add(self.local_user)
statuses = views.helpers.get_activity_feed(
self.local_user,
privacy=['public', 'unlisted', 'followers'],
following_only=True
privacy=["public", "unlisted", "followers"],
following_only=True,
)
self.assertEqual(len(statuses), 5)
self.assertEqual(statuses[4], public_status)
@ -158,187 +160,187 @@ class ViewsHelpers(TestCase):
self.assertEqual(statuses[1], followers_status)
self.assertEqual(statuses[0], rat_mention)
def test_get_activity_feed_blocks(self):
''' feed generation with blocked users '''
""" feed generation with blocked users """
rat = models.User.objects.create_user(
'rat', 'rat@rat.rat', 'password', local=True)
"rat", "rat@rat.rat", "password", local=True
)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
public_status = models.Comment.objects.create(
content='public status', book=self.book, user=self.local_user)
rat_public = models.Status.objects.create(
content='blah blah', user=rat)
content="public status", book=self.book, user=self.local_user
)
rat_public = models.Status.objects.create(content="blah blah", user=rat)
statuses = views.helpers.get_activity_feed(
self.local_user, privacy=['public'])
self.local_user, privacy=["public"]
)
self.assertEqual(len(statuses), 2)
# block relationship
rat.blocks.add(self.local_user)
statuses = views.helpers.get_activity_feed(
self.local_user, privacy=['public'])
statuses = views.helpers.get_activity_feed(self.local_user, privacy=["public"])
self.assertEqual(len(statuses), 1)
self.assertEqual(statuses[0], public_status)
statuses = views.helpers.get_activity_feed(
rat, privacy=['public'])
statuses = views.helpers.get_activity_feed(rat, privacy=["public"])
self.assertEqual(len(statuses), 1)
self.assertEqual(statuses[0], rat_public)
def test_is_bookwyrm_request(self):
''' checks if a request came from a bookwyrm instance '''
request = self.factory.get('', {'q': 'Test Book'})
""" checks if a request came from a bookwyrm instance """
request = self.factory.get("", {"q": "Test Book"})
self.assertFalse(views.helpers.is_bookwyrm_request(request))
request = self.factory.get(
'', {'q': 'Test Book'},
HTTP_USER_AGENT=\
"http.rb/4.4.1 (Mastodon/3.3.0; +https://mastodon.social/)"
"",
{"q": "Test Book"},
HTTP_USER_AGENT="http.rb/4.4.1 (Mastodon/3.3.0; +https://mastodon.social/)",
)
self.assertFalse(views.helpers.is_bookwyrm_request(request))
request = self.factory.get(
'', {'q': 'Test Book'}, HTTP_USER_AGENT=USER_AGENT)
request = self.factory.get("", {"q": "Test Book"}, HTTP_USER_AGENT=USER_AGENT)
self.assertTrue(views.helpers.is_bookwyrm_request(request))
def test_existing_user(self):
''' simple database lookup by username '''
result = views.helpers.handle_remote_webfinger('@mouse@local.com')
""" simple database lookup by username """
result = views.helpers.handle_remote_webfinger("@mouse@local.com")
self.assertEqual(result, self.local_user)
result = views.helpers.handle_remote_webfinger('mouse@local.com')
result = views.helpers.handle_remote_webfinger("mouse@local.com")
self.assertEqual(result, self.local_user)
@responses.activate
def test_load_user(self):
''' find a remote user using webfinger '''
username = 'mouse@example.com'
""" find a remote user using webfinger """
username = "mouse@example.com"
wellknown = {
"subject": "acct:mouse@example.com",
"links": [{
"rel": "self",
"type": "application/activity+json",
"href": "https://example.com/user/mouse"
}]
"links": [
{
"rel": "self",
"type": "application/activity+json",
"href": "https://example.com/user/mouse",
}
],
}
responses.add(
responses.GET,
'https://example.com/.well-known/webfinger?resource=acct:%s' \
% username,
"https://example.com/.well-known/webfinger?resource=acct:%s" % username,
json=wellknown,
status=200)
status=200,
)
responses.add(
responses.GET,
'https://example.com/user/mouse',
"https://example.com/user/mouse",
json=self.userdata,
status=200)
with patch('bookwyrm.models.user.set_remote_server.delay'):
result = views.helpers.handle_remote_webfinger('@mouse@example.com')
status=200,
)
with patch("bookwyrm.models.user.set_remote_server.delay"):
result = views.helpers.handle_remote_webfinger("@mouse@example.com")
self.assertIsInstance(result, models.User)
self.assertEqual(result.username, 'mouse@example.com')
self.assertEqual(result.username, "mouse@example.com")
def test_handle_reading_status_to_read(self):
''' posts shelve activities '''
shelf = self.local_user.shelf_set.get(identifier='to-read')
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" posts shelve activities """
shelf = self.local_user.shelf_set.get(identifier="to-read")
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.helpers.handle_reading_status(
self.local_user, shelf, self.book, 'public')
self.local_user, shelf, self.book, "public"
)
status = models.GeneratedNote.objects.get()
self.assertEqual(status.user, self.local_user)
self.assertEqual(status.mention_books.first(), self.book)
self.assertEqual(status.content, 'wants to read')
self.assertEqual(status.content, "wants to read")
def test_handle_reading_status_reading(self):
''' posts shelve activities '''
shelf = self.local_user.shelf_set.get(identifier='reading')
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" posts shelve activities """
shelf = self.local_user.shelf_set.get(identifier="reading")
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.helpers.handle_reading_status(
self.local_user, shelf, self.book, 'public')
self.local_user, shelf, self.book, "public"
)
status = models.GeneratedNote.objects.get()
self.assertEqual(status.user, self.local_user)
self.assertEqual(status.mention_books.first(), self.book)
self.assertEqual(status.content, 'started reading')
self.assertEqual(status.content, "started reading")
def test_handle_reading_status_read(self):
''' posts shelve activities '''
shelf = self.local_user.shelf_set.get(identifier='read')
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" posts shelve activities """
shelf = self.local_user.shelf_set.get(identifier="read")
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.helpers.handle_reading_status(
self.local_user, shelf, self.book, 'public')
self.local_user, shelf, self.book, "public"
)
status = models.GeneratedNote.objects.get()
self.assertEqual(status.user, self.local_user)
self.assertEqual(status.mention_books.first(), self.book)
self.assertEqual(status.content, 'finished reading')
self.assertEqual(status.content, "finished reading")
def test_handle_reading_status_other(self):
''' posts shelve activities '''
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" posts shelve activities """
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.helpers.handle_reading_status(
self.local_user, self.shelf, self.book, 'public')
self.local_user, self.shelf, self.book, "public"
)
self.assertFalse(models.GeneratedNote.objects.exists())
def test_object_visible_to_user(self):
''' does a user have permission to view an object '''
""" does a user have permission to view an object """
obj = models.Status.objects.create(
content='hi', user=self.remote_user, privacy='public')
self.assertTrue(
views.helpers.object_visible_to_user(self.local_user, obj))
content="hi", user=self.remote_user, privacy="public"
)
self.assertTrue(views.helpers.object_visible_to_user(self.local_user, obj))
obj = models.Shelf.objects.create(
name='test', user=self.remote_user, privacy='unlisted')
self.assertTrue(
views.helpers.object_visible_to_user(self.local_user, obj))
name="test", user=self.remote_user, privacy="unlisted"
)
self.assertTrue(views.helpers.object_visible_to_user(self.local_user, obj))
obj = models.Status.objects.create(
content='hi', user=self.remote_user, privacy='followers')
self.assertFalse(
views.helpers.object_visible_to_user(self.local_user, obj))
content="hi", user=self.remote_user, privacy="followers"
)
self.assertFalse(views.helpers.object_visible_to_user(self.local_user, obj))
obj = models.Status.objects.create(
content='hi', user=self.remote_user, privacy='direct')
self.assertFalse(
views.helpers.object_visible_to_user(self.local_user, obj))
content="hi", user=self.remote_user, privacy="direct"
)
self.assertFalse(views.helpers.object_visible_to_user(self.local_user, obj))
obj = models.Status.objects.create(
content='hi', user=self.remote_user, privacy='direct')
content="hi", user=self.remote_user, privacy="direct"
)
obj.mention_users.add(self.local_user)
self.assertTrue(
views.helpers.object_visible_to_user(self.local_user, obj))
self.assertTrue(views.helpers.object_visible_to_user(self.local_user, obj))
def test_object_visible_to_user_follower(self):
''' what you can see if you follow a user '''
""" what you can see if you follow a user """
self.remote_user.followers.add(self.local_user)
obj = models.Status.objects.create(
content='hi', user=self.remote_user, privacy='followers')
self.assertTrue(
views.helpers.object_visible_to_user(self.local_user, obj))
content="hi", user=self.remote_user, privacy="followers"
)
self.assertTrue(views.helpers.object_visible_to_user(self.local_user, obj))
obj = models.Status.objects.create(
content='hi', user=self.remote_user, privacy='direct')
self.assertFalse(
views.helpers.object_visible_to_user(self.local_user, obj))
content="hi", user=self.remote_user, privacy="direct"
)
self.assertFalse(views.helpers.object_visible_to_user(self.local_user, obj))
obj = models.Status.objects.create(
content='hi', user=self.remote_user, privacy='direct')
content="hi", user=self.remote_user, privacy="direct"
)
obj.mention_users.add(self.local_user)
self.assertTrue(
views.helpers.object_visible_to_user(self.local_user, obj))
self.assertTrue(views.helpers.object_visible_to_user(self.local_user, obj))
def test_object_visible_to_user_blocked(self):
''' you can't see it if they block you '''
""" you can't see it if they block you """
self.remote_user.blocks.add(self.local_user)
obj = models.Status.objects.create(
content='hi', user=self.remote_user, privacy='public')
self.assertFalse(
views.helpers.object_visible_to_user(self.local_user, obj))
content="hi", user=self.remote_user, privacy="public"
)
self.assertFalse(views.helpers.object_visible_to_user(self.local_user, obj))
obj = models.Shelf.objects.create(
name='test', user=self.remote_user, privacy='unlisted')
self.assertFalse(
views.helpers.object_visible_to_user(self.local_user, obj))
name="test", user=self.remote_user, privacy="unlisted"
)
self.assertFalse(views.helpers.object_visible_to_user(self.local_user, obj))

27
bookwyrm/tests/views/test_import.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.template.response import TemplateResponse
from django.test import TestCase
@ -9,34 +9,37 @@ from bookwyrm import views
class ImportViews(TestCase):
''' goodreads import views '''
""" goodreads import views """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.mouse', 'password',
local=True, localname='mouse')
"mouse@local.com",
"mouse@mouse.mouse",
"password",
local=True,
localname="mouse",
)
models.SiteSettings.objects.create()
def test_import_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Import.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
def test_import_status(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.ImportStatus.as_view()
import_job = models.ImportJob.objects.create(user=self.local_user)
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
with patch('bookwyrm.tasks.app.AsyncResult') as async_result:
with patch("bookwyrm.tasks.app.AsyncResult") as async_result:
async_result.return_value = []
result = view(request, import_job.id)
self.assertIsInstance(result, TemplateResponse)

636
bookwyrm/tests/views/test_inbox.py
View File

File diff suppressed because it is too large Load Diff

116
bookwyrm/tests/views/test_interaction.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.test import TestCase
from django.test.client import RequestFactory
@ -7,40 +7,44 @@ from bookwyrm import models, views
class InteractionViews(TestCase):
''' viewing and creating statuses '''
""" viewing and creating statuses """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
with patch('bookwyrm.models.user.set_remote_server'):
with patch("bookwyrm.models.user.set_remote_server"):
self.remote_user = models.User.objects.create_user(
'rat', 'rat@email.com', 'ratword',
"rat",
"rat@email.com",
"ratword",
local=False,
remote_id='https://example.com/users/rat',
inbox='https://example.com/users/rat/inbox',
outbox='https://example.com/users/rat/outbox',
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')
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
title="Example Edition",
remote_id="https://example.com/book/1",
parent_work=work,
)
def test_handle_favorite(self):
''' create and broadcast faving a status '''
""" create and broadcast faving a status """
view = views.Favorite.as_view()
request = self.factory.post('')
request = self.factory.post("")
request.user = self.remote_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
status = models.Status.objects.create(
user=self.local_user, content='hi')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Status.objects.create(user=self.local_user, content="hi")
view(request, status.id)
fav = models.Favorite.objects.get()
@ -48,106 +52,100 @@ class InteractionViews(TestCase):
self.assertEqual(fav.user, self.remote_user)
notification = models.Notification.objects.get()
self.assertEqual(notification.notification_type, 'FAVORITE')
self.assertEqual(notification.notification_type, "FAVORITE")
self.assertEqual(notification.user, self.local_user)
self.assertEqual(notification.related_user, self.remote_user)
def test_handle_unfavorite(self):
''' unfav a status '''
""" unfav a status """
view = views.Unfavorite.as_view()
request = self.factory.post('')
request = self.factory.post("")
request.user = self.remote_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
status = models.Status.objects.create(
user=self.local_user, content='hi')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Status.objects.create(user=self.local_user, content="hi")
views.Favorite.as_view()(request, status.id)
self.assertEqual(models.Favorite.objects.count(), 1)
self.assertEqual(models.Notification.objects.count(), 1)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, status.id)
self.assertEqual(models.Favorite.objects.count(), 0)
self.assertEqual(models.Notification.objects.count(), 0)
def test_handle_boost(self):
''' boost a status '''
""" boost a status """
view = views.Boost.as_view()
request = self.factory.post('')
request = self.factory.post("")
request.user = self.remote_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
status = models.Status.objects.create(
user=self.local_user, content='hi')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Status.objects.create(user=self.local_user, content="hi")
view(request, status.id)
boost = models.Boost.objects.get()
self.assertEqual(boost.boosted_status, status)
self.assertEqual(boost.user, self.remote_user)
self.assertEqual(boost.privacy, 'public')
self.assertEqual(boost.privacy, "public")
notification = models.Notification.objects.get()
self.assertEqual(notification.notification_type, 'BOOST')
self.assertEqual(notification.notification_type, "BOOST")
self.assertEqual(notification.user, self.local_user)
self.assertEqual(notification.related_user, self.remote_user)
self.assertEqual(notification.related_status, status)
def test_handle_boost_unlisted(self):
''' boost a status '''
""" boost a status """
view = views.Boost.as_view()
request = self.factory.post('')
request = self.factory.post("")
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Status.objects.create(
user=self.local_user, content='hi', privacy='unlisted')
user=self.local_user, content="hi", privacy="unlisted"
)
view(request, status.id)
boost = models.Boost.objects.get()
self.assertEqual(boost.privacy, 'unlisted')
self.assertEqual(boost.privacy, "unlisted")
def test_handle_boost_private(self):
''' boost a status '''
""" boost a status """
view = views.Boost.as_view()
request = self.factory.post('')
request = self.factory.post("")
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Status.objects.create(
user=self.local_user, content='hi', privacy='followers')
user=self.local_user, content="hi", privacy="followers"
)
view(request, status.id)
self.assertFalse(models.Boost.objects.exists())
def test_handle_boost_twice(self):
''' boost a status '''
""" boost a status """
view = views.Boost.as_view()
request = self.factory.post('')
request = self.factory.post("")
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
status = models.Status.objects.create(
user=self.local_user, content='hi')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Status.objects.create(user=self.local_user, content="hi")
view(request, status.id)
view(request, status.id)
self.assertEqual(models.Boost.objects.count(), 1)
def test_handle_unboost(self):
''' undo a boost '''
""" undo a boost """
view = views.Unboost.as_view()
request = self.factory.post('')
request = self.factory.post("")
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
status = models.Status.objects.create(
user=self.local_user, content='hi')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Status.objects.create(user=self.local_user, content="hi")
views.Boost.as_view()(request, status.id)
self.assertEqual(models.Boost.objects.count(), 1)
self.assertEqual(models.Notification.objects.count(), 1)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay') \
as mock:
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay") as mock:
view(request, status.id)
self.assertEqual(mock.call_count, 1)
self.assertEqual(models.Boost.objects.count(), 0)

31
bookwyrm/tests/views/test_invite.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.contrib.auth.models import AnonymousUser
@ -11,36 +11,39 @@ from bookwyrm import views
class InviteViews(TestCase):
''' every response to a get request, html or json '''
""" every response to a get request, html or json """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.mouse', 'password',
local=True, localname='mouse')
"mouse@local.com",
"mouse@mouse.mouse",
"password",
local=True,
localname="mouse",
)
models.SiteSettings.objects.create()
def test_invite_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Invite.as_view()
models.SiteInvite.objects.create(code='hi', user=self.local_user)
request = self.factory.get('')
models.SiteInvite.objects.create(code="hi", user=self.local_user)
request = self.factory.get("")
request.user = AnonymousUser
# why?? this is annoying.
request.user.is_authenticated = False
with patch('bookwyrm.models.site.SiteInvite.valid') as invite:
with patch("bookwyrm.models.site.SiteInvite.valid") as invite:
invite.return_value = True
result = view(request, 'hi')
result = view(request, "hi")
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
def test_manage_invites(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.ManageInvites.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
request.user.is_superuser = True
result = view(request)

45
bookwyrm/tests/views/test_isbn.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
import json
from unittest.mock import patch
@ -13,42 +13,41 @@ from bookwyrm.settings import DOMAIN
class IsbnViews(TestCase):
''' tag views'''
""" tag views"""
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
self.work = models.Work.objects.create(title='Test Work')
self.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create(
title='Test Book',
isbn_13='1234567890123',
remote_id='https://example.com/book/1',
parent_work=self.work
title="Test Book",
isbn_13="1234567890123",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
models.Connector.objects.create(
identifier='self',
connector_file='self_connector',
local=True
identifier="self", connector_file="self_connector", local=True
)
models.SiteSettings.objects.create()
def test_isbn_json_response(self):
''' searches local data only and returns book data in json format '''
""" searches local data only and returns book data in json format """
view = views.Isbn.as_view()
request = self.factory.get('')
with patch('bookwyrm.views.isbn.is_api_request') as is_api:
request = self.factory.get("")
with patch("bookwyrm.views.isbn.is_api_request") as is_api:
is_api.return_value = True
response = view(request, isbn='1234567890123')
response = view(request, isbn="1234567890123")
self.assertIsInstance(response, JsonResponse)
data = json.loads(response.content)
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['title'], 'Test Book')
self.assertEqual(
data[0]['key'], 'https://%s/book/%d' % (DOMAIN, self.book.id))
self.assertEqual(data[0]["title"], "Test Book")
self.assertEqual(data[0]["key"], "https://%s/book/%d" % (DOMAIN, self.book.id))

30
bookwyrm/tests/views/test_landing.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from django.contrib.auth.models import AnonymousUser
from django.template.response import TemplateResponse
from django.test import TestCase
@ -9,22 +9,26 @@ from bookwyrm import views
class LandingViews(TestCase):
''' pages you land on without really trying '''
""" pages you land on without really trying """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.mouse', 'password',
local=True, localname='mouse')
"mouse@local.com",
"mouse@mouse.mouse",
"password",
local=True,
localname="mouse",
)
self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False
models.SiteSettings.objects.create()
def test_home_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Home.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request)
self.assertEqual(result.status_code, 200)
@ -36,21 +40,19 @@ class LandingViews(TestCase):
self.assertEqual(result.status_code, 200)
result.render()
def test_about_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.About.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
def test_discover(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Discover.as_view()
request = self.factory.get('')
request = self.factory.get("")
result = view(request)
self.assertIsInstance(result, TemplateResponse)

332
bookwyrm/tests/views/test_list.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.contrib.auth.models import AnonymousUser
@ -9,44 +9,52 @@ from django.test.client import RequestFactory
from bookwyrm import models, views
from bookwyrm.activitypub import ActivitypubResponse
#pylint: disable=unused-argument
# pylint: disable=unused-argument
class ListViews(TestCase):
''' tag views'''
""" tag views"""
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
self.rat = models.User.objects.create_user(
'rat@local.com', 'rat@rat.com', 'ratword',
local=True, localname='rat',
remote_id='https://example.com/users/rat',
"rat@local.com",
"rat@rat.com",
"ratword",
local=True,
localname="rat",
remote_id="https://example.com/users/rat",
)
work = models.Work.objects.create(title='Work')
work = models.Work.objects.create(title="Work")
self.book = models.Edition.objects.create(
title='Example Edition',
remote_id='https://example.com/book/1',
title="Example Edition",
remote_id="https://example.com/book/1",
parent_work=work,
)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.list = models.List.objects.create(
name='Test List', user=self.local_user)
name="Test List", user=self.local_user
)
self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False
models.SiteSettings.objects.create()
def test_lists_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Lists.as_view()
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
models.List.objects.create(name='Public list', user=self.local_user)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.List.objects.create(name="Public list", user=self.local_user)
models.List.objects.create(
name='Private list', privacy='direct', user=self.local_user)
request = self.factory.get('')
name="Private list", privacy="direct", user=self.local_user
)
request = self.factory.get("")
request.user = self.local_user
result = view(request)
@ -61,42 +69,45 @@ class ListViews(TestCase):
result.render()
self.assertEqual(result.status_code, 200)
def test_lists_create(self):
''' create list view '''
""" create list view """
real_broadcast = models.List.broadcast
def mock_broadcast(_, activity, user, **kwargs):
''' ok '''
""" ok """
self.assertEqual(user.remote_id, self.local_user.remote_id)
self.assertEqual(activity['type'], 'Create')
self.assertEqual(activity['actor'], self.local_user.remote_id)
self.assertEqual(activity["type"], "Create")
self.assertEqual(activity["actor"], self.local_user.remote_id)
models.List.broadcast = mock_broadcast
view = views.Lists.as_view()
request = self.factory.post('', {
'name': 'A list',
'description': 'wow',
'privacy': 'unlisted',
'curation': 'open',
'user': self.local_user.id,
})
request = self.factory.post(
"",
{
"name": "A list",
"description": "wow",
"privacy": "unlisted",
"curation": "open",
"user": self.local_user.id,
},
)
request.user = self.local_user
result = view(request)
self.assertEqual(result.status_code, 302)
new_list = models.List.objects.filter(name='A list').get()
self.assertEqual(new_list.description, 'wow')
self.assertEqual(new_list.privacy, 'unlisted')
self.assertEqual(new_list.curation, 'open')
new_list = models.List.objects.filter(name="A list").get()
self.assertEqual(new_list.description, "wow")
self.assertEqual(new_list.privacy, "unlisted")
self.assertEqual(new_list.curation, "open")
models.List.broadcast = real_broadcast
def test_list_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.List.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
with patch('bookwyrm.views.list.is_api_request') as is_api:
with patch("bookwyrm.views.list.is_api_request") as is_api:
is_api.return_value = False
result = view(request, self.list.id)
self.assertIsInstance(result, TemplateResponse)
@ -104,68 +115,72 @@ class ListViews(TestCase):
self.assertEqual(result.status_code, 200)
request.user = self.anonymous_user
with patch('bookwyrm.views.list.is_api_request') as is_api:
with patch("bookwyrm.views.list.is_api_request") as is_api:
is_api.return_value = False
result = view(request, self.list.id)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
with patch('bookwyrm.views.list.is_api_request') as is_api:
with patch("bookwyrm.views.list.is_api_request") as is_api:
is_api.return_value = True
result = view(request, self.list.id)
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
request = self.factory.get('/?page=1')
request = self.factory.get("/?page=1")
request.user = self.local_user
with patch('bookwyrm.views.list.is_api_request') as is_api:
with patch("bookwyrm.views.list.is_api_request") as is_api:
is_api.return_value = True
result = view(request, self.list.id)
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_list_edit(self):
''' edit a list '''
""" edit a list """
real_broadcast = models.List.broadcast
def mock_broadcast(_, activity, user, **kwargs):
''' ok '''
""" ok """
self.assertEqual(user.remote_id, self.local_user.remote_id)
self.assertEqual(activity['type'], 'Update')
self.assertEqual(activity['actor'], self.local_user.remote_id)
self.assertEqual(activity['object']['id'], self.list.remote_id)
self.assertEqual(activity["type"], "Update")
self.assertEqual(activity["actor"], self.local_user.remote_id)
self.assertEqual(activity["object"]["id"], self.list.remote_id)
models.List.broadcast = mock_broadcast
view = views.List.as_view()
request = self.factory.post('', {
'name': 'New Name',
'description': 'wow',
'privacy': 'direct',
'curation': 'curated',
'user': self.local_user.id,
})
request = self.factory.post(
"",
{
"name": "New Name",
"description": "wow",
"privacy": "direct",
"curation": "curated",
"user": self.local_user.id,
},
)
request.user = self.local_user
result = view(request, self.list.id)
self.assertEqual(result.status_code, 302)
self.list.refresh_from_db()
self.assertEqual(self.list.name, 'New Name')
self.assertEqual(self.list.description, 'wow')
self.assertEqual(self.list.privacy, 'direct')
self.assertEqual(self.list.curation, 'curated')
self.assertEqual(self.list.name, "New Name")
self.assertEqual(self.list.description, "wow")
self.assertEqual(self.list.privacy, "direct")
self.assertEqual(self.list.curation, "curated")
models.List.broadcast = real_broadcast
def test_curate_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Curate.as_view()
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
models.List.objects.create(name='Public list', user=self.local_user)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.List.objects.create(name="Public list", user=self.local_user)
models.List.objects.create(
name='Private list', privacy='direct', user=self.local_user)
request = self.factory.get('')
name="Private list", privacy="direct", user=self.local_user
)
request = self.factory.get("")
request.user = self.local_user
result = view(request, self.list.id)
@ -177,31 +192,35 @@ class ListViews(TestCase):
result = view(request, self.list.id)
self.assertEqual(result.status_code, 302)
def test_curate_approve(self):
''' approve a pending item '''
""" approve a pending item """
real_broadcast = models.List.broadcast
def mock_broadcast(_, activity, user, **kwargs):
''' ok '''
""" ok """
self.assertEqual(user.remote_id, self.local_user.remote_id)
self.assertEqual(activity['type'], 'Add')
self.assertEqual(activity['actor'], self.local_user.remote_id)
self.assertEqual(activity['target'], self.list.remote_id)
self.assertEqual(activity["type"], "Add")
self.assertEqual(activity["actor"], self.local_user.remote_id)
self.assertEqual(activity["target"], self.list.remote_id)
models.ListItem.broadcast = mock_broadcast
view = views.Curate.as_view()
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
pending = models.ListItem.objects.create(
book_list=self.list,
user=self.local_user,
book=self.book,
approved=False
approved=False,
)
request = self.factory.post('', {
'item': pending.id,
'approved': 'true',
})
request = self.factory.post(
"",
{
"item": pending.id,
"approved": "true",
},
)
request.user = self.local_user
view(request, self.list.id)
@ -211,43 +230,49 @@ class ListViews(TestCase):
self.assertTrue(pending.approved)
models.ListItem.broadcast = real_broadcast
def test_curate_reject(self):
''' approve a pending item '''
""" approve a pending item """
view = views.Curate.as_view()
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
pending = models.ListItem.objects.create(
book_list=self.list,
user=self.local_user,
book=self.book,
approved=False
approved=False,
)
request = self.factory.post('', {
'item': pending.id,
'approved': 'false',
})
request = self.factory.post(
"",
{
"item": pending.id,
"approved": "false",
},
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, self.list.id)
self.assertFalse(self.list.books.exists())
self.assertFalse(models.ListItem.objects.exists())
def test_add_book(self):
''' put a book on a list '''
""" put a book on a list """
real_broadcast = models.List.broadcast
def mock_broadcast(_, activity, user):
''' ok '''
""" ok """
self.assertEqual(user.remote_id, self.local_user.remote_id)
self.assertEqual(activity['type'], 'Add')
self.assertEqual(activity['actor'], self.local_user.remote_id)
self.assertEqual(activity['target'], self.list.remote_id)
self.assertEqual(activity["type"], "Add")
self.assertEqual(activity["actor"], self.local_user.remote_id)
self.assertEqual(activity["target"], self.list.remote_id)
models.ListItem.broadcast = mock_broadcast
request = self.factory.post('', {
'book': self.book.id,
})
request = self.factory.post(
"",
{
"book": self.book.id,
},
)
request.user = self.local_user
views.list.add_book(request, self.list.id)
@ -257,22 +282,26 @@ class ListViews(TestCase):
self.assertTrue(item.approved)
models.ListItem.broadcast = real_broadcast
def test_add_book_outsider(self):
''' put a book on a list '''
""" put a book on a list """
real_broadcast = models.List.broadcast
def mock_broadcast(_, activity, user):
''' ok '''
""" ok """
self.assertEqual(user.remote_id, self.rat.remote_id)
self.assertEqual(activity['type'], 'Add')
self.assertEqual(activity['actor'], self.rat.remote_id)
self.assertEqual(activity['target'], self.list.remote_id)
self.assertEqual(activity["type"], "Add")
self.assertEqual(activity["actor"], self.rat.remote_id)
self.assertEqual(activity["target"], self.list.remote_id)
models.ListItem.broadcast = mock_broadcast
self.list.curation = 'open'
self.list.curation = "open"
self.list.save(broadcast=False)
request = self.factory.post('', {
'book': self.book.id,
})
request = self.factory.post(
"",
{
"book": self.book.id,
},
)
request.user = self.rat
views.list.add_book(request, self.list.id)
@ -282,23 +311,27 @@ class ListViews(TestCase):
self.assertTrue(item.approved)
models.ListItem.broadcast = real_broadcast
def test_add_book_pending(self):
''' put a book on a list awaiting approval '''
""" put a book on a list awaiting approval """
real_broadcast = models.List.broadcast
def mock_broadcast(_, activity, user):
''' ok '''
""" ok """
self.assertEqual(user.remote_id, self.rat.remote_id)
self.assertEqual(activity['type'], 'Add')
self.assertEqual(activity['actor'], self.rat.remote_id)
self.assertEqual(activity['target'], self.list.remote_id)
self.assertEqual(activity['object']['id'], self.book.remote_id)
self.assertEqual(activity["type"], "Add")
self.assertEqual(activity["actor"], self.rat.remote_id)
self.assertEqual(activity["target"], self.list.remote_id)
self.assertEqual(activity["object"]["id"], self.book.remote_id)
models.ListItem.broadcast = mock_broadcast
self.list.curation = 'curated'
self.list.curation = "curated"
self.list.save(broadcast=False)
request = self.factory.post('', {
'book': self.book.id,
})
request = self.factory.post(
"",
{
"book": self.book.id,
},
)
request.user = self.rat
views.list.add_book(request, self.list.id)
@ -308,23 +341,27 @@ class ListViews(TestCase):
self.assertFalse(item.approved)
models.ListItem.broadcast = real_broadcast
def test_add_book_self_curated(self):
''' put a book on a list automatically approved '''
""" put a book on a list automatically approved """
real_broadcast = models.ListItem.broadcast
def mock_broadcast(_, activity, user):
''' ok '''
""" ok """
self.assertEqual(user.remote_id, self.local_user.remote_id)
self.assertEqual(activity['type'], 'Add')
self.assertEqual(activity['actor'], self.local_user.remote_id)
self.assertEqual(activity['target'], self.list.remote_id)
self.assertEqual(activity["type"], "Add")
self.assertEqual(activity["actor"], self.local_user.remote_id)
self.assertEqual(activity["target"], self.list.remote_id)
models.ListItem.broadcast = mock_broadcast
self.list.curation = 'curated'
self.list.curation = "curated"
self.list.save(broadcast=False)
request = self.factory.post('', {
'book': self.book.id,
})
request = self.factory.post(
"",
{
"book": self.book.id,
},
)
request.user = self.local_user
views.list.add_book(request, self.list.id)
@ -334,12 +371,11 @@ class ListViews(TestCase):
self.assertTrue(item.approved)
models.ListItem.broadcast = real_broadcast
def test_remove_book(self):
''' take an item off a list '''
""" take an item off a list """
real_broadcast = models.ListItem.broadcast
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
item = models.ListItem.objects.create(
book_list=self.list,
user=self.local_user,
@ -348,15 +384,19 @@ class ListViews(TestCase):
self.assertTrue(self.list.listitem_set.exists())
def mock_broadcast(_, activity, user):
''' ok '''
""" ok """
self.assertEqual(user.remote_id, self.local_user.remote_id)
self.assertEqual(activity['type'], 'Remove')
self.assertEqual(activity['actor'], self.local_user.remote_id)
self.assertEqual(activity['target'], self.list.remote_id)
self.assertEqual(activity["type"], "Remove")
self.assertEqual(activity["actor"], self.local_user.remote_id)
self.assertEqual(activity["target"], self.list.remote_id)
models.ListItem.broadcast = mock_broadcast
request = self.factory.post('', {
'item': item.id,
})
request = self.factory.post(
"",
{
"item": item.id,
},
)
request.user = self.local_user
views.list.remove_book(request, self.list.id)
@ -364,19 +404,21 @@ class ListViews(TestCase):
self.assertFalse(self.list.listitem_set.exists())
models.ListItem.broadcast = real_broadcast
def test_remove_book_unauthorized(self):
''' take an item off a list '''
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" take an item off a list """
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
item = models.ListItem.objects.create(
book_list=self.list,
user=self.local_user,
book=self.book,
)
self.assertTrue(self.list.listitem_set.exists())
request = self.factory.post('', {
'item': item.id,
})
request = self.factory.post(
"",
{
"item": item.id,
},
)
request.user = self.rat
views.list.remove_book(request, self.list.id)

29
bookwyrm/tests/views/test_notifications.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from django.template.response import TemplateResponse
from django.test import TestCase
from django.test.client import RequestFactory
@ -8,19 +8,24 @@ from bookwyrm import views
class NotificationViews(TestCase):
''' notifications '''
""" notifications """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.mouse', 'password',
local=True, localname='mouse')
"mouse@local.com",
"mouse@mouse.mouse",
"password",
local=True,
localname="mouse",
)
models.SiteSettings.objects.create()
def test_notifications_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Notifications.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request)
self.assertIsInstance(result, TemplateResponse)
@ -28,14 +33,16 @@ class NotificationViews(TestCase):
self.assertEqual(result.status_code, 200)
def test_clear_notifications(self):
''' erase notifications '''
""" erase notifications """
models.Notification.objects.create(
user=self.local_user, notification_type='FAVORITE')
user=self.local_user, notification_type="FAVORITE"
)
models.Notification.objects.create(
user=self.local_user, notification_type='MENTION', read=True)
user=self.local_user, notification_type="MENTION", read=True
)
self.assertEqual(models.Notification.objects.count(), 2)
view = views.Notifications.as_view()
request = self.factory.post('')
request = self.factory.post("")
request.user = self.local_user
result = view(request)
self.assertEqual(result.status_code, 302)

137
bookwyrm/tests/views/test_outbox.py
View File

@ -1,4 +1,4 @@
''' sending out activities '''
""" sending out activities """
from unittest.mock import patch
import json
@ -12,118 +12,127 @@ from bookwyrm.settings import USER_AGENT
# pylint: disable=too-many-public-methods
class OutboxView(TestCase):
''' sends out activities '''
""" sends out activities """
def setUp(self):
''' we'll need some data '''
""" we'll need some data """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
work = models.Work.objects.create(title='Test 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
title="Example Edition",
remote_id="https://example.com/book/1",
parent_work=work,
)
def test_outbox(self):
''' returns user's statuses '''
request = self.factory.get('')
result = views.Outbox.as_view()(request, 'mouse')
""" returns user's statuses """
request = self.factory.get("")
result = views.Outbox.as_view()(request, "mouse")
self.assertIsInstance(result, JsonResponse)
def test_outbox_bad_method(self):
''' can't POST to outbox '''
request = self.factory.post('')
result = views.Outbox.as_view()(request, 'mouse')
""" can't POST to outbox """
request = self.factory.post("")
result = views.Outbox.as_view()(request, "mouse")
self.assertEqual(result.status_code, 405)
def test_outbox_unknown_user(self):
''' should 404 for unknown and remote users '''
request = self.factory.post('')
result = views.Outbox.as_view()(request, 'beepboop')
""" should 404 for unknown and remote users """
request = self.factory.post("")
result = views.Outbox.as_view()(request, "beepboop")
self.assertEqual(result.status_code, 405)
result = views.Outbox.as_view()(request, 'rat')
result = views.Outbox.as_view()(request, "rat")
self.assertEqual(result.status_code, 405)
def test_outbox_privacy(self):
''' don't show dms et cetera in outbox '''
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" don't show dms et cetera in outbox """
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.Status.objects.create(
content='PRIVATE!!', user=self.local_user, privacy='direct')
content="PRIVATE!!", user=self.local_user, privacy="direct"
)
models.Status.objects.create(
content='bffs ONLY', user=self.local_user, privacy='followers')
content="bffs ONLY", user=self.local_user, privacy="followers"
)
models.Status.objects.create(
content='unlisted status', user=self.local_user,
privacy='unlisted')
content="unlisted status", user=self.local_user, privacy="unlisted"
)
models.Status.objects.create(
content='look at this', user=self.local_user, privacy='public')
content="look at this", user=self.local_user, privacy="public"
)
request = self.factory.get('')
result = views.Outbox.as_view()(request, 'mouse')
request = self.factory.get("")
result = views.Outbox.as_view()(request, "mouse")
self.assertIsInstance(result, JsonResponse)
data = json.loads(result.content)
self.assertEqual(data['type'], 'OrderedCollection')
self.assertEqual(data['totalItems'], 2)
self.assertEqual(data["type"], "OrderedCollection")
self.assertEqual(data["totalItems"], 2)
def test_outbox_filter(self):
''' if we only care about reviews, only get reviews '''
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" if we only care about reviews, only get reviews """
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.Review.objects.create(
content='look at this', name='hi', rating=1,
book=self.book, user=self.local_user)
models.Status.objects.create(
content='look at this', user=self.local_user)
content="look at this",
name="hi",
rating=1,
book=self.book,
user=self.local_user,
)
models.Status.objects.create(content="look at this", user=self.local_user)
request = self.factory.get('', {'type': 'bleh'})
result = views.Outbox.as_view()(request, 'mouse')
request = self.factory.get("", {"type": "bleh"})
result = views.Outbox.as_view()(request, "mouse")
self.assertIsInstance(result, JsonResponse)
data = json.loads(result.content)
self.assertEqual(data['type'], 'OrderedCollection')
self.assertEqual(data['totalItems'], 2)
self.assertEqual(data["type"], "OrderedCollection")
self.assertEqual(data["totalItems"], 2)
request = self.factory.get('', {'type': 'Review'})
result = views.Outbox.as_view()(request, 'mouse')
request = self.factory.get("", {"type": "Review"})
result = views.Outbox.as_view()(request, "mouse")
self.assertIsInstance(result, JsonResponse)
data = json.loads(result.content)
self.assertEqual(data['type'], 'OrderedCollection')
self.assertEqual(data['totalItems'], 1)
self.assertEqual(data["type"], "OrderedCollection")
self.assertEqual(data["totalItems"], 1)
def test_outbox_bookwyrm_request_true(self):
''' should differentiate between bookwyrm and outside requests '''
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" should differentiate between bookwyrm and outside requests """
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.Review.objects.create(
name='hi',
content='look at this',
name="hi",
content="look at this",
user=self.local_user,
book=self.book,
privacy='public',
privacy="public",
)
request = self.factory.get('', {'page': 1}, HTTP_USER_AGENT=USER_AGENT)
result = views.Outbox.as_view()(request, 'mouse')
request = self.factory.get("", {"page": 1}, HTTP_USER_AGENT=USER_AGENT)
result = views.Outbox.as_view()(request, "mouse")
data = json.loads(result.content)
self.assertEqual(len(data['orderedItems']), 1)
self.assertEqual(data['orderedItems'][0]['type'], 'Review')
self.assertEqual(len(data["orderedItems"]), 1)
self.assertEqual(data["orderedItems"][0]["type"], "Review")
def test_outbox_bookwyrm_request_false(self):
''' should differentiate between bookwyrm and outside requests '''
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" should differentiate between bookwyrm and outside requests """
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.Review.objects.create(
name='hi',
content='look at this',
name="hi",
content="look at this",
user=self.local_user,
book=self.book,
privacy='public',
privacy="public",
)
request = self.factory.get('', {'page': 1})
result = views.Outbox.as_view()(request, 'mouse')
request = self.factory.get("", {"page": 1})
result = views.Outbox.as_view()(request, "mouse")
data = json.loads(result.content)
self.assertEqual(len(data['orderedItems']), 1)
self.assertEqual(data['orderedItems'][0]['type'], 'Article')
self.assertEqual(len(data["orderedItems"]), 1)
self.assertEqual(data["orderedItems"][0]["type"], "Article")

84
bookwyrm/tests/views/test_password.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.contrib.auth.models import AnonymousUser
@ -10,22 +10,26 @@ from bookwyrm import models, views
class PasswordViews(TestCase):
''' view user and edit profile '''
""" view user and edit profile """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'password',
local=True, localname='mouse')
"mouse@local.com",
"mouse@mouse.com",
"password",
local=True,
localname="mouse",
)
self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False
models.SiteSettings.objects.create(id=1)
def test_password_reset_request(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.PasswordResetRequest.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request)
@ -33,76 +37,63 @@ class PasswordViews(TestCase):
result.render()
self.assertEqual(result.status_code, 200)
def test_password_reset_request_post(self):
''' send 'em an email '''
request = self.factory.post('', {'email': 'aa@bb.ccc'})
""" send 'em an email """
request = self.factory.post("", {"email": "aa@bb.ccc"})
view = views.PasswordResetRequest.as_view()
resp = view(request)
self.assertEqual(resp.status_code, 302)
request = self.factory.post('', {'email': 'mouse@mouse.com'})
with patch('bookwyrm.emailing.send_email.delay'):
request = self.factory.post("", {"email": "mouse@mouse.com"})
with patch("bookwyrm.emailing.send_email.delay"):
resp = view(request)
resp.render()
self.assertEqual(
models.PasswordReset.objects.get().user, self.local_user)
self.assertEqual(models.PasswordReset.objects.get().user, self.local_user)
def test_password_reset(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.PasswordReset.as_view()
code = models.PasswordReset.objects.create(user=self.local_user)
request = self.factory.get('')
request = self.factory.get("")
request.user = self.anonymous_user
result = view(request, code.code)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
def test_password_reset_post(self):
''' reset from code '''
""" reset from code """
view = views.PasswordReset.as_view()
code = models.PasswordReset.objects.create(user=self.local_user)
request = self.factory.post('', {
'password': 'hi',
'confirm-password': 'hi'
})
with patch('bookwyrm.views.password.login'):
request = self.factory.post("", {"password": "hi", "confirm-password": "hi"})
with patch("bookwyrm.views.password.login"):
resp = view(request, code.code)
self.assertEqual(resp.status_code, 302)
self.assertFalse(models.PasswordReset.objects.exists())
def test_password_reset_wrong_code(self):
''' reset from code '''
""" reset from code """
view = views.PasswordReset.as_view()
models.PasswordReset.objects.create(user=self.local_user)
request = self.factory.post('', {
'password': 'hi',
'confirm-password': 'hi'
})
resp = view(request, 'jhgdkfjgdf')
request = self.factory.post("", {"password": "hi", "confirm-password": "hi"})
resp = view(request, "jhgdkfjgdf")
resp.render()
self.assertTrue(models.PasswordReset.objects.exists())
def test_password_reset_mismatch(self):
''' reset from code '''
""" reset from code """
view = views.PasswordReset.as_view()
code = models.PasswordReset.objects.create(user=self.local_user)
request = self.factory.post('', {
'password': 'hi',
'confirm-password': 'hihi'
})
request = self.factory.post("", {"password": "hi", "confirm-password": "hihi"})
resp = view(request, code.code)
resp.render()
self.assertTrue(models.PasswordReset.objects.exists())
def test_password_change_get(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.ChangePassword.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request)
@ -110,28 +101,21 @@ class PasswordViews(TestCase):
result.render()
self.assertEqual(result.status_code, 200)
def test_password_change(self):
''' change password '''
""" change password """
view = views.ChangePassword.as_view()
password_hash = self.local_user.password
request = self.factory.post('', {
'password': 'hi',
'confirm-password': 'hi'
})
request = self.factory.post("", {"password": "hi", "confirm-password": "hi"})
request.user = self.local_user
with patch('bookwyrm.views.password.login'):
with patch("bookwyrm.views.password.login"):
view(request)
self.assertNotEqual(self.local_user.password, password_hash)
def test_password_change_mismatch(self):
''' change password '''
""" change password """
view = views.ChangePassword.as_view()
password_hash = self.local_user.password
request = self.factory.post('', {
'password': 'hi',
'confirm-password': 'hihi'
})
request = self.factory.post("", {"password": "hi", "confirm-password": "hihi"})
request.user = self.local_user
view(request)
self.assertEqual(self.local_user.password, password_hash)

162
bookwyrm/tests/views/test_reading.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
import dateutil
from django.test import TestCase
@ -7,45 +7,54 @@ from django.utils import timezone
from bookwyrm import models, views
class ReadingViews(TestCase):
''' viewing and creating statuses '''
""" viewing and creating statuses """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
self.work = models.Work.objects.create(title='Test Work')
self.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create(
title='Test Book',
remote_id='https://example.com/book/1',
parent_work=self.work
title="Test Book",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
with patch('bookwyrm.models.user.set_remote_server.delay'):
with patch("bookwyrm.models.user.set_remote_server.delay"):
self.remote_user = models.User.objects.create_user(
'rat', 'rat@rat.com', 'ratword',
"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',
remote_id="https://example.com/users/rat",
inbox="https://example.com/users/rat/inbox",
outbox="https://example.com/users/rat/outbox",
)
def test_start_reading(self):
''' begin a book '''
shelf = self.local_user.shelf_set.get(identifier='reading')
""" begin a book """
shelf = self.local_user.shelf_set.get(identifier="reading")
self.assertFalse(shelf.books.exists())
self.assertFalse(models.Status.objects.exists())
request = self.factory.post('', {
'post-status': True,
'privacy': 'followers',
'start_date': '2020-01-05',
})
request = self.factory.post(
"",
{
"post-status": True,
"privacy": "followers",
"start_date": "2020-01-05",
},
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.start_reading(request, self.book.id)
self.assertEqual(shelf.books.get(), self.book)
@ -53,7 +62,7 @@ class ReadingViews(TestCase):
status = models.GeneratedNote.objects.get()
self.assertEqual(status.user, self.local_user)
self.assertEqual(status.mention_books.get(), self.book)
self.assertEqual(status.privacy, 'followers')
self.assertEqual(status.privacy, "followers")
readthrough = models.ReadThrough.objects.get()
self.assertIsNotNone(readthrough.start_date)
@ -61,45 +70,47 @@ class ReadingViews(TestCase):
self.assertEqual(readthrough.user, self.local_user)
self.assertEqual(readthrough.book, self.book)
def test_start_reading_reshelf(self):
''' begin a book '''
to_read_shelf = self.local_user.shelf_set.get(identifier='to-read')
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" begin a book """
to_read_shelf = self.local_user.shelf_set.get(identifier="to-read")
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.ShelfBook.objects.create(
shelf=to_read_shelf, book=self.book, user=self.local_user)
shelf = self.local_user.shelf_set.get(identifier='reading')
shelf=to_read_shelf, book=self.book, user=self.local_user
)
shelf = self.local_user.shelf_set.get(identifier="reading")
self.assertEqual(to_read_shelf.books.get(), self.book)
self.assertFalse(shelf.books.exists())
self.assertFalse(models.Status.objects.exists())
request = self.factory.post('')
request = self.factory.post("")
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.start_reading(request, self.book.id)
self.assertFalse(to_read_shelf.books.exists())
self.assertEqual(shelf.books.get(), self.book)
def test_finish_reading(self):
''' begin a book '''
shelf = self.local_user.shelf_set.get(identifier='read')
""" begin a book """
shelf = self.local_user.shelf_set.get(identifier="read")
self.assertFalse(shelf.books.exists())
self.assertFalse(models.Status.objects.exists())
readthrough = models.ReadThrough.objects.create(
user=self.local_user,
start_date=timezone.now(),
book=self.book)
user=self.local_user, start_date=timezone.now(), book=self.book
)
request = self.factory.post('', {
'post-status': True,
'privacy': 'followers',
'finish_date': '2020-01-07',
'id': readthrough.id,
})
request = self.factory.post(
"",
{
"post-status": True,
"privacy": "followers",
"finish_date": "2020-01-07",
"id": readthrough.id,
},
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.finish_reading(request, self.book.id)
self.assertEqual(shelf.books.get(), self.book)
@ -107,7 +118,7 @@ class ReadingViews(TestCase):
status = models.GeneratedNote.objects.get()
self.assertEqual(status.user, self.local_user)
self.assertEqual(status.mention_books.get(), self.book)
self.assertEqual(status.privacy, 'followers')
self.assertEqual(status.privacy, "followers")
readthrough = models.ReadThrough.objects.get()
self.assertIsNotNone(readthrough.start_date)
@ -115,19 +126,21 @@ class ReadingViews(TestCase):
self.assertEqual(readthrough.user, self.local_user)
self.assertEqual(readthrough.book, self.book)
def test_edit_readthrough(self):
''' adding dates to an ongoing readthrough '''
start = timezone.make_aware(dateutil.parser.parse('2021-01-03'))
""" adding dates to an ongoing readthrough """
start = timezone.make_aware(dateutil.parser.parse("2021-01-03"))
readthrough = models.ReadThrough.objects.create(
book=self.book, user=self.local_user, start_date=start)
book=self.book, user=self.local_user, start_date=start
)
request = self.factory.post(
'', {
'start_date': '2017-01-01',
'finish_date': '2018-03-07',
'book': '',
'id': readthrough.id,
})
"",
{
"start_date": "2017-01-01",
"finish_date": "2018-03-07",
"book": "",
"id": readthrough.id,
},
)
request.user = self.local_user
views.edit_readthrough(request)
@ -140,33 +153,34 @@ class ReadingViews(TestCase):
self.assertEqual(readthrough.finish_date.day, 7)
self.assertEqual(readthrough.book, self.book)
def test_delete_readthrough(self):
''' remove a readthrough '''
""" remove a readthrough """
readthrough = models.ReadThrough.objects.create(
book=self.book, user=self.local_user)
models.ReadThrough.objects.create(
book=self.book, user=self.local_user)
book=self.book, user=self.local_user
)
models.ReadThrough.objects.create(book=self.book, user=self.local_user)
request = self.factory.post(
'', {
'id': readthrough.id,
})
"",
{
"id": readthrough.id,
},
)
request.user = self.local_user
views.delete_readthrough(request)
self.assertFalse(
models.ReadThrough.objects.filter(id=readthrough.id).exists())
self.assertFalse(models.ReadThrough.objects.filter(id=readthrough.id).exists())
def test_create_readthrough(self):
''' adding new read dates '''
""" adding new read dates """
request = self.factory.post(
'', {
'start_date': '2017-01-01',
'finish_date': '2018-03-07',
'book': self.book.id,
'id': '',
})
"",
{
"start_date": "2017-01-01",
"finish_date": "2018-03-07",
"book": self.book.id,
"id": "",
},
)
request.user = self.local_user
views.create_readthrough(request)

78
bookwyrm/tests/views/test_readthrough.py
View File

@ -1,4 +1,4 @@
''' tests updating reading progress '''
""" tests updating reading progress """
from datetime import datetime
from unittest.mock import patch
from django.test import TestCase, Client
@ -6,63 +6,68 @@ from django.utils import timezone
from bookwyrm import models
@patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay')
@patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
class ReadThrough(TestCase):
''' readthrough tests '''
""" readthrough tests """
def setUp(self):
''' basic user and book data '''
""" basic user and book data """
self.client = Client()
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
title="Example Edition", parent_work=self.work
)
self.work.default_edition = self.edition
self.work.save()
self.user = models.User.objects.create_user(
'cinco', 'cinco@example.com', 'seissiete',
local=True, localname='cinco')
"cinco", "cinco@example.com", "seissiete", local=True, localname="cinco"
)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.client.force_login(self.user)
def test_create_basic_readthrough(self, delay_mock):
"""A basic readthrough doesn't create a progress update"""
self.assertEqual(self.edition.readthrough_set.count(), 0)
self.client.post('/start-reading/{}'.format(self.edition.id), {
'start_date': '2020-11-27',
})
self.client.post(
"/start-reading/{}".format(self.edition.id),
{
"start_date": "2020-11-27",
},
)
readthroughs = self.edition.readthrough_set.all()
self.assertEqual(len(readthroughs), 1)
self.assertEqual(readthroughs[0].progressupdate_set.count(), 0)
self.assertEqual(
readthroughs[0].start_date,
datetime(2020, 11, 27, tzinfo=timezone.utc))
readthroughs[0].start_date, datetime(2020, 11, 27, tzinfo=timezone.utc)
)
self.assertEqual(readthroughs[0].progress, None)
self.assertEqual(readthroughs[0].finish_date, None)
self.assertEqual(delay_mock.call_count, 1)
def test_create_progress_readthrough(self, delay_mock):
''' a readthrough with progress '''
""" a readthrough with progress """
self.assertEqual(self.edition.readthrough_set.count(), 0)
self.client.post('/start-reading/{}'.format(self.edition.id), {
'start_date': '2020-11-27',
'progress': 50,
})
self.client.post(
"/start-reading/{}".format(self.edition.id),
{
"start_date": "2020-11-27",
"progress": 50,
},
)
readthroughs = self.edition.readthrough_set.all()
self.assertEqual(len(readthroughs), 1)
self.assertEqual(
readthroughs[0].start_date,
datetime(2020, 11, 27, tzinfo=timezone.utc))
readthroughs[0].start_date, datetime(2020, 11, 27, tzinfo=timezone.utc)
)
self.assertEqual(readthroughs[0].progress, 50)
self.assertEqual(readthroughs[0].finish_date, None)
@ -73,13 +78,17 @@ class ReadThrough(TestCase):
self.assertEqual(delay_mock.call_count, 1)
# Update progress
self.client.post('/edit-readthrough', {
'id': readthroughs[0].id,
'progress': 100,
})
self.client.post(
"/edit-readthrough",
{
"id": readthroughs[0].id,
"progress": 100,
},
)
progress_updates = readthroughs[0].progressupdate_set\
.order_by('updated_date').all()
progress_updates = (
readthroughs[0].progressupdate_set.order_by("updated_date").all()
)
self.assertEqual(len(progress_updates), 2)
self.assertEqual(progress_updates[1].mode, models.ProgressMode.PAGE)
self.assertEqual(progress_updates[1].progress, 100)
@ -87,9 +96,12 @@ class ReadThrough(TestCase):
# Edit doesn't publish anything
self.assertEqual(delay_mock.call_count, 1)
self.client.post('/delete-readthrough', {
'id': readthroughs[0].id,
})
self.client.post(
"/delete-readthrough",
{
"id": readthroughs[0].id,
},
)
readthroughs = self.edition.readthrough_set.all()
updates = self.user.progressupdate_set.all()

48
bookwyrm/tests/views/test_rss_feed.py
View File

@ -1,4 +1,4 @@
''' testing import '''
""" testing import """
from unittest.mock import patch
from django.test import RequestFactory, TestCase
@ -6,41 +6,51 @@ from django.test import RequestFactory, TestCase
from bookwyrm import models
from bookwyrm.views import rss_feed
class RssFeedView(TestCase):
''' rss feed behaves as expected '''
""" rss feed behaves as expected """
def setUp(self):
''' test data '''
""" test data """
self.site = models.SiteSettings.objects.create()
self.user = models.User.objects.create_user(
'rss_user', 'rss@test.rss', 'password', local=True)
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
"rss_user", "rss@test.rss", "password", local=True
)
with patch('bookwyrm.models.activitypub_mixin.broadcast_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,
)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.review = models.Review.objects.create(
name='Review name', content='test content', rating=3,
user=self.user, book=self.book)
name="Review name",
content="test content",
rating=3,
user=self.user,
book=self.book,
)
self.quote = models.Quotation.objects.create(
quote='a sickening sense', content='test content',
user=self.user, book=self.book)
quote="a sickening sense",
content="test content",
user=self.user,
book=self.book,
)
self.generatednote = models.GeneratedNote.objects.create(
content='test content', user=self.user)
content="test content", user=self.user
)
self.factory = RequestFactory()
def test_rss_feed(self):
''' load an rss feed '''
""" load an rss feed """
view = rss_feed.RssFeed()
request = self.factory.get('/user/rss_user/rss')
request = self.factory.get("/user/rss_user/rss")
request.user = self.user
with patch("bookwyrm.models.SiteSettings.objects.get") as site:
site.return_value = self.site

98
bookwyrm/tests/views/test_search.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
import json
from unittest.mock import patch
@ -13,103 +13,107 @@ from bookwyrm.settings import DOMAIN
class ShelfViews(TestCase):
''' tag views'''
""" tag views"""
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
self.work = models.Work.objects.create(title='Test Work')
self.work = models.Work.objects.create(title="Test Work")
self.book = models.Edition.objects.create(
title='Test Book',
remote_id='https://example.com/book/1',
parent_work=self.work
title="Test Book",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
models.Connector.objects.create(
identifier='self',
connector_file='self_connector',
local=True
identifier="self", connector_file="self_connector", local=True
)
models.SiteSettings.objects.create()
def test_search_json_response(self):
''' searches local data only and returns book data in json format '''
""" searches local data only and returns book data in json format """
view = views.Search.as_view()
# we need a connector for this, sorry
request = self.factory.get('', {'q': 'Test Book'})
with patch('bookwyrm.views.search.is_api_request') as is_api:
request = self.factory.get("", {"q": "Test Book"})
with patch("bookwyrm.views.search.is_api_request") as is_api:
is_api.return_value = True
response = view(request)
self.assertIsInstance(response, JsonResponse)
data = json.loads(response.content)
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['title'], 'Test Book')
self.assertEqual(
data[0]['key'], 'https://%s/book/%d' % (DOMAIN, self.book.id))
self.assertEqual(data[0]["title"], "Test Book")
self.assertEqual(data[0]["key"], "https://%s/book/%d" % (DOMAIN, self.book.id))
def test_search_html_response(self):
''' searches remote connectors '''
""" searches remote connectors """
view = views.Search.as_view()
class TestConnector(abstract_connector.AbstractMinimalConnector):
''' nothing added here '''
""" nothing added here """
def format_search_result(self, search_result):
pass
def get_or_create_book(self, remote_id):
pass
def parse_search_data(self, data):
pass
def format_isbn_search_result(self, search_result):
return search_result
def parse_isbn_search_data(self, data):
return data
models.Connector.objects.create(
identifier='example.com',
connector_file='openlibrary',
base_url='https://example.com',
books_url='https://example.com/books',
covers_url='https://example.com/covers',
search_url='https://example.com/search?q=',
identifier="example.com",
connector_file="openlibrary",
base_url="https://example.com",
books_url="https://example.com/books",
covers_url="https://example.com/covers",
search_url="https://example.com/search?q=",
)
connector = TestConnector('example.com')
connector = TestConnector("example.com")
search_result = abstract_connector.SearchResult(
key='http://www.example.com/book/1',
title='Gideon the Ninth',
author='Tamsyn Muir',
year='2019',
connector=connector
key="http://www.example.com/book/1",
title="Gideon the Ninth",
author="Tamsyn Muir",
year="2019",
connector=connector,
)
request = self.factory.get('', {'q': 'Test Book'})
request = self.factory.get("", {"q": "Test Book"})
request.user = self.local_user
with patch('bookwyrm.views.search.is_api_request') as is_api:
with patch("bookwyrm.views.search.is_api_request") as is_api:
is_api.return_value = False
with patch(
'bookwyrm.connectors.connector_manager.search') as manager:
with patch("bookwyrm.connectors.connector_manager.search") as manager:
manager.return_value = [search_result]
response = view(request)
self.assertIsInstance(response, TemplateResponse)
response.render()
self.assertEqual(
response.context_data['book_results'][0].title, 'Gideon the Ninth')
response.context_data["book_results"][0].title, "Gideon the Ninth"
)
def test_search_html_response_users(self):
''' searches remote connectors '''
""" searches remote connectors """
view = views.Search.as_view()
request = self.factory.get('', {'q': 'mouse'})
request = self.factory.get("", {"q": "mouse"})
request.user = self.local_user
with patch('bookwyrm.views.search.is_api_request') as is_api:
with patch("bookwyrm.views.search.is_api_request") as is_api:
is_api.return_value = False
with patch('bookwyrm.connectors.connector_manager.search'):
with patch("bookwyrm.connectors.connector_manager.search"):
response = view(request)
self.assertIsInstance(response, TemplateResponse)
response.render()
self.assertEqual(
response.context_data['user_results'][0], self.local_user)
self.assertEqual(response.context_data["user_results"][0], self.local_user)

181
bookwyrm/tests/views/test_shelf.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.template.response import TemplateResponse
from django.test import TestCase
@ -8,195 +8,172 @@ from bookwyrm import models, views
from bookwyrm.activitypub import ActivitypubResponse
@patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay')
@patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay")
class ShelfViews(TestCase):
''' tag views'''
""" tag views"""
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
self.work = models.Work.objects.create(title='Test Work')
self.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=self.work
title="Example Edition",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
self.shelf = models.Shelf.objects.create(
name='Test Shelf',
identifier='test-shelf',
user=self.local_user
name="Test Shelf", identifier="test-shelf", user=self.local_user
)
models.SiteSettings.objects.create()
def test_shelf_page(self, _):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Shelf.as_view()
shelf = self.local_user.shelf_set.first()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
with patch('bookwyrm.views.shelf.is_api_request') as is_api:
with patch("bookwyrm.views.shelf.is_api_request") as is_api:
is_api.return_value = False
result = view(request, self.local_user.username, shelf.identifier)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
with patch('bookwyrm.views.shelf.is_api_request') as is_api:
with patch("bookwyrm.views.shelf.is_api_request") as is_api:
is_api.return_value = True
result = view(
request, self.local_user.username, shelf.identifier)
result = view(request, self.local_user.username, shelf.identifier)
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
request = self.factory.get('/?page=1')
request = self.factory.get("/?page=1")
request.user = self.local_user
with patch('bookwyrm.views.shelf.is_api_request') as is_api:
with patch("bookwyrm.views.shelf.is_api_request") as is_api:
is_api.return_value = True
result = view(
request, self.local_user.username, shelf.identifier)
result = view(request, self.local_user.username, shelf.identifier)
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_edit_shelf_privacy(self, _):
''' set name or privacy on shelf '''
""" set name or privacy on shelf """
view = views.Shelf.as_view()
shelf = self.local_user.shelf_set.get(identifier='to-read')
self.assertEqual(shelf.privacy, 'public')
shelf = self.local_user.shelf_set.get(identifier="to-read")
self.assertEqual(shelf.privacy, "public")
request = self.factory.post(
'', {
'privacy': 'unlisted',
'user': self.local_user.id,
'name': 'To Read',
})
"",
{
"privacy": "unlisted",
"user": self.local_user.id,
"name": "To Read",
},
)
request.user = self.local_user
view(request, self.local_user.username, shelf.identifier)
shelf.refresh_from_db()
self.assertEqual(shelf.privacy, 'unlisted')
self.assertEqual(shelf.privacy, "unlisted")
def test_edit_shelf_name(self, _):
''' change the name of an editable shelf '''
""" change the name of an editable shelf """
view = views.Shelf.as_view()
shelf = models.Shelf.objects.create(
name='Test Shelf', user=self.local_user)
self.assertEqual(shelf.privacy, 'public')
shelf = models.Shelf.objects.create(name="Test Shelf", user=self.local_user)
self.assertEqual(shelf.privacy, "public")
request = self.factory.post(
'', {
'privacy': 'public',
'user': self.local_user.id,
'name': 'cool name'
})
"", {"privacy": "public", "user": self.local_user.id, "name": "cool name"}
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, request.user.username, shelf.identifier)
shelf.refresh_from_db()
self.assertEqual(shelf.name, 'cool name')
self.assertEqual(shelf.identifier, 'testshelf-%d' % shelf.id)
self.assertEqual(shelf.name, "cool name")
self.assertEqual(shelf.identifier, "testshelf-%d" % shelf.id)
def test_edit_shelf_name_not_editable(self, _):
''' can't change the name of an non-editable shelf '''
""" can't change the name of an non-editable shelf """
view = views.Shelf.as_view()
shelf = self.local_user.shelf_set.get(identifier='to-read')
self.assertEqual(shelf.privacy, 'public')
shelf = self.local_user.shelf_set.get(identifier="to-read")
self.assertEqual(shelf.privacy, "public")
request = self.factory.post(
'', {
'privacy': 'public',
'user': self.local_user.id,
'name': 'cool name'
})
"", {"privacy": "public", "user": self.local_user.id, "name": "cool name"}
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, request.user.username, shelf.identifier)
self.assertEqual(shelf.name, 'To Read')
self.assertEqual(shelf.name, "To Read")
def test_handle_shelve(self, _):
''' shelve a book '''
request = self.factory.post('', {
'book': self.book.id,
'shelf': self.shelf.identifier
})
""" shelve a book """
request = self.factory.post(
"", {"book": self.book.id, "shelf": self.shelf.identifier}
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.shelve(request)
# make sure the book is on the shelf
self.assertEqual(self.shelf.books.get(), self.book)
def test_handle_shelve_to_read(self, _):
''' special behavior for the to-read shelf '''
shelf = models.Shelf.objects.get(identifier='to-read')
request = self.factory.post('', {
'book': self.book.id,
'shelf': shelf.identifier
})
""" special behavior for the to-read shelf """
shelf = models.Shelf.objects.get(identifier="to-read")
request = self.factory.post(
"", {"book": self.book.id, "shelf": shelf.identifier}
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.shelve(request)
# make sure the book is on the shelf
self.assertEqual(shelf.books.get(), self.book)
def test_handle_shelve_reading(self, _):
''' special behavior for the reading shelf '''
shelf = models.Shelf.objects.get(identifier='reading')
request = self.factory.post('', {
'book': self.book.id,
'shelf': shelf.identifier
})
""" special behavior for the reading shelf """
shelf = models.Shelf.objects.get(identifier="reading")
request = self.factory.post(
"", {"book": self.book.id, "shelf": shelf.identifier}
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.shelve(request)
# make sure the book is on the shelf
self.assertEqual(shelf.books.get(), self.book)
def test_handle_shelve_read(self, _):
''' special behavior for the read shelf '''
shelf = models.Shelf.objects.get(identifier='read')
request = self.factory.post('', {
'book': self.book.id,
'shelf': shelf.identifier
})
""" special behavior for the read shelf """
shelf = models.Shelf.objects.get(identifier="read")
request = self.factory.post(
"", {"book": self.book.id, "shelf": shelf.identifier}
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.shelve(request)
# make sure the book is on the shelf
self.assertEqual(shelf.books.get(), self.book)
def test_handle_unshelve(self, _):
''' remove a book from a shelf '''
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
""" remove a book from a shelf """
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
models.ShelfBook.objects.create(
book=self.book,
user=self.local_user,
shelf=self.shelf
book=self.book, user=self.local_user, shelf=self.shelf
)
self.shelf.save()
self.assertEqual(self.shelf.books.count(), 1)
request = self.factory.post('', {
'book': self.book.id,
'shelf': self.shelf.id
})
request = self.factory.post("", {"book": self.book.id, "shelf": self.shelf.id})
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
views.unshelve(request)
self.assertEqual(self.shelf.books.count(), 0)

294
bookwyrm/tests/views/test_status.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
import json
from unittest.mock import patch
from django.test import TestCase
@ -9,239 +9,247 @@ from bookwyrm.settings import DOMAIN
class StatusViews(TestCase):
''' viewing and creating statuses '''
""" viewing and creating statuses """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
with patch('bookwyrm.models.user.set_remote_server'):
with patch("bookwyrm.models.user.set_remote_server"):
self.remote_user = models.User.objects.create_user(
'rat', 'rat@email.com', 'ratword',
"rat",
"rat@email.com",
"ratword",
local=False,
remote_id='https://example.com/users/rat',
inbox='https://example.com/users/rat/inbox',
outbox='https://example.com/users/rat/outbox',
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')
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
title="Example Edition",
remote_id="https://example.com/book/1",
parent_work=work,
)
def test_handle_status(self):
''' create a status '''
""" create a status """
view = views.CreateStatus.as_view()
form = forms.CommentForm({
'content': 'hi',
'user': self.local_user.id,
'book': self.book.id,
'privacy': 'public',
})
request = self.factory.post('', form.data)
form = forms.CommentForm(
{
"content": "hi",
"user": self.local_user.id,
"book": self.book.id,
"privacy": "public",
}
)
request = self.factory.post("", form.data)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
view(request, 'comment')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, "comment")
status = models.Comment.objects.get()
self.assertEqual(status.content, '<p>hi</p>')
self.assertEqual(status.content, "<p>hi</p>")
self.assertEqual(status.user, self.local_user)
self.assertEqual(status.book, self.book)
def test_handle_status_reply(self):
''' create a status in reply to an existing status '''
""" create a status in reply to an existing status """
view = views.CreateStatus.as_view()
user = models.User.objects.create_user(
'rat', 'rat@rat.com', 'password', local=True)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
"rat", "rat@rat.com", "password", local=True
)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
parent = models.Status.objects.create(
content='parent status', user=self.local_user)
form = forms.ReplyForm({
'content': 'hi',
'user': user.id,
'reply_parent': parent.id,
'privacy': 'public',
})
request = self.factory.post('', form.data)
content="parent status", user=self.local_user
)
form = forms.ReplyForm(
{
"content": "hi",
"user": user.id,
"reply_parent": parent.id,
"privacy": "public",
}
)
request = self.factory.post("", form.data)
request.user = user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
view(request, 'reply')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, "reply")
status = models.Status.objects.get(user=user)
self.assertEqual(status.content, '<p>hi</p>')
self.assertEqual(status.content, "<p>hi</p>")
self.assertEqual(status.user, user)
self.assertEqual(
models.Notification.objects.get().user, self.local_user)
self.assertEqual(models.Notification.objects.get().user, self.local_user)
def test_handle_status_mentions(self):
''' @mention a user in a post '''
""" @mention a user in a post """
view = views.CreateStatus.as_view()
user = models.User.objects.create_user(
'rat@%s' % DOMAIN, 'rat@rat.com', 'password',
local=True, localname='rat')
form = forms.CommentForm({
'content': 'hi @rat',
'user': self.local_user.id,
'book': self.book.id,
'privacy': 'public',
})
request = self.factory.post('', form.data)
"rat@%s" % DOMAIN, "rat@rat.com", "password", local=True, localname="rat"
)
form = forms.CommentForm(
{
"content": "hi @rat",
"user": self.local_user.id,
"book": self.book.id,
"privacy": "public",
}
)
request = self.factory.post("", form.data)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
view(request, 'comment')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, "comment")
status = models.Status.objects.get()
self.assertEqual(list(status.mention_users.all()), [user])
self.assertEqual(models.Notification.objects.get().user, user)
self.assertEqual(
status.content,
'<p>hi <a href="%s">@rat</a></p>' % user.remote_id)
status.content, '<p>hi <a href="%s">@rat</a></p>' % user.remote_id
)
def test_handle_status_reply_with_mentions(self):
''' reply to a post with an @mention'ed user '''
""" reply to a post with an @mention'ed user """
view = views.CreateStatus.as_view()
user = models.User.objects.create_user(
'rat', 'rat@rat.com', 'password',
local=True, localname='rat')
form = forms.CommentForm({
'content': 'hi @rat@example.com',
'user': self.local_user.id,
'book': self.book.id,
'privacy': 'public',
})
request = self.factory.post('', form.data)
"rat", "rat@rat.com", "password", local=True, localname="rat"
)
form = forms.CommentForm(
{
"content": "hi @rat@example.com",
"user": self.local_user.id,
"book": self.book.id,
"privacy": "public",
}
)
request = self.factory.post("", form.data)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
view(request, 'comment')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, "comment")
status = models.Status.objects.get()
form = forms.ReplyForm({
'content': 'right',
'user': user.id,
'privacy': 'public',
'reply_parent': status.id
})
request = self.factory.post('', form.data)
form = forms.ReplyForm(
{
"content": "right",
"user": user.id,
"privacy": "public",
"reply_parent": status.id,
}
)
request = self.factory.post("", form.data)
request.user = user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
view(request, 'reply')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request, "reply")
reply = models.Status.replies(status).first()
self.assertEqual(reply.content, '<p>right</p>')
self.assertEqual(reply.content, "<p>right</p>")
self.assertEqual(reply.user, user)
# the mentioned user in the parent post is only included if @'ed
self.assertFalse(self.remote_user in reply.mention_users.all())
self.assertTrue(self.local_user in reply.mention_users.all())
def test_find_mentions(self):
''' detect and look up @ mentions of users '''
""" detect and look up @ mentions of users """
user = models.User.objects.create_user(
'nutria@%s' % DOMAIN, 'nutria@nutria.com', 'password',
local=True, localname='nutria')
self.assertEqual(user.username, 'nutria@%s' % DOMAIN)
"nutria@%s" % DOMAIN,
"nutria@nutria.com",
"password",
local=True,
localname="nutria",
)
self.assertEqual(user.username, "nutria@%s" % DOMAIN)
self.assertEqual(
list(views.status.find_mentions('@nutria'))[0],
('@nutria', user)
list(views.status.find_mentions("@nutria"))[0], ("@nutria", user)
)
self.assertEqual(
list(views.status.find_mentions('leading text @nutria'))[0],
('@nutria', user)
list(views.status.find_mentions("leading text @nutria"))[0],
("@nutria", user),
)
self.assertEqual(
list(views.status.find_mentions(
'leading @nutria trailing text'))[0],
('@nutria', user)
list(views.status.find_mentions("leading @nutria trailing text"))[0],
("@nutria", user),
)
self.assertEqual(
list(views.status.find_mentions(
'@rat@example.com'))[0],
('@rat@example.com', self.remote_user)
list(views.status.find_mentions("@rat@example.com"))[0],
("@rat@example.com", self.remote_user),
)
multiple = list(views.status.find_mentions(
'@nutria and @rat@example.com'))
self.assertEqual(multiple[0], ('@nutria', user))
self.assertEqual(multiple[1], ('@rat@example.com', self.remote_user))
multiple = list(views.status.find_mentions("@nutria and @rat@example.com"))
self.assertEqual(multiple[0], ("@nutria", user))
self.assertEqual(multiple[1], ("@rat@example.com", self.remote_user))
with patch('bookwyrm.views.status.handle_remote_webfinger') as rw:
with patch("bookwyrm.views.status.handle_remote_webfinger") as rw:
rw.return_value = self.local_user
self.assertEqual(
list(views.status.find_mentions('@beep@beep.com'))[0],
('@beep@beep.com', self.local_user)
list(views.status.find_mentions("@beep@beep.com"))[0],
("@beep@beep.com", self.local_user),
)
with patch('bookwyrm.views.status.handle_remote_webfinger') as rw:
with patch("bookwyrm.views.status.handle_remote_webfinger") as rw:
rw.return_value = None
self.assertEqual(list(views.status.find_mentions(
'@beep@beep.com')), [])
self.assertEqual(list(views.status.find_mentions("@beep@beep.com")), [])
self.assertEqual(
list(views.status.find_mentions('@nutria@%s' % DOMAIN))[0],
('@nutria@%s' % DOMAIN, user)
list(views.status.find_mentions("@nutria@%s" % DOMAIN))[0],
("@nutria@%s" % DOMAIN, user),
)
def test_format_links(self):
''' find and format urls into a tags '''
url = 'http://www.fish.com/'
""" find and format urls into a tags """
url = "http://www.fish.com/"
self.assertEqual(
views.status.format_links(url), '<a href="%s">www.fish.com/</a>' % url
)
self.assertEqual(
views.status.format_links("(%s)" % url),
'(<a href="%s">www.fish.com/</a>)' % url,
)
url = "https://archive.org/details/dli.granth.72113/page/n25/mode/2up"
self.assertEqual(
views.status.format_links(url),
'<a href="%s">www.fish.com/</a>' % url)
self.assertEqual(
views.status.format_links('(%s)' % url),
'(<a href="%s">www.fish.com/</a>)' % url)
url = 'https://archive.org/details/dli.granth.72113/page/n25/mode/2up'
'<a href="%s">'
"archive.org/details/dli.granth.72113/page/n25/mode/2up</a>" % url,
)
url = "https://openlibrary.org/search" "?q=arkady+strugatsky&mode=everything"
self.assertEqual(
views.status.format_links(url),
'<a href="%s">' \
'archive.org/details/dli.granth.72113/page/n25/mode/2up</a>' \
% url)
url = 'https://openlibrary.org/search' \
'?q=arkady+strugatsky&mode=everything'
self.assertEqual(
views.status.format_links(url),
'<a href="%s">openlibrary.org/search' \
'?q=arkady+strugatsky&mode=everything</a>' % url)
'<a href="%s">openlibrary.org/search'
"?q=arkady+strugatsky&mode=everything</a>" % url,
)
def test_to_markdown(self):
''' this is mostly handled in other places, but nonetheless '''
text = '_hi_ and http://fish.com is <marquee>rad</marquee>'
""" this is mostly handled in other places, but nonetheless """
text = "_hi_ and http://fish.com is <marquee>rad</marquee>"
result = views.status.to_markdown(text)
self.assertEqual(
result,
'<p><em>hi</em> and <a href="http://fish.com">fish.com</a> ' \
'is rad</p>')
'<p><em>hi</em> and <a href="http://fish.com">fish.com</a> ' "is rad</p>",
)
def test_to_markdown_link(self):
''' this is mostly handled in other places, but nonetheless '''
text = '[hi](http://fish.com) is <marquee>rad</marquee>'
""" this is mostly handled in other places, but nonetheless """
text = "[hi](http://fish.com) is <marquee>rad</marquee>"
result = views.status.to_markdown(text)
self.assertEqual(
result,
'<p><a href="http://fish.com">hi</a> ' \
'is rad</p>')
self.assertEqual(result, '<p><a href="http://fish.com">hi</a> ' "is rad</p>")
def test_handle_delete_status(self):
''' marks a status as deleted '''
""" marks a status as deleted """
view = views.DeleteStatus.as_view()
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
status = models.Status.objects.create(
user=self.local_user, content='hi')
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
status = models.Status.objects.create(user=self.local_user, content="hi")
self.assertFalse(status.deleted)
request = self.factory.post('')
request = self.factory.post("")
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay') \
as mock:
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay") as mock:
view(request, status.id)
activity = json.loads(mock.call_args_list[0][0][1])
self.assertEqual(activity['type'], 'Delete')
self.assertEqual(activity['object']['type'], 'Tombstone')
self.assertEqual(activity["type"], "Delete")
self.assertEqual(activity["object"]["type"], "Tombstone")
status.refresh_from_db()
self.assertTrue(status.deleted)

110
bookwyrm/tests/views/test_tag.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
from unittest.mock import patch
from django.contrib.auth.models import Group, Permission
from django.contrib.contenttypes.models import ContentType
@ -11,107 +11,109 @@ from bookwyrm.activitypub import ActivitypubResponse
class TagViews(TestCase):
''' tag views'''
""" tag views"""
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.com', 'mouseword',
local=True, localname='mouse',
remote_id='https://example.com/users/mouse',
"mouse@local.com",
"mouse@mouse.com",
"mouseword",
local=True,
localname="mouse",
remote_id="https://example.com/users/mouse",
)
self.group = Group.objects.create(name='editor')
self.group = Group.objects.create(name="editor")
self.group.permissions.add(
Permission.objects.create(
name='edit_book',
codename='edit_book',
content_type=ContentType.objects.get_for_model(models.User)).id
name="edit_book",
codename="edit_book",
content_type=ContentType.objects.get_for_model(models.User),
).id
)
self.work = models.Work.objects.create(title='Test Work')
self.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=self.work
title="Example Edition",
remote_id="https://example.com/book/1",
parent_work=self.work,
)
models.SiteSettings.objects.create()
def test_tag_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Tag.as_view()
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
tag = models.Tag.objects.create(name='hi there')
models.UserTag.objects.create(
tag=tag, user=self.local_user, book=self.book)
request = self.factory.get('')
with patch('bookwyrm.views.tag.is_api_request') as is_api:
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
tag = models.Tag.objects.create(name="hi there")
models.UserTag.objects.create(tag=tag, user=self.local_user, book=self.book)
request = self.factory.get("")
with patch("bookwyrm.views.tag.is_api_request") as is_api:
is_api.return_value = False
result = view(request, tag.identifier)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
request = self.factory.get('')
with patch('bookwyrm.views.tag.is_api_request') as is_api:
request = self.factory.get("")
with patch("bookwyrm.views.tag.is_api_request") as is_api:
is_api.return_value = True
result = view(request, tag.identifier)
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_tag_page_activitypub_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Tag.as_view()
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
tag = models.Tag.objects.create(name='hi there')
models.UserTag.objects.create(
tag=tag, user=self.local_user, book=self.book)
request = self.factory.get('', {'page': 1})
with patch('bookwyrm.views.tag.is_api_request') as is_api:
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
tag = models.Tag.objects.create(name="hi there")
models.UserTag.objects.create(tag=tag, user=self.local_user, book=self.book)
request = self.factory.get("", {"page": 1})
with patch("bookwyrm.views.tag.is_api_request") as is_api:
is_api.return_value = True
result = view(request, tag.identifier)
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_tag(self):
''' add a tag to a book '''
""" add a tag to a book """
view = views.AddTag.as_view()
request = self.factory.post(
'', {
'name': 'A Tag!?',
'book': self.book.id,
})
"",
{
"name": "A Tag!?",
"book": self.book.id,
},
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request)
tag = models.Tag.objects.get()
user_tag = models.UserTag.objects.get()
self.assertEqual(tag.name, 'A Tag!?')
self.assertEqual(tag.identifier, 'A+Tag%21%3F')
self.assertEqual(tag.name, "A Tag!?")
self.assertEqual(tag.identifier, "A+Tag%21%3F")
self.assertEqual(user_tag.user, self.local_user)
self.assertEqual(user_tag.book, self.book)
def test_untag(self):
''' remove a tag from a book '''
""" remove a tag from a book """
view = views.RemoveTag.as_view()
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
tag = models.Tag.objects.create(name='A Tag!?')
models.UserTag.objects.create(
user=self.local_user, book=self.book, tag=tag)
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
tag = models.Tag.objects.create(name="A Tag!?")
models.UserTag.objects.create(user=self.local_user, book=self.book, tag=tag)
request = self.factory.post(
'', {
'user': self.local_user.id,
'book': self.book.id,
'name': tag.name,
})
"",
{
"user": self.local_user.id,
"book": self.book.id,
"name": tag.name,
},
)
request.user = self.local_user
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay'):
with patch("bookwyrm.models.activitypub_mixin.broadcast_task.delay"):
view(request)
self.assertTrue(models.Tag.objects.filter(name='A Tag!?').exists())
self.assertTrue(models.Tag.objects.filter(name="A Tag!?").exists())
self.assertFalse(models.UserTag.objects.exists())

163
bookwyrm/tests/views/test_user.py
View File

@ -1,4 +1,4 @@
''' test for app action functionality '''
""" test for app action functionality """
import pathlib
from unittest.mock import patch
from PIL import Image
@ -15,180 +15,177 @@ from bookwyrm.activitypub import ActivitypubResponse
class UserViews(TestCase):
''' view user and edit profile '''
""" view user and edit profile """
def setUp(self):
''' we need basic test data and mocks '''
""" we need basic test data and mocks """
self.factory = RequestFactory()
self.local_user = models.User.objects.create_user(
'mouse@local.com', 'mouse@mouse.mouse', 'password',
local=True, localname='mouse')
"mouse@local.com",
"mouse@mouse.mouse",
"password",
local=True,
localname="mouse",
)
self.rat = models.User.objects.create_user(
'rat@local.com', 'rat@rat.rat', 'password',
local=True, localname='rat')
"rat@local.com", "rat@rat.rat", "password", local=True, localname="rat"
)
models.SiteSettings.objects.create()
self.anonymous_user = AnonymousUser
self.anonymous_user.is_authenticated = False
def test_user_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.User.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
with patch('bookwyrm.views.user.is_api_request') as is_api:
with patch("bookwyrm.views.user.is_api_request") as is_api:
is_api.return_value = False
result = view(request, 'mouse')
result = view(request, "mouse")
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
request.user = self.anonymous_user
with patch('bookwyrm.views.user.is_api_request') as is_api:
with patch("bookwyrm.views.user.is_api_request") as is_api:
is_api.return_value = False
result = view(request, 'mouse')
result = view(request, "mouse")
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
with patch('bookwyrm.views.user.is_api_request') as is_api:
with patch("bookwyrm.views.user.is_api_request") as is_api:
is_api.return_value = True
result = view(request, 'mouse')
result = view(request, "mouse")
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_user_page_blocked(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.User.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
self.rat.blocks.add(self.local_user)
with patch('bookwyrm.views.user.is_api_request') as is_api:
with patch("bookwyrm.views.user.is_api_request") as is_api:
is_api.return_value = False
result = view(request, 'rat')
result = view(request, "rat")
self.assertEqual(result.status_code, 404)
def test_followers_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Followers.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
with patch('bookwyrm.views.user.is_api_request') as is_api:
with patch("bookwyrm.views.user.is_api_request") as is_api:
is_api.return_value = False
result = view(request, 'mouse')
result = view(request, "mouse")
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
with patch('bookwyrm.views.user.is_api_request') as is_api:
with patch("bookwyrm.views.user.is_api_request") as is_api:
is_api.return_value = True
result = view(request, 'mouse')
result = view(request, "mouse")
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_followers_page_blocked(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Followers.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
self.rat.blocks.add(self.local_user)
with patch('bookwyrm.views.user.is_api_request') as is_api:
with patch("bookwyrm.views.user.is_api_request") as is_api:
is_api.return_value = False
result = view(request, 'rat')
result = view(request, "rat")
self.assertEqual(result.status_code, 404)
def test_following_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Following.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
with patch('bookwyrm.views.user.is_api_request') as is_api:
with patch("bookwyrm.views.user.is_api_request") as is_api:
is_api.return_value = False
result = view(request, 'mouse')
result = view(request, "mouse")
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
with patch('bookwyrm.views.user.is_api_request') as is_api:
with patch("bookwyrm.views.user.is_api_request") as is_api:
is_api.return_value = True
result = view(request, 'mouse')
result = view(request, "mouse")
self.assertIsInstance(result, ActivitypubResponse)
self.assertEqual(result.status_code, 200)
def test_following_page_blocked(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.Following.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
self.rat.blocks.add(self.local_user)
with patch('bookwyrm.views.user.is_api_request') as is_api:
with patch("bookwyrm.views.user.is_api_request") as is_api:
is_api.return_value = False
result = view(request, 'rat')
result = view(request, "rat")
self.assertEqual(result.status_code, 404)
def test_edit_user_page(self):
''' there are so many views, this just makes sure it LOADS '''
""" there are so many views, this just makes sure it LOADS """
view = views.EditUser.as_view()
request = self.factory.get('')
request = self.factory.get("")
request.user = self.local_user
result = view(request)
self.assertIsInstance(result, TemplateResponse)
result.render()
self.assertEqual(result.status_code, 200)
def test_edit_user(self):
''' use a form to update a user '''
""" use a form to update a user """
view = views.EditUser.as_view()
form = forms.EditUserForm(instance=self.local_user)
form.data['name'] = 'New Name'
form.data['email'] = 'wow@email.com'
request = self.factory.post('', form.data)
form.data["name"] = "New Name"
form.data["email"] = "wow@email.com"
request = self.factory.post("", form.data)
request.user = self.local_user
self.assertIsNone(self.local_user.name)
with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay') \
as delay_mock:
with patch(
"bookwyrm.models.activitypub_mixin.broadcast_task.delay"
) as delay_mock:
view(request)
self.assertEqual(delay_mock.call_count, 1)
self.assertEqual(self.local_user.name, 'New Name')
self.assertEqual(self.local_user.email, 'wow@email.com')
self.assertEqual(self.local_user.name, "New Name")
self.assertEqual(self.local_user.email, "wow@email.com")
# idk how to mock the upload form, got tired of triyng to make it work
# def test_edit_user_avatar(self):
# ''' use a form to update a user '''
# view = views.EditUser.as_view()
# form = forms.EditUserForm(instance=self.local_user)
# form.data['name'] = 'New Name'
# form.data['email'] = 'wow@email.com'
# image_file = pathlib.Path(__file__).parent.joinpath(
# '../../static/images/no_cover.jpg')
# image = Image.open(image_file)
# form.files['avatar'] = SimpleUploadedFile(
# image_file, open(image_file), content_type='image/jpeg')
# request = self.factory.post('', form.data, form.files)
# request.user = self.local_user
# idk how to mock the upload form, got tired of triyng to make it work
# def test_edit_user_avatar(self):
# ''' use a form to update a user '''
# view = views.EditUser.as_view()
# form = forms.EditUserForm(instance=self.local_user)
# form.data['name'] = 'New Name'
# form.data['email'] = 'wow@email.com'
# image_file = pathlib.Path(__file__).parent.joinpath(
# '../../static/images/no_cover.jpg')
# image = Image.open(image_file)
# form.files['avatar'] = SimpleUploadedFile(
# image_file, open(image_file), content_type='image/jpeg')
# request = self.factory.post('', form.data, form.files)
# request.user = self.local_user
# with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay') \
# as delay_mock:
# view(request)
# self.assertEqual(delay_mock.call_count, 1)
# self.assertEqual(self.local_user.name, 'New Name')
# self.assertEqual(self.local_user.email, 'wow@email.com')
# self.assertIsNotNone(self.local_user.avatar)
# self.assertEqual(self.local_user.avatar.size, (120, 120))
# with patch('bookwyrm.models.activitypub_mixin.broadcast_task.delay') \
# as delay_mock:
# view(request)
# self.assertEqual(delay_mock.call_count, 1)
# self.assertEqual(self.local_user.name, 'New Name')
# self.assertEqual(self.local_user.email, 'wow@email.com')
# self.assertIsNotNone(self.local_user.avatar)
# self.assertEqual(self.local_user.avatar.size, (120, 120))
def test_crop_avatar(self):
''' reduce that image size '''
""" reduce that image size """
image_file = pathlib.Path(__file__).parent.joinpath(
'../../static/images/no_cover.jpg')
"../../static/images/no_cover.jpg"
)
image = Image.open(image_file)
result = views.user.crop_avatar(image)