)?%%%SJIS(\d+)(?:<\/p>)?/, (match, capture) => { - return '
$1');
+ /\[search\]((?:[^\[]|\[(?!\/?search\]))+)\[\/search\]/gi,
+ '$1'
+ );
}
}
class SpoilersWrapper extends BaseMarkdownWrapper {
postprocess(text) {
return text.replace(
- /\[spoiler\]((?:[^\[]|\[(?!\/?spoiler\]))+)\[\/spoiler\]/ig,
- '$1');
+ /\[spoiler\]((?:[^\[]|\[(?!\/?spoiler\]))+)\[\/spoiler\]/gi,
+ '$1'
+ );
}
}
class SmallWrapper extends BaseMarkdownWrapper {
postprocess(text) {
return text.replace(
- /\[small\]((?:[^\[]|\[(?!\/?small\]))+)\[\/small\]/ig,
- '$1');
+ /\[small\]((?:[^\[]|\[(?!\/?small\]))+)\[\/small\]/gi,
+ "$1"
+ );
}
}
class StrikeThroughWrapper extends BaseMarkdownWrapper {
postprocess(text) {
- text = text.replace(/(^|[^\\])(~~|~)([^~]+)\2/g, '$1\nEverything there is ' +
- b'online about\nW3 is linked directly or indirectly\nto this docum' +
- b'ent, including an \nEverything there is "
+ + b"online about\nW3 is linked directly or indirectly\nto this docum"
+ + b'ent, including an \n
\n\n')
+ b'World Wide Web
The WorldWideWeb'
+ + b' (W3) is a wide-area\n
\n\n'
+ )
actual_content = net.download(url)
assert actual_content == expected_content
-@pytest.mark.parametrize('url', [
- 'https://samples.ffmpeg.org/MPEG-4/video.mp4',
-])
+@pytest.mark.parametrize(
+ "url", ["https://samples.ffmpeg.org/MPEG-4/video.mp4",]
+)
def test_too_large_download(url):
- pytest.xfail('Download limit not implemented yet')
+ pytest.xfail("Download limit not implemented yet")
with pytest.raises(errors.ProcessingError):
net.download(url)
-@pytest.mark.parametrize('url,expected_sha1', [
- ('https://www.youtube.com/watch?v=C0DPdy98e4c',
- '365af1c8f59c6865e1a84c6e13e3e25ff89e0ba1'),
- ('https://gfycat.com/immaterialchillyiberianmole',
- '953000e81d7bd1da95ce264f872e7b6c4a6484be'),
-])
+@pytest.mark.parametrize(
+ "url,expected_sha1",
+ [
+ (
+ "https://www.youtube.com/watch?v=C0DPdy98e4c",
+ "365af1c8f59c6865e1a84c6e13e3e25ff89e0ba1",
+ ),
+ (
+ "https://gfycat.com/immaterialchillyiberianmole",
+ "953000e81d7bd1da95ce264f872e7b6c4a6484be",
+ ),
+ ],
+)
def test_video_download(url, expected_sha1):
actual_content = net.download(url, use_video_downloader=True)
assert get_sha1(actual_content) == expected_sha1
-@pytest.mark.parametrize('url', [
- 'https://samples.ffmpeg.org/flac/short.flac', # not a video
- 'https://www.youtube.com/watch?v=dQw4w9WgXcQ', # video too large
-])
+@pytest.mark.parametrize(
+ "url",
+ [
+ "https://samples.ffmpeg.org/flac/short.flac", # not a video
+ "https://www.youtube.com/watch?v=dQw4w9WgXcQ", # video too large
+ ],
+)
def test_failed_video_download(url):
with pytest.raises(errors.ThirdPartyError):
net.download(url, use_video_downloader=True)
diff --git a/server/szurubooru/tests/func/test_posts.py b/server/szurubooru/tests/func/test_posts.py
index ed008792..acedf6f3 100644
--- a/server/szurubooru/tests/func/test_posts.py
+++ b/server/szurubooru/tests/func/test_posts.py
@@ -1,40 +1,58 @@
+import os
from datetime import datetime
from unittest.mock import patch
-import os
+
import pytest
+
from szurubooru import db, model
from szurubooru.func import (
- posts, users, comments, tags, images, files, util, image_hash)
+ comments,
+ files,
+ image_hash,
+ images,
+ posts,
+ tags,
+ users,
+ util,
+)
-@pytest.mark.parametrize('input_mime_type,expected_url', [
- ('image/jpeg', 'http://example.com/posts/1_244c8840887984c4.jpg'),
- ('image/gif', 'http://example.com/posts/1_244c8840887984c4.gif'),
- ('totally/unknown', 'http://example.com/posts/1_244c8840887984c4.dat'),
-])
+@pytest.mark.parametrize(
+ "input_mime_type,expected_url",
+ [
+ ("image/jpeg", "http://example.com/posts/1_244c8840887984c4.jpg"),
+ ("image/gif", "http://example.com/posts/1_244c8840887984c4.gif"),
+ ("totally/unknown", "http://example.com/posts/1_244c8840887984c4.dat"),
+ ],
+)
def test_get_post_url(input_mime_type, expected_url, config_injector):
- config_injector({'data_url': 'http://example.com/', 'secret': 'test'})
+ config_injector({"data_url": "http://example.com/", "secret": "test"})
post = model.Post()
post.post_id = 1
post.mime_type = input_mime_type
assert posts.get_post_content_url(post) == expected_url
-@pytest.mark.parametrize('input_mime_type', ['image/jpeg', 'image/gif'])
+@pytest.mark.parametrize("input_mime_type", ["image/jpeg", "image/gif"])
def test_get_post_thumbnail_url(input_mime_type, config_injector):
- config_injector({'data_url': 'http://example.com/', 'secret': 'test'})
+ config_injector({"data_url": "http://example.com/", "secret": "test"})
post = model.Post()
post.post_id = 1
post.mime_type = input_mime_type
- assert posts.get_post_thumbnail_url(post) \
- == 'http://example.com/generated-thumbnails/1_244c8840887984c4.jpg'
+ assert (
+ posts.get_post_thumbnail_url(post)
+ == "http://example.com/generated-thumbnails/1_244c8840887984c4.jpg"
+ )
-@pytest.mark.parametrize('input_mime_type,expected_path', [
- ('image/jpeg', 'posts/1_244c8840887984c4.jpg'),
- ('image/gif', 'posts/1_244c8840887984c4.gif'),
- ('totally/unknown', 'posts/1_244c8840887984c4.dat'),
-])
+@pytest.mark.parametrize(
+ "input_mime_type,expected_path",
+ [
+ ("image/jpeg", "posts/1_244c8840887984c4.jpg"),
+ ("image/gif", "posts/1_244c8840887984c4.gif"),
+ ("totally/unknown", "posts/1_244c8840887984c4.dat"),
+ ],
+)
def test_get_post_content_path(input_mime_type, expected_path):
post = model.Post()
post.post_id = 1
@@ -42,31 +60,35 @@ def test_get_post_content_path(input_mime_type, expected_path):
assert posts.get_post_content_path(post) == expected_path
-@pytest.mark.parametrize('input_mime_type', ['image/jpeg', 'image/gif'])
+@pytest.mark.parametrize("input_mime_type", ["image/jpeg", "image/gif"])
def test_get_post_thumbnail_path(input_mime_type):
post = model.Post()
post.post_id = 1
post.mime_type = input_mime_type
- assert posts.get_post_thumbnail_path(post) \
- == 'generated-thumbnails/1_244c8840887984c4.jpg'
+ assert (
+ posts.get_post_thumbnail_path(post)
+ == "generated-thumbnails/1_244c8840887984c4.jpg"
+ )
-@pytest.mark.parametrize('input_mime_type', ['image/jpeg', 'image/gif'])
+@pytest.mark.parametrize("input_mime_type", ["image/jpeg", "image/gif"])
def test_get_post_thumbnail_backup_path(input_mime_type):
post = model.Post()
post.post_id = 1
post.mime_type = input_mime_type
- assert posts.get_post_thumbnail_backup_path(post) \
- == 'posts/custom-thumbnails/1_244c8840887984c4.dat'
+ assert (
+ posts.get_post_thumbnail_backup_path(post)
+ == "posts/custom-thumbnails/1_244c8840887984c4.dat"
+ )
def test_serialize_note():
note = model.PostNote()
note.polygon = [[0, 1], [1, 1], [1, 0], [0, 0]]
- note.text = '...'
+ note.text = "..."
assert posts.serialize_note(note) == {
- 'polygon': [[0, 1], [1, 1], [1, 0], [0, 0]],
- 'text': '...'
+ "polygon": [[0, 1], [1, 1], [1, 0], [0, 0]],
+ "text": "...",
}
@@ -75,94 +97,110 @@ def test_serialize_post_when_empty():
def test_serialize_post(
- user_factory,
- comment_factory,
- tag_factory,
- tag_category_factory,
- pool_factory,
- pool_category_factory,
- config_injector):
- config_injector({'data_url': 'http://example.com/', 'secret': 'test'})
- with patch('szurubooru.func.comments.serialize_comment'), \
- patch('szurubooru.func.users.serialize_micro_user'), \
- patch('szurubooru.func.posts.files.has'):
+ user_factory,
+ comment_factory,
+ tag_factory,
+ tag_category_factory,
+ pool_factory,
+ pool_category_factory,
+ config_injector,
+):
+ config_injector({"data_url": "http://example.com/", "secret": "test"})
+ with patch("szurubooru.func.comments.serialize_comment"), patch(
+ "szurubooru.func.users.serialize_micro_user"
+ ), patch("szurubooru.func.posts.files.has"):
files.has.return_value = True
- users.serialize_micro_user.side_effect \
- = lambda user, auth_user: user.name
- comments.serialize_comment.side_effect \
- = lambda comment, auth_user: comment.user.name
+ users.serialize_micro_user.side_effect = (
+ lambda user, auth_user: user.name
+ )
+ comments.serialize_comment.side_effect = (
+ lambda comment, auth_user: comment.user.name
+ )
- auth_user = user_factory(name='auth user')
+ auth_user = user_factory(name="auth user")
post = model.Post()
post.post_id = 1
post.creation_time = datetime(1997, 1, 1)
post.last_edit_time = datetime(1998, 1, 1)
post.tags = [
tag_factory(
- names=['tag1', 'tag2'],
- category=tag_category_factory('test-cat1')),
+ names=["tag1", "tag2"],
+ category=tag_category_factory("test-cat1"),
+ ),
tag_factory(
- names=['tag3'],
- category=tag_category_factory('test-cat2'))
+ names=["tag3"], category=tag_category_factory("test-cat2")
+ ),
]
post.safety = model.Post.SAFETY_SAFE
- post.source = '4gag'
+ post.source = "4gag"
post.type = model.Post.TYPE_IMAGE
- post.checksum = 'deadbeef'
- post.mime_type = 'image/jpeg'
+ post.checksum = "deadbeef"
+ post.mime_type = "image/jpeg"
post.file_size = 100
- post.user = user_factory(name='post author')
+ post.user = user_factory(name="post author")
post.canvas_width = 200
post.canvas_height = 300
- post.flags = ['loop']
+ post.flags = ["loop"]
db.session.add(post)
db.session.flush()
- db.session.add_all([
- comment_factory(
- user=user_factory(name='commenter1'),
- post=post,
- time=datetime(1999, 1, 1)),
- comment_factory(
- user=user_factory(name='commenter2'),
- post=post,
- time=datetime(1999, 1, 2)),
- model.PostFavorite(
- post=post,
- user=user_factory(name='fav1'),
- time=datetime(1800, 1, 1)),
- model.PostFeature(
- post=post,
- user=user_factory(),
- time=datetime(1999, 1, 1)),
- model.PostScore(
- post=post,
- user=auth_user,
- score=-1,
- time=datetime(1800, 1, 1)),
- model.PostScore(
- post=post,
- user=user_factory(),
- score=1,
- time=datetime(1800, 1, 1)),
- model.PostScore(
- post=post,
- user=user_factory(),
- score=1,
- time=datetime(1800, 1, 1))])
+ db.session.add_all(
+ [
+ comment_factory(
+ user=user_factory(name="commenter1"),
+ post=post,
+ time=datetime(1999, 1, 1),
+ ),
+ comment_factory(
+ user=user_factory(name="commenter2"),
+ post=post,
+ time=datetime(1999, 1, 2),
+ ),
+ model.PostFavorite(
+ post=post,
+ user=user_factory(name="fav1"),
+ time=datetime(1800, 1, 1),
+ ),
+ model.PostFeature(
+ post=post, user=user_factory(), time=datetime(1999, 1, 1)
+ ),
+ model.PostScore(
+ post=post,
+ user=auth_user,
+ score=-1,
+ time=datetime(1800, 1, 1),
+ ),
+ model.PostScore(
+ post=post,
+ user=user_factory(),
+ score=1,
+ time=datetime(1800, 1, 1),
+ ),
+ model.PostScore(
+ post=post,
+ user=user_factory(),
+ score=1,
+ time=datetime(1800, 1, 1),
+ ),
+ ]
+ )
db.session.flush()
- pool1 = pool_factory(id=1,
- names=['pool1', 'pool2'],
- description='desc',
- category=pool_category_factory('test-cat1'))
+ pool1 = pool_factory(
+ id=1,
+ names=["pool1", "pool2"],
+ description="desc",
+ category=pool_category_factory("test-cat1"),
+ )
pool1.last_edit_time = datetime(1998, 1, 1)
pool1.posts.append(post)
- pool2 = pool_factory(id=2,
- names=['pool3'],
- description='desc2',
- category=pool_category_factory('test-cat2'))
+ pool2 = pool_factory(
+ id=2,
+ names=["pool3"],
+ description="desc2",
+ category=pool_category_factory("test-cat2"),
+ )
pool2.last_edit_time = datetime(1998, 1, 1)
pool2.posts.append(post)
@@ -170,105 +208,100 @@ def test_serialize_post(
db.session.flush()
result = posts.serialize_post(post, auth_user)
- result['tags'].sort(key=lambda tag: tag['names'][0])
+ result["tags"].sort(key=lambda tag: tag["names"][0])
assert result == {
- 'id': 1,
- 'version': 1,
- 'creationTime': datetime(1997, 1, 1),
- 'lastEditTime': datetime(1998, 1, 1),
- 'safety': 'safe',
- 'source': '4gag',
- 'type': 'image',
- 'checksum': 'deadbeef',
- 'fileSize': 100,
- 'canvasWidth': 200,
- 'canvasHeight': 300,
- 'contentUrl': 'http://example.com/posts/1_244c8840887984c4.jpg',
- 'thumbnailUrl':
- 'http://example.com/'
- 'generated-thumbnails/1_244c8840887984c4.jpg',
- 'flags': ['loop'],
- 'tags': [
+ "id": 1,
+ "version": 1,
+ "creationTime": datetime(1997, 1, 1),
+ "lastEditTime": datetime(1998, 1, 1),
+ "safety": "safe",
+ "source": "4gag",
+ "type": "image",
+ "checksum": "deadbeef",
+ "fileSize": 100,
+ "canvasWidth": 200,
+ "canvasHeight": 300,
+ "contentUrl": "http://example.com/posts/1_244c8840887984c4.jpg",
+ "thumbnailUrl": "http://example.com/"
+ "generated-thumbnails/1_244c8840887984c4.jpg",
+ "flags": ["loop"],
+ "tags": [
{
- 'names': ['tag1', 'tag2'],
- 'category': 'test-cat1', 'usages': 1,
- },
- {
- 'names': ['tag3'],
- 'category': 'test-cat2',
- 'usages': 1,
+ "names": ["tag1", "tag2"],
+ "category": "test-cat1",
+ "usages": 1,
},
+ {"names": ["tag3"], "category": "test-cat2", "usages": 1,},
],
- 'relations': [],
- 'notes': [],
- 'pools': [
+ "relations": [],
+ "notes": [],
+ "pools": [
{
- 'id': 1,
- 'names': ['pool1', 'pool2'],
- 'description': 'desc',
- 'category': 'test-cat1',
- 'postCount': 1,
- 'posts': [
+ "id": 1,
+ "names": ["pool1", "pool2"],
+ "description": "desc",
+ "category": "test-cat1",
+ "postCount": 1,
+ "posts": [
{
- 'id': 1,
- 'thumbnailUrl':
- 'http://example.com/'
- 'generated-thumbnails/1_244c8840887984c4.jpg',
+ "id": 1,
+ "thumbnailUrl": "http://example.com/"
+ "generated-thumbnails/1_244c8840887984c4.jpg",
}
],
- 'version': 1,
- 'creationTime': datetime(1996, 1, 1),
- 'lastEditTime': datetime(1998, 1, 1),
+ "version": 1,
+ "creationTime": datetime(1996, 1, 1),
+ "lastEditTime": datetime(1998, 1, 1),
},
{
- 'id': 2,
- 'names': ['pool3'],
- 'description': 'desc2',
- 'category': 'test-cat2',
- 'postCount': 1,
- 'posts': [
+ "id": 2,
+ "names": ["pool3"],
+ "description": "desc2",
+ "category": "test-cat2",
+ "postCount": 1,
+ "posts": [
{
- 'id': 1,
- 'thumbnailUrl':
- 'http://example.com/'
- 'generated-thumbnails/1_244c8840887984c4.jpg',
+ "id": 1,
+ "thumbnailUrl": "http://example.com/"
+ "generated-thumbnails/1_244c8840887984c4.jpg",
}
],
- 'version': 1,
- 'creationTime': datetime(1996, 1, 1),
- 'lastEditTime': datetime(1998, 1, 1),
- }
+ "version": 1,
+ "creationTime": datetime(1996, 1, 1),
+ "lastEditTime": datetime(1998, 1, 1),
+ },
],
- 'user': 'post author',
- 'score': 1,
- 'ownFavorite': False,
- 'ownScore': -1,
- 'tagCount': 2,
- 'favoriteCount': 1,
- 'commentCount': 2,
- 'noteCount': 0,
- 'featureCount': 1,
- 'relationCount': 0,
- 'lastFeatureTime': datetime(1999, 1, 1),
- 'favoritedBy': ['fav1'],
- 'hasCustomThumbnail': True,
- 'mimeType': 'image/jpeg',
- 'comments': ['commenter1', 'commenter2'],
+ "user": "post author",
+ "score": 1,
+ "ownFavorite": False,
+ "ownScore": -1,
+ "tagCount": 2,
+ "favoriteCount": 1,
+ "commentCount": 2,
+ "noteCount": 0,
+ "featureCount": 1,
+ "relationCount": 0,
+ "lastFeatureTime": datetime(1999, 1, 1),
+ "favoritedBy": ["fav1"],
+ "hasCustomThumbnail": True,
+ "mimeType": "image/jpeg",
+ "comments": ["commenter1", "commenter2"],
}
def test_serialize_micro_post(post_factory, user_factory):
- with patch('szurubooru.func.posts.get_post_thumbnail_url'):
- posts.get_post_thumbnail_url.return_value \
- = 'https://example.com/thumb.png'
+ with patch("szurubooru.func.posts.get_post_thumbnail_url"):
+ posts.get_post_thumbnail_url.return_value = (
+ "https://example.com/thumb.png"
+ )
auth_user = user_factory()
post = post_factory()
db.session.add(post)
db.session.flush()
assert posts.serialize_micro_post(post, auth_user) == {
- 'id': post.post_id,
- 'thumbnailUrl': 'https://example.com/thumb.png',
+ "id": post.post_id,
+ "thumbnailUrl": "https://example.com/thumb.png",
}
@@ -299,22 +332,25 @@ def test_get_post_by_id(post_factory):
def test_create_post(user_factory, fake_datetime):
- with patch('szurubooru.func.posts.update_post_content'), \
- patch('szurubooru.func.posts.update_post_tags'), \
- fake_datetime('1997-01-01'):
+ with patch("szurubooru.func.posts.update_post_content"), patch(
+ "szurubooru.func.posts.update_post_tags"
+ ), fake_datetime("1997-01-01"):
auth_user = user_factory()
- post, _new_tags = posts.create_post('content', ['tag'], auth_user)
+ post, _new_tags = posts.create_post("content", ["tag"], auth_user)
assert post.creation_time == datetime(1997, 1, 1)
assert post.last_edit_time is None
- posts.update_post_tags.assert_called_once_with(post, ['tag'])
- posts.update_post_content.assert_called_once_with(post, 'content')
+ posts.update_post_tags.assert_called_once_with(post, ["tag"])
+ posts.update_post_content.assert_called_once_with(post, "content")
-@pytest.mark.parametrize('input_safety,expected_safety', [
- ('safe', model.Post.SAFETY_SAFE),
- ('sketchy', model.Post.SAFETY_SKETCHY),
- ('unsafe', model.Post.SAFETY_UNSAFE),
-])
+@pytest.mark.parametrize(
+ "input_safety,expected_safety",
+ [
+ ("safe", model.Post.SAFETY_SAFE),
+ ("sketchy", model.Post.SAFETY_SKETCHY),
+ ("unsafe", model.Post.SAFETY_UNSAFE),
+ ],
+)
def test_update_post_safety(input_safety, expected_safety):
post = model.Post()
posts.update_post_safety(post, input_safety)
@@ -324,96 +360,104 @@ def test_update_post_safety(input_safety, expected_safety):
def test_update_post_safety_with_invalid_string():
post = model.Post()
with pytest.raises(posts.InvalidPostSafetyError):
- posts.update_post_safety(post, 'bad')
+ posts.update_post_safety(post, "bad")
def test_update_post_source():
post = model.Post()
- posts.update_post_source(post, 'x')
- assert post.source == 'x'
+ posts.update_post_source(post, "x")
+ assert post.source == "x"
def test_update_post_source_with_too_long_string():
post = model.Post()
with pytest.raises(posts.InvalidPostSourceError):
- posts.update_post_source(post, 'x' * 3000)
+ posts.update_post_source(post, "x" * 3000)
@pytest.mark.parametrize(
- 'is_existing,input_file,expected_mime_type,expected_type,output_file_name',
+ "is_existing,input_file,expected_mime_type,expected_type,output_file_name",
[
(
True,
- 'png.png',
- 'image/png',
+ "png.png",
+ "image/png",
model.Post.TYPE_IMAGE,
- '1_244c8840887984c4.png',
+ "1_244c8840887984c4.png",
),
(
False,
- 'png.png',
- 'image/png',
+ "png.png",
+ "image/png",
model.Post.TYPE_IMAGE,
- '1_244c8840887984c4.png',
+ "1_244c8840887984c4.png",
),
(
False,
- 'jpeg.jpg',
- 'image/jpeg',
+ "jpeg.jpg",
+ "image/jpeg",
model.Post.TYPE_IMAGE,
- '1_244c8840887984c4.jpg',
+ "1_244c8840887984c4.jpg",
),
(
False,
- 'gif.gif',
- 'image/gif',
+ "gif.gif",
+ "image/gif",
model.Post.TYPE_IMAGE,
- '1_244c8840887984c4.gif',
+ "1_244c8840887984c4.gif",
),
(
False,
- 'gif-animated.gif',
- 'image/gif',
+ "gif-animated.gif",
+ "image/gif",
model.Post.TYPE_ANIMATION,
- '1_244c8840887984c4.gif',
+ "1_244c8840887984c4.gif",
),
(
False,
- 'webm.webm',
- 'video/webm',
+ "webm.webm",
+ "video/webm",
model.Post.TYPE_VIDEO,
- '1_244c8840887984c4.webm',
+ "1_244c8840887984c4.webm",
),
(
False,
- 'mp4.mp4',
- 'video/mp4',
+ "mp4.mp4",
+ "video/mp4",
model.Post.TYPE_VIDEO,
- '1_244c8840887984c4.mp4',
+ "1_244c8840887984c4.mp4",
),
(
False,
- 'flash.swf',
- 'application/x-shockwave-flash',
+ "flash.swf",
+ "application/x-shockwave-flash",
model.Post.TYPE_FLASH,
- '1_244c8840887984c4.swf',
+ "1_244c8840887984c4.swf",
),
- ])
+ ],
+)
def test_update_post_content_for_new_post(
- tmpdir, config_injector, post_factory, read_asset, is_existing,
- input_file, expected_mime_type, expected_type, output_file_name):
- with patch('szurubooru.func.util.get_sha1'):
- util.get_sha1.return_value = 'crc'
- config_injector({
- 'data_dir': str(tmpdir.mkdir('data')),
- 'thumbnails': {
- 'post_width': 300,
- 'post_height': 300,
- },
- 'secret': 'test',
- 'allow_broken_uploads': False,
- })
- output_file_path = '{}/data/posts/{}'.format(tmpdir, output_file_name)
+ tmpdir,
+ config_injector,
+ post_factory,
+ read_asset,
+ is_existing,
+ input_file,
+ expected_mime_type,
+ expected_type,
+ output_file_name,
+):
+ with patch("szurubooru.func.util.get_sha1"):
+ util.get_sha1.return_value = "crc"
+ config_injector(
+ {
+ "data_dir": str(tmpdir.mkdir("data")),
+ "thumbnails": {"post_width": 300, "post_height": 300,},
+ "secret": "test",
+ "allow_broken_uploads": False,
+ }
+ )
+ output_file_path = "{}/data/posts/{}".format(tmpdir, output_file_name)
post = post_factory(id=1)
db.session.add(post)
if is_existing:
@@ -426,7 +470,7 @@ def test_update_post_content_for_new_post(
db.session.flush()
assert post.mime_type == expected_mime_type
assert post.type == expected_type
- assert post.checksum == 'crc'
+ assert post.checksum == "crc"
assert os.path.exists(output_file_path)
if post.type in (model.Post.TYPE_IMAGE, model.Post.TYPE_ANIMATION):
assert db.session.query(model.PostSignature).count() == 1
@@ -435,130 +479,134 @@ def test_update_post_content_for_new_post(
def test_update_post_content_to_existing_content(
- tmpdir, config_injector, post_factory, read_asset):
- config_injector({
- 'data_dir': str(tmpdir.mkdir('data')),
- 'data_url': 'example.com',
- 'thumbnails': {
- 'post_width': 300,
- 'post_height': 300,
- },
- 'secret': 'test',
- 'allow_broken_uploads': False,
- })
+ tmpdir, config_injector, post_factory, read_asset
+):
+ config_injector(
+ {
+ "data_dir": str(tmpdir.mkdir("data")),
+ "data_url": "example.com",
+ "thumbnails": {"post_width": 300, "post_height": 300,},
+ "secret": "test",
+ "allow_broken_uploads": False,
+ }
+ )
post = post_factory()
another_post = post_factory()
db.session.add_all([post, another_post])
- posts.update_post_content(post, read_asset('png.png'))
+ posts.update_post_content(post, read_asset("png.png"))
db.session.flush()
with pytest.raises(posts.PostAlreadyUploadedError):
- posts.update_post_content(another_post, read_asset('png.png'))
+ posts.update_post_content(another_post, read_asset("png.png"))
-@pytest.mark.parametrize('allow_broken_uploads', [True, False])
+@pytest.mark.parametrize("allow_broken_uploads", [True, False])
def test_update_post_content_with_broken_content(
- tmpdir, config_injector, post_factory, read_asset,
- allow_broken_uploads):
+ tmpdir, config_injector, post_factory, read_asset, allow_broken_uploads
+):
# the rationale behind this behavior is to salvage user upload even if the
# server software thinks it's broken. chances are the server is wrong,
# especially about flash movies.
- config_injector({
- 'data_dir': str(tmpdir.mkdir('data')),
- 'thumbnails': {
- 'post_width': 300,
- 'post_height': 300,
- },
- 'secret': 'test',
- 'allow_broken_uploads': allow_broken_uploads,
- })
+ config_injector(
+ {
+ "data_dir": str(tmpdir.mkdir("data")),
+ "thumbnails": {"post_width": 300, "post_height": 300,},
+ "secret": "test",
+ "allow_broken_uploads": allow_broken_uploads,
+ }
+ )
post = post_factory()
another_post = post_factory()
db.session.add_all([post, another_post])
if allow_broken_uploads:
- posts.update_post_content(post, read_asset('png-broken.png'))
+ posts.update_post_content(post, read_asset("png-broken.png"))
db.session.flush()
assert post.canvas_width is None
assert post.canvas_height is None
else:
with pytest.raises(posts.InvalidPostContentError):
- posts.update_post_content(post, read_asset('png-broken.png'))
+ posts.update_post_content(post, read_asset("png-broken.png"))
db.session.flush()
-@pytest.mark.parametrize('input_content', [None, b'not a media file'])
+@pytest.mark.parametrize("input_content", [None, b"not a media file"])
def test_update_post_content_with_invalid_content(
- config_injector, input_content):
- config_injector({
- 'allow_broken_uploads': True,
- })
+ config_injector, input_content
+):
+ config_injector(
+ {"allow_broken_uploads": True,}
+ )
post = model.Post()
with pytest.raises(posts.InvalidPostContentError):
posts.update_post_content(post, input_content)
-@pytest.mark.parametrize('is_existing', (True, False))
+@pytest.mark.parametrize("is_existing", (True, False))
def test_update_post_thumbnail_to_new_one(
- tmpdir, config_injector, read_asset, post_factory, is_existing):
- config_injector({
- 'data_dir': str(tmpdir.mkdir('data')),
- 'thumbnails': {
- 'post_width': 300,
- 'post_height': 300,
- },
- 'secret': 'test',
- 'allow_broken_uploads': False,
- })
+ tmpdir, config_injector, read_asset, post_factory, is_existing
+):
+ config_injector(
+ {
+ "data_dir": str(tmpdir.mkdir("data")),
+ "thumbnails": {"post_width": 300, "post_height": 300,},
+ "secret": "test",
+ "allow_broken_uploads": False,
+ }
+ )
post = post_factory(id=1)
db.session.add(post)
if is_existing:
db.session.flush()
assert post.post_id
generated_path = (
- '{}/data/generated-thumbnails/1_244c8840887984c4.jpg'
- .format(tmpdir))
+ "{}/data/generated-thumbnails/".format(tmpdir)
+ + "1_244c8840887984c4.jpg"
+ )
source_path = (
- '{}/data/posts/custom-thumbnails/1_244c8840887984c4.dat'
- .format(tmpdir))
+ "{}/data/posts/custom-thumbnails/".format(tmpdir)
+ + "1_244c8840887984c4.dat"
+ )
assert not os.path.exists(generated_path)
assert not os.path.exists(source_path)
- posts.update_post_content(post, read_asset('png.png'))
- posts.update_post_thumbnail(post, read_asset('jpeg.jpg'))
+ posts.update_post_content(post, read_asset("png.png"))
+ posts.update_post_thumbnail(post, read_asset("jpeg.jpg"))
assert not os.path.exists(generated_path)
assert not os.path.exists(source_path)
db.session.flush()
assert os.path.exists(generated_path)
assert os.path.exists(source_path)
- with open(source_path, 'rb') as handle:
- assert handle.read() == read_asset('jpeg.jpg')
+ with open(source_path, "rb") as handle:
+ assert handle.read() == read_asset("jpeg.jpg")
-@pytest.mark.parametrize('is_existing', (True, False))
+@pytest.mark.parametrize("is_existing", (True, False))
def test_update_post_thumbnail_to_default(
- tmpdir, config_injector, read_asset, post_factory, is_existing):
- config_injector({
- 'data_dir': str(tmpdir.mkdir('data')),
- 'thumbnails': {
- 'post_width': 300,
- 'post_height': 300,
- },
- 'secret': 'test',
- 'allow_broken_uploads': False,
- })
+ tmpdir, config_injector, read_asset, post_factory, is_existing
+):
+ config_injector(
+ {
+ "data_dir": str(tmpdir.mkdir("data")),
+ "thumbnails": {"post_width": 300, "post_height": 300,},
+ "secret": "test",
+ "allow_broken_uploads": False,
+ }
+ )
post = post_factory(id=1)
db.session.add(post)
if is_existing:
db.session.flush()
assert post.post_id
generated_path = (
- '{}/data/generated-thumbnails/1_244c8840887984c4.jpg'
- .format(tmpdir))
+ "{}/data/generated-thumbnails/".format(tmpdir)
+ + "1_244c8840887984c4.jpg"
+ )
source_path = (
- '{}/data/posts/custom-thumbnails/1_244c8840887984c4.dat'
- .format(tmpdir))
+ "{}/data/posts/custom-thumbnails/".format(tmpdir)
+ + "1_244c8840887984c4.dat"
+ )
assert not os.path.exists(generated_path)
assert not os.path.exists(source_path)
- posts.update_post_content(post, read_asset('png.png'))
- posts.update_post_thumbnail(post, read_asset('jpeg.jpg'))
+ posts.update_post_content(post, read_asset("png.png"))
+ posts.update_post_thumbnail(post, read_asset("jpeg.jpg"))
posts.update_post_thumbnail(post, None)
assert not os.path.exists(generated_path)
assert not os.path.exists(source_path)
@@ -567,82 +615,88 @@ def test_update_post_thumbnail_to_default(
assert not os.path.exists(source_path)
-@pytest.mark.parametrize('is_existing', (True, False))
+@pytest.mark.parametrize("is_existing", (True, False))
def test_update_post_thumbnail_with_broken_thumbnail(
- tmpdir, config_injector, read_asset, post_factory, is_existing):
- config_injector({
- 'data_dir': str(tmpdir.mkdir('data')),
- 'thumbnails': {
- 'post_width': 300,
- 'post_height': 300,
- },
- 'secret': 'test',
- 'allow_broken_uploads': False,
- })
+ tmpdir, config_injector, read_asset, post_factory, is_existing
+):
+ config_injector(
+ {
+ "data_dir": str(tmpdir.mkdir("data")),
+ "thumbnails": {"post_width": 300, "post_height": 300,},
+ "secret": "test",
+ "allow_broken_uploads": False,
+ }
+ )
post = post_factory(id=1)
db.session.add(post)
if is_existing:
db.session.flush()
assert post.post_id
generated_path = (
- '{}/data/generated-thumbnails/1_244c8840887984c4.jpg'
- .format(tmpdir))
+ "{}/data/generated-thumbnails/".format(tmpdir)
+ + "1_244c8840887984c4.jpg"
+ )
source_path = (
- '{}/data/posts/custom-thumbnails/1_244c8840887984c4.dat'
- .format(tmpdir))
+ "{}/data/posts/custom-thumbnails/".format(tmpdir)
+ + "1_244c8840887984c4.dat"
+ )
assert not os.path.exists(generated_path)
assert not os.path.exists(source_path)
- posts.update_post_content(post, read_asset('png.png'))
- posts.update_post_thumbnail(post, read_asset('png-broken.png'))
+ posts.update_post_content(post, read_asset("png.png"))
+ posts.update_post_thumbnail(post, read_asset("png-broken.png"))
assert not os.path.exists(generated_path)
assert not os.path.exists(source_path)
db.session.flush()
assert os.path.exists(generated_path)
assert os.path.exists(source_path)
- with open(source_path, 'rb') as handle:
- assert handle.read() == read_asset('png-broken.png')
- with open(generated_path, 'rb') as handle:
+ with open(source_path, "rb") as handle:
+ assert handle.read() == read_asset("png-broken.png")
+ with open(generated_path, "rb") as handle:
image = images.Image(handle.read())
assert image.width == 1
assert image.height == 1
def test_update_post_content_leaving_custom_thumbnail(
- tmpdir, config_injector, read_asset, post_factory):
- config_injector({
- 'data_dir': str(tmpdir.mkdir('data')),
- 'thumbnails': {
- 'post_width': 300,
- 'post_height': 300,
- },
- 'secret': 'test',
- 'allow_broken_uploads': False,
- })
+ tmpdir, config_injector, read_asset, post_factory
+):
+ config_injector(
+ {
+ "data_dir": str(tmpdir.mkdir("data")),
+ "thumbnails": {"post_width": 300, "post_height": 300,},
+ "secret": "test",
+ "allow_broken_uploads": False,
+ }
+ )
post = post_factory(id=1)
db.session.add(post)
- posts.update_post_content(post, read_asset('png.png'))
- posts.update_post_thumbnail(post, read_asset('jpeg.jpg'))
- posts.update_post_content(post, read_asset('png.png'))
+ posts.update_post_content(post, read_asset("png.png"))
+ posts.update_post_thumbnail(post, read_asset("jpeg.jpg"))
+ posts.update_post_content(post, read_asset("png.png"))
db.session.flush()
generated_path = (
- '{}/data/generated-thumbnails/1_244c8840887984c4.jpg'
- .format(tmpdir))
+ "{}/data/generated-thumbnails/".format(tmpdir)
+ + "1_244c8840887984c4.jpg"
+ )
source_path = (
- '{}/data/posts/custom-thumbnails/1_244c8840887984c4.dat'
- .format(tmpdir))
+ "{}/data/posts/custom-thumbnails/".format(tmpdir)
+ + "1_244c8840887984c4.dat"
+ )
assert os.path.exists(source_path)
assert os.path.exists(generated_path)
def test_update_post_tags(tag_factory):
post = model.Post()
- with patch('szurubooru.func.tags.get_or_create_tags_by_names'):
- tags.get_or_create_tags_by_names.side_effect = lambda tag_names: \
- ([tag_factory(names=[name]) for name in tag_names], [])
- posts.update_post_tags(post, ['tag1', 'tag2'])
+ with patch("szurubooru.func.tags.get_or_create_tags_by_names"):
+ tags.get_or_create_tags_by_names.side_effect = lambda tag_names: (
+ [tag_factory(names=[name]) for name in tag_names],
+ [],
+ )
+ posts.update_post_tags(post, ["tag1", "tag2"])
assert len(post.tags) == 2
- assert post.tags[0].names[0].name == 'tag1'
- assert post.tags[1].names[0].name == 'tag2'
+ assert post.tags[0].names[0].name == "tag1"
+ assert post.tags[1].names[0].name == "tag2"
def test_update_post_relations(post_factory):
@@ -654,7 +708,9 @@ def test_update_post_relations(post_factory):
posts.update_post_relations(post, [relation1.post_id, relation2.post_id])
assert len(post.relations) == 2
assert sorted(r.post_id for r in post.relations) == [
- relation1.post_id, relation2.post_id]
+ relation1.post_id,
+ relation2.post_id,
+ ]
def test_update_post_relations_bidirectionality(post_factory):
@@ -689,35 +745,44 @@ def test_update_post_notes():
posts.update_post_notes(
post,
[
- {'polygon': [[0, 0], [0, 1], [1, 0], [0, 0]], 'text': 'text1'},
- {'polygon': [[0, 0], [0, 1], [1, 0], [0, 0]], 'text': 'text2'},
- ])
+ {"polygon": [[0, 0], [0, 1], [1, 0], [0, 0]], "text": "text1"},
+ {"polygon": [[0, 0], [0, 1], [1, 0], [0, 0]], "text": "text2"},
+ ],
+ )
assert len(post.notes) == 2
assert post.notes[0].polygon == [[0, 0], [0, 1], [1, 0], [0, 0]]
- assert post.notes[0].text == 'text1'
+ assert post.notes[0].text == "text1"
assert post.notes[1].polygon == [[0, 0], [0, 1], [1, 0], [0, 0]]
- assert post.notes[1].text == 'text2'
+ assert post.notes[1].text == "text2"
-@pytest.mark.parametrize('input', [
- [{'text': '...'}],
- [{'polygon': None, 'text': '...'}],
- [{'polygon': 'trash', 'text': '...'}],
- [{'polygon': ['trash', 'trash', 'trash'], 'text': '...'}],
- [{'polygon': {2: 'trash', 3: 'trash', 4: 'trash'}, 'text': '...'}],
- [{'polygon': [[0, 0]], 'text': '...'}],
- [{'polygon': [[0, 0], [0, 0], None], 'text': '...'}],
- [{'polygon': [[0, 0], [0, 0], 'surprise'], 'text': '...'}],
- [{'polygon': [[0, 0], [0, 0], {2: 'trash', 3: 'trash'}], 'text': '...'}],
- [{'polygon': [[0, 0], [0, 0], 5], 'text': '...'}],
- [{'polygon': [[0, 0], [0, 0], [0, 2]], 'text': '...'}],
- [{'polygon': [[0, 0], [0, 0], [0, '...']], 'text': '...'}],
- [{'polygon': [[0, 0], [0, 0], [0, 0, 0]], 'text': '...'}],
- [{'polygon': [[0, 0], [0, 0], [0]], 'text': '...'}],
- [{'polygon': [[0, 0], [0, 0], [0, 1]], 'text': ''}],
- [{'polygon': [[0, 0], [0, 0], [0, 1]], 'text': None}],
- [{'polygon': [[0, 0], [0, 0], [0, 1]]}],
-])
+@pytest.mark.parametrize(
+ "input",
+ [
+ [{"text": "..."}],
+ [{"polygon": None, "text": "..."}],
+ [{"polygon": "trash", "text": "..."}],
+ [{"polygon": ["trash", "trash", "trash"], "text": "..."}],
+ [{"polygon": {2: "trash", 3: "trash", 4: "trash"}, "text": "..."}],
+ [{"polygon": [[0, 0]], "text": "..."}],
+ [{"polygon": [[0, 0], [0, 0], None], "text": "..."}],
+ [{"polygon": [[0, 0], [0, 0], "surprise"], "text": "..."}],
+ [
+ {
+ "polygon": [[0, 0], [0, 0], {2: "trash", 3: "trash"}],
+ "text": "...",
+ }
+ ],
+ [{"polygon": [[0, 0], [0, 0], 5], "text": "..."}],
+ [{"polygon": [[0, 0], [0, 0], [0, 2]], "text": "..."}],
+ [{"polygon": [[0, 0], [0, 0], [0, "..."]], "text": "..."}],
+ [{"polygon": [[0, 0], [0, 0], [0, 0, 0]], "text": "..."}],
+ [{"polygon": [[0, 0], [0, 0], [0]], "text": "..."}],
+ [{"polygon": [[0, 0], [0, 0], [0, 1]], "text": ""}],
+ [{"polygon": [[0, 0], [0, 0], [0, 1]], "text": None}],
+ [{"polygon": [[0, 0], [0, 0], [0, 1]]}],
+ ],
+)
def test_update_post_notes_with_invalid_content(input):
post = model.Post()
with pytest.raises(posts.InvalidPostNoteError):
@@ -726,14 +791,14 @@ def test_update_post_notes_with_invalid_content(input):
def test_update_post_flags():
post = model.Post()
- posts.update_post_flags(post, ['loop'])
- assert post.flags == ['loop']
+ posts.update_post_flags(post, ["loop"])
+ assert post.flags == ["loop"]
def test_update_post_flags_with_invalid_content():
post = model.Post()
with pytest.raises(posts.InvalidPostFlagError):
- posts.update_post_flags(post, ['invalid'])
+ posts.update_post_flags(post, ["invalid"])
def test_feature_post(post_factory, user_factory):
@@ -749,7 +814,7 @@ def test_feature_post(post_factory, user_factory):
def test_delete(post_factory, config_injector):
- config_injector({'delete_source_files': False})
+ config_injector({"delete_source_files": False})
post = post_factory()
db.session.add(post)
db.session.flush()
@@ -760,7 +825,7 @@ def test_delete(post_factory, config_injector):
def test_merge_posts_deletes_source_post(post_factory, config_injector):
- config_injector({'delete_source_files': False})
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
db.session.add_all([source_post, target_post])
@@ -773,7 +838,7 @@ def test_merge_posts_deletes_source_post(post_factory, config_injector):
def test_merge_posts_with_itself(post_factory, config_injector):
- config_injector({'delete_source_files': False})
+ config_injector({"delete_source_files": False})
source_post = post_factory()
db.session.add(source_post)
db.session.flush()
@@ -782,7 +847,7 @@ def test_merge_posts_with_itself(post_factory, config_injector):
def test_merge_posts_moves_tags(post_factory, tag_factory, config_injector):
- config_injector({'delete_source_files': False})
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
tag = tag_factory()
@@ -798,8 +863,9 @@ def test_merge_posts_moves_tags(post_factory, tag_factory, config_injector):
def test_merge_posts_doesnt_duplicate_tags(
- post_factory, tag_factory, config_injector):
- config_injector({'delete_source_files': False})
+ post_factory, tag_factory, config_injector
+):
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
tag = tag_factory()
@@ -815,8 +881,9 @@ def test_merge_posts_doesnt_duplicate_tags(
def test_merge_posts_moves_comments(
- post_factory, comment_factory, config_injector):
- config_injector({'delete_source_files': False})
+ post_factory, comment_factory, config_injector
+):
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
comment = comment_factory(post=source_post)
@@ -831,8 +898,9 @@ def test_merge_posts_moves_comments(
def test_merge_posts_moves_scores(
- post_factory, post_score_factory, config_injector):
- config_injector({'delete_source_files': False})
+ post_factory, post_score_factory, config_injector
+):
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
score = post_score_factory(post=source_post, score=1)
@@ -847,8 +915,9 @@ def test_merge_posts_moves_scores(
def test_merge_posts_doesnt_duplicate_scores(
- post_factory, user_factory, post_score_factory, config_injector):
- config_injector({'delete_source_files': False})
+ post_factory, user_factory, post_score_factory, config_injector
+):
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
user = user_factory()
@@ -865,8 +934,9 @@ def test_merge_posts_doesnt_duplicate_scores(
def test_merge_posts_moves_favorites(
- post_factory, post_favorite_factory, config_injector):
- config_injector({'delete_source_files': False})
+ post_factory, post_favorite_factory, config_injector
+):
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
favorite = post_favorite_factory(post=source_post)
@@ -881,8 +951,9 @@ def test_merge_posts_moves_favorites(
def test_merge_posts_doesnt_duplicate_favorites(
- post_factory, user_factory, post_favorite_factory, config_injector):
- config_injector({'delete_source_files': False})
+ post_factory, user_factory, post_favorite_factory, config_injector
+):
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
user = user_factory()
@@ -899,7 +970,7 @@ def test_merge_posts_doesnt_duplicate_favorites(
def test_merge_posts_moves_child_relations(post_factory, config_injector):
- config_injector({'delete_source_files': False})
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
related_post = post_factory()
@@ -915,8 +986,9 @@ def test_merge_posts_moves_child_relations(post_factory, config_injector):
def test_merge_posts_doesnt_duplicate_child_relations(
- post_factory, config_injector):
- config_injector({'delete_source_files': False})
+ post_factory, config_injector
+):
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
related_post = post_factory()
@@ -933,7 +1005,7 @@ def test_merge_posts_doesnt_duplicate_child_relations(
def test_merge_posts_moves_parent_relations(post_factory, config_injector):
- config_injector({'delete_source_files': False})
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
related_post = post_factory()
@@ -951,8 +1023,9 @@ def test_merge_posts_moves_parent_relations(post_factory, config_injector):
def test_merge_posts_doesnt_duplicate_parent_relations(
- post_factory, config_injector):
- config_injector({'delete_source_files': False})
+ post_factory, config_injector
+):
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
related_post = post_factory()
@@ -970,8 +1043,9 @@ def test_merge_posts_doesnt_duplicate_parent_relations(
def test_merge_posts_doesnt_create_relation_loop_for_children(
- post_factory, config_injector):
- config_injector({'delete_source_files': False})
+ post_factory, config_injector
+):
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
source_post.relations = [target_post]
@@ -986,8 +1060,9 @@ def test_merge_posts_doesnt_create_relation_loop_for_children(
def test_merge_posts_doesnt_create_relation_loop_for_parents(
- post_factory, config_injector):
- config_injector({'delete_source_files': False})
+ post_factory, config_injector
+):
+ config_injector({"delete_source_files": False})
source_post = post_factory()
target_post = post_factory()
target_post.relations = [source_post]
@@ -1002,30 +1077,33 @@ def test_merge_posts_doesnt_create_relation_loop_for_parents(
def test_merge_posts_replaces_content(
- post_factory, config_injector, tmpdir, read_asset):
- config_injector({
- 'data_dir': str(tmpdir.mkdir('data')),
- 'data_url': 'example.com',
- 'delete_source_files': False,
- 'thumbnails': {
- 'post_width': 300,
- 'post_height': 300,
- },
- 'secret': 'test',
- })
+ post_factory, config_injector, tmpdir, read_asset
+):
+ config_injector(
+ {
+ "data_dir": str(tmpdir.mkdir("data")),
+ "data_url": "example.com",
+ "delete_source_files": False,
+ "thumbnails": {"post_width": 300, "post_height": 300,},
+ "secret": "test",
+ }
+ )
source_post = post_factory(id=1)
target_post = post_factory(id=2)
- content = read_asset('png.png')
+ content = read_asset("png.png")
db.session.add_all([source_post, target_post])
db.session.commit()
posts.update_post_content(source_post, content)
db.session.flush()
- source_path = (
- os.path.join('{}/data/posts/1_244c8840887984c4.png'.format(tmpdir)))
- target_path1 = (
- os.path.join('{}/data/posts/2_49caeb3ec1643406.png'.format(tmpdir)))
- target_path2 = (
- os.path.join('{}/data/posts/2_49caeb3ec1643406.dat'.format(tmpdir)))
+ source_path = os.path.join(
+ "{}/data/posts/1_244c8840887984c4.png".format(tmpdir)
+ )
+ target_path1 = os.path.join(
+ "{}/data/posts/2_49caeb3ec1643406.png".format(tmpdir)
+ )
+ target_path2 = os.path.join(
+ "{}/data/posts/2_49caeb3ec1643406.dat".format(tmpdir)
+ )
assert os.path.exists(source_path)
assert not os.path.exists(target_path1)
assert not os.path.exists(target_path2)
@@ -1040,16 +1118,16 @@ def test_merge_posts_replaces_content(
def test_search_by_image(post_factory, config_injector, read_asset):
- config_injector({'allow_broken_uploads': False})
+ config_injector({"allow_broken_uploads": False})
post = post_factory()
- posts.generate_post_signature(post, read_asset('jpeg.jpg'))
+ posts.generate_post_signature(post, read_asset("jpeg.jpg"))
db.session.flush()
- result1 = posts.search_by_image(read_asset('jpeg-similar.jpg'))
+ result1 = posts.search_by_image(read_asset("jpeg-similar.jpg"))
assert len(result1) == 1
result1_distance, result1_post = result1[0]
assert abs(result1_distance - 0.19713075553164386) < 1e-8
assert result1_post.post_id == post.post_id
- result2 = posts.search_by_image(read_asset('png.png'))
+ result2 = posts.search_by_image(read_asset("png.png"))
assert not result2
diff --git a/server/szurubooru/tests/func/test_snapshots.py b/server/szurubooru/tests/func/test_snapshots.py
index 053cf982..b4dda1cc 100644
--- a/server/szurubooru/tests/func/test_snapshots.py
+++ b/server/szurubooru/tests/func/test_snapshots.py
@@ -1,55 +1,57 @@
-from unittest.mock import patch
from datetime import datetime
+from unittest.mock import patch
+
import pytest
+
from szurubooru import db, model
from szurubooru.func import snapshots, users
def test_get_tag_category_snapshot(tag_category_factory):
- category = tag_category_factory(name='name', color='color')
+ category = tag_category_factory(name="name", color="color")
assert snapshots.get_tag_category_snapshot(category) == {
- 'name': 'name',
- 'color': 'color',
- 'default': False,
+ "name": "name",
+ "color": "color",
+ "default": False,
}
category.default = True
assert snapshots.get_tag_category_snapshot(category) == {
- 'name': 'name',
- 'color': 'color',
- 'default': True,
+ "name": "name",
+ "color": "color",
+ "default": True,
}
def test_get_tag_snapshot(tag_factory, tag_category_factory):
- category = tag_category_factory(name='dummy')
- tag = tag_factory(names=['main_name', 'alias'], category=category)
+ category = tag_category_factory(name="dummy")
+ tag = tag_factory(names=["main_name", "alias"], category=category)
assert snapshots.get_tag_snapshot(tag) == {
- 'names': ['main_name', 'alias'],
- 'category': 'dummy',
- 'suggestions': [],
- 'implications': [],
+ "names": ["main_name", "alias"],
+ "category": "dummy",
+ "suggestions": [],
+ "implications": [],
}
- tag = tag_factory(names=['main_name', 'alias'], category=category)
- imp1 = tag_factory(names=['imp1_main_name', 'imp1_alias'])
- imp2 = tag_factory(names=['imp2_main_name', 'imp2_alias'])
- sug1 = tag_factory(names=['sug1_main_name', 'sug1_alias'])
- sug2 = tag_factory(names=['sug2_main_name', 'sug2_alias'])
+ tag = tag_factory(names=["main_name", "alias"], category=category)
+ imp1 = tag_factory(names=["imp1_main_name", "imp1_alias"])
+ imp2 = tag_factory(names=["imp2_main_name", "imp2_alias"])
+ sug1 = tag_factory(names=["sug1_main_name", "sug1_alias"])
+ sug2 = tag_factory(names=["sug2_main_name", "sug2_alias"])
db.session.add_all([imp1, imp2, sug1, sug2])
tag.implications = [imp1, imp2]
tag.suggestions = [sug1, sug2]
db.session.flush()
assert snapshots.get_tag_snapshot(tag) == {
- 'names': ['main_name', 'alias'],
- 'category': 'dummy',
- 'implications': ['imp1_main_name', 'imp2_main_name'],
- 'suggestions': ['sug1_main_name', 'sug2_main_name'],
+ "names": ["main_name", "alias"],
+ "category": "dummy",
+ "implications": ["imp1_main_name", "imp2_main_name"],
+ "suggestions": ["sug1_main_name", "sug2_main_name"],
}
def test_get_post_snapshot(post_factory, user_factory, tag_factory):
- user = user_factory(name='dummy-user')
- tag1 = tag_factory(names=['dummy-tag1'])
- tag2 = tag_factory(names=['dummy-tag2'])
+ user = user_factory(name="dummy-user")
+ tag1 = tag_factory(names=["dummy-tag1"])
+ tag2 = tag_factory(names=["dummy-tag2"])
post = post_factory(id=1)
related_post1 = post_factory(id=2)
related_post2 = post_factory(id=3)
@@ -72,13 +74,13 @@ def test_get_post_snapshot(post_factory, user_factory, tag_factory):
note = model.PostNote()
note.post = post
note.polygon = [(1, 1), (200, 1), (200, 200), (1, 200)]
- note.text = 'some text'
+ note.text = "some text"
db.session.add_all([score])
db.session.flush()
post.user = user
- post.checksum = 'deadbeef'
- post.source = 'example.com'
+ post.checksum = "deadbeef"
+ post.source = "example.com"
post.tags.append(tag1)
post.tags.append(tag2)
post.relations.append(related_post1)
@@ -89,17 +91,19 @@ def test_get_post_snapshot(post_factory, user_factory, tag_factory):
post.notes.append(note)
assert snapshots.get_post_snapshot(post) == {
- 'checksum': 'deadbeef',
- 'featured': True,
- 'flags': [],
- 'notes': [{
- 'polygon': [[1, 1], [200, 1], [200, 200], [1, 200]],
- 'text': 'some text',
- }],
- 'relations': [2, 3],
- 'safety': 'safe',
- 'source': 'example.com',
- 'tags': ['dummy-tag1', 'dummy-tag2'],
+ "checksum": "deadbeef",
+ "featured": True,
+ "flags": [],
+ "notes": [
+ {
+ "polygon": [[1, 1], [200, 1], [200, 200], [1, 200]],
+ "text": "some text",
+ }
+ ],
+ "relations": [2, 3],
+ "safety": "safe",
+ "source": "example.com",
+ "tags": ["dummy-tag1", "dummy-tag2"],
}
@@ -107,75 +111,78 @@ def test_serialize_snapshot(user_factory):
auth_user = user_factory()
snapshot = model.Snapshot()
snapshot.operation = snapshot.OPERATION_CREATED
- snapshot.resource_type = 'type'
- snapshot.resource_name = 'id'
- snapshot.user = user_factory(name='issuer')
- snapshot.data = {'complex': list('object')}
+ snapshot.resource_type = "type"
+ snapshot.resource_name = "id"
+ snapshot.user = user_factory(name="issuer")
+ snapshot.data = {"complex": list("object")}
snapshot.creation_time = datetime(1997, 1, 1)
- with patch('szurubooru.func.users.serialize_micro_user'):
- users.serialize_micro_user.return_value = 'mocked'
+ with patch("szurubooru.func.users.serialize_micro_user"):
+ users.serialize_micro_user.return_value = "mocked"
assert snapshots.serialize_snapshot(snapshot, auth_user) == {
- 'operation': 'created',
- 'type': 'type',
- 'id': 'id',
- 'user': 'mocked',
- 'data': {'complex': list('object')},
- 'time': datetime(1997, 1, 1),
+ "operation": "created",
+ "type": "type",
+ "id": "id",
+ "user": "mocked",
+ "data": {"complex": list("object")},
+ "time": datetime(1997, 1, 1),
}
def test_create(tag_factory, user_factory):
- tag = tag_factory(names=['dummy'])
+ tag = tag_factory(names=["dummy"])
db.session.add(tag)
db.session.flush()
- with patch('szurubooru.func.snapshots.get_tag_snapshot'):
- snapshots.get_tag_snapshot.return_value = 'mocked'
+ with patch("szurubooru.func.snapshots.get_tag_snapshot"):
+ snapshots.get_tag_snapshot.return_value = "mocked"
snapshots.create(tag, user_factory())
db.session.flush()
results = db.session.query(model.Snapshot).all()
assert len(results) == 1
assert results[0].operation == model.Snapshot.OPERATION_CREATED
- assert results[0].data == 'mocked'
+ assert results[0].data == "mocked"
def test_modify_saves_non_empty_diffs(post_factory, user_factory):
- if 'sqlite' in db.session.get_bind().driver:
+ if "sqlite" in db.session.get_bind().driver:
pytest.xfail(
- 'SQLite doesn\'t support transaction isolation, '
- 'which is required to retrieve original entity')
+ "SQLite doesn't support transaction isolation, "
+ "which is required to retrieve original entity"
+ )
post = post_factory()
- post.notes = [model.PostNote(polygon=[(0, 0), (0, 1), (1, 1)], text='old')]
+ post.notes = [model.PostNote(polygon=[(0, 0), (0, 1), (1, 1)], text="old")]
user = user_factory()
db.session.add_all([post, user])
db.session.commit()
- post.source = 'new source'
- post.notes = [model.PostNote(polygon=[(0, 0), (0, 1), (1, 1)], text='new')]
+ post.source = "new source"
+ post.notes = [model.PostNote(polygon=[(0, 0), (0, 1), (1, 1)], text="new")]
db.session.flush()
snapshots.modify(post, user)
db.session.flush()
results = db.session.query(model.Snapshot).all()
assert len(results) == 1
assert results[0].data == {
- 'type': 'object change',
- 'value': {
- 'source': {
- 'type': 'primitive change',
- 'old-value': None,
- 'new-value': 'new source',
+ "type": "object change",
+ "value": {
+ "source": {
+ "type": "primitive change",
+ "old-value": None,
+ "new-value": "new source",
},
- 'notes': {
- 'type': 'list change',
- 'removed': [
- {'polygon': [[0, 0], [0, 1], [1, 1]], 'text': 'old'}],
- 'added': [
- {'polygon': [[0, 0], [0, 1], [1, 1]], 'text': 'new'}],
+ "notes": {
+ "type": "list change",
+ "removed": [
+ {"polygon": [[0, 0], [0, 1], [1, 1]], "text": "old"}
+ ],
+ "added": [
+ {"polygon": [[0, 0], [0, 1], [1, 1]], "text": "new"}
+ ],
},
},
}
def test_modify_doesnt_save_empty_diffs(tag_factory, user_factory):
- tag = tag_factory(names=['dummy'])
+ tag = tag_factory(names=["dummy"])
user = user_factory()
db.session.add_all([tag, user])
db.session.commit()
@@ -185,26 +192,26 @@ def test_modify_doesnt_save_empty_diffs(tag_factory, user_factory):
def test_delete(tag_factory, user_factory):
- tag = tag_factory(names=['dummy'])
+ tag = tag_factory(names=["dummy"])
db.session.add(tag)
db.session.flush()
- with patch('szurubooru.func.snapshots.get_tag_snapshot'):
- snapshots.get_tag_snapshot.return_value = 'mocked'
+ with patch("szurubooru.func.snapshots.get_tag_snapshot"):
+ snapshots.get_tag_snapshot.return_value = "mocked"
snapshots.delete(tag, user_factory())
db.session.flush()
results = db.session.query(model.Snapshot).all()
assert len(results) == 1
assert results[0].operation == model.Snapshot.OPERATION_DELETED
- assert results[0].data == 'mocked'
+ assert results[0].data == "mocked"
def test_merge(tag_factory, user_factory):
- source_tag = tag_factory(names=['source'])
- target_tag = tag_factory(names=['target'])
+ source_tag = tag_factory(names=["source"])
+ target_tag = tag_factory(names=["target"])
db.session.add_all([source_tag, target_tag])
db.session.flush()
snapshots.merge(source_tag, target_tag, user_factory())
db.session.flush()
result = db.session.query(model.Snapshot).one()
assert result.operation == model.Snapshot.OPERATION_MERGED
- assert result.data == ['tag', 'target']
+ assert result.data == ["tag", "target"]
diff --git a/server/szurubooru/tests/func/test_tag_categories.py b/server/szurubooru/tests/func/test_tag_categories.py
index d8867034..143cc49f 100644
--- a/server/szurubooru/tests/func/test_tag_categories.py
+++ b/server/szurubooru/tests/func/test_tag_categories.py
@@ -1,7 +1,9 @@
from unittest.mock import patch
+
import pytest
+
from szurubooru import db, model
-from szurubooru.func import tag_categories, cache
+from szurubooru.func import cache, tag_categories
@pytest.fixture(autouse=True)
@@ -14,7 +16,7 @@ def test_serialize_category_when_empty():
def test_serialize_category(tag_category_factory, tag_factory):
- category = tag_category_factory(name='name', color='color')
+ category = tag_category_factory(name="name", color="color")
category.category_id = 1
category.default = True
tag1 = tag_factory(category=category)
@@ -23,36 +25,42 @@ def test_serialize_category(tag_category_factory, tag_factory):
db.session.flush()
result = tag_categories.serialize_category(category)
assert result == {
- 'name': 'name',
- 'color': 'color',
- 'default': True,
- 'version': 1,
- 'usages': 2,
+ "name": "name",
+ "color": "color",
+ "default": True,
+ "version": 1,
+ "usages": 2,
}
def test_create_category_when_first():
- with patch('szurubooru.func.tag_categories.update_category_name'), \
- patch('szurubooru.func.tag_categories.update_category_color'):
- category = tag_categories.create_category('name', 'color')
+ with patch("szurubooru.func.tag_categories.update_category_name"), patch(
+ "szurubooru.func.tag_categories.update_category_color"
+ ):
+ category = tag_categories.create_category("name", "color")
assert category.default
- tag_categories.update_category_name \
- .assert_called_once_with(category, 'name')
- tag_categories.update_category_color \
- .assert_called_once_with(category, 'color')
+ tag_categories.update_category_name.assert_called_once_with(
+ category, "name"
+ )
+ tag_categories.update_category_color.assert_called_once_with(
+ category, "color"
+ )
def test_create_category_when_subsequent(tag_category_factory):
db.session.add(tag_category_factory())
db.session.flush()
- with patch('szurubooru.func.tag_categories.update_category_name'), \
- patch('szurubooru.func.tag_categories.update_category_color'):
- category = tag_categories.create_category('name', 'color')
+ with patch("szurubooru.func.tag_categories.update_category_name"), patch(
+ "szurubooru.func.tag_categories.update_category_color"
+ ):
+ category = tag_categories.create_category("name", "color")
assert not category.default
- tag_categories.update_category_name \
- .assert_called_once_with(category, 'name')
- tag_categories.update_category_color \
- .assert_called_once_with(category, 'color')
+ tag_categories.update_category_name.assert_called_once_with(
+ category, "name"
+ )
+ tag_categories.update_category_color.assert_called_once_with(
+ category, "color"
+ )
def test_update_category_name_with_empty_string(tag_category_factory):
@@ -62,38 +70,42 @@ def test_update_category_name_with_empty_string(tag_category_factory):
def test_update_category_name_with_invalid_name(
- config_injector, tag_category_factory):
- config_injector({'tag_category_name_regex': '^[a-z]+$'})
+ config_injector, tag_category_factory
+):
+ config_injector({"tag_category_name_regex": "^[a-z]+$"})
category = tag_category_factory()
with pytest.raises(tag_categories.InvalidTagCategoryNameError):
- tag_categories.update_category_name(category, '0')
+ tag_categories.update_category_name(category, "0")
def test_update_category_name_with_too_long_string(
- config_injector, tag_category_factory):
- config_injector({'tag_category_name_regex': '^[a-z]+$'})
+ config_injector, tag_category_factory
+):
+ config_injector({"tag_category_name_regex": "^[a-z]+$"})
category = tag_category_factory()
with pytest.raises(tag_categories.InvalidTagCategoryNameError):
- tag_categories.update_category_name(category, 'a' * 3000)
+ tag_categories.update_category_name(category, "a" * 3000)
def test_update_category_name_reusing_other_name(
- config_injector, tag_category_factory):
- config_injector({'tag_category_name_regex': '.*'})
- db.session.add(tag_category_factory(name='name'))
+ config_injector, tag_category_factory
+):
+ config_injector({"tag_category_name_regex": ".*"})
+ db.session.add(tag_category_factory(name="name"))
db.session.flush()
category = tag_category_factory()
with pytest.raises(tag_categories.TagCategoryAlreadyExistsError):
- tag_categories.update_category_name(category, 'name')
+ tag_categories.update_category_name(category, "name")
with pytest.raises(tag_categories.TagCategoryAlreadyExistsError):
- tag_categories.update_category_name(category, 'NAME')
+ tag_categories.update_category_name(category, "NAME")
def test_update_category_name_reusing_own_name(
- config_injector, tag_category_factory):
- config_injector({'tag_category_name_regex': '.*'})
- for name in ['name', 'NAME']:
- category = tag_category_factory(name='name')
+ config_injector, tag_category_factory
+):
+ config_injector({"tag_category_name_regex": ".*"})
+ for name in ["name", "NAME"]:
+ category = tag_category_factory(name="name")
db.session.add(category)
db.session.flush()
tag_categories.update_category_name(category, name)
@@ -110,16 +122,16 @@ def test_update_category_color_with_empty_string(tag_category_factory):
def test_update_category_color_with_too_long_string(tag_category_factory):
category = tag_category_factory()
with pytest.raises(tag_categories.InvalidTagCategoryColorError):
- tag_categories.update_category_color(category, 'a' * 3000)
+ tag_categories.update_category_color(category, "a" * 3000)
def test_update_category_color_with_invalid_string(tag_category_factory):
category = tag_category_factory()
with pytest.raises(tag_categories.InvalidTagCategoryColorError):
- tag_categories.update_category_color(category, 'NOPE')
+ tag_categories.update_category_color(category, "NOPE")
-@pytest.mark.parametrize('attempt', ['#aaaaaa', '#012345', '012345', 'red'])
+@pytest.mark.parametrize("attempt", ["#aaaaaa", "#012345", "012345", "red"])
def test_update_category_color(attempt, tag_category_factory):
category = tag_category_factory()
tag_categories.update_category_color(category, attempt)
@@ -127,35 +139,35 @@ def test_update_category_color(attempt, tag_category_factory):
def test_try_get_category_by_name(tag_category_factory):
- category = tag_category_factory(name='test')
+ category = tag_category_factory(name="test")
db.session.add(category)
db.session.flush()
- assert tag_categories.try_get_category_by_name('test') == category
- assert tag_categories.try_get_category_by_name('TEST') == category
- assert tag_categories.try_get_category_by_name('-') is None
+ assert tag_categories.try_get_category_by_name("test") == category
+ assert tag_categories.try_get_category_by_name("TEST") == category
+ assert tag_categories.try_get_category_by_name("-") is None
def test_get_category_by_name(tag_category_factory):
- category = tag_category_factory(name='test')
+ category = tag_category_factory(name="test")
db.session.add(category)
db.session.flush()
- assert tag_categories.get_category_by_name('test') == category
- assert tag_categories.get_category_by_name('TEST') == category
+ assert tag_categories.get_category_by_name("test") == category
+ assert tag_categories.get_category_by_name("TEST") == category
with pytest.raises(tag_categories.TagCategoryNotFoundError):
- tag_categories.get_category_by_name('-')
+ tag_categories.get_category_by_name("-")
def test_get_all_category_names(tag_category_factory):
- category1 = tag_category_factory(name='cat1')
- category2 = tag_category_factory(name='cat2')
+ category1 = tag_category_factory(name="cat1")
+ category2 = tag_category_factory(name="cat2")
db.session.add_all([category2, category1])
db.session.flush()
- assert tag_categories.get_all_category_names() == ['cat1', 'cat2']
+ assert tag_categories.get_all_category_names() == ["cat1", "cat2"]
def test_get_all_categories(tag_category_factory):
- category1 = tag_category_factory(name='cat1')
- category2 = tag_category_factory(name='cat2')
+ category1 = tag_category_factory(name="cat1")
+ category2 = tag_category_factory(name="cat2")
db.session.add_all([category2, category1])
db.session.flush()
assert tag_categories.get_all_categories() == [category1, category2]
@@ -211,12 +223,12 @@ def test_get_default_category_name_caching(tag_category_factory):
def test_get_default_category():
- with patch('szurubooru.func.tag_categories.try_get_default_category'):
+ with patch("szurubooru.func.tag_categories.try_get_default_category"):
tag_categories.try_get_default_category.return_value = None
with pytest.raises(tag_categories.TagCategoryNotFoundError):
tag_categories.get_default_category()
- tag_categories.try_get_default_category.return_value = 'mocked'
- assert tag_categories.get_default_category() == 'mocked'
+ tag_categories.try_get_default_category.return_value = "mocked"
+ assert tag_categories.get_default_category() == "mocked"
def test_set_default_category_with_previous_default(tag_category_factory):
@@ -257,9 +269,9 @@ def test_delete_category_with_usages(tag_category_factory, tag_factory):
def test_delete_category(tag_category_factory):
db.session.add(tag_category_factory())
- category = tag_category_factory(name='target')
+ category = tag_category_factory(name="target")
db.session.add(category)
db.session.flush()
tag_categories.delete_category(category)
db.session.flush()
- assert tag_categories.try_get_category_by_name('target') is None
+ assert tag_categories.try_get_category_by_name("target") is None
diff --git a/server/szurubooru/tests/func/test_tags.py b/server/szurubooru/tests/func/test_tags.py
index 673e37f8..ac8963c7 100644
--- a/server/szurubooru/tests/func/test_tags.py
+++ b/server/szurubooru/tests/func/test_tags.py
@@ -1,10 +1,12 @@
-import os
import json
-from unittest.mock import patch
+import os
from datetime import datetime
+from unittest.mock import patch
+
import pytest
+
from szurubooru import db, model
-from szurubooru.func import tags, tag_categories, cache
+from szurubooru.func import cache, tag_categories, tags
@pytest.fixture(autouse=True)
@@ -14,18 +16,35 @@ def purge_cache():
def _assert_tag_siblings(result, expected_names_and_occurrences):
actual_names_and_occurences = [
- (tag.names[0].name, occurrences) for tag, occurrences in result]
+ (tag.names[0].name, occurrences) for tag, occurrences in result
+ ]
assert actual_names_and_occurences == expected_names_and_occurrences
-@pytest.mark.parametrize('input,expected_tag_names', [
- ([('a', 'a', True), ('b', 'b', False), ('c', 'c', False)], list('bca')),
- ([('c', 'a', True), ('b', 'b', False), ('a', 'c', False)], list('bac')),
- ([('a', 'c', True), ('b', 'b', False), ('c', 'a', False)], list('cba')),
- ([('a', 'c', False), ('b', 'b', False), ('c', 'a', True)], list('bac')),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ (
+ [("a", "a", True), ("b", "b", False), ("c", "c", False)],
+ list("bca"),
+ ),
+ (
+ [("c", "a", True), ("b", "b", False), ("a", "c", False)],
+ list("bac"),
+ ),
+ (
+ [("a", "c", True), ("b", "b", False), ("c", "a", False)],
+ list("cba"),
+ ),
+ (
+ [("a", "c", False), ("b", "b", False), ("c", "a", True)],
+ list("bac"),
+ ),
+ ],
+)
def test_sort_tags(
- input, expected_tag_names, tag_factory, tag_category_factory):
+ input, expected_tag_names, tag_factory, tag_category_factory
+):
db_tags = []
for tag in input:
tag_name, category_name, category_is_default = tag
@@ -33,7 +52,10 @@ def test_sort_tags(
tag_factory(
names=[tag_name],
category=tag_category_factory(
- name=category_name, default=category_is_default)))
+ name=category_name, default=category_is_default
+ ),
+ )
+ )
db.session.add_all(db_tags)
db.session.flush()
actual_tag_names = [tag.names[0].name for tag in tags.sort_tags(db_tags)]
@@ -45,17 +67,17 @@ def test_serialize_tag_when_empty():
def test_serialize_tag(post_factory, tag_factory, tag_category_factory):
- cat = tag_category_factory(name='cat')
- tag = tag_factory(names=['tag1', 'tag2'], category=cat)
+ cat = tag_category_factory(name="cat")
+ tag = tag_factory(names=["tag1", "tag2"], category=cat)
# tag.tag_id = 1
- tag.description = 'description'
+ tag.description = "description"
tag.suggestions = [
- tag_factory(names=['sug1'], category=cat),
- tag_factory(names=['sug2'], category=cat),
+ tag_factory(names=["sug1"], category=cat),
+ tag_factory(names=["sug2"], category=cat),
]
tag.implications = [
- tag_factory(names=['impl1'], category=cat),
- tag_factory(names=['impl2'], category=cat),
+ tag_factory(names=["impl1"], category=cat),
+ tag_factory(names=["impl2"], category=cat),
]
tag.last_edit_time = datetime(1998, 1, 1)
@@ -67,36 +89,39 @@ def test_serialize_tag(post_factory, tag_factory, tag_category_factory):
db.session.flush()
result = tags.serialize_tag(tag)
- result['suggestions'].sort(key=lambda relation: relation['names'][0])
- result['implications'].sort(key=lambda relation: relation['names'][0])
+ result["suggestions"].sort(key=lambda relation: relation["names"][0])
+ result["implications"].sort(key=lambda relation: relation["names"][0])
assert result == {
- 'names': ['tag1', 'tag2'],
- 'version': 1,
- 'category': 'cat',
- 'creationTime': datetime(1996, 1, 1, 0, 0),
- 'lastEditTime': datetime(1998, 1, 1, 0, 0),
- 'description': 'description',
- 'suggestions': [
- {'names': ['sug1'], 'category': 'cat', 'usages': 0},
- {'names': ['sug2'], 'category': 'cat', 'usages': 0},
+ "names": ["tag1", "tag2"],
+ "version": 1,
+ "category": "cat",
+ "creationTime": datetime(1996, 1, 1, 0, 0),
+ "lastEditTime": datetime(1998, 1, 1, 0, 0),
+ "description": "description",
+ "suggestions": [
+ {"names": ["sug1"], "category": "cat", "usages": 0},
+ {"names": ["sug2"], "category": "cat", "usages": 0},
],
- 'implications': [
- {'names': ['impl1'], 'category': 'cat', 'usages': 0},
- {'names': ['impl2'], 'category': 'cat', 'usages': 0},
+ "implications": [
+ {"names": ["impl1"], "category": "cat", "usages": 0},
+ {"names": ["impl2"], "category": "cat", "usages": 0},
],
- 'usages': 2,
+ "usages": 2,
}
-@pytest.mark.parametrize('name_to_search,expected_to_find', [
- ('name', True),
- ('NAME', True),
- ('alias', True),
- ('ALIAS', True),
- ('-', False),
-])
+@pytest.mark.parametrize(
+ "name_to_search,expected_to_find",
+ [
+ ("name", True),
+ ("NAME", True),
+ ("alias", True),
+ ("ALIAS", True),
+ ("-", False),
+ ],
+)
def test_try_get_tag_by_name(name_to_search, expected_to_find, tag_factory):
- tag = tag_factory(names=['name', 'ALIAS'])
+ tag = tag_factory(names=["name", "ALIAS"])
db.session.add(tag)
db.session.flush()
if expected_to_find:
@@ -105,15 +130,18 @@ def test_try_get_tag_by_name(name_to_search, expected_to_find, tag_factory):
assert tags.try_get_tag_by_name(name_to_search) is None
-@pytest.mark.parametrize('name_to_search,expected_to_find', [
- ('name', True),
- ('NAME', True),
- ('alias', True),
- ('ALIAS', True),
- ('-', False),
-])
+@pytest.mark.parametrize(
+ "name_to_search,expected_to_find",
+ [
+ ("name", True),
+ ("NAME", True),
+ ("alias", True),
+ ("ALIAS", True),
+ ("-", False),
+ ],
+)
def test_get_tag_by_name(name_to_search, expected_to_find, tag_factory):
- tag = tag_factory(names=['name', 'ALIAS'])
+ tag = tag_factory(names=["name", "ALIAS"])
db.session.add(tag)
db.session.flush()
if expected_to_find:
@@ -123,25 +151,28 @@ def test_get_tag_by_name(name_to_search, expected_to_find, tag_factory):
tags.get_tag_by_name(name_to_search)
-@pytest.mark.parametrize('names,expected_indexes', [
- ([], []),
- (['name1'], [0]),
- (['NAME1'], [0]),
- (['alias1'], [0]),
- (['ALIAS1'], [0]),
- (['name2'], [1]),
- (['name1', 'name1'], [0]),
- (['name1', 'NAME1'], [0]),
- (['name1', 'alias1'], [0]),
- (['name1', 'alias2'], [0, 1]),
- (['NAME1', 'alias2'], [0, 1]),
- (['name1', 'ALIAS2'], [0, 1]),
- (['name2', 'alias1'], [0, 1]),
-])
+@pytest.mark.parametrize(
+ "names,expected_indexes",
+ [
+ ([], []),
+ (["name1"], [0]),
+ (["NAME1"], [0]),
+ (["alias1"], [0]),
+ (["ALIAS1"], [0]),
+ (["name2"], [1]),
+ (["name1", "name1"], [0]),
+ (["name1", "NAME1"], [0]),
+ (["name1", "alias1"], [0]),
+ (["name1", "alias2"], [0, 1]),
+ (["NAME1", "alias2"], [0, 1]),
+ (["name1", "ALIAS2"], [0, 1]),
+ (["name2", "alias1"], [0, 1]),
+ ],
+)
def test_get_tag_by_names(names, expected_indexes, tag_factory):
input_tags = [
- tag_factory(names=['name1', 'ALIAS1']),
- tag_factory(names=['name2', 'ALIAS2']),
+ tag_factory(names=["name1", "ALIAS1"]),
+ tag_factory(names=["name2", "ALIAS2"]),
]
db.session.add_all(input_tags)
db.session.flush()
@@ -151,49 +182,52 @@ def test_get_tag_by_names(names, expected_indexes, tag_factory):
@pytest.mark.parametrize(
- 'names,expected_indexes,expected_created_names', [
+ "names,expected_indexes,expected_created_names",
+ [
([], [], []),
- (['name1'], [0], []),
- (['NAME1'], [0], []),
- (['alias1'], [0], []),
- (['ALIAS1'], [0], []),
- (['name2'], [1], []),
- (['name1', 'name1'], [0], []),
- (['name1', 'NAME1'], [0], []),
- (['name1', 'alias1'], [0], []),
- (['name1', 'alias2'], [0, 1], []),
- (['NAME1', 'alias2'], [0, 1], []),
- (['name1', 'ALIAS2'], [0, 1], []),
- (['name2', 'alias1'], [0, 1], []),
- (['new'], [], ['new']),
- (['new', 'name1'], [0], ['new']),
- (['new', 'NAME1'], [0], ['new']),
- (['new', 'alias1'], [0], ['new']),
- (['new', 'ALIAS1'], [0], ['new']),
- (['new', 'name2'], [1], ['new']),
- (['new', 'name1', 'name1'], [0], ['new']),
- (['new', 'name1', 'NAME1'], [0], ['new']),
- (['new', 'name1', 'alias1'], [0], ['new']),
- (['new', 'name1', 'alias2'], [0, 1], ['new']),
- (['new', 'NAME1', 'alias2'], [0, 1], ['new']),
- (['new', 'name1', 'ALIAS2'], [0, 1], ['new']),
- (['new', 'name2', 'alias1'], [0, 1], ['new']),
- (['new', 'new'], [], ['new']),
- (['new', 'NEW'], [], ['new']),
- (['new', 'new2'], [], ['new', 'new2']),
- ])
+ (["name1"], [0], []),
+ (["NAME1"], [0], []),
+ (["alias1"], [0], []),
+ (["ALIAS1"], [0], []),
+ (["name2"], [1], []),
+ (["name1", "name1"], [0], []),
+ (["name1", "NAME1"], [0], []),
+ (["name1", "alias1"], [0], []),
+ (["name1", "alias2"], [0, 1], []),
+ (["NAME1", "alias2"], [0, 1], []),
+ (["name1", "ALIAS2"], [0, 1], []),
+ (["name2", "alias1"], [0, 1], []),
+ (["new"], [], ["new"]),
+ (["new", "name1"], [0], ["new"]),
+ (["new", "NAME1"], [0], ["new"]),
+ (["new", "alias1"], [0], ["new"]),
+ (["new", "ALIAS1"], [0], ["new"]),
+ (["new", "name2"], [1], ["new"]),
+ (["new", "name1", "name1"], [0], ["new"]),
+ (["new", "name1", "NAME1"], [0], ["new"]),
+ (["new", "name1", "alias1"], [0], ["new"]),
+ (["new", "name1", "alias2"], [0, 1], ["new"]),
+ (["new", "NAME1", "alias2"], [0, 1], ["new"]),
+ (["new", "name1", "ALIAS2"], [0, 1], ["new"]),
+ (["new", "name2", "alias1"], [0, 1], ["new"]),
+ (["new", "new"], [], ["new"]),
+ (["new", "NEW"], [], ["new"]),
+ (["new", "new2"], [], ["new", "new2"]),
+ ],
+)
def test_get_or_create_tags_by_names(
- names,
- expected_indexes,
- expected_created_names,
- tag_factory,
- tag_category_factory,
- config_injector):
- config_injector({'tag_name_regex': '.*'})
+ names,
+ expected_indexes,
+ expected_created_names,
+ tag_factory,
+ tag_category_factory,
+ config_injector,
+):
+ config_injector({"tag_name_regex": ".*"})
category = tag_category_factory()
input_tags = [
- tag_factory(names=['name1', 'ALIAS1'], category=category),
- tag_factory(names=['name2', 'ALIAS2'], category=category),
+ tag_factory(names=["name1", "ALIAS1"], category=category),
+ tag_factory(names=["name2", "ALIAS2"], category=category),
]
db.session.add_all(input_tags)
db.session.flush()
@@ -206,14 +240,14 @@ def test_get_or_create_tags_by_names(
def test_get_tag_siblings_for_unused(tag_factory):
- tag = tag_factory(names=['tag'])
+ tag = tag_factory(names=["tag"])
db.session.add(tag)
db.session.flush()
_assert_tag_siblings(tags.get_tag_siblings(tag), [])
def test_get_tag_siblings_for_used_alone(tag_factory, post_factory):
- tag = tag_factory(names=['tag'])
+ tag = tag_factory(names=["tag"])
post = post_factory()
post.tags = [tag]
db.session.add_all([post, tag])
@@ -222,20 +256,20 @@ def test_get_tag_siblings_for_used_alone(tag_factory, post_factory):
def test_get_tag_siblings_for_used_with_others(tag_factory, post_factory):
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
post = post_factory()
post.tags = [tag1, tag2]
db.session.add_all([post, tag1, tag2])
db.session.flush()
- _assert_tag_siblings(tags.get_tag_siblings(tag1), [('t2', 1)])
- _assert_tag_siblings(tags.get_tag_siblings(tag2), [('t1', 1)])
+ _assert_tag_siblings(tags.get_tag_siblings(tag1), [("t2", 1)])
+ _assert_tag_siblings(tags.get_tag_siblings(tag2), [("t1", 1)])
def test_get_tag_siblings_used_for_multiple_others(tag_factory, post_factory):
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
- tag3 = tag_factory(names=['t3'])
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
+ tag3 = tag_factory(names=["t3"])
post1 = post_factory()
post2 = post_factory()
post3 = post_factory()
@@ -246,16 +280,16 @@ def test_get_tag_siblings_used_for_multiple_others(tag_factory, post_factory):
post4.tags = [tag2]
db.session.add_all([post1, post2, post3, post4, tag1, tag2, tag3])
db.session.flush()
- _assert_tag_siblings(tags.get_tag_siblings(tag1), [('t3', 2), ('t2', 1)])
- _assert_tag_siblings(tags.get_tag_siblings(tag2), [('t1', 1), ('t3', 1)])
+ _assert_tag_siblings(tags.get_tag_siblings(tag1), [("t3", 2), ("t2", 1)])
+ _assert_tag_siblings(tags.get_tag_siblings(tag2), [("t1", 1), ("t3", 1)])
# even though tag2 is used more widely, tag1 is more relevant to tag3
- _assert_tag_siblings(tags.get_tag_siblings(tag3), [('t1', 2), ('t2', 1)])
+ _assert_tag_siblings(tags.get_tag_siblings(tag3), [("t1", 2), ("t2", 1)])
def test_delete(tag_factory):
- tag = tag_factory(names=['tag'])
- tag.suggestions = [tag_factory(names=['sug'])]
- tag.implications = [tag_factory(names=['imp'])]
+ tag = tag_factory(names=["tag"])
+ tag.suggestions = [tag_factory(names=["sug"])]
+ tag.implications = [tag_factory(names=["imp"])]
db.session.add(tag)
db.session.flush()
assert db.session.query(model.Tag).count() == 3
@@ -265,19 +299,19 @@ def test_delete(tag_factory):
def test_merge_tags_deletes_source_tag(tag_factory):
- source_tag = tag_factory(names=['source'])
- target_tag = tag_factory(names=['target'])
+ source_tag = tag_factory(names=["source"])
+ target_tag = tag_factory(names=["target"])
db.session.add_all([source_tag, target_tag])
db.session.flush()
tags.merge_tags(source_tag, target_tag)
db.session.flush()
- assert tags.try_get_tag_by_name('source') is None
- tag = tags.get_tag_by_name('target')
+ assert tags.try_get_tag_by_name("source") is None
+ tag = tags.get_tag_by_name("target")
assert tag is not None
def test_merge_tags_with_itself(tag_factory):
- source_tag = tag_factory(names=['source'])
+ source_tag = tag_factory(names=["source"])
db.session.add(source_tag)
db.session.flush()
with pytest.raises(tags.InvalidTagRelationError):
@@ -285,8 +319,8 @@ def test_merge_tags_with_itself(tag_factory):
def test_merge_tags_moves_usages(tag_factory, post_factory):
- source_tag = tag_factory(names=['source'])
- target_tag = tag_factory(names=['target'])
+ source_tag = tag_factory(names=["source"])
+ target_tag = tag_factory(names=["target"])
post = post_factory()
post.tags = [source_tag]
db.session.add_all([source_tag, target_tag, post])
@@ -295,13 +329,13 @@ def test_merge_tags_moves_usages(tag_factory, post_factory):
assert target_tag.post_count == 0
tags.merge_tags(source_tag, target_tag)
db.session.commit()
- assert tags.try_get_tag_by_name('source') is None
- assert tags.get_tag_by_name('target').post_count == 1
+ assert tags.try_get_tag_by_name("source") is None
+ assert tags.get_tag_by_name("target").post_count == 1
def test_merge_tags_doesnt_duplicate_usages(tag_factory, post_factory):
- source_tag = tag_factory(names=['source'])
- target_tag = tag_factory(names=['target'])
+ source_tag = tag_factory(names=["source"])
+ target_tag = tag_factory(names=["target"])
post = post_factory()
post.tags = [source_tag, target_tag]
db.session.add_all([source_tag, target_tag, post])
@@ -310,13 +344,13 @@ def test_merge_tags_doesnt_duplicate_usages(tag_factory, post_factory):
assert target_tag.post_count == 1
tags.merge_tags(source_tag, target_tag)
db.session.flush()
- assert tags.try_get_tag_by_name('source') is None
- assert tags.get_tag_by_name('target').post_count == 1
+ assert tags.try_get_tag_by_name("source") is None
+ assert tags.get_tag_by_name("target").post_count == 1
def test_merge_tags_moves_child_relations(tag_factory):
- source_tag = tag_factory(names=['source'])
- target_tag = tag_factory(names=['target'])
+ source_tag = tag_factory(names=["source"])
+ target_tag = tag_factory(names=["target"])
related_tag = tag_factory()
source_tag.suggestions = [related_tag]
source_tag.implications = [related_tag]
@@ -328,14 +362,14 @@ def test_merge_tags_moves_child_relations(tag_factory):
assert target_tag.implication_count == 0
tags.merge_tags(source_tag, target_tag)
db.session.commit()
- assert tags.try_get_tag_by_name('source') is None
- assert tags.get_tag_by_name('target').suggestion_count == 1
- assert tags.get_tag_by_name('target').implication_count == 1
+ assert tags.try_get_tag_by_name("source") is None
+ assert tags.get_tag_by_name("target").suggestion_count == 1
+ assert tags.get_tag_by_name("target").implication_count == 1
def test_merge_tags_doesnt_duplicate_child_relations(tag_factory):
- source_tag = tag_factory(names=['source'])
- target_tag = tag_factory(names=['target'])
+ source_tag = tag_factory(names=["source"])
+ target_tag = tag_factory(names=["target"])
related_tag = tag_factory()
source_tag.suggestions = [related_tag]
source_tag.implications = [related_tag]
@@ -349,15 +383,15 @@ def test_merge_tags_doesnt_duplicate_child_relations(tag_factory):
assert target_tag.implication_count == 1
tags.merge_tags(source_tag, target_tag)
db.session.commit()
- assert tags.try_get_tag_by_name('source') is None
- assert tags.get_tag_by_name('target').suggestion_count == 1
- assert tags.get_tag_by_name('target').implication_count == 1
+ assert tags.try_get_tag_by_name("source") is None
+ assert tags.get_tag_by_name("target").suggestion_count == 1
+ assert tags.get_tag_by_name("target").implication_count == 1
def test_merge_tags_moves_parent_relations(tag_factory):
- source_tag = tag_factory(names=['source'])
- target_tag = tag_factory(names=['target'])
- related_tag = tag_factory(names=['related'])
+ source_tag = tag_factory(names=["source"])
+ target_tag = tag_factory(names=["target"])
+ related_tag = tag_factory(names=["related"])
related_tag.suggestions = [related_tag]
related_tag.implications = [related_tag]
db.session.add_all([source_tag, target_tag, related_tag])
@@ -368,16 +402,16 @@ def test_merge_tags_moves_parent_relations(tag_factory):
assert target_tag.implication_count == 0
tags.merge_tags(source_tag, target_tag)
db.session.commit()
- assert tags.try_get_tag_by_name('source') is None
- assert tags.get_tag_by_name('related').suggestion_count == 1
- assert tags.get_tag_by_name('related').suggestion_count == 1
- assert tags.get_tag_by_name('target').suggestion_count == 0
- assert tags.get_tag_by_name('target').implication_count == 0
+ assert tags.try_get_tag_by_name("source") is None
+ assert tags.get_tag_by_name("related").suggestion_count == 1
+ assert tags.get_tag_by_name("related").suggestion_count == 1
+ assert tags.get_tag_by_name("target").suggestion_count == 0
+ assert tags.get_tag_by_name("target").implication_count == 0
def test_merge_tags_doesnt_create_relation_loop_for_children(tag_factory):
- source_tag = tag_factory(names=['source'])
- target_tag = tag_factory(names=['target'])
+ source_tag = tag_factory(names=["source"])
+ target_tag = tag_factory(names=["target"])
source_tag.suggestions = [target_tag]
source_tag.implications = [target_tag]
db.session.add_all([source_tag, target_tag])
@@ -388,14 +422,14 @@ def test_merge_tags_doesnt_create_relation_loop_for_children(tag_factory):
assert target_tag.implication_count == 0
tags.merge_tags(source_tag, target_tag)
db.session.commit()
- assert tags.try_get_tag_by_name('source') is None
- assert tags.get_tag_by_name('target').suggestion_count == 0
- assert tags.get_tag_by_name('target').implication_count == 0
+ assert tags.try_get_tag_by_name("source") is None
+ assert tags.get_tag_by_name("target").suggestion_count == 0
+ assert tags.get_tag_by_name("target").implication_count == 0
def test_merge_tags_doesnt_create_relation_loop_for_parents(tag_factory):
- source_tag = tag_factory(names=['source'])
- target_tag = tag_factory(names=['target'])
+ source_tag = tag_factory(names=["source"])
+ target_tag = tag_factory(names=["target"])
target_tag.suggestions = [source_tag]
target_tag.implications = [source_tag]
db.session.add_all([source_tag, target_tag])
@@ -406,33 +440,35 @@ def test_merge_tags_doesnt_create_relation_loop_for_parents(tag_factory):
assert target_tag.implication_count == 1
tags.merge_tags(source_tag, target_tag)
db.session.commit()
- assert tags.try_get_tag_by_name('source') is None
- assert tags.get_tag_by_name('target').suggestion_count == 0
- assert tags.get_tag_by_name('target').implication_count == 0
+ assert tags.try_get_tag_by_name("source") is None
+ assert tags.get_tag_by_name("target").suggestion_count == 0
+ assert tags.get_tag_by_name("target").implication_count == 0
def test_create_tag(fake_datetime):
- with patch('szurubooru.func.tags.update_tag_names'), \
- patch('szurubooru.func.tags.update_tag_category_name'), \
- patch('szurubooru.func.tags.update_tag_suggestions'), \
- patch('szurubooru.func.tags.update_tag_implications'), \
- fake_datetime('1997-01-01'):
- tag = tags.create_tag(['name'], 'cat', ['sug'], ['imp'])
+ with patch("szurubooru.func.tags.update_tag_names"), patch(
+ "szurubooru.func.tags.update_tag_category_name"
+ ), patch("szurubooru.func.tags.update_tag_suggestions"), patch(
+ "szurubooru.func.tags.update_tag_implications"
+ ), fake_datetime(
+ "1997-01-01"
+ ):
+ tag = tags.create_tag(["name"], "cat", ["sug"], ["imp"])
assert tag.creation_time == datetime(1997, 1, 1)
assert tag.last_edit_time is None
- tags.update_tag_names.assert_called_once_with(tag, ['name'])
- tags.update_tag_category_name.assert_called_once_with(tag, 'cat')
- tags.update_tag_suggestions.assert_called_once_with(tag, ['sug'])
- tags.update_tag_implications.assert_called_once_with(tag, ['imp'])
+ tags.update_tag_names.assert_called_once_with(tag, ["name"])
+ tags.update_tag_category_name.assert_called_once_with(tag, "cat")
+ tags.update_tag_suggestions.assert_called_once_with(tag, ["sug"])
+ tags.update_tag_implications.assert_called_once_with(tag, ["imp"])
def test_update_tag_category_name(tag_factory):
- with patch('szurubooru.func.tag_categories.get_category_by_name'):
- tag_categories.get_category_by_name.return_value = 'mocked'
+ with patch("szurubooru.func.tag_categories.get_category_by_name"):
+ tag_categories.get_category_by_name.return_value = "mocked"
tag = tag_factory()
- tags.update_tag_category_name(tag, 'cat')
- assert tag_categories.get_category_by_name.called_once_with('cat')
- assert tag.category == 'mocked'
+ tags.update_tag_category_name(tag, "cat")
+ assert tag_categories.get_category_by_name.called_once_with("cat")
+ assert tag.category == "mocked"
def test_update_tag_names_to_empty(tag_factory):
@@ -442,44 +478,45 @@ def test_update_tag_names_to_empty(tag_factory):
def test_update_tag_names_with_invalid_name(config_injector, tag_factory):
- config_injector({'tag_name_regex': '^[a-z]*$'})
+ config_injector({"tag_name_regex": "^[a-z]*$"})
tag = tag_factory()
with pytest.raises(tags.InvalidTagNameError):
- tags.update_tag_names(tag, ['0'])
+ tags.update_tag_names(tag, ["0"])
def test_update_tag_names_with_too_long_string(config_injector, tag_factory):
- config_injector({'tag_name_regex': '^[a-z]*$'})
+ config_injector({"tag_name_regex": "^[a-z]*$"})
tag = tag_factory()
with pytest.raises(tags.InvalidTagNameError):
- tags.update_tag_names(tag, ['a' * 300])
+ tags.update_tag_names(tag, ["a" * 300])
def test_update_tag_names_with_duplicate_names(config_injector, tag_factory):
- config_injector({'tag_name_regex': '^[a-z]*$'})
+ config_injector({"tag_name_regex": "^[a-z]*$"})
tag = tag_factory()
- tags.update_tag_names(tag, ['a', 'A'])
- assert [tag_name.name for tag_name in tag.names] == ['a']
+ tags.update_tag_names(tag, ["a", "A"])
+ assert [tag_name.name for tag_name in tag.names] == ["a"]
def test_update_tag_names_trying_to_use_taken_name(
- config_injector, tag_factory):
- config_injector({'tag_name_regex': '^[a-zA-Z]*$'})
- existing_tag = tag_factory(names=['a'])
+ config_injector, tag_factory
+):
+ config_injector({"tag_name_regex": "^[a-zA-Z]*$"})
+ existing_tag = tag_factory(names=["a"])
db.session.add(existing_tag)
tag = tag_factory()
db.session.add(tag)
db.session.flush()
with pytest.raises(tags.TagAlreadyExistsError):
- tags.update_tag_names(tag, ['a'])
+ tags.update_tag_names(tag, ["a"])
with pytest.raises(tags.TagAlreadyExistsError):
- tags.update_tag_names(tag, ['A'])
+ tags.update_tag_names(tag, ["A"])
def test_update_tag_names_reusing_own_name(config_injector, tag_factory):
- config_injector({'tag_name_regex': '^[a-zA-Z]*$'})
- for name in list('aA'):
- tag = tag_factory(names=['a'])
+ config_injector({"tag_name_regex": "^[a-zA-Z]*$"})
+ for name in list("aA"):
+ tag = tag_factory(names=["a"])
db.session.add(tag)
db.session.flush()
tags.update_tag_names(tag, [name])
@@ -488,48 +525,48 @@ def test_update_tag_names_reusing_own_name(config_injector, tag_factory):
def test_update_tag_names_changing_primary_name(config_injector, tag_factory):
- config_injector({'tag_name_regex': '^[a-zA-Z]*$'})
- tag = tag_factory(names=['a', 'b'])
+ config_injector({"tag_name_regex": "^[a-zA-Z]*$"})
+ tag = tag_factory(names=["a", "b"])
db.session.add(tag)
db.session.flush()
- tags.update_tag_names(tag, ['b', 'a'])
+ tags.update_tag_names(tag, ["b", "a"])
db.session.flush()
db.session.refresh(tag)
- assert [tag_name.name for tag_name in tag.names] == ['b', 'a']
+ assert [tag_name.name for tag_name in tag.names] == ["b", "a"]
db.session.rollback()
-@pytest.mark.parametrize('attempt', ['name', 'NAME', 'alias', 'ALIAS'])
+@pytest.mark.parametrize("attempt", ["name", "NAME", "alias", "ALIAS"])
def test_update_tag_suggestions_with_itself(attempt, tag_factory):
- tag = tag_factory(names=['name', 'ALIAS'])
+ tag = tag_factory(names=["name", "ALIAS"])
with pytest.raises(tags.InvalidTagRelationError):
tags.update_tag_suggestions(tag, [attempt])
def test_update_tag_suggestions(tag_factory):
- tag = tag_factory(names=['name', 'ALIAS'])
- with patch('szurubooru.func.tags.get_tags_by_names'):
- tags.get_tags_by_names.return_value = ['returned tags']
- tags.update_tag_suggestions(tag, ['test'])
- assert tag.suggestions == ['returned tags']
+ tag = tag_factory(names=["name", "ALIAS"])
+ with patch("szurubooru.func.tags.get_tags_by_names"):
+ tags.get_tags_by_names.return_value = ["returned tags"]
+ tags.update_tag_suggestions(tag, ["test"])
+ assert tag.suggestions == ["returned tags"]
-@pytest.mark.parametrize('attempt', ['name', 'NAME', 'alias', 'ALIAS'])
+@pytest.mark.parametrize("attempt", ["name", "NAME", "alias", "ALIAS"])
def test_update_tag_implications_with_itself(attempt, tag_factory):
- tag = tag_factory(names=['name', 'ALIAS'])
+ tag = tag_factory(names=["name", "ALIAS"])
with pytest.raises(tags.InvalidTagRelationError):
tags.update_tag_implications(tag, [attempt])
def test_update_tag_implications(tag_factory):
- tag = tag_factory(names=['name', 'ALIAS'])
- with patch('szurubooru.func.tags.get_tags_by_names'):
- tags.get_tags_by_names.return_value = ['returned tags']
- tags.update_tag_implications(tag, ['test'])
- assert tag.implications == ['returned tags']
+ tag = tag_factory(names=["name", "ALIAS"])
+ with patch("szurubooru.func.tags.get_tags_by_names"):
+ tags.get_tags_by_names.return_value = ["returned tags"]
+ tags.update_tag_implications(tag, ["test"])
+ assert tag.implications == ["returned tags"]
def test_update_tag_description(tag_factory):
tag = tag_factory()
- tags.update_tag_description(tag, 'test')
- assert tag.description == 'test'
+ tags.update_tag_description(tag, "test")
+ assert tag.description == "test"
diff --git a/server/szurubooru/tests/func/test_user_tokens.py b/server/szurubooru/tests/func/test_user_tokens.py
index 8c3577c8..0422f4d3 100644
--- a/server/szurubooru/tests/func/test_user_tokens.py
+++ b/server/szurubooru/tests/func/test_user_tokens.py
@@ -1,32 +1,35 @@
-from datetime import datetime, timedelta
-from unittest.mock import patch
-import pytest
-import pytz
import random
import string
+from datetime import datetime, timedelta
+from unittest.mock import patch
+
+import pytest
+import pytz
+
from szurubooru import db, model
-from szurubooru.func import user_tokens, users, auth, util
+from szurubooru.func import auth, user_tokens, users, util
def test_serialize_user_token(user_token_factory):
user_token = user_token_factory()
db.session.add(user_token)
db.session.flush()
- with patch('szurubooru.func.users.get_avatar_url'):
- users.get_avatar_url.return_value = 'https://example.com/avatar.png'
+ with patch("szurubooru.func.users.get_avatar_url"):
+ users.get_avatar_url.return_value = "https://example.com/avatar.png"
result = user_tokens.serialize_user_token(user_token, user_token.user)
assert result == {
- 'creationTime': datetime(1997, 1, 1, 0, 0),
- 'enabled': True,
- 'expirationTime': None,
- 'lastEditTime': None,
- 'lastUsageTime': None,
- 'note': None,
- 'token': 'dummy',
- 'user': {
- 'avatarUrl': 'https://example.com/avatar.png',
- 'name': user_token.user.name},
- 'version': 1
+ "creationTime": datetime(1997, 1, 1, 0, 0),
+ "enabled": True,
+ "expirationTime": None,
+ "lastEditTime": None,
+ "lastUsageTime": None,
+ "note": None,
+ "token": "dummy",
+ "user": {
+ "avatarUrl": "https://example.com/avatar.png",
+ "name": user_token.user.name,
+ },
+ "version": 1,
}
@@ -41,7 +44,8 @@ def test_get_by_user_and_token(user_token_factory):
db.session.flush()
db.session.commit()
result = user_tokens.get_by_user_and_token(
- user_token.user, user_token.token)
+ user_token.user, user_token.token
+ )
assert result == user_token
@@ -61,10 +65,10 @@ def test_create_user_token(user_factory):
db.session.add(user)
db.session.flush()
db.session.commit()
- with patch('szurubooru.func.auth.generate_authorization_token'):
- auth.generate_authorization_token.return_value = 'test'
+ with patch("szurubooru.func.auth.generate_authorization_token"):
+ auth.generate_authorization_token.return_value = "test"
result = user_tokens.create_user_token(user, True)
- assert result.token == 'test'
+ assert result.token == "test"
assert result.user == user
@@ -85,8 +89,8 @@ def test_update_user_token_edit_time(user_token_factory):
def test_update_user_token_note(user_token_factory):
user_token = user_token_factory()
assert user_token.note is None
- user_tokens.update_user_token_note(user_token, ' Test Note ')
- assert user_token.note == 'Test Note'
+ user_tokens.update_user_token_note(user_token, " Test Note ")
+ assert user_token.note == "Test Note"
assert user_token.last_edit_time is not None
@@ -94,8 +98,9 @@ def test_update_user_token_note_input_too_long(user_token_factory):
user_token = user_token_factory()
assert user_token.note is None
note_max_length = util.get_column_size(model.UserToken.note) + 1
- note = ''.join(
- random.choice(string.ascii_letters) for _ in range(note_max_length))
+ note = "".join(
+ random.choice(string.ascii_letters) for _ in range(note_max_length)
+ )
with pytest.raises(user_tokens.InvalidNoteError):
user_tokens.update_user_token_note(user_token, note)
@@ -104,11 +109,11 @@ def test_update_user_token_expiration_time(user_token_factory):
user_token = user_token_factory()
assert user_token.expiration_time is None
expiration_time_str = (
- (datetime.utcnow() + timedelta(days=1))
- .replace(tzinfo=pytz.utc)
+ (datetime.utcnow() + timedelta(days=1)).replace(tzinfo=pytz.utc)
).isoformat()
user_tokens.update_user_token_expiration_time(
- user_token, expiration_time_str)
+ user_token, expiration_time_str
+ )
assert user_token.expiration_time.isoformat() == expiration_time_str
assert user_token.last_edit_time is not None
@@ -117,39 +122,45 @@ def test_update_user_token_expiration_time_in_past(user_token_factory):
user_token = user_token_factory()
assert user_token.expiration_time is None
expiration_time_str = (
- (datetime.utcnow() - timedelta(days=1))
- .replace(tzinfo=pytz.utc)
+ (datetime.utcnow() - timedelta(days=1)).replace(tzinfo=pytz.utc)
).isoformat()
with pytest.raises(
- user_tokens.InvalidExpirationError,
- match='Expiration cannot happen in the past'):
+ user_tokens.InvalidExpirationError,
+ match="Expiration cannot happen in the past",
+ ):
user_tokens.update_user_token_expiration_time(
- user_token, expiration_time_str)
+ user_token, expiration_time_str
+ )
-@pytest.mark.parametrize('expiration_time_str', [
- datetime.utcnow().isoformat(),
- (datetime.utcnow() - timedelta(days=1)).ctime(),
- '1970/01/01 00:00:01.0000Z',
- '70/01/01 00:00:01.0000Z',
- ''.join(random.choice(string.ascii_letters) for _ in range(15)),
- ''.join(random.choice(string.digits) for _ in range(8))
-])
+@pytest.mark.parametrize(
+ "expiration_time_str",
+ [
+ datetime.utcnow().isoformat(),
+ (datetime.utcnow() - timedelta(days=1)).ctime(),
+ "1970/01/01 00:00:01.0000Z",
+ "70/01/01 00:00:01.0000Z",
+ "".join(random.choice(string.ascii_letters) for _ in range(15)),
+ "".join(random.choice(string.digits) for _ in range(8)),
+ ],
+)
def test_update_user_token_expiration_time_invalid_format(
- expiration_time_str, user_token_factory):
+ expiration_time_str, user_token_factory
+):
user_token = user_token_factory()
assert user_token.expiration_time is None
with pytest.raises(
- user_tokens.InvalidExpirationError,
- match='Expiration is in an invalid format %s'
- % expiration_time_str):
+ user_tokens.InvalidExpirationError,
+ match="Expiration is in an invalid format %s" % expiration_time_str,
+ ):
user_tokens.update_user_token_expiration_time(
- user_token, expiration_time_str)
+ user_token, expiration_time_str
+ )
def test_bump_usage_time(user_token_factory, fake_datetime):
user_token = user_token_factory()
- with fake_datetime('1997-01-01'):
+ with fake_datetime("1997-01-01"):
user_tokens.bump_usage_time(user_token)
assert user_token.last_usage_time == datetime(1997, 1, 1)
diff --git a/server/szurubooru/tests/func/test_users.py b/server/szurubooru/tests/func/test_users.py
index 55061276..94e9c7c1 100644
--- a/server/szurubooru/tests/func/test_users.py
+++ b/server/szurubooru/tests/func/test_users.py
@@ -1,56 +1,70 @@
-from unittest.mock import patch
from datetime import datetime
-import pytest
-from szurubooru import db, model, errors
-from szurubooru.func import auth, users, files, util
+from unittest.mock import patch
+import pytest
+
+from szurubooru import db, errors, model
+from szurubooru.func import auth, files, users, util
EMPTY_PIXEL = (
- b'\x47\x49\x46\x38\x39\x61\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00'
- b'\xff\xff\xff\x21\xf9\x04\x01\x00\x00\x01\x00\x2c\x00\x00\x00\x00'
- b'\x01\x00\x01\x00\x00\x02\x02\x4c\x01\x00\x3b')
+ b"\x47\x49\x46\x38\x39\x61\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00"
+ b"\xff\xff\xff\x21\xf9\x04\x01\x00\x00\x01\x00\x2c\x00\x00\x00\x00"
+ b"\x01\x00\x01\x00\x00\x02\x02\x4c\x01\x00\x3b"
+)
-@pytest.mark.parametrize('user_name', ['test', 'TEST'])
+@pytest.mark.parametrize("user_name", ["test", "TEST"])
def test_get_avatar_path(user_name):
- assert users.get_avatar_path(user_name) == 'avatars/test.png'
+ assert users.get_avatar_path(user_name) == "avatars/test.png"
-@pytest.mark.parametrize('user_name,user_email,avatar_style,expected_url', [
- (
- 'user',
- None,
- model.User.AVATAR_GRAVATAR,
- ('https://gravatar.com/avatar/' +
- 'ee11cbb19052e40b07aac0ca060c23ee?d=retro&s=100'),
- ),
- (
- None,
- 'user@example.com',
- model.User.AVATAR_GRAVATAR,
- ('https://gravatar.com/avatar/' +
- 'b58996c504c5638798eb6b511e6f49af?d=retro&s=100'),
- ),
- (
- 'user',
- 'user@example.com',
- model.User.AVATAR_GRAVATAR,
- ('https://gravatar.com/avatar/' +
- 'b58996c504c5638798eb6b511e6f49af?d=retro&s=100'),
- ),
- (
- 'user',
- None,
- model.User.AVATAR_MANUAL,
- 'http://example.com/avatars/user.png',
- ),
-])
+@pytest.mark.parametrize(
+ "user_name,user_email,avatar_style,expected_url",
+ [
+ (
+ "user",
+ None,
+ model.User.AVATAR_GRAVATAR,
+ (
+ "https://gravatar.com/avatar/"
+ + "ee11cbb19052e40b07aac0ca060c23ee?d=retro&s=100"
+ ),
+ ),
+ (
+ None,
+ "user@example.com",
+ model.User.AVATAR_GRAVATAR,
+ (
+ "https://gravatar.com/avatar/"
+ + "b58996c504c5638798eb6b511e6f49af?d=retro&s=100"
+ ),
+ ),
+ (
+ "user",
+ "user@example.com",
+ model.User.AVATAR_GRAVATAR,
+ (
+ "https://gravatar.com/avatar/"
+ + "b58996c504c5638798eb6b511e6f49af?d=retro&s=100"
+ ),
+ ),
+ (
+ "user",
+ None,
+ model.User.AVATAR_MANUAL,
+ "http://example.com/avatars/user.png",
+ ),
+ ],
+)
def test_get_avatar_url(
- user_name, user_email, avatar_style, expected_url, config_injector):
- config_injector({
- 'data_url': 'http://example.com/',
- 'thumbnails': {'avatar_width': 100},
- })
+ user_name, user_email, avatar_style, expected_url, config_injector
+):
+ config_injector(
+ {
+ "data_url": "http://example.com/",
+ "thumbnails": {"avatar_width": 100},
+ }
+ )
user = model.User()
user.name = user_name
user.email = user_email
@@ -59,23 +73,21 @@ def test_get_avatar_url(
@pytest.mark.parametrize(
- 'same_user,can_edit_any_email,force_show,expected_email',
+ "same_user,can_edit_any_email,force_show,expected_email",
[
(False, False, False, False),
- (True, False, False, 'test@example.com'),
- (False, True, False, 'test@example.com'),
- (False, False, True, 'test@example.com'),
- ])
+ (True, False, False, "test@example.com"),
+ (False, True, False, "test@example.com"),
+ (False, False, True, "test@example.com"),
+ ],
+)
def test_get_email(
- same_user,
- can_edit_any_email,
- force_show,
- expected_email,
- user_factory):
- with patch('szurubooru.func.auth.has_privilege'):
+ same_user, can_edit_any_email, force_show, expected_email, user_factory
+):
+ with patch("szurubooru.func.auth.has_privilege"):
auth.has_privilege = lambda user, name: can_edit_any_email
user = user_factory()
- user.email = 'test@example.com'
+ user.email = "test@example.com"
auth_user = user if same_user else user_factory()
db.session.add_all([user, auth_user])
db.session.flush()
@@ -83,25 +95,28 @@ def test_get_email(
@pytest.mark.parametrize(
- 'same_user,score,expected_liked_post_count,expected_disliked_post_count',
+ "same_user,score,expected_liked_post_count,expected_disliked_post_count",
[
(False, 1, False, False),
(False, -1, False, False),
(True, 1, 1, 0),
(True, -1, 0, 1),
- ])
+ ],
+)
def test_get_liked_post_count(
- same_user,
- score,
- expected_liked_post_count,
- expected_disliked_post_count,
- user_factory,
- post_factory):
+ same_user,
+ score,
+ expected_liked_post_count,
+ expected_disliked_post_count,
+ user_factory,
+ post_factory,
+):
user = user_factory()
post = post_factory()
auth_user = user if same_user else user_factory()
score = model.PostScore(
- post=post, user=user, score=score, time=datetime.now())
+ post=post, user=user, score=score, time=datetime.now()
+ )
db.session.add_all([post, user, score])
db.session.flush()
actual_liked_post_count = users.get_liked_post_count(user, auth_user)
@@ -115,16 +130,17 @@ def test_serialize_user_when_empty():
def test_serialize_user(user_factory):
- with patch('szurubooru.func.users.get_email'), \
- patch('szurubooru.func.users.get_avatar_url'), \
- patch('szurubooru.func.users.get_liked_post_count'), \
- patch('szurubooru.func.users.get_disliked_post_count'):
- users.get_email.return_value = 'test@example.com'
- users.get_avatar_url.return_value = 'https://example.com/avatar.png'
+ with patch("szurubooru.func.users.get_email"), patch(
+ "szurubooru.func.users.get_avatar_url"
+ ), patch("szurubooru.func.users.get_liked_post_count"), patch(
+ "szurubooru.func.users.get_disliked_post_count"
+ ):
+ users.get_email.return_value = "test@example.com"
+ users.get_avatar_url.return_value = "https://example.com/avatar.png"
users.get_liked_post_count.return_value = 66
users.get_disliked_post_count.return_value = 33
auth_user = user_factory()
- user = user_factory(name='dummy user')
+ user = user_factory(name="dummy user")
user.creation_time = datetime(1997, 1, 1)
user.last_edit_time = datetime(1998, 1, 1)
user.avatar_style = model.User.AVATAR_MANUAL
@@ -132,36 +148,36 @@ def test_serialize_user(user_factory):
db.session.add(user)
db.session.flush()
assert users.serialize_user(user, auth_user) == {
- 'version': 1,
- 'name': 'dummy user',
- 'email': 'test@example.com',
- 'rank': 'administrator',
- 'creationTime': datetime(1997, 1, 1, 0, 0),
- 'lastLoginTime': None,
- 'avatarStyle': 'manual',
- 'avatarUrl': 'https://example.com/avatar.png',
- 'likedPostCount': 66,
- 'dislikedPostCount': 33,
- 'commentCount': 0,
- 'favoritePostCount': 0,
- 'uploadedPostCount': 0,
+ "version": 1,
+ "name": "dummy user",
+ "email": "test@example.com",
+ "rank": "administrator",
+ "creationTime": datetime(1997, 1, 1, 0, 0),
+ "lastLoginTime": None,
+ "avatarStyle": "manual",
+ "avatarUrl": "https://example.com/avatar.png",
+ "likedPostCount": 66,
+ "dislikedPostCount": 33,
+ "commentCount": 0,
+ "favoritePostCount": 0,
+ "uploadedPostCount": 0,
}
def test_serialize_micro_user(user_factory):
- with patch('szurubooru.func.users.get_avatar_url'):
- users.get_avatar_url.return_value = 'https://example.com/avatar.png'
+ with patch("szurubooru.func.users.get_avatar_url"):
+ users.get_avatar_url.return_value = "https://example.com/avatar.png"
auth_user = user_factory()
- user = user_factory(name='dummy user')
+ user = user_factory(name="dummy user")
db.session.add(user)
db.session.flush()
assert users.serialize_micro_user(user, auth_user) == {
- 'name': 'dummy user',
- 'avatarUrl': 'https://example.com/avatar.png',
+ "name": "dummy user",
+ "avatarUrl": "https://example.com/avatar.png",
}
-@pytest.mark.parametrize('count', [0, 1, 2])
+@pytest.mark.parametrize("count", [0, 1, 2])
def test_get_user_count(count, user_factory):
for _ in range(count):
db.session.add(user_factory())
@@ -170,72 +186,73 @@ def test_get_user_count(count, user_factory):
def test_try_get_user_by_name(user_factory):
- user = user_factory(name='name', email='email')
+ user = user_factory(name="name", email="email")
db.session.add(user)
db.session.flush()
- assert users.try_get_user_by_name('non-existing') is None
- assert users.try_get_user_by_name('email') is None
- assert users.try_get_user_by_name('name') is user
- assert users.try_get_user_by_name('NAME') is user
+ assert users.try_get_user_by_name("non-existing") is None
+ assert users.try_get_user_by_name("email") is None
+ assert users.try_get_user_by_name("name") is user
+ assert users.try_get_user_by_name("NAME") is user
def test_get_user_by_name(user_factory):
- user = user_factory(name='name', email='email')
+ user = user_factory(name="name", email="email")
db.session.add(user)
db.session.flush()
with pytest.raises(users.UserNotFoundError):
- assert users.get_user_by_name('non-existing')
+ assert users.get_user_by_name("non-existing")
with pytest.raises(users.UserNotFoundError):
- assert users.get_user_by_name('email')
- assert users.get_user_by_name('name') is user
- assert users.get_user_by_name('NAME') is user
+ assert users.get_user_by_name("email")
+ assert users.get_user_by_name("name") is user
+ assert users.get_user_by_name("NAME") is user
def test_try_get_user_by_name_or_email(user_factory):
- user = user_factory(name='name', email='email')
+ user = user_factory(name="name", email="email")
db.session.add(user)
db.session.flush()
- assert users.try_get_user_by_name_or_email('non-existing') is None
- assert users.try_get_user_by_name_or_email('email') is user
- assert users.try_get_user_by_name_or_email('EMAIL') is user
- assert users.try_get_user_by_name_or_email('name') is user
- assert users.try_get_user_by_name_or_email('NAME') is user
+ assert users.try_get_user_by_name_or_email("non-existing") is None
+ assert users.try_get_user_by_name_or_email("email") is user
+ assert users.try_get_user_by_name_or_email("EMAIL") is user
+ assert users.try_get_user_by_name_or_email("name") is user
+ assert users.try_get_user_by_name_or_email("NAME") is user
def test_get_user_by_name_or_email(user_factory):
- user = user_factory(name='name', email='email')
+ user = user_factory(name="name", email="email")
db.session.add(user)
db.session.flush()
with pytest.raises(users.UserNotFoundError):
- assert users.get_user_by_name_or_email('non-existing')
- assert users.get_user_by_name_or_email('email') is user
- assert users.get_user_by_name_or_email('EMAIL') is user
- assert users.get_user_by_name_or_email('name') is user
- assert users.get_user_by_name_or_email('NAME') is user
+ assert users.get_user_by_name_or_email("non-existing")
+ assert users.get_user_by_name_or_email("email") is user
+ assert users.get_user_by_name_or_email("EMAIL") is user
+ assert users.get_user_by_name_or_email("name") is user
+ assert users.get_user_by_name_or_email("NAME") is user
def test_create_user_for_first_user(fake_datetime):
- with patch('szurubooru.func.users.update_user_name'), \
- patch('szurubooru.func.users.update_user_password'), \
- patch('szurubooru.func.users.update_user_email'), \
- fake_datetime('1997-01-01'):
- user = users.create_user('name', 'password', 'email')
+ with patch("szurubooru.func.users.update_user_name"), patch(
+ "szurubooru.func.users.update_user_password"
+ ), patch("szurubooru.func.users.update_user_email"), fake_datetime(
+ "1997-01-01"
+ ):
+ user = users.create_user("name", "password", "email")
assert user.creation_time == datetime(1997, 1, 1)
assert user.last_login_time is None
assert user.rank == model.User.RANK_ADMINISTRATOR
- users.update_user_name.assert_called_once_with(user, 'name')
- users.update_user_password.assert_called_once_with(user, 'password')
- users.update_user_email.assert_called_once_with(user, 'email')
+ users.update_user_name.assert_called_once_with(user, "name")
+ users.update_user_password.assert_called_once_with(user, "password")
+ users.update_user_email.assert_called_once_with(user, "email")
def test_create_user_for_subsequent_users(user_factory, config_injector):
- config_injector({'default_rank': 'regular'})
+ config_injector({"default_rank": "regular"})
db.session.add(user_factory())
db.session.flush()
- with patch('szurubooru.func.users.update_user_name'), \
- patch('szurubooru.func.users.update_user_email'), \
- patch('szurubooru.func.users.update_user_password'):
- user = users.create_user('name', 'password', 'email')
+ with patch("szurubooru.func.users.update_user_name"), patch(
+ "szurubooru.func.users.update_user_email"
+ ), patch("szurubooru.func.users.update_user_password"):
+ user = users.create_user("name", "password", "email")
assert user.rank == model.User.RANK_REGULAR
@@ -248,56 +265,58 @@ def test_update_user_name_with_empty_string(user_factory):
def test_update_user_name_with_too_long_string(user_factory):
user = user_factory()
with pytest.raises(users.InvalidUserNameError):
- users.update_user_name(user, 'a' * 300)
+ users.update_user_name(user, "a" * 300)
def test_update_user_name_with_invalid_name(user_factory, config_injector):
- config_injector({'user_name_regex': '^[a-z]+$'})
+ config_injector({"user_name_regex": "^[a-z]+$"})
user = user_factory()
with pytest.raises(users.InvalidUserNameError):
- users.update_user_name(user, '0')
+ users.update_user_name(user, "0")
def test_update_user_name_with_duplicate_name(user_factory, config_injector):
- config_injector({'user_name_regex': '^[a-z]+$'})
+ config_injector({"user_name_regex": "^[a-z]+$"})
user = user_factory()
- existing_user = user_factory(name='dummy')
+ existing_user = user_factory(name="dummy")
db.session.add(existing_user)
db.session.flush()
with pytest.raises(users.UserAlreadyExistsError):
- users.update_user_name(user, 'dummy')
+ users.update_user_name(user, "dummy")
def test_update_user_name_reusing_own_name(user_factory, config_injector):
- config_injector({'user_name_regex': '^[a-z]+$'})
- user = user_factory(name='dummy')
+ config_injector({"user_name_regex": "^[a-z]+$"})
+ user = user_factory(name="dummy")
db.session.add(user)
db.session.flush()
- with patch('szurubooru.func.files.has'):
+ with patch("szurubooru.func.files.has"):
files.has.return_value = False
- users.update_user_name(user, 'dummy')
+ users.update_user_name(user, "dummy")
db.session.flush()
- assert users.try_get_user_by_name('dummy') is user
+ assert users.try_get_user_by_name("dummy") is user
def test_update_user_name_for_new_user(user_factory, config_injector):
- config_injector({'user_name_regex': '^[a-z]+$'})
+ config_injector({"user_name_regex": "^[a-z]+$"})
user = user_factory()
- with patch('szurubooru.func.files.has'):
+ with patch("szurubooru.func.files.has"):
files.has.return_value = False
- users.update_user_name(user, 'dummy')
- assert user.name == 'dummy'
+ users.update_user_name(user, "dummy")
+ assert user.name == "dummy"
def test_update_user_name_moves_avatar(user_factory, config_injector):
- config_injector({'user_name_regex': '^[a-z]+$'})
- user = user_factory(name='old')
- with patch('szurubooru.func.files.has'), \
- patch('szurubooru.func.files.move'):
+ config_injector({"user_name_regex": "^[a-z]+$"})
+ user = user_factory(name="old")
+ with patch("szurubooru.func.files.has"), patch(
+ "szurubooru.func.files.move"
+ ):
files.has.return_value = True
- users.update_user_name(user, 'new')
+ users.update_user_name(user, "new")
files.move.assert_called_once_with(
- 'avatars/old.png', 'avatars/new.png')
+ "avatars/old.png", "avatars/new.png"
+ )
def test_update_user_password_with_empty_string(user_factory):
@@ -307,72 +326,74 @@ def test_update_user_password_with_empty_string(user_factory):
def test_update_user_password_with_invalid_string(
- user_factory, config_injector):
- config_injector({'password_regex': '^[a-z]+$'})
+ user_factory, config_injector
+):
+ config_injector({"password_regex": "^[a-z]+$"})
user = user_factory()
with pytest.raises(users.InvalidPasswordError):
- users.update_user_password(user, '0')
+ users.update_user_password(user, "0")
def test_update_user_password(user_factory, config_injector):
- config_injector({'password_regex': '^[a-z]+$'})
+ config_injector({"password_regex": "^[a-z]+$"})
user = user_factory()
- with patch('szurubooru.func.auth.create_password'), \
- patch('szurubooru.func.auth.get_password_hash'):
- auth.create_password.return_value = 'salt'
- auth.get_password_hash.return_value = ('hash', 3)
- users.update_user_password(user, 'a')
- assert user.password_salt == 'salt'
- assert user.password_hash == 'hash'
+ with patch("szurubooru.func.auth.create_password"), patch(
+ "szurubooru.func.auth.get_password_hash"
+ ):
+ auth.create_password.return_value = "salt"
+ auth.get_password_hash.return_value = ("hash", 3)
+ users.update_user_password(user, "a")
+ assert user.password_salt == "salt"
+ assert user.password_hash == "hash"
assert user.password_revision == 3
def test_update_user_email_with_too_long_string(user_factory):
user = user_factory()
with pytest.raises(users.InvalidEmailError):
- users.update_user_email(user, 'a' * 300)
+ users.update_user_email(user, "a" * 300)
def test_update_user_email_with_invalid_email(user_factory):
user = user_factory()
- with patch('szurubooru.func.util.is_valid_email'):
+ with patch("szurubooru.func.util.is_valid_email"):
util.is_valid_email.return_value = False
with pytest.raises(users.InvalidEmailError):
- users.update_user_email(user, 'a')
+ users.update_user_email(user, "a")
def test_update_user_email_with_empty_string(user_factory):
user = user_factory()
- with patch('szurubooru.func.util.is_valid_email'):
+ with patch("szurubooru.func.util.is_valid_email"):
util.is_valid_email.return_value = True
- users.update_user_email(user, '')
+ users.update_user_email(user, "")
assert user.email is None
def test_update_user_email(user_factory):
user = user_factory()
- with patch('szurubooru.func.util.is_valid_email'):
+ with patch("szurubooru.func.util.is_valid_email"):
util.is_valid_email.return_value = True
- users.update_user_email(user, 'a')
- assert user.email == 'a'
+ users.update_user_email(user, "a")
+ assert user.email == "a"
def test_update_user_rank_with_empty_string(user_factory):
user = user_factory()
auth_user = user_factory()
with pytest.raises(users.InvalidRankError):
- users.update_user_rank(user, '', auth_user)
+ users.update_user_rank(user, "", auth_user)
def test_update_user_rank_with_invalid_string(user_factory):
user = user_factory()
auth_user = user_factory()
with pytest.raises(users.InvalidRankError):
- users.update_user_rank(user, 'invalid', auth_user)
+ users.update_user_rank(user, "invalid", auth_user)
with pytest.raises(users.InvalidRankError):
- users.update_user_rank(user, 'anonymous', auth_user)
+ users.update_user_rank(user, "anonymous", auth_user)
with pytest.raises(users.InvalidRankError):
- users.update_user_rank(user, 'nobody', auth_user)
+ users.update_user_rank(user, "nobody", auth_user)
def test_update_user_rank_with_higher_rank_than_possible(user_factory):
@@ -382,9 +403,9 @@ def test_update_user_rank_with_higher_rank_than_possible(user_factory):
auth_user = user_factory()
auth_user.rank = model.User.RANK_ANONYMOUS
with pytest.raises(errors.AuthError):
- users.update_user_rank(user, 'regular', auth_user)
+ users.update_user_rank(user, "regular", auth_user)
with pytest.raises(errors.AuthError):
- users.update_user_rank(auth_user, 'regular', auth_user)
+ users.update_user_rank(auth_user, "regular", auth_user)
def test_update_user_rank(user_factory):
@@ -393,8 +414,8 @@ def test_update_user_rank(user_factory):
user = user_factory()
auth_user = user_factory()
auth_user.rank = model.User.RANK_ADMINISTRATOR
- users.update_user_rank(user, 'regular', auth_user)
- users.update_user_rank(auth_user, 'regular', auth_user)
+ users.update_user_rank(user, "regular", auth_user)
+ users.update_user_rank(auth_user, "regular", auth_user)
assert user.rank == model.User.RANK_REGULAR
assert auth_user.rank == model.User.RANK_REGULAR
@@ -402,54 +423,57 @@ def test_update_user_rank(user_factory):
def test_update_user_avatar_with_invalid_style(user_factory):
user = user_factory()
with pytest.raises(users.InvalidAvatarError):
- users.update_user_avatar(user, 'invalid', b'')
+ users.update_user_avatar(user, "invalid", b"")
def test_update_user_avatar_to_gravatar(user_factory):
user = user_factory()
- users.update_user_avatar(user, 'gravatar')
+ users.update_user_avatar(user, "gravatar")
assert user.avatar_style == model.User.AVATAR_GRAVATAR
def test_update_user_avatar_to_empty_manual(user_factory):
user = user_factory()
- with patch('szurubooru.func.files.has'), \
- pytest.raises(users.InvalidAvatarError):
+ with patch("szurubooru.func.files.has"), pytest.raises(
+ users.InvalidAvatarError
+ ):
files.has.return_value = False
- users.update_user_avatar(user, 'manual', b'')
+ users.update_user_avatar(user, "manual", b"")
def test_update_user_avatar_to_previous_manual(user_factory):
user = user_factory()
- with patch('szurubooru.func.files.has'):
+ with patch("szurubooru.func.files.has"):
files.has.return_value = True
- users.update_user_avatar(user, 'manual', b'')
+ users.update_user_avatar(user, "manual", b"")
def test_update_user_avatar_to_new_manual(user_factory, config_injector):
config_injector(
- {'thumbnails': {'avatar_width': 500, 'avatar_height': 500}})
+ {"thumbnails": {"avatar_width": 500, "avatar_height": 500}}
+ )
user = user_factory()
- with patch('szurubooru.func.files.save'):
- users.update_user_avatar(user, 'manual', EMPTY_PIXEL)
+ with patch("szurubooru.func.files.save"):
+ users.update_user_avatar(user, "manual", EMPTY_PIXEL)
assert user.avatar_style == model.User.AVATAR_MANUAL
assert files.save.called
def test_bump_user_login_time(user_factory, fake_datetime):
user = user_factory()
- with fake_datetime('1997-01-01'):
+ with fake_datetime("1997-01-01"):
users.bump_user_login_time(user)
assert user.last_login_time == datetime(1997, 1, 1)
def test_reset_user_password(user_factory):
- with patch('szurubooru.func.auth.create_password'), \
- patch('szurubooru.func.auth.get_password_hash'):
+ with patch("szurubooru.func.auth.create_password"), patch(
+ "szurubooru.func.auth.get_password_hash"
+ ):
user = user_factory()
- auth.create_password.return_value = 'salt'
- auth.get_password_hash.return_value = ('hash', 3)
+ auth.create_password.return_value = "salt"
+ auth.get_password_hash.return_value = ("hash", 3)
users.reset_user_password(user)
- assert user.password_salt == 'salt'
- assert user.password_hash == 'hash'
+ assert user.password_salt == "salt"
+ assert user.password_hash == "hash"
assert user.password_revision == 3
diff --git a/server/szurubooru/tests/func/test_util.py b/server/szurubooru/tests/func/test_util.py
index 1307ab90..f42ba29e 100644
--- a/server/szurubooru/tests/func/test_util.py
+++ b/server/szurubooru/tests/func/test_util.py
@@ -1,40 +1,47 @@
from datetime import datetime
+
import pytest
+
from szurubooru import errors
from szurubooru.func import util
-
dt = datetime
def test_parsing_empty_date_time():
with pytest.raises(errors.ValidationError):
- util.parse_time_range('')
+ util.parse_time_range("")
-@pytest.mark.parametrize('output,input', [
- ((dt(1997, 1, 2, 0, 0, 0), dt(1997, 1, 2, 23, 59, 59)), 'today'),
- ((dt(1997, 1, 1, 0, 0, 0), dt(1997, 1, 1, 23, 59, 59)), 'yesterday'),
- ((dt(1999, 1, 1, 0, 0, 0), dt(1999, 12, 31, 23, 59, 59)), '1999'),
- ((dt(1999, 2, 1, 0, 0, 0), dt(1999, 2, 28, 23, 59, 59)), '1999-2'),
- ((dt(1999, 2, 1, 0, 0, 0), dt(1999, 2, 28, 23, 59, 59)), '1999-02'),
- ((dt(1999, 2, 6, 0, 0, 0), dt(1999, 2, 6, 23, 59, 59)), '1999-2-6'),
- ((dt(1999, 2, 6, 0, 0, 0), dt(1999, 2, 6, 23, 59, 59)), '1999-02-6'),
- ((dt(1999, 2, 6, 0, 0, 0), dt(1999, 2, 6, 23, 59, 59)), '1999-2-06'),
- ((dt(1999, 2, 6, 0, 0, 0), dt(1999, 2, 6, 23, 59, 59)), '1999-02-06'),
-])
+@pytest.mark.parametrize(
+ "output,input",
+ [
+ ((dt(1997, 1, 2, 0, 0, 0), dt(1997, 1, 2, 23, 59, 59)), "today"),
+ ((dt(1997, 1, 1, 0, 0, 0), dt(1997, 1, 1, 23, 59, 59)), "yesterday"),
+ ((dt(1999, 1, 1, 0, 0, 0), dt(1999, 12, 31, 23, 59, 59)), "1999"),
+ ((dt(1999, 2, 1, 0, 0, 0), dt(1999, 2, 28, 23, 59, 59)), "1999-2"),
+ ((dt(1999, 2, 1, 0, 0, 0), dt(1999, 2, 28, 23, 59, 59)), "1999-02"),
+ ((dt(1999, 2, 6, 0, 0, 0), dt(1999, 2, 6, 23, 59, 59)), "1999-2-6"),
+ ((dt(1999, 2, 6, 0, 0, 0), dt(1999, 2, 6, 23, 59, 59)), "1999-02-6"),
+ ((dt(1999, 2, 6, 0, 0, 0), dt(1999, 2, 6, 23, 59, 59)), "1999-2-06"),
+ ((dt(1999, 2, 6, 0, 0, 0), dt(1999, 2, 6, 23, 59, 59)), "1999-02-06"),
+ ],
+)
def test_parsing_date_time(fake_datetime, input, output):
- with fake_datetime('1997-01-02 03:04:05'):
+ with fake_datetime("1997-01-02 03:04:05"):
assert util.parse_time_range(input) == output
-@pytest.mark.parametrize('input,output', [
- ([], []),
- (['a', 'b', 'c'], ['a', 'b', 'c']),
- (['a', 'b', 'a'], ['a', 'b']),
- (['a', 'a', 'b'], ['a', 'b']),
- (['a', 'A', 'b'], ['a', 'b']),
- (['a', 'A', 'b', 'B'], ['a', 'b']),
-])
+@pytest.mark.parametrize(
+ "input,output",
+ [
+ ([], []),
+ (["a", "b", "c"], ["a", "b", "c"]),
+ (["a", "b", "a"], ["a", "b"]),
+ (["a", "a", "b"], ["a", "b"]),
+ (["a", "A", "b"], ["a", "b"]),
+ (["a", "A", "b", "B"], ["a", "b"]),
+ ],
+)
def test_icase_unique(input, output):
assert util.icase_unique(input) == output
diff --git a/server/szurubooru/tests/middleware/test_authenticator.py b/server/szurubooru/tests/middleware/test_authenticator.py
index be21a931..9a4a3cc6 100644
--- a/server/szurubooru/tests/middleware/test_authenticator.py
+++ b/server/szurubooru/tests/middleware/test_authenticator.py
@@ -1,7 +1,9 @@
from unittest.mock import patch
+
import pytest
+
from szurubooru import db
-from szurubooru.func import auth, users, user_tokens
+from szurubooru.func import auth, user_tokens, users
from szurubooru.middleware import authenticator
from szurubooru.rest import errors
@@ -17,14 +19,12 @@ def test_process_request_bump_login(context_factory, user_factory):
db.session.add(user)
db.session.flush()
ctx = context_factory(
- headers={
- 'Authorization': 'Basic dGVzdFVzZXI6dGVzdFRva2Vu'
- },
- params={
- 'bump-login': 'true'
- })
- with patch('szurubooru.func.auth.is_valid_password'), \
- patch('szurubooru.func.users.get_user_by_name'):
+ headers={"Authorization": "Basic dGVzdFVzZXI6dGVzdFRva2Vu"},
+ params={"bump-login": "true"},
+ )
+ with patch("szurubooru.func.auth.is_valid_password"), patch(
+ "szurubooru.func.users.get_user_by_name"
+ ):
users.get_user_by_name.return_value = user
auth.is_valid_password.return_value = True
authenticator.process_request(ctx)
@@ -32,20 +32,18 @@ def test_process_request_bump_login(context_factory, user_factory):
def test_process_request_bump_login_with_token(
- context_factory, user_token_factory):
+ context_factory, user_token_factory
+):
user_token = user_token_factory()
db.session.add(user_token)
db.session.flush()
ctx = context_factory(
- headers={
- 'Authorization': 'Token dGVzdFVzZXI6dGVzdFRva2Vu'
- },
- params={
- 'bump-login': 'true'
- })
- with patch('szurubooru.func.auth.is_valid_token'), \
- patch('szurubooru.func.users.get_user_by_name'), \
- patch('szurubooru.func.user_tokens.get_by_user_and_token'):
+ headers={"Authorization": "Token dGVzdFVzZXI6dGVzdFRva2Vu"},
+ params={"bump-login": "true"},
+ )
+ with patch("szurubooru.func.auth.is_valid_token"), patch(
+ "szurubooru.func.users.get_user_by_name"
+ ), patch("szurubooru.func.user_tokens.get_by_user_and_token"):
users.get_user_by_name.return_value = user_token.user
user_tokens.get_by_user_and_token.return_value = user_token
auth.is_valid_token.return_value = True
@@ -57,11 +55,11 @@ def test_process_request_bump_login_with_token(
def test_process_request_basic_auth_valid(context_factory, user_factory):
user = user_factory()
ctx = context_factory(
- headers={
- 'Authorization': 'Basic dGVzdFVzZXI6dGVzdFBhc3N3b3Jk'
- })
- with patch('szurubooru.func.auth.is_valid_password'), \
- patch('szurubooru.func.users.get_user_by_name'):
+ headers={"Authorization": "Basic dGVzdFVzZXI6dGVzdFBhc3N3b3Jk"}
+ )
+ with patch("szurubooru.func.auth.is_valid_password"), patch(
+ "szurubooru.func.users.get_user_by_name"
+ ):
users.get_user_by_name.return_value = user
auth.is_valid_password.return_value = True
authenticator.process_request(ctx)
@@ -71,12 +69,11 @@ def test_process_request_basic_auth_valid(context_factory, user_factory):
def test_process_request_token_auth_valid(context_factory, user_token_factory):
user_token = user_token_factory()
ctx = context_factory(
- headers={
- 'Authorization': 'Token dGVzdFVzZXI6dGVzdFRva2Vu'
- })
- with patch('szurubooru.func.auth.is_valid_token'), \
- patch('szurubooru.func.users.get_user_by_name'), \
- patch('szurubooru.func.user_tokens.get_by_user_and_token'):
+ headers={"Authorization": "Token dGVzdFVzZXI6dGVzdFRva2Vu"}
+ )
+ with patch("szurubooru.func.auth.is_valid_token"), patch(
+ "szurubooru.func.users.get_user_by_name"
+ ), patch("szurubooru.func.user_tokens.get_by_user_and_token"):
users.get_user_by_name.return_value = user_token.user
user_tokens.get_by_user_and_token.return_value = user_token
auth.is_valid_token.return_value = True
@@ -85,9 +82,6 @@ def test_process_request_token_auth_valid(context_factory, user_token_factory):
def test_process_request_bad_header(context_factory):
- ctx = context_factory(
- headers={
- 'Authorization': 'Secret SuperSecretValue'
- })
+ ctx = context_factory(headers={"Authorization": "Secret SuperSecretValue"})
with pytest.raises(errors.HttpBadRequest):
authenticator.process_request(ctx)
diff --git a/server/szurubooru/tests/model/test_comment.py b/server/szurubooru/tests/model/test_comment.py
index ffd51893..fcbf1763 100644
--- a/server/szurubooru/tests/model/test_comment.py
+++ b/server/szurubooru/tests/model/test_comment.py
@@ -1,4 +1,5 @@
from datetime import datetime
+
from szurubooru import db, model
@@ -6,7 +7,7 @@ def test_saving_comment(user_factory, post_factory):
user = user_factory()
post = post_factory()
comment = model.Comment()
- comment.text = 'long text' * 1000
+ comment.text = "long text" * 1000
comment.user = user
comment.post = post
comment.creation_time = datetime(1997, 1, 1)
@@ -17,7 +18,7 @@ def test_saving_comment(user_factory, post_factory):
db.session.refresh(comment)
assert not db.session.dirty
assert comment.user is not None and comment.user.user_id is not None
- assert comment.text == 'long text' * 1000
+ assert comment.text == "long text" * 1000
assert comment.creation_time == datetime(1997, 1, 1)
assert comment.last_edit_time == datetime(1998, 1, 1)
diff --git a/server/szurubooru/tests/model/test_pool.py b/server/szurubooru/tests/model/test_pool.py
index 589e9ba6..bec95605 100644
--- a/server/szurubooru/tests/model/test_pool.py
+++ b/server/szurubooru/tests/model/test_pool.py
@@ -1,24 +1,24 @@
from datetime import datetime
+
import pytest
+
from szurubooru import db, model
@pytest.fixture(autouse=True)
def inject_config(config_injector):
- config_injector({
- 'delete_source_files': False,
- 'secret': 'secret',
- 'data_dir': ''
- })
+ config_injector(
+ {"delete_source_files": False, "secret": "secret", "data_dir": ""}
+ )
def test_saving_pool(pool_factory, post_factory):
post1 = post_factory()
post2 = post_factory()
pool = model.Pool()
- pool.names = [model.PoolName('alias1', 0), model.PoolName('alias2', 1)]
+ pool.names = [model.PoolName("alias1", 0), model.PoolName("alias2", 1)]
pool.posts = []
- pool.category = model.PoolCategory('category')
+ pool.category = model.PoolCategory("category")
pool.creation_time = datetime(1997, 1, 1)
pool.last_edit_time = datetime(1998, 1, 1)
db.session.add_all([pool, post1, post2])
@@ -30,13 +30,13 @@ def test_saving_pool(pool_factory, post_factory):
db.session.commit()
pool = (
- db.session
- .query(model.Pool)
+ db.session.query(model.Pool)
.join(model.PoolName)
- .filter(model.PoolName.name == 'alias1')
- .one())
- assert [pool_name.name for pool_name in pool.names] == ['alias1', 'alias2']
- assert pool.category.name == 'category'
+ .filter(model.PoolName.name == "alias1")
+ .one()
+ )
+ assert [pool_name.name for pool_name in pool.names] == ["alias1", "alias2"]
+ assert pool.category.name == "category"
assert pool.creation_time == datetime(1997, 1, 1)
assert pool.last_edit_time == datetime(1998, 1, 1)
assert [post.post_id for post in pool.posts] == [1, 2]
@@ -46,9 +46,9 @@ def test_cascade_deletions(pool_factory, post_factory):
post1 = post_factory()
post2 = post_factory()
pool = model.Pool()
- pool.names = [model.PoolName('alias1', 0), model.PoolName('alias2', 1)]
+ pool.names = [model.PoolName("alias1", 0), model.PoolName("alias2", 1)]
pool.posts = []
- pool.category = model.PoolCategory('category')
+ pool.category = model.PoolCategory("category")
pool.creation_time = datetime(1997, 1, 1)
pool.last_edit_time = datetime(1998, 1, 1)
db.session.add_all([pool, post1, post2])
diff --git a/server/szurubooru/tests/model/test_post.py b/server/szurubooru/tests/model/test_post.py
index 47c088d3..f01455d3 100644
--- a/server/szurubooru/tests/model/test_post.py
+++ b/server/szurubooru/tests/model/test_post.py
@@ -1,15 +1,15 @@
from datetime import datetime
+
import pytest
+
from szurubooru import db, model
@pytest.fixture(autouse=True)
def inject_config(config_injector):
- config_injector({
- 'secret': 'secret',
- 'data_dir': '',
- 'delete_source_files': False
- })
+ config_injector(
+ {"secret": "secret", "data_dir": "", "delete_source_files": False}
+ )
def test_saving_post(post_factory, user_factory, tag_factory):
@@ -19,12 +19,12 @@ def test_saving_post(post_factory, user_factory, tag_factory):
related_post1 = post_factory()
related_post2 = post_factory()
post = model.Post()
- post.safety = 'safety'
- post.type = 'type'
- post.checksum = 'deadbeef'
+ post.safety = "safety"
+ post.type = "type"
+ post.checksum = "deadbeef"
post.creation_time = datetime(1997, 1, 1)
post.last_edit_time = datetime(1998, 1, 1)
- post.mime_type = 'application/whatever'
+ post.mime_type = "application/whatever"
db.session.add_all([user, tag1, tag2, related_post1, related_post2, post])
post.user = user
@@ -39,9 +39,9 @@ def test_saving_post(post_factory, user_factory, tag_factory):
db.session.refresh(related_post2)
assert not db.session.dirty
assert post.user.user_id is not None
- assert post.safety == 'safety'
- assert post.type == 'type'
- assert post.checksum == 'deadbeef'
+ assert post.safety == "safety"
+ assert post.type == "type"
+ assert post.checksum == "deadbeef"
assert post.creation_time == datetime(1997, 1, 1)
assert post.last_edit_time == datetime(1998, 1, 1)
assert len(post.relations) == 2
@@ -51,7 +51,8 @@ def test_saving_post(post_factory, user_factory, tag_factory):
def test_cascade_deletions(
- post_factory, user_factory, tag_factory, comment_factory):
+ post_factory, user_factory, tag_factory, comment_factory
+):
user = user_factory()
tag1 = tag_factory()
tag2 = tag_factory()
@@ -59,8 +60,9 @@ def test_cascade_deletions(
related_post2 = post_factory()
post = post_factory()
comment = comment_factory(post=post, user=user)
- db.session.add_all([
- user, tag1, tag2, post, related_post1, related_post2, comment])
+ db.session.add_all(
+ [user, tag1, tag2, post, related_post1, related_post2, comment]
+ )
db.session.flush()
score = model.PostScore()
@@ -78,11 +80,11 @@ def test_cascade_deletions(
feature.time = datetime(1997, 1, 1)
note = model.PostNote()
note.post = post
- note.polygon = ''
- note.text = ''
+ note.polygon = ""
+ note.text = ""
signature = model.PostSignature()
signature.post = post
- signature.signature = b'testvalue'
+ signature.signature = b"testvalue"
signature.words = list(range(50))
db.session.add_all([score, favorite, feature, note, signature])
db.session.flush()
diff --git a/server/szurubooru/tests/model/test_tag.py b/server/szurubooru/tests/model/test_tag.py
index b677eeff..9332f0da 100644
--- a/server/szurubooru/tests/model/test_tag.py
+++ b/server/szurubooru/tests/model/test_tag.py
@@ -1,27 +1,27 @@
from datetime import datetime
+
import pytest
+
from szurubooru import db, model
@pytest.fixture(autouse=True)
def inject_config(config_injector):
- config_injector({
- 'delete_source_files': False,
- 'secret': 'secret',
- 'data_dir': ''
- })
+ config_injector(
+ {"delete_source_files": False, "secret": "secret", "data_dir": ""}
+ )
def test_saving_tag(tag_factory):
- sug1 = tag_factory(names=['sug1'])
- sug2 = tag_factory(names=['sug2'])
- imp1 = tag_factory(names=['imp1'])
- imp2 = tag_factory(names=['imp2'])
+ sug1 = tag_factory(names=["sug1"])
+ sug2 = tag_factory(names=["sug2"])
+ imp1 = tag_factory(names=["imp1"])
+ imp2 = tag_factory(names=["imp2"])
tag = model.Tag()
- tag.names = [model.TagName('alias1', 0), model.TagName('alias2', 1)]
+ tag.names = [model.TagName("alias1", 0), model.TagName("alias2", 1)]
tag.suggestions = []
tag.implications = []
- tag.category = model.TagCategory('category')
+ tag.category = model.TagCategory("category")
tag.creation_time = datetime(1997, 1, 1)
tag.last_edit_time = datetime(1998, 1, 1)
db.session.add_all([tag, sug1, sug2, imp1, imp2])
@@ -39,31 +39,35 @@ def test_saving_tag(tag_factory):
db.session.commit()
tag = (
- db.session
- .query(model.Tag)
+ db.session.query(model.Tag)
.join(model.TagName)
- .filter(model.TagName.name == 'alias1')
- .one())
- assert [tag_name.name for tag_name in tag.names] == ['alias1', 'alias2']
- assert tag.category.name == 'category'
+ .filter(model.TagName.name == "alias1")
+ .one()
+ )
+ assert [tag_name.name for tag_name in tag.names] == ["alias1", "alias2"]
+ assert tag.category.name == "category"
assert tag.creation_time == datetime(1997, 1, 1)
assert tag.last_edit_time == datetime(1998, 1, 1)
- assert [relation.names[0].name for relation in tag.suggestions] \
- == ['sug1', 'sug2']
- assert [relation.names[0].name for relation in tag.implications] \
- == ['imp1', 'imp2']
+ assert [relation.names[0].name for relation in tag.suggestions] == [
+ "sug1",
+ "sug2",
+ ]
+ assert [relation.names[0].name for relation in tag.implications] == [
+ "imp1",
+ "imp2",
+ ]
def test_cascade_deletions(tag_factory):
- sug1 = tag_factory(names=['sug1'])
- sug2 = tag_factory(names=['sug2'])
- imp1 = tag_factory(names=['imp1'])
- imp2 = tag_factory(names=['imp2'])
+ sug1 = tag_factory(names=["sug1"])
+ sug2 = tag_factory(names=["sug2"])
+ imp1 = tag_factory(names=["imp1"])
+ imp2 = tag_factory(names=["imp2"])
tag = model.Tag()
- tag.names = [model.TagName('alias1', 0), model.TagName('alias2', 1)]
+ tag.names = [model.TagName("alias1", 0), model.TagName("alias2", 1)]
tag.suggestions = []
tag.implications = []
- tag.category = model.TagCategory('category')
+ tag.category = model.TagCategory("category")
tag.creation_time = datetime(1997, 1, 1)
tag.last_edit_time = datetime(1998, 1, 1)
tag.post_count = 1
diff --git a/server/szurubooru/tests/model/test_user.py b/server/szurubooru/tests/model/test_user.py
index ced3a5ef..20279a00 100644
--- a/server/szurubooru/tests/model/test_user.py
+++ b/server/szurubooru/tests/model/test_user.py
@@ -1,25 +1,26 @@
from datetime import datetime
+
from szurubooru import db, model
def test_saving_user():
user = model.User()
- user.name = 'name'
- user.password_salt = 'salt'
- user.password_hash = 'hash'
- user.email = 'email'
- user.rank = 'rank'
+ user.name = "name"
+ user.password_salt = "salt"
+ user.password_hash = "hash"
+ user.email = "email"
+ user.rank = "rank"
user.creation_time = datetime(1997, 1, 1)
user.avatar_style = model.User.AVATAR_GRAVATAR
db.session.add(user)
db.session.flush()
db.session.refresh(user)
assert not db.session.dirty
- assert user.name == 'name'
- assert user.password_salt == 'salt'
- assert user.password_hash == 'hash'
- assert user.email == 'email'
- assert user.rank == 'rank'
+ assert user.name == "name"
+ assert user.password_salt == "salt"
+ assert user.password_hash == "hash"
+ assert user.email == "email"
+ assert user.rank == "rank"
assert user.creation_time == datetime(1997, 1, 1)
assert user.avatar_style == model.User.AVATAR_GRAVATAR
@@ -43,10 +44,9 @@ def test_comment_count(user_factory, comment_factory):
db.session.add(user)
db.session.flush()
assert user.comment_count == 0
- db.session.add_all([
- comment_factory(user=user),
- comment_factory(),
- ])
+ db.session.add_all(
+ [comment_factory(user=user), comment_factory(),]
+ )
db.session.flush()
db.session.refresh(user)
assert user.comment_count == 1
@@ -60,10 +60,12 @@ def test_favorite_count(user_factory, post_factory):
assert user1.comment_count == 0
post1 = post_factory()
post2 = post_factory()
- db.session.add_all([
- model.PostFavorite(post=post1, time=datetime.utcnow(), user=user1),
- model.PostFavorite(post=post2, time=datetime.utcnow(), user=user2),
- ])
+ db.session.add_all(
+ [
+ model.PostFavorite(post=post1, time=datetime.utcnow(), user=user1),
+ model.PostFavorite(post=post2, time=datetime.utcnow(), user=user2),
+ ]
+ )
db.session.flush()
db.session.refresh(user1)
assert user1.favorite_post_count == 1
@@ -78,12 +80,16 @@ def test_liked_post_count(user_factory, post_factory):
assert user1.disliked_post_count == 0
post1 = post_factory()
post2 = post_factory()
- db.session.add_all([
- model.PostScore(
- post=post1, time=datetime.utcnow(), user=user1, score=1),
- model.PostScore(
- post=post2, time=datetime.utcnow(), user=user2, score=1),
- ])
+ db.session.add_all(
+ [
+ model.PostScore(
+ post=post1, time=datetime.utcnow(), user=user1, score=1
+ ),
+ model.PostScore(
+ post=post2, time=datetime.utcnow(), user=user2, score=1
+ ),
+ ]
+ )
db.session.flush()
db.session.refresh(user1)
assert user1.liked_post_count == 1
@@ -99,12 +105,16 @@ def test_disliked_post_count(user_factory, post_factory):
assert user1.disliked_post_count == 0
post1 = post_factory()
post2 = post_factory()
- db.session.add_all([
- model.PostScore(
- post=post1, time=datetime.utcnow(), user=user1, score=-1),
- model.PostScore(
- post=post2, time=datetime.utcnow(), user=user2, score=1),
- ])
+ db.session.add_all(
+ [
+ model.PostScore(
+ post=post1, time=datetime.utcnow(), user=user1, score=-1
+ ),
+ model.PostScore(
+ post=post2, time=datetime.utcnow(), user=user2, score=1
+ ),
+ ]
+ )
db.session.flush()
db.session.refresh(user1)
assert user1.liked_post_count == 0
@@ -147,10 +157,10 @@ def test_cascade_deletions(post_factory, user_factory, comment_factory):
snapshot = model.Snapshot()
snapshot.user = user
snapshot.creation_time = datetime(1997, 1, 1)
- snapshot.resource_type = '-'
+ snapshot.resource_type = "-"
snapshot.resource_pkey = 1
- snapshot.resource_name = '-'
- snapshot.operation = '-'
+ snapshot.resource_name = "-"
+ snapshot.operation = "-"
db.session.add_all([user, post, comment, snapshot])
db.session.commit()
diff --git a/server/szurubooru/tests/model/test_user_token.py b/server/szurubooru/tests/model/test_user_token.py
index 0280082e..cddb5cf5 100644
--- a/server/szurubooru/tests/model/test_user_token.py
+++ b/server/szurubooru/tests/model/test_user_token.py
@@ -1,4 +1,5 @@
from datetime import datetime
+
from szurubooru import db
@@ -9,6 +10,6 @@ def test_saving_user_token(user_token_factory):
db.session.refresh(user_token)
assert not db.session.dirty
assert user_token.user is not None
- assert user_token.token == 'dummy'
+ assert user_token.token == "dummy"
assert user_token.enabled is True
assert user_token.creation_time == datetime(1997, 1, 1)
diff --git a/server/szurubooru/tests/rest/test_context.py b/server/szurubooru/tests/rest/test_context.py
index 0de1e320..ec652b18 100644
--- a/server/szurubooru/tests/rest/test_context.py
+++ b/server/szurubooru/tests/rest/test_context.py
@@ -1,33 +1,38 @@
import unittest.mock
+
import pytest
-from szurubooru import rest, errors
+
+from szurubooru import errors, rest
from szurubooru.func import net
def test_has_param():
- ctx = rest.Context(env={}, method=None, url=None, params={'key': 'value'})
- assert ctx.has_param('key')
- assert not ctx.has_param('non-existing')
+ ctx = rest.Context(env={}, method=None, url=None, params={"key": "value"})
+ assert ctx.has_param("key")
+ assert not ctx.has_param("non-existing")
def test_get_file():
ctx = rest.Context(
- env={}, method=None, url=None, files={'key': b'content'})
- assert ctx.get_file('key') == b'content'
+ env={}, method=None, url=None, files={"key": b"content"}
+ )
+ assert ctx.get_file("key") == b"content"
with pytest.raises(errors.ValidationError):
- ctx.get_file('non-existing')
+ ctx.get_file("non-existing")
def test_get_file_from_url():
- with unittest.mock.patch('szurubooru.func.net.download'):
- net.download.return_value = b'content'
+ with unittest.mock.patch("szurubooru.func.net.download"):
+ net.download.return_value = b"content"
ctx = rest.Context(
- env={}, method=None, url=None, params={'keyUrl': 'example.com'})
- assert ctx.get_file('key') == b'content'
+ env={}, method=None, url=None, params={"keyUrl": "example.com"}
+ )
+ assert ctx.get_file("key") == b"content"
net.download.assert_called_once_with(
- 'example.com', use_video_downloader=False)
+ "example.com", use_video_downloader=False
+ )
with pytest.raises(errors.ValidationError):
- assert ctx.get_file('non-existing')
+ assert ctx.get_file("non-existing")
def test_getting_list_parameter():
@@ -35,12 +40,13 @@ def test_getting_list_parameter():
env={},
method=None,
url=None,
- params={'key': 'value', 'list': ['1', '2', '3']})
- assert ctx.get_param_as_list('key') == ['value']
- assert ctx.get_param_as_list('list') == ['1', '2', '3']
+ params={"key": "value", "list": ["1", "2", "3"]},
+ )
+ assert ctx.get_param_as_list("key") == ["value"]
+ assert ctx.get_param_as_list("list") == ["1", "2", "3"]
with pytest.raises(errors.ValidationError):
- ctx.get_param_as_list('non-existing')
- assert ctx.get_param_as_list('non-existing', default=['def']) == ['def']
+ ctx.get_param_as_list("non-existing")
+ assert ctx.get_param_as_list("non-existing", default=["def"]) == ["def"]
def test_getting_string_parameter():
@@ -48,12 +54,13 @@ def test_getting_string_parameter():
env={},
method=None,
url=None,
- params={'key': 'value', 'list': ['1', '2', '3']})
- assert ctx.get_param_as_string('key') == 'value'
- assert ctx.get_param_as_string('list') == '1,2,3'
+ params={"key": "value", "list": ["1", "2", "3"]},
+ )
+ assert ctx.get_param_as_string("key") == "value"
+ assert ctx.get_param_as_string("list") == "1,2,3"
with pytest.raises(errors.ValidationError):
- ctx.get_param_as_string('non-existing')
- assert ctx.get_param_as_string('non-existing', default='x') == 'x'
+ ctx.get_param_as_string("non-existing")
+ assert ctx.get_param_as_string("non-existing", default="x") == "x"
def test_getting_int_parameter():
@@ -61,55 +68,57 @@ def test_getting_int_parameter():
env={},
method=None,
url=None,
- params={'key': '50', 'err': 'invalid', 'list': [1, 2, 3]})
- assert ctx.get_param_as_int('key') == 50
+ params={"key": "50", "err": "invalid", "list": [1, 2, 3]},
+ )
+ assert ctx.get_param_as_int("key") == 50
with pytest.raises(errors.ValidationError):
- ctx.get_param_as_int('list')
+ ctx.get_param_as_int("list")
with pytest.raises(errors.ValidationError):
- ctx.get_param_as_int('non-existing')
- assert ctx.get_param_as_int('non-existing', default=5) == 5
+ ctx.get_param_as_int("non-existing")
+ assert ctx.get_param_as_int("non-existing", default=5) == 5
with pytest.raises(errors.ValidationError):
- ctx.get_param_as_int('err')
+ ctx.get_param_as_int("err")
with pytest.raises(errors.ValidationError):
- assert ctx.get_param_as_int('key', min=50) == 50
- ctx.get_param_as_int('key', min=51)
+ assert ctx.get_param_as_int("key", min=50) == 50
+ ctx.get_param_as_int("key", min=51)
with pytest.raises(errors.ValidationError):
- assert ctx.get_param_as_int('key', max=50) == 50
- ctx.get_param_as_int('key', max=49)
+ assert ctx.get_param_as_int("key", max=50) == 50
+ ctx.get_param_as_int("key", max=49)
def test_getting_bool_parameter():
def test(value):
ctx = rest.Context(
- env={}, method=None, url=None, params={'key': value})
- return ctx.get_param_as_bool('key')
+ env={}, method=None, url=None, params={"key": value}
+ )
+ return ctx.get_param_as_bool("key")
- assert test('1') is True
- assert test('y') is True
- assert test('yes') is True
- assert test('yep') is True
- assert test('yup') is True
- assert test('yeah') is True
- assert test('t') is True
- assert test('true') is True
- assert test('TRUE') is True
+ assert test("1") is True
+ assert test("y") is True
+ assert test("yes") is True
+ assert test("yep") is True
+ assert test("yup") is True
+ assert test("yeah") is True
+ assert test("t") is True
+ assert test("true") is True
+ assert test("TRUE") is True
- assert test('0') is False
- assert test('n') is False
- assert test('no') is False
- assert test('nope') is False
- assert test('f') is False
- assert test('false') is False
- assert test('FALSE') is False
+ assert test("0") is False
+ assert test("n") is False
+ assert test("no") is False
+ assert test("nope") is False
+ assert test("f") is False
+ assert test("false") is False
+ assert test("FALSE") is False
with pytest.raises(errors.ValidationError):
- test('herp')
+ test("herp")
with pytest.raises(errors.ValidationError):
- test('2')
+ test("2")
with pytest.raises(errors.ValidationError):
- test(['1', '2'])
+ test(["1", "2"])
ctx = rest.Context(env={}, method=None, url=None)
with pytest.raises(errors.ValidationError):
- ctx.get_param_as_bool('non-existing')
- assert ctx.get_param_as_bool('non-existing', default=True) is True
+ ctx.get_param_as_bool("non-existing")
+ assert ctx.get_param_as_bool("non-existing", default=True) is True
diff --git a/server/szurubooru/tests/search/configs/test_comment_search_config.py b/server/szurubooru/tests/search/configs/test_comment_search_config.py
index 7279c1be..a592b302 100644
--- a/server/szurubooru/tests/search/configs/test_comment_search_config.py
+++ b/server/szurubooru/tests/search/configs/test_comment_search_config.py
@@ -1,5 +1,7 @@
from datetime import datetime
+
import pytest
+
from szurubooru import db, search
@@ -12,22 +14,28 @@ def executor():
def verify_unpaged(executor):
def verify(input, expected_comment_text):
actual_count, actual_comments = executor.execute(
- input, offset=0, limit=100)
+ input, offset=0, limit=100
+ )
actual_comment_text = [c.text for c in actual_comments]
assert actual_count == len(expected_comment_text)
assert actual_comment_text == expected_comment_text
+
return verify
-@pytest.mark.parametrize('input,expected_comment_text', [
- ('creation-time:2014', ['t2', 't1']),
- ('creation-date:2014', ['t2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_comment_text",
+ [
+ ("creation-time:2014", ["t2", "t1"]),
+ ("creation-date:2014", ["t2", "t1"]),
+ ],
+)
def test_filter_by_creation_time(
- verify_unpaged, comment_factory, input, expected_comment_text):
- comment1 = comment_factory(text='t1')
- comment2 = comment_factory(text='t2')
- comment3 = comment_factory(text='t3')
+ verify_unpaged, comment_factory, input, expected_comment_text
+):
+ comment1 = comment_factory(text="t1")
+ comment2 = comment_factory(text="t2")
+ comment3 = comment_factory(text="t3")
comment1.creation_time = datetime(2014, 1, 1)
comment2.creation_time = datetime(2014, 6, 1)
comment3.creation_time = datetime(2015, 1, 1)
@@ -36,109 +44,107 @@ def test_filter_by_creation_time(
verify_unpaged(input, expected_comment_text)
-@pytest.mark.parametrize('input,expected_comment_text', [
- ('text:t1', ['t1']),
- ('text:t2', ['t2']),
- ('text:t1,t2', ['t1', 't2']),
- ('text:t*', ['t1', 't2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_comment_text",
+ [
+ ("text:t1", ["t1"]),
+ ("text:t2", ["t2"]),
+ ("text:t1,t2", ["t1", "t2"]),
+ ("text:t*", ["t1", "t2"]),
+ ],
+)
def test_filter_by_text(
- verify_unpaged, comment_factory, input, expected_comment_text):
- comment1 = comment_factory(text='t1')
- comment2 = comment_factory(text='t2')
+ verify_unpaged, comment_factory, input, expected_comment_text
+):
+ comment1 = comment_factory(text="t1")
+ comment2 = comment_factory(text="t2")
db.session.add_all([comment1, comment2])
db.session.flush()
verify_unpaged(input, expected_comment_text)
-@pytest.mark.parametrize('input,expected_comment_text', [
- ('user:u1', ['t1']),
- ('user:u2', ['t2']),
- ('user:u1,u2', ['t2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_comment_text",
+ [("user:u1", ["t1"]), ("user:u2", ["t2"]), ("user:u1,u2", ["t2", "t1"]),],
+)
def test_filter_by_user(
- verify_unpaged,
- comment_factory,
- user_factory,
- input,
- expected_comment_text):
- db.session.add(comment_factory(text='t2', user=user_factory(name='u2')))
- db.session.add(comment_factory(text='t1', user=user_factory(name='u1')))
+ verify_unpaged, comment_factory, user_factory, input, expected_comment_text
+):
+ db.session.add(comment_factory(text="t2", user=user_factory(name="u2")))
+ db.session.add(comment_factory(text="t1", user=user_factory(name="u1")))
db.session.flush()
verify_unpaged(input, expected_comment_text)
-@pytest.mark.parametrize('input,expected_comment_text', [
- ('post:1', ['t1']),
- ('post:2', ['t2']),
- ('post:1,2', ['t1', 't2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_comment_text",
+ [("post:1", ["t1"]), ("post:2", ["t2"]), ("post:1,2", ["t1", "t2"]),],
+)
def test_filter_by_post(
- verify_unpaged,
- comment_factory,
- post_factory,
- input,
- expected_comment_text):
- db.session.add(comment_factory(text='t1', post=post_factory(id=1)))
- db.session.add(comment_factory(text='t2', post=post_factory(id=2)))
+ verify_unpaged, comment_factory, post_factory, input, expected_comment_text
+):
+ db.session.add(comment_factory(text="t1", post=post_factory(id=1)))
+ db.session.add(comment_factory(text="t2", post=post_factory(id=2)))
db.session.flush()
verify_unpaged(input, expected_comment_text)
-@pytest.mark.parametrize('input,expected_comment_text', [
- ('', ['t1', 't2']),
- ('t1', ['t1']),
- ('t2', ['t2']),
- ('t1,t2', ['t1', 't2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_comment_text",
+ [
+ ("", ["t1", "t2"]),
+ ("t1", ["t1"]),
+ ("t2", ["t2"]),
+ ("t1,t2", ["t1", "t2"]),
+ ],
+)
def test_anonymous(
- verify_unpaged, comment_factory, input, expected_comment_text):
- db.session.add(comment_factory(text='t1'))
- db.session.add(comment_factory(text='t2'))
+ verify_unpaged, comment_factory, input, expected_comment_text
+):
+ db.session.add(comment_factory(text="t1"))
+ db.session.add(comment_factory(text="t2"))
db.session.flush()
verify_unpaged(input, expected_comment_text)
-@pytest.mark.parametrize('input,expected_comment_text', [
- ('sort:user', ['t1', 't2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_comment_text", [("sort:user", ["t1", "t2"]),]
+)
def test_sort_by_user(
- verify_unpaged,
- comment_factory,
- user_factory,
- input,
- expected_comment_text):
- db.session.add(comment_factory(text='t2', user=user_factory(name='u2')))
- db.session.add(comment_factory(text='t1', user=user_factory(name='u1')))
+ verify_unpaged, comment_factory, user_factory, input, expected_comment_text
+):
+ db.session.add(comment_factory(text="t2", user=user_factory(name="u2")))
+ db.session.add(comment_factory(text="t1", user=user_factory(name="u1")))
db.session.flush()
verify_unpaged(input, expected_comment_text)
-@pytest.mark.parametrize('input,expected_comment_text', [
- ('sort:post', ['t2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_comment_text", [("sort:post", ["t2", "t1"]),]
+)
def test_sort_by_post(
- verify_unpaged,
- comment_factory,
- post_factory,
- input,
- expected_comment_text):
- db.session.add(comment_factory(text='t1', post=post_factory(id=1)))
- db.session.add(comment_factory(text='t2', post=post_factory(id=2)))
+ verify_unpaged, comment_factory, post_factory, input, expected_comment_text
+):
+ db.session.add(comment_factory(text="t1", post=post_factory(id=1)))
+ db.session.add(comment_factory(text="t2", post=post_factory(id=2)))
db.session.flush()
verify_unpaged(input, expected_comment_text)
-@pytest.mark.parametrize('input,expected_comment_text', [
- ('', ['t3', 't2', 't1']),
- ('sort:creation-date', ['t3', 't2', 't1']),
- ('sort:creation-time', ['t3', 't2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_comment_text",
+ [
+ ("", ["t3", "t2", "t1"]),
+ ("sort:creation-date", ["t3", "t2", "t1"]),
+ ("sort:creation-time", ["t3", "t2", "t1"]),
+ ],
+)
def test_sort_by_creation_time(
- verify_unpaged, comment_factory, input, expected_comment_text):
- comment1 = comment_factory(text='t1')
- comment2 = comment_factory(text='t2')
- comment3 = comment_factory(text='t3')
+ verify_unpaged, comment_factory, input, expected_comment_text
+):
+ comment1 = comment_factory(text="t1")
+ comment2 = comment_factory(text="t2")
+ comment3 = comment_factory(text="t3")
comment1.creation_time = datetime(1991, 1, 1)
comment2.creation_time = datetime(1991, 1, 2)
comment3.creation_time = datetime(1991, 1, 3)
@@ -147,17 +153,21 @@ def test_sort_by_creation_time(
verify_unpaged(input, expected_comment_text)
-@pytest.mark.parametrize('input,expected_comment_text', [
- ('sort:last-edit-date', ['t3', 't2', 't1']),
- ('sort:last-edit-time', ['t3', 't2', 't1']),
- ('sort:edit-date', ['t3', 't2', 't1']),
- ('sort:edit-time', ['t3', 't2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_comment_text",
+ [
+ ("sort:last-edit-date", ["t3", "t2", "t1"]),
+ ("sort:last-edit-time", ["t3", "t2", "t1"]),
+ ("sort:edit-date", ["t3", "t2", "t1"]),
+ ("sort:edit-time", ["t3", "t2", "t1"]),
+ ],
+)
def test_sort_by_last_edit_time(
- verify_unpaged, comment_factory, input, expected_comment_text):
- comment1 = comment_factory(text='t1')
- comment2 = comment_factory(text='t2')
- comment3 = comment_factory(text='t3')
+ verify_unpaged, comment_factory, input, expected_comment_text
+):
+ comment1 = comment_factory(text="t1")
+ comment2 = comment_factory(text="t2")
+ comment3 = comment_factory(text="t3")
comment1.last_edit_time = datetime(1991, 1, 1)
comment2.last_edit_time = datetime(1991, 1, 2)
comment3.last_edit_time = datetime(1991, 1, 3)
diff --git a/server/szurubooru/tests/search/configs/test_pool_search_config.py b/server/szurubooru/tests/search/configs/test_pool_search_config.py
index 731a6767..201bf793 100644
--- a/server/szurubooru/tests/search/configs/test_pool_search_config.py
+++ b/server/szurubooru/tests/search/configs/test_pool_search_config.py
@@ -1,5 +1,7 @@
from datetime import datetime
+
import pytest
+
from szurubooru import db, errors, search
@@ -12,77 +14,106 @@ def executor():
def verify_unpaged(executor):
def verify(input, expected_pool_names):
actual_count, actual_pools = executor.execute(
- input, offset=0, limit=100)
+ input, offset=0, limit=100
+ )
actual_pool_names = [u.names[0].name for u in actual_pools]
assert actual_count == len(expected_pool_names)
assert actual_pool_names == expected_pool_names
+
return verify
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('', ['t1', 't2']),
- ('t1', ['t1']),
- ('t2', ['t2']),
- ('t1,t2', ['t1', 't2']),
- ('T1,T2', ['t1', 't2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names",
+ [
+ ("", ["t1", "t2"]),
+ ("t1", ["t1"]),
+ ("t2", ["t2"]),
+ ("t1,t2", ["t1", "t2"]),
+ ("T1,T2", ["t1", "t2"]),
+ ],
+)
def test_filter_anonymous(
- verify_unpaged, pool_factory, input, expected_pool_names):
- db.session.add(pool_factory(id=1, names=['t1']))
- db.session.add(pool_factory(id=2, names=['t2']))
+ verify_unpaged, pool_factory, input, expected_pool_names
+):
+ db.session.add(pool_factory(id=1, names=["t1"]))
+ db.session.add(pool_factory(id=2, names=["t2"]))
db.session.flush()
verify_unpaged(input, expected_pool_names)
-@pytest.mark.parametrize('db_driver,input,expected_pool_names', [
- (None, ',', None),
- (None, 't1,', None),
- (None, 't1,t2', ['t1', 't2']),
- (None, 't1\\,', []),
- (None, 'asd..asd', None),
- (None, 'asd\\..asd', []),
- (None, 'asd.\\.asd', []),
- (None, 'asd\\.\\.asd', []),
- (None, '-', None),
- (None, '\\-', ['-']),
- (None, '--', [
- 't1', 't2', '*', '*asd*', ':', 'asd:asd', '\\', '\\asd', '-asd',
- ]),
- (None, '\\--', []),
- (None, '-\\-', [
- 't1', 't2', '*', '*asd*', ':', 'asd:asd', '\\', '\\asd', '-asd',
- ]),
- (None, '-*', []),
- (None, '\\-*', ['-', '-asd']),
- (None, ':', None),
- (None, '\\:', [':']),
- (None, '\\:asd', []),
- (None, '*\\:*', [':', 'asd:asd']),
- (None, 'asd:asd', None),
- (None, 'asd\\:asd', ['asd:asd']),
- (None, '*', [
- 't1', 't2', '*', '*asd*', ':', 'asd:asd', '\\', '\\asd', '-', '-asd'
- ]),
- (None, '\\*', ['*']),
- (None, '\\', None),
- (None, '\\asd', None),
- ('psycopg2', '\\\\', ['\\']),
- ('psycopg2', '\\\\asd', ['\\asd']),
-])
+@pytest.mark.parametrize(
+ "db_driver,input,expected_pool_names",
+ [
+ (None, ",", None),
+ (None, "t1,", None),
+ (None, "t1,t2", ["t1", "t2"]),
+ (None, "t1\\,", []),
+ (None, "asd..asd", None),
+ (None, "asd\\..asd", []),
+ (None, "asd.\\.asd", []),
+ (None, "asd\\.\\.asd", []),
+ (None, "-", None),
+ (None, "\\-", ["-"]),
+ (
+ None,
+ "--",
+ ["t1", "t2", "*", "*asd*", ":", "asd:asd", "\\", "\\asd", "-asd",],
+ ),
+ (None, "\\--", []),
+ (
+ None,
+ "-\\-",
+ ["t1", "t2", "*", "*asd*", ":", "asd:asd", "\\", "\\asd", "-asd",],
+ ),
+ (None, "-*", []),
+ (None, "\\-*", ["-", "-asd"]),
+ (None, ":", None),
+ (None, "\\:", [":"]),
+ (None, "\\:asd", []),
+ (None, "*\\:*", [":", "asd:asd"]),
+ (None, "asd:asd", None),
+ (None, "asd\\:asd", ["asd:asd"]),
+ (
+ None,
+ "*",
+ [
+ "t1",
+ "t2",
+ "*",
+ "*asd*",
+ ":",
+ "asd:asd",
+ "\\",
+ "\\asd",
+ "-",
+ "-asd",
+ ],
+ ),
+ (None, "\\*", ["*"]),
+ (None, "\\", None),
+ (None, "\\asd", None),
+ ("psycopg2", "\\\\", ["\\"]),
+ ("psycopg2", "\\\\asd", ["\\asd"]),
+ ],
+)
def test_escaping(
- executor, pool_factory, input, expected_pool_names, db_driver):
- db.session.add_all([
- pool_factory(id=1, names=['t1']),
- pool_factory(id=2, names=['t2']),
- pool_factory(id=3, names=['*']),
- pool_factory(id=4, names=['*asd*']),
- pool_factory(id=5, names=[':']),
- pool_factory(id=6, names=['asd:asd']),
- pool_factory(id=7, names=['\\']),
- pool_factory(id=8, names=['\\asd']),
- pool_factory(id=9, names=['-']),
- pool_factory(id=10, names=['-asd'])
- ])
+ executor, pool_factory, input, expected_pool_names, db_driver
+):
+ db.session.add_all(
+ [
+ pool_factory(id=1, names=["t1"]),
+ pool_factory(id=2, names=["t2"]),
+ pool_factory(id=3, names=["*"]),
+ pool_factory(id=4, names=["*asd*"]),
+ pool_factory(id=5, names=[":"]),
+ pool_factory(id=6, names=["asd:asd"]),
+ pool_factory(id=7, names=["\\"]),
+ pool_factory(id=8, names=["\\asd"]),
+ pool_factory(id=9, names=["-"]),
+ pool_factory(id=10, names=["-asd"]),
+ ]
+ )
db.session.flush()
if db_driver and db.session.get_bind().driver != db_driver:
@@ -92,99 +123,112 @@ def test_escaping(
executor.execute(input, offset=0, limit=100)
else:
actual_count, actual_pools = executor.execute(
- input, offset=0, limit=100)
+ input, offset=0, limit=100
+ )
actual_pool_names = [u.names[0].name for u in actual_pools]
assert actual_count == len(expected_pool_names)
assert sorted(actual_pool_names) == sorted(expected_pool_names)
def test_filter_anonymous_starting_with_colon(verify_unpaged, pool_factory):
- db.session.add(pool_factory(id=1, names=[':t']))
+ db.session.add(pool_factory(id=1, names=[":t"]))
db.session.flush()
with pytest.raises(errors.SearchError):
- verify_unpaged(':t', [':t'])
- verify_unpaged('\\:t', [':t'])
+ verify_unpaged(":t", [":t"])
+ verify_unpaged("\\:t", [":t"])
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('name:pool1', ['pool1']),
- ('name:pool2', ['pool2']),
- ('name:none', []),
- ('name:', []),
- ('name:*1', ['pool1']),
- ('name:*2', ['pool2']),
- ('name:*', ['pool1', 'pool2', 'pool3', 'pool4']),
- ('name:p*', ['pool1', 'pool2', 'pool3', 'pool4']),
- ('name:*o*', ['pool1', 'pool2', 'pool3', 'pool4']),
- ('name:*!*', []),
- ('name:!*', []),
- ('name:*!', []),
- ('-name:pool1', ['pool2', 'pool3', 'pool4']),
- ('-name:pool2', ['pool1', 'pool3', 'pool4']),
- ('name:pool1,pool2', ['pool1', 'pool2']),
- ('-name:pool1,pool3', ['pool2', 'pool4']),
- ('name:pool4', ['pool4']),
- ('name:pool5', ['pool4']),
- ('name:pool4,pool5', ['pool4']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names",
+ [
+ ("name:pool1", ["pool1"]),
+ ("name:pool2", ["pool2"]),
+ ("name:none", []),
+ ("name:", []),
+ ("name:*1", ["pool1"]),
+ ("name:*2", ["pool2"]),
+ ("name:*", ["pool1", "pool2", "pool3", "pool4"]),
+ ("name:p*", ["pool1", "pool2", "pool3", "pool4"]),
+ ("name:*o*", ["pool1", "pool2", "pool3", "pool4"]),
+ ("name:*!*", []),
+ ("name:!*", []),
+ ("name:*!", []),
+ ("-name:pool1", ["pool2", "pool3", "pool4"]),
+ ("-name:pool2", ["pool1", "pool3", "pool4"]),
+ ("name:pool1,pool2", ["pool1", "pool2"]),
+ ("-name:pool1,pool3", ["pool2", "pool4"]),
+ ("name:pool4", ["pool4"]),
+ ("name:pool5", ["pool4"]),
+ ("name:pool4,pool5", ["pool4"]),
+ ],
+)
def test_filter_by_name(
- verify_unpaged, pool_factory, input, expected_pool_names):
- db.session.add(pool_factory(id=1, names=['pool1']))
- db.session.add(pool_factory(id=2, names=['pool2']))
- db.session.add(pool_factory(id=3, names=['pool3']))
- db.session.add(pool_factory(id=4, names=['pool4', 'pool5', 'pool6']))
+ verify_unpaged, pool_factory, input, expected_pool_names
+):
+ db.session.add(pool_factory(id=1, names=["pool1"]))
+ db.session.add(pool_factory(id=2, names=["pool2"]))
+ db.session.add(pool_factory(id=3, names=["pool3"]))
+ db.session.add(pool_factory(id=4, names=["pool4", "pool5", "pool6"]))
db.session.flush()
verify_unpaged(input, expected_pool_names)
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('category:cat1', ['t1', 't2']),
- ('category:cat2', ['t3']),
- ('category:cat1,cat2', ['t1', 't2', 't3']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names",
+ [
+ ("category:cat1", ["t1", "t2"]),
+ ("category:cat2", ["t3"]),
+ ("category:cat1,cat2", ["t1", "t2", "t3"]),
+ ],
+)
def test_filter_by_category(
- verify_unpaged,
- pool_factory,
- pool_category_factory,
- input,
- expected_pool_names):
- cat1 = pool_category_factory(name='cat1')
- cat2 = pool_category_factory(name='cat2')
- pool1 = pool_factory(id=1, names=['t1'], category=cat1)
- pool2 = pool_factory(id=2, names=['t2'], category=cat1)
- pool3 = pool_factory(id=3, names=['t3'], category=cat2)
+ verify_unpaged,
+ pool_factory,
+ pool_category_factory,
+ input,
+ expected_pool_names,
+):
+ cat1 = pool_category_factory(name="cat1")
+ cat2 = pool_category_factory(name="cat2")
+ pool1 = pool_factory(id=1, names=["t1"], category=cat1)
+ pool2 = pool_factory(id=2, names=["t2"], category=cat1)
+ pool3 = pool_factory(id=3, names=["t3"], category=cat2)
db.session.add_all([pool1, pool2, pool3])
db.session.flush()
verify_unpaged(input, expected_pool_names)
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('creation-time:2014', ['t1', 't2']),
- ('creation-date:2014', ['t1', 't2']),
- ('-creation-time:2014', ['t3']),
- ('-creation-date:2014', ['t3']),
- ('creation-time:2014..2014-06', ['t1', 't2']),
- ('creation-time:2014-06..2015-01-01', ['t2', 't3']),
- ('creation-time:2014-06..', ['t2', 't3']),
- ('creation-time:..2014-06', ['t1', 't2']),
- ('-creation-time:2014..2014-06', ['t3']),
- ('-creation-time:2014-06..2015-01-01', ['t1']),
- ('creation-date:2014..2014-06', ['t1', 't2']),
- ('creation-date:2014-06..2015-01-01', ['t2', 't3']),
- ('creation-date:2014-06..', ['t2', 't3']),
- ('creation-date:..2014-06', ['t1', 't2']),
- ('-creation-date:2014..2014-06', ['t3']),
- ('-creation-date:2014-06..2015-01-01', ['t1']),
- ('creation-time:2014-01,2015', ['t1', 't3']),
- ('creation-date:2014-01,2015', ['t1', 't3']),
- ('-creation-time:2014-01,2015', ['t2']),
- ('-creation-date:2014-01,2015', ['t2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names",
+ [
+ ("creation-time:2014", ["t1", "t2"]),
+ ("creation-date:2014", ["t1", "t2"]),
+ ("-creation-time:2014", ["t3"]),
+ ("-creation-date:2014", ["t3"]),
+ ("creation-time:2014..2014-06", ["t1", "t2"]),
+ ("creation-time:2014-06..2015-01-01", ["t2", "t3"]),
+ ("creation-time:2014-06..", ["t2", "t3"]),
+ ("creation-time:..2014-06", ["t1", "t2"]),
+ ("-creation-time:2014..2014-06", ["t3"]),
+ ("-creation-time:2014-06..2015-01-01", ["t1"]),
+ ("creation-date:2014..2014-06", ["t1", "t2"]),
+ ("creation-date:2014-06..2015-01-01", ["t2", "t3"]),
+ ("creation-date:2014-06..", ["t2", "t3"]),
+ ("creation-date:..2014-06", ["t1", "t2"]),
+ ("-creation-date:2014..2014-06", ["t3"]),
+ ("-creation-date:2014-06..2015-01-01", ["t1"]),
+ ("creation-time:2014-01,2015", ["t1", "t3"]),
+ ("creation-date:2014-01,2015", ["t1", "t3"]),
+ ("-creation-time:2014-01,2015", ["t2"]),
+ ("-creation-date:2014-01,2015", ["t2"]),
+ ],
+)
def test_filter_by_creation_time(
- verify_unpaged, pool_factory, input, expected_pool_names):
- pool1 = pool_factory(id=1, names=['t1'])
- pool2 = pool_factory(id=2, names=['t2'])
- pool3 = pool_factory(id=3, names=['t3'])
+ verify_unpaged, pool_factory, input, expected_pool_names
+):
+ pool1 = pool_factory(id=1, names=["t1"])
+ pool2 = pool_factory(id=2, names=["t2"])
+ pool3 = pool_factory(id=3, names=["t3"])
pool1.creation_time = datetime(2014, 1, 1)
pool2.creation_time = datetime(2014, 6, 1)
pool3.creation_time = datetime(2015, 1, 1)
@@ -193,17 +237,21 @@ def test_filter_by_creation_time(
verify_unpaged(input, expected_pool_names)
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('last-edit-date:2014', ['t1', 't3']),
- ('last-edit-time:2014', ['t1', 't3']),
- ('edit-date:2014', ['t1', 't3']),
- ('edit-time:2014', ['t1', 't3']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names",
+ [
+ ("last-edit-date:2014", ["t1", "t3"]),
+ ("last-edit-time:2014", ["t1", "t3"]),
+ ("edit-date:2014", ["t1", "t3"]),
+ ("edit-time:2014", ["t1", "t3"]),
+ ],
+)
def test_filter_by_edit_time(
- verify_unpaged, pool_factory, input, expected_pool_names):
- pool1 = pool_factory(id=1, names=['t1'])
- pool2 = pool_factory(id=2, names=['t2'])
- pool3 = pool_factory(id=3, names=['t3'])
+ verify_unpaged, pool_factory, input, expected_pool_names
+):
+ pool1 = pool_factory(id=1, names=["t1"])
+ pool2 = pool_factory(id=2, names=["t2"])
+ pool3 = pool_factory(id=3, names=["t3"])
pool1.last_edit_time = datetime(2014, 1, 1)
pool2.last_edit_time = datetime(2015, 1, 1)
pool3.last_edit_time = datetime(2014, 1, 1)
@@ -212,24 +260,24 @@ def test_filter_by_edit_time(
verify_unpaged(input, expected_pool_names)
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('post-count:2', ['t1']),
- ('post-count:1', ['t2']),
- ('post-count:1..', ['t1', 't2']),
- ('post-count-min:1', ['t1', 't2']),
- ('post-count:..1', ['t2']),
- ('post-count-max:1', ['t2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names",
+ [
+ ("post-count:2", ["t1"]),
+ ("post-count:1", ["t2"]),
+ ("post-count:1..", ["t1", "t2"]),
+ ("post-count-min:1", ["t1", "t2"]),
+ ("post-count:..1", ["t2"]),
+ ("post-count-max:1", ["t2"]),
+ ],
+)
def test_filter_by_post_count(
- verify_unpaged,
- pool_factory,
- post_factory,
- input,
- expected_pool_names):
+ verify_unpaged, pool_factory, post_factory, input, expected_pool_names
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
- pool1 = pool_factory(id=1, names=['t1'])
- pool2 = pool_factory(id=2, names=['t2'])
+ pool1 = pool_factory(id=1, names=["t1"])
+ pool2 = pool_factory(id=2, names=["t2"])
db.session.add_all([post1, post2, pool1, pool2])
pool1.posts.append(post1)
pool1.posts.append(post2)
@@ -238,49 +286,57 @@ def test_filter_by_post_count(
verify_unpaged(input, expected_pool_names)
-@pytest.mark.parametrize('input', [
- 'post-count:..',
- 'post-count:asd',
- 'post-count:asd,1',
- 'post-count:1,asd',
- 'post-count:asd..1',
- 'post-count:1..asd',
-])
+@pytest.mark.parametrize(
+ "input",
+ [
+ "post-count:..",
+ "post-count:asd",
+ "post-count:asd,1",
+ "post-count:1,asd",
+ "post-count:asd..1",
+ "post-count:1..asd",
+ ],
+)
def test_filter_by_invalid_input(executor, input):
with pytest.raises(errors.SearchError):
executor.execute(input, offset=0, limit=100)
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('', ['t1', 't2']),
- ('sort:name', ['t1', 't2']),
- ('-sort:name', ['t2', 't1']),
- ('sort:name,asc', ['t1', 't2']),
- ('sort:name,desc', ['t2', 't1']),
- ('-sort:name,asc', ['t2', 't1']),
- ('-sort:name,desc', ['t1', 't2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names",
+ [
+ ("", ["t1", "t2"]),
+ ("sort:name", ["t1", "t2"]),
+ ("-sort:name", ["t2", "t1"]),
+ ("sort:name,asc", ["t1", "t2"]),
+ ("sort:name,desc", ["t2", "t1"]),
+ ("-sort:name,asc", ["t2", "t1"]),
+ ("-sort:name,desc", ["t1", "t2"]),
+ ],
+)
def test_sort_by_name(
- verify_unpaged,
- pool_factory,
- input,
- expected_pool_names):
- db.session.add(pool_factory(id=2, names=['t2']))
- db.session.add(pool_factory(id=1, names=['t1']))
+ verify_unpaged, pool_factory, input, expected_pool_names
+):
+ db.session.add(pool_factory(id=2, names=["t2"]))
+ db.session.add(pool_factory(id=1, names=["t1"]))
db.session.flush()
verify_unpaged(input, expected_pool_names)
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('', ['t1', 't2', 't3']),
- ('sort:creation-date', ['t3', 't2', 't1']),
- ('sort:creation-time', ['t3', 't2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names",
+ [
+ ("", ["t1", "t2", "t3"]),
+ ("sort:creation-date", ["t3", "t2", "t1"]),
+ ("sort:creation-time", ["t3", "t2", "t1"]),
+ ],
+)
def test_sort_by_creation_time(
- verify_unpaged, pool_factory, input, expected_pool_names):
- pool1 = pool_factory(id=1, names=['t1'])
- pool2 = pool_factory(id=2, names=['t2'])
- pool3 = pool_factory(id=3, names=['t3'])
+ verify_unpaged, pool_factory, input, expected_pool_names
+):
+ pool1 = pool_factory(id=1, names=["t1"])
+ pool2 = pool_factory(id=2, names=["t2"])
+ pool3 = pool_factory(id=3, names=["t3"])
pool1.creation_time = datetime(1991, 1, 1)
pool2.creation_time = datetime(1991, 1, 2)
pool3.creation_time = datetime(1991, 1, 3)
@@ -289,18 +345,22 @@ def test_sort_by_creation_time(
verify_unpaged(input, expected_pool_names)
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('', ['t1', 't2', 't3']),
- ('sort:last-edit-date', ['t3', 't2', 't1']),
- ('sort:last-edit-time', ['t3', 't2', 't1']),
- ('sort:edit-date', ['t3', 't2', 't1']),
- ('sort:edit-time', ['t3', 't2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names",
+ [
+ ("", ["t1", "t2", "t3"]),
+ ("sort:last-edit-date", ["t3", "t2", "t1"]),
+ ("sort:last-edit-time", ["t3", "t2", "t1"]),
+ ("sort:edit-date", ["t3", "t2", "t1"]),
+ ("sort:edit-time", ["t3", "t2", "t1"]),
+ ],
+)
def test_sort_by_last_edit_time(
- verify_unpaged, pool_factory, input, expected_pool_names):
- pool1 = pool_factory(id=1, names=['t1'])
- pool2 = pool_factory(id=2, names=['t2'])
- pool3 = pool_factory(id=3, names=['t3'])
+ verify_unpaged, pool_factory, input, expected_pool_names
+):
+ pool1 = pool_factory(id=1, names=["t1"])
+ pool2 = pool_factory(id=2, names=["t2"])
+ pool3 = pool_factory(id=3, names=["t3"])
pool1.last_edit_time = datetime(1991, 1, 1)
pool2.last_edit_time = datetime(1991, 1, 2)
pool3.last_edit_time = datetime(1991, 1, 3)
@@ -309,19 +369,16 @@ def test_sort_by_last_edit_time(
verify_unpaged(input, expected_pool_names)
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('sort:post-count', ['t2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names", [("sort:post-count", ["t2", "t1"]),]
+)
def test_sort_by_post_count(
- verify_unpaged,
- pool_factory,
- post_factory,
- input,
- expected_pool_names):
+ verify_unpaged, pool_factory, post_factory, input, expected_pool_names
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
- pool1 = pool_factory(id=1, names=['t1'])
- pool2 = pool_factory(id=2, names=['t2'])
+ pool1 = pool_factory(id=1, names=["t1"])
+ pool2 = pool_factory(id=2, names=["t2"])
db.session.add_all([post1, post2, pool1, pool2])
pool1.posts.append(post1)
pool2.posts.append(post1)
@@ -330,20 +387,21 @@ def test_sort_by_post_count(
verify_unpaged(input, expected_pool_names)
-@pytest.mark.parametrize('input,expected_pool_names', [
- ('sort:category', ['t3', 't1', 't2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_pool_names", [("sort:category", ["t3", "t1", "t2"]),]
+)
def test_sort_by_category(
- verify_unpaged,
- pool_factory,
- pool_category_factory,
- input,
- expected_pool_names):
- cat1 = pool_category_factory(name='cat1')
- cat2 = pool_category_factory(name='cat2')
- pool1 = pool_factory(id=1, names=['t1'], category=cat2)
- pool2 = pool_factory(id=2, names=['t2'], category=cat2)
- pool3 = pool_factory(id=3, names=['t3'], category=cat1)
+ verify_unpaged,
+ pool_factory,
+ pool_category_factory,
+ input,
+ expected_pool_names,
+):
+ cat1 = pool_category_factory(name="cat1")
+ cat2 = pool_category_factory(name="cat2")
+ pool1 = pool_factory(id=1, names=["t1"], category=cat2)
+ pool2 = pool_factory(id=2, names=["t2"], category=cat2)
+ pool3 = pool_factory(id=3, names=["t3"], category=cat1)
db.session.add_all([pool1, pool2, pool3])
db.session.flush()
verify_unpaged(input, expected_pool_names)
diff --git a/server/szurubooru/tests/search/configs/test_post_search_config.py b/server/szurubooru/tests/search/configs/test_post_search_config.py
index 462594c6..172d1ff4 100644
--- a/server/szurubooru/tests/search/configs/test_post_search_config.py
+++ b/server/szurubooru/tests/search/configs/test_post_search_config.py
@@ -1,15 +1,17 @@
from datetime import datetime
+
import pytest
-from szurubooru import db, model, errors, search
+
+from szurubooru import db, errors, model, search
@pytest.fixture
def fav_factory(user_factory):
def factory(post, user=None):
return model.PostFavorite(
- post=post,
- user=user or user_factory(),
- time=datetime.utcnow())
+ post=post, user=user or user_factory(), time=datetime.utcnow()
+ )
+
return factory
@@ -20,14 +22,17 @@ def score_factory(user_factory):
post=post,
user=user or user_factory(),
time=datetime.utcnow(),
- score=score)
+ score=score,
+ )
+
return factory
@pytest.fixture
def note_factory():
- def factory(text='...'):
- return model.PostNote(polygon='...', text=text)
+ def factory(text="..."):
+ return model.PostNote(polygon="...", text=text)
+
return factory
@@ -36,11 +41,10 @@ def feature_factory(user_factory):
def factory(post=None):
if post:
return model.PostFeature(
- time=datetime.utcnow(),
- user=user_factory(),
- post=post)
- return model.PostFeature(
- time=datetime.utcnow(), user=user_factory())
+ time=datetime.utcnow(), user=user_factory(), post=post
+ )
+ return model.PostFeature(time=datetime.utcnow(), user=user_factory())
+
return factory
@@ -57,6 +61,7 @@ def auth_executor(executor, user_factory):
db.session.flush()
executor.config.user = auth_user
return auth_user
+
return wrapper
@@ -64,21 +69,22 @@ def auth_executor(executor, user_factory):
def verify_unpaged(executor):
def verify(input, expected_post_ids, test_order=False):
actual_count, actual_posts = executor.execute(
- input, offset=0, limit=100)
+ input, offset=0, limit=100
+ )
actual_post_ids = list([p.post_id for p in actual_posts])
if not test_order:
actual_post_ids = sorted(actual_post_ids)
expected_post_ids = sorted(expected_post_ids)
assert actual_post_ids == expected_post_ids
assert actual_count == len(expected_post_ids)
+
return verify
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('id:1', [1]),
- ('id:3', [3]),
- ('id:1,3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [("id:1", [1]), ("id:3", [3]), ("id:1,3", [1, 3]),],
+)
def test_filter_by_id(verify_unpaged, post_factory, input, expected_post_ids):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
@@ -88,35 +94,39 @@ def test_filter_by_id(verify_unpaged, post_factory, input, expected_post_ids):
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('tag:t1', [1]),
- ('tag:t2', [2]),
- ('tag:t1,t2', [1, 2]),
- ('tag:t4a', [4]),
- ('tag:t4b', [4]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("tag:t1", [1]),
+ ("tag:t2", [2]),
+ ("tag:t1,t2", [1, 2]),
+ ("tag:t4a", [4]),
+ ("tag:t4b", [4]),
+ ],
+)
def test_filter_by_tag(
- verify_unpaged, post_factory, tag_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, tag_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
post4 = post_factory(id=4)
- post1.tags = [tag_factory(names=['t1'])]
- post2.tags = [tag_factory(names=['t2'])]
- post3.tags = [tag_factory(names=['t3'])]
- post4.tags = [tag_factory(names=['t4a', 't4b'])]
+ post1.tags = [tag_factory(names=["t1"])]
+ post2.tags = [tag_factory(names=["t2"])]
+ post3.tags = [tag_factory(names=["t3"])]
+ post4.tags = [tag_factory(names=["t4a", "t4b"])]
db.session.add_all([post1, post2, post3, post4])
db.session.flush()
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('score:1', [1]),
- ('score:3', [3]),
- ('score:1,3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [("score:1", [1]), ("score:3", [3]), ("score:1,3", [1, 3]),],
+)
def test_filter_by_score(
- verify_unpaged, post_factory, user_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, user_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -126,96 +136,111 @@ def test_filter_by_score(
score=post.post_id,
time=datetime.utcnow(),
post=post,
- user=user_factory()))
+ user=user_factory(),
+ )
+ )
db.session.add_all([post1, post2, post3])
db.session.flush()
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('uploader:', [4]),
- ('uploader:u1', [1]),
- ('uploader:u3', [3]),
- ('uploader:u1,u3', [1, 3]),
- ('upload:', [4]),
- ('upload:u1', [1]),
- ('upload:u3', [3]),
- ('upload:u1,u3', [1, 3]),
- ('submit:', [4]),
- ('submit:u1', [1]),
- ('submit:u3', [3]),
- ('submit:u1,u3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("uploader:", [4]),
+ ("uploader:u1", [1]),
+ ("uploader:u3", [3]),
+ ("uploader:u1,u3", [1, 3]),
+ ("upload:", [4]),
+ ("upload:u1", [1]),
+ ("upload:u3", [3]),
+ ("upload:u1,u3", [1, 3]),
+ ("submit:", [4]),
+ ("submit:u1", [1]),
+ ("submit:u3", [3]),
+ ("submit:u1,u3", [1, 3]),
+ ],
+)
def test_filter_by_uploader(
- verify_unpaged, post_factory, user_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, user_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
post4 = post_factory(id=4)
- post1.user = user_factory(name='u1')
- post2.user = user_factory(name='u2')
- post3.user = user_factory(name='u3')
+ post1.user = user_factory(name="u1")
+ post2.user = user_factory(name="u2")
+ post3.user = user_factory(name="u3")
db.session.add_all([post1, post2, post3, post4])
db.session.flush()
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('comment:u1', [1]),
- ('comment:u3', [3]),
- ('comment:u1,u3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [("comment:u1", [1]), ("comment:u3", [3]), ("comment:u1,u3", [1, 3]),],
+)
def test_filter_by_commenter(
- verify_unpaged,
- post_factory,
- user_factory,
- comment_factory,
- input,
- expected_post_ids):
+ verify_unpaged,
+ post_factory,
+ user_factory,
+ comment_factory,
+ input,
+ expected_post_ids,
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
- db.session.add_all([
- comment_factory(post=post1, user=user_factory(name='u1')),
- comment_factory(post=post2, user=user_factory(name='u2')),
- comment_factory(post=post3, user=user_factory(name='u3')),
- post1, post2, post3,
- ])
+ db.session.add_all(
+ [
+ comment_factory(post=post1, user=user_factory(name="u1")),
+ comment_factory(post=post2, user=user_factory(name="u2")),
+ comment_factory(post=post3, user=user_factory(name="u3")),
+ post1,
+ post2,
+ post3,
+ ]
+ )
db.session.flush()
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('fav:u1', [1]),
- ('fav:u3', [3]),
- ('fav:u1,u3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [("fav:u1", [1]), ("fav:u3", [3]), ("fav:u1,u3", [1, 3]),],
+)
def test_filter_by_favorite(
- verify_unpaged,
- post_factory,
- user_factory,
- fav_factory,
- input,
- expected_post_ids):
+ verify_unpaged,
+ post_factory,
+ user_factory,
+ fav_factory,
+ input,
+ expected_post_ids,
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
- db.session.add_all([
- fav_factory(post=post1, user=user_factory(name='u1')),
- fav_factory(post=post2, user=user_factory(name='u2')),
- fav_factory(post=post3, user=user_factory(name='u3')),
- post1, post2, post3])
+ db.session.add_all(
+ [
+ fav_factory(post=post1, user=user_factory(name="u1")),
+ fav_factory(post=post2, user=user_factory(name="u2")),
+ fav_factory(post=post3, user=user_factory(name="u3")),
+ post1,
+ post2,
+ post3,
+ ]
+ )
db.session.flush()
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('tag-count:1', [1]),
- ('tag-count:3', [3]),
- ('tag-count:1,3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [("tag-count:1", [1]), ("tag-count:3", [3]), ("tag-count:1,3", [1, 3]),],
+)
def test_filter_by_tag_count(
- verify_unpaged, post_factory, tag_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, tag_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -227,61 +252,75 @@ def test_filter_by_tag_count(
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('comment-count:1', [1]),
- ('comment-count:3', [3]),
- ('comment-count:1,3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("comment-count:1", [1]),
+ ("comment-count:3", [3]),
+ ("comment-count:1,3", [1, 3]),
+ ],
+)
def test_filter_by_comment_count(
- verify_unpaged,
- post_factory,
- comment_factory,
- input,
- expected_post_ids):
+ verify_unpaged, post_factory, comment_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
- db.session.add_all([
- comment_factory(post=post1),
- comment_factory(post=post2),
- comment_factory(post=post2),
- comment_factory(post=post3),
- comment_factory(post=post3),
- comment_factory(post=post3),
- post1, post2, post3])
+ db.session.add_all(
+ [
+ comment_factory(post=post1),
+ comment_factory(post=post2),
+ comment_factory(post=post2),
+ comment_factory(post=post3),
+ comment_factory(post=post3),
+ comment_factory(post=post3),
+ post1,
+ post2,
+ post3,
+ ]
+ )
db.session.flush()
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('fav-count:1', [1]),
- ('fav-count:3', [3]),
- ('fav-count:1,3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [("fav-count:1", [1]), ("fav-count:3", [3]), ("fav-count:1,3", [1, 3]),],
+)
def test_filter_by_favorite_count(
- verify_unpaged, post_factory, fav_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, fav_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
- db.session.add_all([
- fav_factory(post=post1),
- fav_factory(post=post2),
- fav_factory(post=post2),
- fav_factory(post=post3),
- fav_factory(post=post3),
- fav_factory(post=post3),
- post1, post2, post3])
+ db.session.add_all(
+ [
+ fav_factory(post=post1),
+ fav_factory(post=post2),
+ fav_factory(post=post2),
+ fav_factory(post=post3),
+ fav_factory(post=post3),
+ fav_factory(post=post3),
+ post1,
+ post2,
+ post3,
+ ]
+ )
db.session.flush()
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('note-count:1', [1]),
- ('note-count:3', [3]),
- ('note-count:1,3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("note-count:1", [1]),
+ ("note-count:3", [3]),
+ ("note-count:1,3", [1, 3]),
+ ],
+)
def test_filter_by_note_count(
- verify_unpaged, post_factory, note_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, note_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -293,36 +332,40 @@ def test_filter_by_note_count(
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('note-text:*', [1, 2, 3]),
- ('note-text:text2', [2]),
- ('note-text:text3*', [3]),
- ('note-text:text3a,text2', [2, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("note-text:*", [1, 2, 3]),
+ ("note-text:text2", [2]),
+ ("note-text:text3*", [3]),
+ ("note-text:text3a,text2", [2, 3]),
+ ],
+)
def test_filter_by_note_text(
- verify_unpaged, post_factory, note_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, note_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
- post1.notes = [note_factory(text='text1')]
- post2.notes = [note_factory(text='text2'), note_factory(text='text2')]
- post3.notes = [note_factory(text='text3a'), note_factory(text='text3b')]
+ post1.notes = [note_factory(text="text1")]
+ post2.notes = [note_factory(text="text2"), note_factory(text="text2")]
+ post3.notes = [note_factory(text="text3a"), note_factory(text="text3b")]
db.session.add_all([post1, post2, post3])
db.session.flush()
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('feature-count:1', [1]),
- ('feature-count:3', [3]),
- ('feature-count:1,3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("feature-count:1", [1]),
+ ("feature-count:3", [3]),
+ ("feature-count:1,3", [1, 3]),
+ ],
+)
def test_filter_by_feature_count(
- verify_unpaged,
- post_factory,
- feature_factory,
- input,
- expected_post_ids):
+ verify_unpaged, post_factory, feature_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -334,18 +377,22 @@ def test_filter_by_feature_count(
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('type:image', [1]),
- ('type:anim', [2]),
- ('type:animation', [2]),
- ('type:gif', [2]),
- ('type:video', [3]),
- ('type:webm', [3]),
- ('type:flash', [4]),
- ('type:swf', [4]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("type:image", [1]),
+ ("type:anim", [2]),
+ ("type:animation", [2]),
+ ("type:gif", [2]),
+ ("type:video", [3]),
+ ("type:webm", [3]),
+ ("type:flash", [4]),
+ ("type:swf", [4]),
+ ],
+)
def test_filter_by_type(
- verify_unpaged, post_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -359,14 +406,18 @@ def test_filter_by_type(
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('safety:safe', [1]),
- ('safety:sketchy', [2]),
- ('safety:questionable', [2]),
- ('safety:unsafe', [3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("safety:safe", [1]),
+ ("safety:sketchy", [2]),
+ ("safety:questionable", [2]),
+ ("safety:unsafe", [3]),
+ ],
+)
def test_filter_by_safety(
- verify_unpaged, post_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -380,34 +431,42 @@ def test_filter_by_safety(
def test_filter_by_invalid_type(executor):
with pytest.raises(errors.SearchError):
- executor.execute('type:invalid', offset=0, limit=100)
+ executor.execute("type:invalid", offset=0, limit=100)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('content-checksum:checksum1', [1]),
- ('content-checksum:checksum3', [3]),
- ('content-checksum:checksum1,checksum3', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("content-checksum:checksum1", [1]),
+ ("content-checksum:checksum3", [3]),
+ ("content-checksum:checksum1,checksum3", [1, 3]),
+ ],
+)
def test_filter_by_content_checksum(
- verify_unpaged, post_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
- post1.checksum = 'checksum1'
- post2.checksum = 'checksum2'
- post3.checksum = 'checksum3'
+ post1.checksum = "checksum1"
+ post2.checksum = "checksum2"
+ post3.checksum = "checksum3"
db.session.add_all([post1, post2, post3])
db.session.flush()
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('file-size:100', [1]),
- ('file-size:102', [3]),
- ('file-size:100,102', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("file-size:100", [1]),
+ ("file-size:102", [3]),
+ ("file-size:100,102", [1, 3]),
+ ],
+)
def test_filter_by_file_size(
- verify_unpaged, post_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -419,25 +478,29 @@ def test_filter_by_file_size(
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('image-width:100', [1]),
- ('image-width:200', [2]),
- ('image-width:100,300', [1, 3]),
- ('image-height:200', [1]),
- ('image-height:100', [2]),
- ('image-height:200,300', [1, 3]),
- ('image-area:20000', [1, 2]),
- ('image-area:90000', [3]),
- ('image-area:20000,90000', [1, 2, 3]),
- ('image-ar:1', [3]),
- ('image-ar:..0.9', [1, 4]),
- ('image-ar:1.1..', [2]),
- ('image-ar:1/1..1/1', [3]),
- ('image-ar:1:1..1:1', [3]),
- ('image-ar:0.62..0.63', [4]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("image-width:100", [1]),
+ ("image-width:200", [2]),
+ ("image-width:100,300", [1, 3]),
+ ("image-height:200", [1]),
+ ("image-height:100", [2]),
+ ("image-height:200,300", [1, 3]),
+ ("image-area:20000", [1, 2]),
+ ("image-area:90000", [3]),
+ ("image-area:20000,90000", [1, 2, 3]),
+ ("image-ar:1", [3]),
+ ("image-ar:..0.9", [1, 4]),
+ ("image-ar:1.1..", [2]),
+ ("image-ar:1/1..1/1", [3]),
+ ("image-ar:1:1..1:1", [3]),
+ ("image-ar:0.62..0.63", [4]),
+ ],
+)
def test_filter_by_image_size(
- verify_unpaged, post_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -457,25 +520,29 @@ def test_filter_by_image_size(
def test_filter_by_invalid_aspect_ratio(executor):
with pytest.raises(errors.SearchError):
- executor.execute('image-ar:1:1:1', offset=0, limit=100)
+ executor.execute("image-ar:1:1:1", offset=0, limit=100)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('creation-date:2014', [1]),
- ('creation-date:2016', [3]),
- ('creation-date:2014,2016', [1, 3]),
- ('creation-time:2014', [1]),
- ('creation-time:2016', [3]),
- ('creation-time:2014,2016', [1, 3]),
- ('date:2014', [1]),
- ('date:2016', [3]),
- ('date:2014,2016', [1, 3]),
- ('time:2014', [1]),
- ('time:2016', [3]),
- ('time:2014,2016', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("creation-date:2014", [1]),
+ ("creation-date:2016", [3]),
+ ("creation-date:2014,2016", [1, 3]),
+ ("creation-time:2014", [1]),
+ ("creation-time:2016", [3]),
+ ("creation-time:2014,2016", [1, 3]),
+ ("date:2014", [1]),
+ ("date:2016", [3]),
+ ("date:2014,2016", [1, 3]),
+ ("time:2014", [1]),
+ ("time:2016", [3]),
+ ("time:2014,2016", [1, 3]),
+ ],
+)
def test_filter_by_creation_time(
- verify_unpaged, post_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -487,22 +554,26 @@ def test_filter_by_creation_time(
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('last-edit-date:2014', [1]),
- ('last-edit-date:2016', [3]),
- ('last-edit-date:2014,2016', [1, 3]),
- ('last-edit-time:2014', [1]),
- ('last-edit-time:2016', [3]),
- ('last-edit-time:2014,2016', [1, 3]),
- ('edit-date:2014', [1]),
- ('edit-date:2016', [3]),
- ('edit-date:2014,2016', [1, 3]),
- ('edit-time:2014', [1]),
- ('edit-time:2016', [3]),
- ('edit-time:2014,2016', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("last-edit-date:2014", [1]),
+ ("last-edit-date:2016", [3]),
+ ("last-edit-date:2014,2016", [1, 3]),
+ ("last-edit-time:2014", [1]),
+ ("last-edit-time:2016", [3]),
+ ("last-edit-time:2014,2016", [1, 3]),
+ ("edit-date:2014", [1]),
+ ("edit-date:2016", [3]),
+ ("edit-date:2014,2016", [1, 3]),
+ ("edit-time:2014", [1]),
+ ("edit-time:2016", [3]),
+ ("edit-time:2014,2016", [1, 3]),
+ ],
+)
def test_filter_by_last_edit_time(
- verify_unpaged, post_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -514,20 +585,20 @@ def test_filter_by_last_edit_time(
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('comment-date:2014', [1]),
- ('comment-date:2016', [3]),
- ('comment-date:2014,2016', [1, 3]),
- ('comment-time:2014', [1]),
- ('comment-time:2016', [3]),
- ('comment-time:2014,2016', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("comment-date:2014", [1]),
+ ("comment-date:2016", [3]),
+ ("comment-date:2014,2016", [1, 3]),
+ ("comment-time:2014", [1]),
+ ("comment-time:2016", [3]),
+ ("comment-time:2014,2016", [1, 3]),
+ ],
+)
def test_filter_by_comment_date(
- verify_unpaged,
- post_factory,
- comment_factory,
- input,
- expected_post_ids):
+ verify_unpaged, post_factory, comment_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -542,16 +613,20 @@ def test_filter_by_comment_date(
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('fav-date:2014', [1]),
- ('fav-date:2016', [3]),
- ('fav-date:2014,2016', [1, 3]),
- ('fav-time:2014', [1]),
- ('fav-time:2016', [3]),
- ('fav-time:2014,2016', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("fav-date:2014", [1]),
+ ("fav-date:2016", [3]),
+ ("fav-date:2014,2016", [1, 3]),
+ ("fav-time:2014", [1]),
+ ("fav-time:2016", [3]),
+ ("fav-time:2014,2016", [1, 3]),
+ ],
+)
def test_filter_by_fav_date(
- verify_unpaged, post_factory, fav_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, fav_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -566,20 +641,20 @@ def test_filter_by_fav_date(
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('feature-date:2014', [1]),
- ('feature-date:2016', [3]),
- ('feature-date:2014,2016', [1, 3]),
- ('feature-time:2014', [1]),
- ('feature-time:2016', [3]),
- ('feature-time:2014,2016', [1, 3]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("feature-date:2014", [1]),
+ ("feature-date:2016", [3]),
+ ("feature-date:2014,2016", [1, 3]),
+ ("feature-time:2014", [1]),
+ ("feature-time:2016", [3]),
+ ("feature-time:2014,2016", [1, 3]),
+ ],
+)
def test_filter_by_feature_date(
- verify_unpaged,
- post_factory,
- feature_factory,
- input,
- expected_post_ids):
+ verify_unpaged, post_factory, feature_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
@@ -594,37 +669,40 @@ def test_filter_by_feature_date(
verify_unpaged(input, expected_post_ids)
-@pytest.mark.parametrize('input', [
- 'sort:random',
- 'sort:id',
- 'sort:score',
- 'sort:tag-count',
- 'sort:comment-count',
- 'sort:fav-count',
- 'sort:note-count',
- 'sort:feature-count',
- 'sort:file-size',
- 'sort:image-width',
- 'sort:width',
- 'sort:image-height',
- 'sort:height',
- 'sort:image-area',
- 'sort:area',
- 'sort:creation-date',
- 'sort:creation-time',
- 'sort:date',
- 'sort:time',
- 'sort:last-edit-date',
- 'sort:last-edit-time',
- 'sort:edit-date',
- 'sort:edit-time',
- 'sort:comment-date',
- 'sort:comment-time',
- 'sort:fav-date',
- 'sort:fav-time',
- 'sort:feature-date',
- 'sort:feature-time',
-])
+@pytest.mark.parametrize(
+ "input",
+ [
+ "sort:random",
+ "sort:id",
+ "sort:score",
+ "sort:tag-count",
+ "sort:comment-count",
+ "sort:fav-count",
+ "sort:note-count",
+ "sort:feature-count",
+ "sort:file-size",
+ "sort:image-width",
+ "sort:width",
+ "sort:image-height",
+ "sort:height",
+ "sort:image-area",
+ "sort:area",
+ "sort:creation-date",
+ "sort:creation-time",
+ "sort:date",
+ "sort:time",
+ "sort:last-edit-date",
+ "sort:last-edit-time",
+ "sort:edit-date",
+ "sort:edit-time",
+ "sort:comment-date",
+ "sort:comment-time",
+ "sort:fav-date",
+ "sort:fav-time",
+ "sort:feature-date",
+ "sort:feature-time",
+ ],
+)
def test_sort_tokens(verify_unpaged, post_factory, input):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
@@ -634,115 +712,124 @@ def test_sort_tokens(verify_unpaged, post_factory, input):
verify_unpaged(input, [1, 2, 3])
-@pytest.mark.parametrize('input,expected_post_ids', [
- ('', [1, 2, 3, 4]),
- ('t1', [1]),
- ('t2', [2]),
- ('t1,t2', [1, 2]),
- ('t4a', [4]),
- ('t4b', [4]),
-])
+@pytest.mark.parametrize(
+ "input,expected_post_ids",
+ [
+ ("", [1, 2, 3, 4]),
+ ("t1", [1]),
+ ("t2", [2]),
+ ("t1,t2", [1, 2]),
+ ("t4a", [4]),
+ ("t4b", [4]),
+ ],
+)
def test_anonymous(
- verify_unpaged, post_factory, tag_factory, input, expected_post_ids):
+ verify_unpaged, post_factory, tag_factory, input, expected_post_ids
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
post4 = post_factory(id=4)
- post1.tags = [tag_factory(names=['t1'])]
- post2.tags = [tag_factory(names=['t2'])]
- post3.tags = [tag_factory(names=['t3'])]
- post4.tags = [tag_factory(names=['t4a', 't4b'])]
+ post1.tags = [tag_factory(names=["t1"])]
+ post2.tags = [tag_factory(names=["t2"])]
+ post3.tags = [tag_factory(names=["t3"])]
+ post4.tags = [tag_factory(names=["t4a", "t4b"])]
db.session.add_all([post1, post2, post3, post4])
db.session.flush()
verify_unpaged(input, expected_post_ids)
def test_own_liked(
- auth_executor,
- post_factory,
- score_factory,
- user_factory,
- verify_unpaged):
+ auth_executor, post_factory, score_factory, user_factory, verify_unpaged
+):
auth_user = auth_executor()
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
- db.session.add_all([
- score_factory(post=post1, user=auth_user, score=1),
- score_factory(post=post2, user=user_factory(name='dummy'), score=1),
- score_factory(post=post3, user=auth_user, score=-1),
- post1, post2, post3,
- ])
+ db.session.add_all(
+ [
+ score_factory(post=post1, user=auth_user, score=1),
+ score_factory(
+ post=post2, user=user_factory(name="dummy"), score=1
+ ),
+ score_factory(post=post3, user=auth_user, score=-1),
+ post1,
+ post2,
+ post3,
+ ]
+ )
db.session.flush()
- verify_unpaged('special:liked', [1])
- verify_unpaged('-special:liked', [2, 3])
+ verify_unpaged("special:liked", [1])
+ verify_unpaged("-special:liked", [2, 3])
def test_own_disliked(
- auth_executor,
- post_factory,
- score_factory,
- user_factory,
- verify_unpaged):
+ auth_executor, post_factory, score_factory, user_factory, verify_unpaged
+):
auth_user = auth_executor()
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
- db.session.add_all([
- score_factory(post=post1, user=auth_user, score=-1),
- score_factory(post=post2, user=user_factory(name='dummy'), score=-1),
- score_factory(post=post3, user=auth_user, score=1),
- post1, post2, post3,
- ])
+ db.session.add_all(
+ [
+ score_factory(post=post1, user=auth_user, score=-1),
+ score_factory(
+ post=post2, user=user_factory(name="dummy"), score=-1
+ ),
+ score_factory(post=post3, user=auth_user, score=1),
+ post1,
+ post2,
+ post3,
+ ]
+ )
db.session.flush()
- verify_unpaged('special:disliked', [1])
- verify_unpaged('-special:disliked', [2, 3])
+ verify_unpaged("special:disliked", [1])
+ verify_unpaged("-special:disliked", [2, 3])
-@pytest.mark.parametrize('input', [
- 'liked:x',
- 'disliked:x',
-])
+@pytest.mark.parametrize("input", ["liked:x", "disliked:x",])
def test_someones_score(executor, input):
with pytest.raises(errors.SearchError):
executor.execute(input, offset=0, limit=100)
def test_own_fav(
- auth_executor,
- post_factory,
- fav_factory,
- user_factory,
- verify_unpaged):
+ auth_executor, post_factory, fav_factory, user_factory, verify_unpaged
+):
auth_user = auth_executor()
post1 = post_factory(id=1)
post2 = post_factory(id=2)
- db.session.add_all([
- fav_factory(post=post1, user=auth_user),
- fav_factory(post=post2, user=user_factory(name='unrelated')),
- post1, post2,
- ])
+ db.session.add_all(
+ [
+ fav_factory(post=post1, user=auth_user),
+ fav_factory(post=post2, user=user_factory(name="unrelated")),
+ post1,
+ post2,
+ ]
+ )
db.session.flush()
- verify_unpaged('special:fav', [1])
- verify_unpaged('-special:fav', [2])
+ verify_unpaged("special:fav", [1])
+ verify_unpaged("-special:fav", [2])
def test_tumbleweed(
- post_factory,
- fav_factory,
- comment_factory,
- score_factory,
- verify_unpaged):
+ post_factory, fav_factory, comment_factory, score_factory, verify_unpaged
+):
post1 = post_factory(id=1)
post2 = post_factory(id=2)
post3 = post_factory(id=3)
post4 = post_factory(id=4)
- db.session.add_all([
- comment_factory(post=post1),
- score_factory(post=post2),
- fav_factory(post=post3),
- post1, post2, post3, post4,
- ])
+ db.session.add_all(
+ [
+ comment_factory(post=post1),
+ score_factory(post=post2),
+ fav_factory(post=post3),
+ post1,
+ post2,
+ post3,
+ post4,
+ ]
+ )
db.session.flush()
- verify_unpaged('special:tumbleweed', [4])
- verify_unpaged('-special:tumbleweed', [1, 2, 3])
+ verify_unpaged("special:tumbleweed", [4])
+ verify_unpaged("-special:tumbleweed", [1, 2, 3])
diff --git a/server/szurubooru/tests/search/configs/test_tag_search_config.py b/server/szurubooru/tests/search/configs/test_tag_search_config.py
index 09a4c403..2ba1b9bc 100644
--- a/server/szurubooru/tests/search/configs/test_tag_search_config.py
+++ b/server/szurubooru/tests/search/configs/test_tag_search_config.py
@@ -1,5 +1,7 @@
from datetime import datetime
+
import pytest
+
from szurubooru import db, errors, search
@@ -12,77 +14,104 @@ def executor():
def verify_unpaged(executor):
def verify(input, expected_tag_names):
actual_count, actual_tags = executor.execute(
- input, offset=0, limit=100)
+ input, offset=0, limit=100
+ )
actual_tag_names = [u.names[0].name for u in actual_tags]
assert actual_count == len(expected_tag_names)
assert actual_tag_names == expected_tag_names
+
return verify
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('', ['t1', 't2']),
- ('t1', ['t1']),
- ('t2', ['t2']),
- ('t1,t2', ['t1', 't2']),
- ('T1,T2', ['t1', 't2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("", ["t1", "t2"]),
+ ("t1", ["t1"]),
+ ("t2", ["t2"]),
+ ("t1,t2", ["t1", "t2"]),
+ ("T1,T2", ["t1", "t2"]),
+ ],
+)
def test_filter_anonymous(
- verify_unpaged, tag_factory, input, expected_tag_names):
- db.session.add(tag_factory(names=['t1']))
- db.session.add(tag_factory(names=['t2']))
+ verify_unpaged, tag_factory, input, expected_tag_names
+):
+ db.session.add(tag_factory(names=["t1"]))
+ db.session.add(tag_factory(names=["t2"]))
db.session.flush()
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('db_driver,input,expected_tag_names', [
- (None, ',', None),
- (None, 't1,', None),
- (None, 't1,t2', ['t1', 't2']),
- (None, 't1\\,', []),
- (None, 'asd..asd', None),
- (None, 'asd\\..asd', []),
- (None, 'asd.\\.asd', []),
- (None, 'asd\\.\\.asd', []),
- (None, '-', None),
- (None, '\\-', ['-']),
- (None, '--', [
- 't1', 't2', '*', '*asd*', ':', 'asd:asd', '\\', '\\asd', '-asd',
- ]),
- (None, '\\--', []),
- (None, '-\\-', [
- 't1', 't2', '*', '*asd*', ':', 'asd:asd', '\\', '\\asd', '-asd',
- ]),
- (None, '-*', []),
- (None, '\\-*', ['-', '-asd']),
- (None, ':', None),
- (None, '\\:', [':']),
- (None, '\\:asd', []),
- (None, '*\\:*', [':', 'asd:asd']),
- (None, 'asd:asd', None),
- (None, 'asd\\:asd', ['asd:asd']),
- (None, '*', [
- 't1', 't2', '*', '*asd*', ':', 'asd:asd', '\\', '\\asd', '-', '-asd'
- ]),
- (None, '\\*', ['*']),
- (None, '\\', None),
- (None, '\\asd', None),
- ('psycopg2', '\\\\', ['\\']),
- ('psycopg2', '\\\\asd', ['\\asd']),
-])
-def test_escaping(
- executor, tag_factory, input, expected_tag_names, db_driver):
- db.session.add_all([
- tag_factory(names=['t1']),
- tag_factory(names=['t2']),
- tag_factory(names=['*']),
- tag_factory(names=['*asd*']),
- tag_factory(names=[':']),
- tag_factory(names=['asd:asd']),
- tag_factory(names=['\\']),
- tag_factory(names=['\\asd']),
- tag_factory(names=['-']),
- tag_factory(names=['-asd'])
- ])
+@pytest.mark.parametrize(
+ "db_driver,input,expected_tag_names",
+ [
+ (None, ",", None),
+ (None, "t1,", None),
+ (None, "t1,t2", ["t1", "t2"]),
+ (None, "t1\\,", []),
+ (None, "asd..asd", None),
+ (None, "asd\\..asd", []),
+ (None, "asd.\\.asd", []),
+ (None, "asd\\.\\.asd", []),
+ (None, "-", None),
+ (None, "\\-", ["-"]),
+ (
+ None,
+ "--",
+ ["t1", "t2", "*", "*asd*", ":", "asd:asd", "\\", "\\asd", "-asd",],
+ ),
+ (None, "\\--", []),
+ (
+ None,
+ "-\\-",
+ ["t1", "t2", "*", "*asd*", ":", "asd:asd", "\\", "\\asd", "-asd",],
+ ),
+ (None, "-*", []),
+ (None, "\\-*", ["-", "-asd"]),
+ (None, ":", None),
+ (None, "\\:", [":"]),
+ (None, "\\:asd", []),
+ (None, "*\\:*", [":", "asd:asd"]),
+ (None, "asd:asd", None),
+ (None, "asd\\:asd", ["asd:asd"]),
+ (
+ None,
+ "*",
+ [
+ "t1",
+ "t2",
+ "*",
+ "*asd*",
+ ":",
+ "asd:asd",
+ "\\",
+ "\\asd",
+ "-",
+ "-asd",
+ ],
+ ),
+ (None, "\\*", ["*"]),
+ (None, "\\", None),
+ (None, "\\asd", None),
+ ("psycopg2", "\\\\", ["\\"]),
+ ("psycopg2", "\\\\asd", ["\\asd"]),
+ ],
+)
+def test_escaping(executor, tag_factory, input, expected_tag_names, db_driver):
+ db.session.add_all(
+ [
+ tag_factory(names=["t1"]),
+ tag_factory(names=["t2"]),
+ tag_factory(names=["*"]),
+ tag_factory(names=["*asd*"]),
+ tag_factory(names=[":"]),
+ tag_factory(names=["asd:asd"]),
+ tag_factory(names=["\\"]),
+ tag_factory(names=["\\asd"]),
+ tag_factory(names=["-"]),
+ tag_factory(names=["-asd"]),
+ ]
+ )
db.session.flush()
if db_driver and db.session.get_bind().driver != db_driver:
@@ -92,99 +121,112 @@ def test_escaping(
executor.execute(input, offset=0, limit=100)
else:
actual_count, actual_tags = executor.execute(
- input, offset=0, limit=100)
+ input, offset=0, limit=100
+ )
actual_tag_names = [u.names[0].name for u in actual_tags]
assert actual_count == len(expected_tag_names)
assert sorted(actual_tag_names) == sorted(expected_tag_names)
def test_filter_anonymous_starting_with_colon(verify_unpaged, tag_factory):
- db.session.add(tag_factory(names=[':t']))
+ db.session.add(tag_factory(names=[":t"]))
db.session.flush()
with pytest.raises(errors.SearchError):
- verify_unpaged(':t', [':t'])
- verify_unpaged('\\:t', [':t'])
+ verify_unpaged(":t", [":t"])
+ verify_unpaged("\\:t", [":t"])
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('name:tag1', ['tag1']),
- ('name:tag2', ['tag2']),
- ('name:none', []),
- ('name:', []),
- ('name:*1', ['tag1']),
- ('name:*2', ['tag2']),
- ('name:*', ['tag1', 'tag2', 'tag3', 'tag4']),
- ('name:t*', ['tag1', 'tag2', 'tag3', 'tag4']),
- ('name:*a*', ['tag1', 'tag2', 'tag3', 'tag4']),
- ('name:*!*', []),
- ('name:!*', []),
- ('name:*!', []),
- ('-name:tag1', ['tag2', 'tag3', 'tag4']),
- ('-name:tag2', ['tag1', 'tag3', 'tag4']),
- ('name:tag1,tag2', ['tag1', 'tag2']),
- ('-name:tag1,tag3', ['tag2', 'tag4']),
- ('name:tag4', ['tag4']),
- ('name:tag5', ['tag4']),
- ('name:tag4,tag5', ['tag4']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("name:tag1", ["tag1"]),
+ ("name:tag2", ["tag2"]),
+ ("name:none", []),
+ ("name:", []),
+ ("name:*1", ["tag1"]),
+ ("name:*2", ["tag2"]),
+ ("name:*", ["tag1", "tag2", "tag3", "tag4"]),
+ ("name:t*", ["tag1", "tag2", "tag3", "tag4"]),
+ ("name:*a*", ["tag1", "tag2", "tag3", "tag4"]),
+ ("name:*!*", []),
+ ("name:!*", []),
+ ("name:*!", []),
+ ("-name:tag1", ["tag2", "tag3", "tag4"]),
+ ("-name:tag2", ["tag1", "tag3", "tag4"]),
+ ("name:tag1,tag2", ["tag1", "tag2"]),
+ ("-name:tag1,tag3", ["tag2", "tag4"]),
+ ("name:tag4", ["tag4"]),
+ ("name:tag5", ["tag4"]),
+ ("name:tag4,tag5", ["tag4"]),
+ ],
+)
def test_filter_by_name(
- verify_unpaged, tag_factory, input, expected_tag_names):
- db.session.add(tag_factory(names=['tag1']))
- db.session.add(tag_factory(names=['tag2']))
- db.session.add(tag_factory(names=['tag3']))
- db.session.add(tag_factory(names=['tag4', 'tag5', 'tag6']))
+ verify_unpaged, tag_factory, input, expected_tag_names
+):
+ db.session.add(tag_factory(names=["tag1"]))
+ db.session.add(tag_factory(names=["tag2"]))
+ db.session.add(tag_factory(names=["tag3"]))
+ db.session.add(tag_factory(names=["tag4", "tag5", "tag6"]))
db.session.flush()
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('category:cat1', ['t1', 't2']),
- ('category:cat2', ['t3']),
- ('category:cat1,cat2', ['t1', 't2', 't3']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("category:cat1", ["t1", "t2"]),
+ ("category:cat2", ["t3"]),
+ ("category:cat1,cat2", ["t1", "t2", "t3"]),
+ ],
+)
def test_filter_by_category(
- verify_unpaged,
- tag_factory,
- tag_category_factory,
- input,
- expected_tag_names):
- cat1 = tag_category_factory(name='cat1')
- cat2 = tag_category_factory(name='cat2')
- tag1 = tag_factory(names=['t1'], category=cat1)
- tag2 = tag_factory(names=['t2'], category=cat1)
- tag3 = tag_factory(names=['t3'], category=cat2)
+ verify_unpaged,
+ tag_factory,
+ tag_category_factory,
+ input,
+ expected_tag_names,
+):
+ cat1 = tag_category_factory(name="cat1")
+ cat2 = tag_category_factory(name="cat2")
+ tag1 = tag_factory(names=["t1"], category=cat1)
+ tag2 = tag_factory(names=["t2"], category=cat1)
+ tag3 = tag_factory(names=["t3"], category=cat2)
db.session.add_all([tag1, tag2, tag3])
db.session.flush()
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('creation-time:2014', ['t1', 't2']),
- ('creation-date:2014', ['t1', 't2']),
- ('-creation-time:2014', ['t3']),
- ('-creation-date:2014', ['t3']),
- ('creation-time:2014..2014-06', ['t1', 't2']),
- ('creation-time:2014-06..2015-01-01', ['t2', 't3']),
- ('creation-time:2014-06..', ['t2', 't3']),
- ('creation-time:..2014-06', ['t1', 't2']),
- ('-creation-time:2014..2014-06', ['t3']),
- ('-creation-time:2014-06..2015-01-01', ['t1']),
- ('creation-date:2014..2014-06', ['t1', 't2']),
- ('creation-date:2014-06..2015-01-01', ['t2', 't3']),
- ('creation-date:2014-06..', ['t2', 't3']),
- ('creation-date:..2014-06', ['t1', 't2']),
- ('-creation-date:2014..2014-06', ['t3']),
- ('-creation-date:2014-06..2015-01-01', ['t1']),
- ('creation-time:2014-01,2015', ['t1', 't3']),
- ('creation-date:2014-01,2015', ['t1', 't3']),
- ('-creation-time:2014-01,2015', ['t2']),
- ('-creation-date:2014-01,2015', ['t2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("creation-time:2014", ["t1", "t2"]),
+ ("creation-date:2014", ["t1", "t2"]),
+ ("-creation-time:2014", ["t3"]),
+ ("-creation-date:2014", ["t3"]),
+ ("creation-time:2014..2014-06", ["t1", "t2"]),
+ ("creation-time:2014-06..2015-01-01", ["t2", "t3"]),
+ ("creation-time:2014-06..", ["t2", "t3"]),
+ ("creation-time:..2014-06", ["t1", "t2"]),
+ ("-creation-time:2014..2014-06", ["t3"]),
+ ("-creation-time:2014-06..2015-01-01", ["t1"]),
+ ("creation-date:2014..2014-06", ["t1", "t2"]),
+ ("creation-date:2014-06..2015-01-01", ["t2", "t3"]),
+ ("creation-date:2014-06..", ["t2", "t3"]),
+ ("creation-date:..2014-06", ["t1", "t2"]),
+ ("-creation-date:2014..2014-06", ["t3"]),
+ ("-creation-date:2014-06..2015-01-01", ["t1"]),
+ ("creation-time:2014-01,2015", ["t1", "t3"]),
+ ("creation-date:2014-01,2015", ["t1", "t3"]),
+ ("-creation-time:2014-01,2015", ["t2"]),
+ ("-creation-date:2014-01,2015", ["t2"]),
+ ],
+)
def test_filter_by_creation_time(
- verify_unpaged, tag_factory, input, expected_tag_names):
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
- tag3 = tag_factory(names=['t3'])
+ verify_unpaged, tag_factory, input, expected_tag_names
+):
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
+ tag3 = tag_factory(names=["t3"])
tag1.creation_time = datetime(2014, 1, 1)
tag2.creation_time = datetime(2014, 6, 1)
tag3.creation_time = datetime(2015, 1, 1)
@@ -193,17 +235,21 @@ def test_filter_by_creation_time(
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('last-edit-date:2014', ['t1', 't3']),
- ('last-edit-time:2014', ['t1', 't3']),
- ('edit-date:2014', ['t1', 't3']),
- ('edit-time:2014', ['t1', 't3']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("last-edit-date:2014", ["t1", "t3"]),
+ ("last-edit-time:2014", ["t1", "t3"]),
+ ("edit-date:2014", ["t1", "t3"]),
+ ("edit-time:2014", ["t1", "t3"]),
+ ],
+)
def test_filter_by_edit_time(
- verify_unpaged, tag_factory, input, expected_tag_names):
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
- tag3 = tag_factory(names=['t3'])
+ verify_unpaged, tag_factory, input, expected_tag_names
+):
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
+ tag3 = tag_factory(names=["t3"])
tag1.last_edit_time = datetime(2014, 1, 1)
tag2.last_edit_time = datetime(2015, 1, 1)
tag3.last_edit_time = datetime(2014, 1, 1)
@@ -212,24 +258,28 @@ def test_filter_by_edit_time(
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('post-count:2', ['t1']),
- ('post-count:1', ['t2']),
- ('post-count:1..', ['t1', 't2']),
- ('post-count-min:1', ['t1', 't2']),
- ('post-count:..1', ['t2']),
- ('post-count-max:1', ['t2']),
- ('usage-count:2', ['t1']),
- ('usage-count:1', ['t2']),
- ('usages:2', ['t1']),
- ('usages:1', ['t2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("post-count:2", ["t1"]),
+ ("post-count:1", ["t2"]),
+ ("post-count:1..", ["t1", "t2"]),
+ ("post-count-min:1", ["t1", "t2"]),
+ ("post-count:..1", ["t2"]),
+ ("post-count-max:1", ["t2"]),
+ ("usage-count:2", ["t1"]),
+ ("usage-count:1", ["t2"]),
+ ("usages:2", ["t1"]),
+ ("usages:1", ["t2"]),
+ ],
+)
def test_filter_by_post_count(
- verify_unpaged, tag_factory, post_factory, input, expected_tag_names):
+ verify_unpaged, tag_factory, post_factory, input, expected_tag_names
+):
post1 = post_factory()
post2 = post_factory()
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
db.session.add_all([post1, post2, tag1, tag2])
post1.tags.append(tag1)
post1.tags.append(tag2)
@@ -238,31 +288,38 @@ def test_filter_by_post_count(
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input', [
- 'post-count:..',
- 'post-count:asd',
- 'post-count:asd,1',
- 'post-count:1,asd',
- 'post-count:asd..1',
- 'post-count:1..asd',
-])
+@pytest.mark.parametrize(
+ "input",
+ [
+ "post-count:..",
+ "post-count:asd",
+ "post-count:asd,1",
+ "post-count:1,asd",
+ "post-count:asd..1",
+ "post-count:1..asd",
+ ],
+)
def test_filter_by_invalid_input(executor, input):
with pytest.raises(errors.SearchError):
executor.execute(input, offset=0, limit=100)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('suggestion-count:2', ['t1']),
- ('suggestion-count:1', ['t2']),
- ('suggestion-count:0', ['sug1', 'sug2', 'sug3']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("suggestion-count:2", ["t1"]),
+ ("suggestion-count:1", ["t2"]),
+ ("suggestion-count:0", ["sug1", "sug2", "sug3"]),
+ ],
+)
def test_filter_by_suggestion_count(
- verify_unpaged, tag_factory, input, expected_tag_names):
- sug1 = tag_factory(names=['sug1'])
- sug2 = tag_factory(names=['sug2'])
- sug3 = tag_factory(names=['sug3'])
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
+ verify_unpaged, tag_factory, input, expected_tag_names
+):
+ sug1 = tag_factory(names=["sug1"])
+ sug2 = tag_factory(names=["sug2"])
+ sug3 = tag_factory(names=["sug3"])
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
db.session.add_all([sug1, sug3, tag2, sug2, tag1])
tag1.suggestions.append(sug1)
tag1.suggestions.append(sug2)
@@ -271,18 +328,22 @@ def test_filter_by_suggestion_count(
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('implication-count:2', ['t1']),
- ('implication-count:1', ['t2']),
- ('implication-count:0', ['sug1', 'sug2', 'sug3']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("implication-count:2", ["t1"]),
+ ("implication-count:1", ["t2"]),
+ ("implication-count:0", ["sug1", "sug2", "sug3"]),
+ ],
+)
def test_filter_by_implication_count(
- verify_unpaged, tag_factory, input, expected_tag_names):
- sug1 = tag_factory(names=['sug1'])
- sug2 = tag_factory(names=['sug2'])
- sug3 = tag_factory(names=['sug3'])
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
+ verify_unpaged, tag_factory, input, expected_tag_names
+):
+ sug1 = tag_factory(names=["sug1"])
+ sug2 = tag_factory(names=["sug2"])
+ sug3 = tag_factory(names=["sug3"])
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
db.session.add_all([sug1, sug3, tag2, sug2, tag1])
tag1.implications.append(sug1)
tag1.implications.append(sug2)
@@ -291,32 +352,39 @@ def test_filter_by_implication_count(
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('', ['t1', 't2']),
- ('sort:name', ['t1', 't2']),
- ('-sort:name', ['t2', 't1']),
- ('sort:name,asc', ['t1', 't2']),
- ('sort:name,desc', ['t2', 't1']),
- ('-sort:name,asc', ['t2', 't1']),
- ('-sort:name,desc', ['t1', 't2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("", ["t1", "t2"]),
+ ("sort:name", ["t1", "t2"]),
+ ("-sort:name", ["t2", "t1"]),
+ ("sort:name,asc", ["t1", "t2"]),
+ ("sort:name,desc", ["t2", "t1"]),
+ ("-sort:name,asc", ["t2", "t1"]),
+ ("-sort:name,desc", ["t1", "t2"]),
+ ],
+)
def test_sort_by_name(verify_unpaged, tag_factory, input, expected_tag_names):
- db.session.add(tag_factory(names=['t2']))
- db.session.add(tag_factory(names=['t1']))
+ db.session.add(tag_factory(names=["t2"]))
+ db.session.add(tag_factory(names=["t1"]))
db.session.flush()
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('', ['t1', 't2', 't3']),
- ('sort:creation-date', ['t3', 't2', 't1']),
- ('sort:creation-time', ['t3', 't2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("", ["t1", "t2", "t3"]),
+ ("sort:creation-date", ["t3", "t2", "t1"]),
+ ("sort:creation-time", ["t3", "t2", "t1"]),
+ ],
+)
def test_sort_by_creation_time(
- verify_unpaged, tag_factory, input, expected_tag_names):
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
- tag3 = tag_factory(names=['t3'])
+ verify_unpaged, tag_factory, input, expected_tag_names
+):
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
+ tag3 = tag_factory(names=["t3"])
tag1.creation_time = datetime(1991, 1, 1)
tag2.creation_time = datetime(1991, 1, 2)
tag3.creation_time = datetime(1991, 1, 3)
@@ -325,18 +393,22 @@ def test_sort_by_creation_time(
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('', ['t1', 't2', 't3']),
- ('sort:last-edit-date', ['t3', 't2', 't1']),
- ('sort:last-edit-time', ['t3', 't2', 't1']),
- ('sort:edit-date', ['t3', 't2', 't1']),
- ('sort:edit-time', ['t3', 't2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("", ["t1", "t2", "t3"]),
+ ("sort:last-edit-date", ["t3", "t2", "t1"]),
+ ("sort:last-edit-time", ["t3", "t2", "t1"]),
+ ("sort:edit-date", ["t3", "t2", "t1"]),
+ ("sort:edit-time", ["t3", "t2", "t1"]),
+ ],
+)
def test_sort_by_last_edit_time(
- verify_unpaged, tag_factory, input, expected_tag_names):
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
- tag3 = tag_factory(names=['t3'])
+ verify_unpaged, tag_factory, input, expected_tag_names
+):
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
+ tag3 = tag_factory(names=["t3"])
tag1.last_edit_time = datetime(1991, 1, 1)
tag2.last_edit_time = datetime(1991, 1, 2)
tag3.last_edit_time = datetime(1991, 1, 3)
@@ -345,17 +417,21 @@ def test_sort_by_last_edit_time(
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('sort:post-count', ['t2', 't1']),
- ('sort:usage-count', ['t2', 't1']),
- ('sort:usages', ['t2', 't1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [
+ ("sort:post-count", ["t2", "t1"]),
+ ("sort:usage-count", ["t2", "t1"]),
+ ("sort:usages", ["t2", "t1"]),
+ ],
+)
def test_sort_by_post_count(
- verify_unpaged, tag_factory, post_factory, input, expected_tag_names):
+ verify_unpaged, tag_factory, post_factory, input, expected_tag_names
+):
post1 = post_factory()
post2 = post_factory()
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
db.session.add_all([post1, post2, tag1, tag2])
post1.tags.append(tag1)
post1.tags.append(tag2)
@@ -364,16 +440,18 @@ def test_sort_by_post_count(
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('sort:suggestion-count', ['t1', 't2', 'sug1', 'sug2', 'sug3']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [("sort:suggestion-count", ["t1", "t2", "sug1", "sug2", "sug3"]),],
+)
def test_sort_by_suggestion_count(
- verify_unpaged, tag_factory, input, expected_tag_names):
- sug1 = tag_factory(names=['sug1'])
- sug2 = tag_factory(names=['sug2'])
- sug3 = tag_factory(names=['sug3'])
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
+ verify_unpaged, tag_factory, input, expected_tag_names
+):
+ sug1 = tag_factory(names=["sug1"])
+ sug2 = tag_factory(names=["sug2"])
+ sug3 = tag_factory(names=["sug3"])
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
db.session.add_all([sug1, sug3, tag2, sug2, tag1])
tag1.suggestions.append(sug1)
tag1.suggestions.append(sug2)
@@ -382,16 +460,18 @@ def test_sort_by_suggestion_count(
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('sort:implication-count', ['t1', 't2', 'sug1', 'sug2', 'sug3']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names",
+ [("sort:implication-count", ["t1", "t2", "sug1", "sug2", "sug3"]),],
+)
def test_sort_by_implication_count(
- verify_unpaged, tag_factory, input, expected_tag_names):
- sug1 = tag_factory(names=['sug1'])
- sug2 = tag_factory(names=['sug2'])
- sug3 = tag_factory(names=['sug3'])
- tag1 = tag_factory(names=['t1'])
- tag2 = tag_factory(names=['t2'])
+ verify_unpaged, tag_factory, input, expected_tag_names
+):
+ sug1 = tag_factory(names=["sug1"])
+ sug2 = tag_factory(names=["sug2"])
+ sug3 = tag_factory(names=["sug3"])
+ tag1 = tag_factory(names=["t1"])
+ tag2 = tag_factory(names=["t2"])
db.session.add_all([sug1, sug3, tag2, sug2, tag1])
tag1.implications.append(sug1)
tag1.implications.append(sug2)
@@ -400,20 +480,21 @@ def test_sort_by_implication_count(
verify_unpaged(input, expected_tag_names)
-@pytest.mark.parametrize('input,expected_tag_names', [
- ('sort:category', ['t3', 't1', 't2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_tag_names", [("sort:category", ["t3", "t1", "t2"]),]
+)
def test_sort_by_category(
- verify_unpaged,
- tag_factory,
- tag_category_factory,
- input,
- expected_tag_names):
- cat1 = tag_category_factory(name='cat1')
- cat2 = tag_category_factory(name='cat2')
- tag1 = tag_factory(names=['t1'], category=cat2)
- tag2 = tag_factory(names=['t2'], category=cat2)
- tag3 = tag_factory(names=['t3'], category=cat1)
+ verify_unpaged,
+ tag_factory,
+ tag_category_factory,
+ input,
+ expected_tag_names,
+):
+ cat1 = tag_category_factory(name="cat1")
+ cat2 = tag_category_factory(name="cat2")
+ tag1 = tag_factory(names=["t1"], category=cat2)
+ tag2 = tag_factory(names=["t2"], category=cat2)
+ tag3 = tag_factory(names=["t3"], category=cat1)
db.session.add_all([tag1, tag2, tag3])
db.session.flush()
verify_unpaged(input, expected_tag_names)
diff --git a/server/szurubooru/tests/search/configs/test_user_search_config.py b/server/szurubooru/tests/search/configs/test_user_search_config.py
index e9cea5a6..485ab1c6 100644
--- a/server/szurubooru/tests/search/configs/test_user_search_config.py
+++ b/server/szurubooru/tests/search/configs/test_user_search_config.py
@@ -1,5 +1,7 @@
from datetime import datetime
+
import pytest
+
from szurubooru import db, errors, search
@@ -12,135 +14,48 @@ def executor():
def verify_unpaged(executor):
def verify(input, expected_user_names):
actual_count, actual_users = executor.execute(
- input, offset=0, limit=100)
+ input, offset=0, limit=100
+ )
actual_user_names = [u.name for u in actual_users]
assert actual_count == len(expected_user_names)
assert actual_user_names == expected_user_names
+
return verify
-@pytest.mark.parametrize('input,expected_user_names', [
- ('creation-time:2014', ['u1', 'u2']),
- ('creation-date:2014', ['u1', 'u2']),
- ('-creation-time:2014', ['u3']),
- ('-creation-date:2014', ['u3']),
- ('creation-time:2014..2014-06', ['u1', 'u2']),
- ('creation-time:2014-06..2015-01-01', ['u2', 'u3']),
- ('creation-time:2014-06..', ['u2', 'u3']),
- ('creation-time:..2014-06', ['u1', 'u2']),
- ('creation-time-min:2014-06', ['u2', 'u3']),
- ('creation-time-max:2014-06', ['u1', 'u2']),
- ('-creation-time:2014..2014-06', ['u3']),
- ('-creation-time:2014-06..2015-01-01', ['u1']),
- ('creation-date:2014..2014-06', ['u1', 'u2']),
- ('creation-date:2014-06..2015-01-01', ['u2', 'u3']),
- ('creation-date:2014-06..', ['u2', 'u3']),
- ('creation-date:..2014-06', ['u1', 'u2']),
- ('-creation-date:2014..2014-06', ['u3']),
- ('-creation-date:2014-06..2015-01-01', ['u1']),
- ('creation-time:2014-01,2015', ['u1', 'u3']),
- ('creation-date:2014-01,2015', ['u1', 'u3']),
- ('-creation-time:2014-01,2015', ['u2']),
- ('-creation-date:2014-01,2015', ['u2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_user_names",
+ [
+ ("creation-time:2014", ["u1", "u2"]),
+ ("creation-date:2014", ["u1", "u2"]),
+ ("-creation-time:2014", ["u3"]),
+ ("-creation-date:2014", ["u3"]),
+ ("creation-time:2014..2014-06", ["u1", "u2"]),
+ ("creation-time:2014-06..2015-01-01", ["u2", "u3"]),
+ ("creation-time:2014-06..", ["u2", "u3"]),
+ ("creation-time:..2014-06", ["u1", "u2"]),
+ ("creation-time-min:2014-06", ["u2", "u3"]),
+ ("creation-time-max:2014-06", ["u1", "u2"]),
+ ("-creation-time:2014..2014-06", ["u3"]),
+ ("-creation-time:2014-06..2015-01-01", ["u1"]),
+ ("creation-date:2014..2014-06", ["u1", "u2"]),
+ ("creation-date:2014-06..2015-01-01", ["u2", "u3"]),
+ ("creation-date:2014-06..", ["u2", "u3"]),
+ ("creation-date:..2014-06", ["u1", "u2"]),
+ ("-creation-date:2014..2014-06", ["u3"]),
+ ("-creation-date:2014-06..2015-01-01", ["u1"]),
+ ("creation-time:2014-01,2015", ["u1", "u3"]),
+ ("creation-date:2014-01,2015", ["u1", "u3"]),
+ ("-creation-time:2014-01,2015", ["u2"]),
+ ("-creation-date:2014-01,2015", ["u2"]),
+ ],
+)
def test_filter_by_creation_time(
- verify_unpaged, input, expected_user_names, user_factory):
- user1 = user_factory(name='u1')
- user2 = user_factory(name='u2')
- user3 = user_factory(name='u3')
- user1.creation_time = datetime(2014, 1, 1)
- user2.creation_time = datetime(2014, 6, 1)
- user3.creation_time = datetime(2015, 1, 1)
- db.session.add_all([user1, user2, user3])
- db.session.flush()
- verify_unpaged(input, expected_user_names)
-
-
-@pytest.mark.parametrize('input,expected_user_names', [
- ('name:user1', ['user1']),
- ('name:user2', ['user2']),
- ('name:none', []),
- ('name:', []),
- ('name:*1', ['user1']),
- ('name:*2', ['user2']),
- ('name:*', ['user1', 'user2', 'user3']),
- ('name:u*', ['user1', 'user2', 'user3']),
- ('name:*ser*', ['user1', 'user2', 'user3']),
- ('name:*zer*', []),
- ('name:zer*', []),
- ('name:*zer', []),
- ('-name:user1', ['user2', 'user3']),
- ('-name:user2', ['user1', 'user3']),
- ('name:user1,user2', ['user1', 'user2']),
- ('-name:user1,user3', ['user2']),
-])
-def test_filter_by_name(
- verify_unpaged, input, expected_user_names, user_factory):
- db.session.add(user_factory(name='user1'))
- db.session.add(user_factory(name='user2'))
- db.session.add(user_factory(name='user3'))
- db.session.flush()
- verify_unpaged(input, expected_user_names)
-
-
-@pytest.mark.parametrize('input,expected_user_names', [
- ('name:u1', ['u1']),
- ('name:u2*', ['u2..']),
- ('name:u1,u3..x', ['u1', 'u3..x']),
- ('name:u2..', None),
- ('name:*..*', None),
- ('name:u3..x', None),
- ('name:*..x', None),
- ('name:u2\\..', ['u2..']),
- ('name:*\\..*', ['u2..', 'u3..x']),
- ('name:u3\\..x', ['u3..x']),
- ('name:*\\..x', ['u3..x']),
- ('name:u2.\\.', ['u2..']),
- ('name:*.\\.*', ['u2..', 'u3..x']),
- ('name:u3.\\.x', ['u3..x']),
- ('name:*.\\.x', ['u3..x']),
- ('name:u2\\.\\.', ['u2..']),
- ('name:*\\.\\.*', ['u2..', 'u3..x']),
- ('name:u3\\.\\.x', ['u3..x']),
- ('name:*\\.\\.x', ['u3..x']),
-])
-def test_filter_by_name_that_looks_like_range(
- verify_unpaged, input, expected_user_names, user_factory):
- db.session.add(user_factory(name='u1'))
- db.session.add(user_factory(name='u2..'))
- db.session.add(user_factory(name='u3..x'))
- db.session.flush()
- if not expected_user_names:
- with pytest.raises(errors.SearchError):
- verify_unpaged(input, expected_user_names)
- else:
- verify_unpaged(input, expected_user_names)
-
-
-@pytest.mark.parametrize('input,expected_user_names', [
- ('', ['u1', 'u2']),
- ('u1', ['u1']),
- ('u2', ['u2']),
- ('u1,u2', ['u1', 'u2']),
-])
-def test_anonymous(
- verify_unpaged, input, expected_user_names, user_factory):
- db.session.add(user_factory(name='u1'))
- db.session.add(user_factory(name='u2'))
- db.session.flush()
- verify_unpaged(input, expected_user_names)
-
-
-@pytest.mark.parametrize('input,expected_user_names', [
- ('creation-time:2014 u1', ['u1']),
- ('creation-time:2014 u2', ['u2']),
- ('creation-time:2016 u2', []),
-])
-def test_combining_tokens(
- verify_unpaged, input, expected_user_names, user_factory):
- user1 = user_factory(name='u1')
- user2 = user_factory(name='u2')
- user3 = user_factory(name='u3')
+ verify_unpaged, input, expected_user_names, user_factory
+):
+ user1 = user_factory(name="u1")
+ user2 = user_factory(name="u2")
+ user3 = user_factory(name="u3")
user1.creation_time = datetime(2014, 1, 1)
user2.creation_time = datetime(2014, 6, 1)
user3.creation_time = datetime(2015, 1, 1)
@@ -150,61 +65,184 @@ def test_combining_tokens(
@pytest.mark.parametrize(
- 'offset,limit,expected_total_count,expected_user_names', [
- (0, 1, 2, ['u1']),
- (1, 1, 2, ['u2']),
+ "input,expected_user_names",
+ [
+ ("name:user1", ["user1"]),
+ ("name:user2", ["user2"]),
+ ("name:none", []),
+ ("name:", []),
+ ("name:*1", ["user1"]),
+ ("name:*2", ["user2"]),
+ ("name:*", ["user1", "user2", "user3"]),
+ ("name:u*", ["user1", "user2", "user3"]),
+ ("name:*ser*", ["user1", "user2", "user3"]),
+ ("name:*zer*", []),
+ ("name:zer*", []),
+ ("name:*zer", []),
+ ("-name:user1", ["user2", "user3"]),
+ ("-name:user2", ["user1", "user3"]),
+ ("name:user1,user2", ["user1", "user2"]),
+ ("-name:user1,user3", ["user2"]),
+ ],
+)
+def test_filter_by_name(
+ verify_unpaged, input, expected_user_names, user_factory
+):
+ db.session.add(user_factory(name="user1"))
+ db.session.add(user_factory(name="user2"))
+ db.session.add(user_factory(name="user3"))
+ db.session.flush()
+ verify_unpaged(input, expected_user_names)
+
+
+@pytest.mark.parametrize(
+ "input,expected_user_names",
+ [
+ ("name:u1", ["u1"]),
+ ("name:u2*", ["u2.."]),
+ ("name:u1,u3..x", ["u1", "u3..x"]),
+ ("name:u2..", None),
+ ("name:*..*", None),
+ ("name:u3..x", None),
+ ("name:*..x", None),
+ ("name:u2\\..", ["u2.."]),
+ ("name:*\\..*", ["u2..", "u3..x"]),
+ ("name:u3\\..x", ["u3..x"]),
+ ("name:*\\..x", ["u3..x"]),
+ ("name:u2.\\.", ["u2.."]),
+ ("name:*.\\.*", ["u2..", "u3..x"]),
+ ("name:u3.\\.x", ["u3..x"]),
+ ("name:*.\\.x", ["u3..x"]),
+ ("name:u2\\.\\.", ["u2.."]),
+ ("name:*\\.\\.*", ["u2..", "u3..x"]),
+ ("name:u3\\.\\.x", ["u3..x"]),
+ ("name:*\\.\\.x", ["u3..x"]),
+ ],
+)
+def test_filter_by_name_that_looks_like_range(
+ verify_unpaged, input, expected_user_names, user_factory
+):
+ db.session.add(user_factory(name="u1"))
+ db.session.add(user_factory(name="u2.."))
+ db.session.add(user_factory(name="u3..x"))
+ db.session.flush()
+ if not expected_user_names:
+ with pytest.raises(errors.SearchError):
+ verify_unpaged(input, expected_user_names)
+ else:
+ verify_unpaged(input, expected_user_names)
+
+
+@pytest.mark.parametrize(
+ "input,expected_user_names",
+ [
+ ("", ["u1", "u2"]),
+ ("u1", ["u1"]),
+ ("u2", ["u2"]),
+ ("u1,u2", ["u1", "u2"]),
+ ],
+)
+def test_anonymous(verify_unpaged, input, expected_user_names, user_factory):
+ db.session.add(user_factory(name="u1"))
+ db.session.add(user_factory(name="u2"))
+ db.session.flush()
+ verify_unpaged(input, expected_user_names)
+
+
+@pytest.mark.parametrize(
+ "input,expected_user_names",
+ [
+ ("creation-time:2014 u1", ["u1"]),
+ ("creation-time:2014 u2", ["u2"]),
+ ("creation-time:2016 u2", []),
+ ],
+)
+def test_combining_tokens(
+ verify_unpaged, input, expected_user_names, user_factory
+):
+ user1 = user_factory(name="u1")
+ user2 = user_factory(name="u2")
+ user3 = user_factory(name="u3")
+ user1.creation_time = datetime(2014, 1, 1)
+ user2.creation_time = datetime(2014, 6, 1)
+ user3.creation_time = datetime(2015, 1, 1)
+ db.session.add_all([user1, user2, user3])
+ db.session.flush()
+ verify_unpaged(input, expected_user_names)
+
+
+@pytest.mark.parametrize(
+ "offset,limit,expected_total_count,expected_user_names",
+ [
+ (0, 1, 2, ["u1"]),
+ (1, 1, 2, ["u2"]),
(2, 1, 2, []),
(-1, 1, 2, []),
- (-1, 2, 2, ['u1']),
- (0, 2, 2, ['u1', 'u2']),
+ (-1, 2, 2, ["u1"]),
+ (0, 2, 2, ["u1", "u2"]),
(3, 1, 2, []),
(0, 0, 2, []),
- ])
+ ],
+)
def test_paging(
- executor, user_factory, offset, limit,
- expected_total_count, expected_user_names):
- db.session.add(user_factory(name='u1'))
- db.session.add(user_factory(name='u2'))
+ executor,
+ user_factory,
+ offset,
+ limit,
+ expected_total_count,
+ expected_user_names,
+):
+ db.session.add(user_factory(name="u1"))
+ db.session.add(user_factory(name="u2"))
db.session.flush()
actual_count, actual_users = executor.execute(
- '', offset=offset, limit=limit)
+ "", offset=offset, limit=limit
+ )
actual_user_names = [u.name for u in actual_users]
assert actual_count == expected_total_count
assert actual_user_names == expected_user_names
-@pytest.mark.parametrize('input,expected_user_names', [
- ('', ['u1', 'u2']),
- ('sort:name', ['u1', 'u2']),
- ('-sort:name', ['u2', 'u1']),
- ('sort:name,asc', ['u1', 'u2']),
- ('sort:name,desc', ['u2', 'u1']),
- ('-sort:name,asc', ['u2', 'u1']),
- ('-sort:name,desc', ['u1', 'u2']),
-])
+@pytest.mark.parametrize(
+ "input,expected_user_names",
+ [
+ ("", ["u1", "u2"]),
+ ("sort:name", ["u1", "u2"]),
+ ("-sort:name", ["u2", "u1"]),
+ ("sort:name,asc", ["u1", "u2"]),
+ ("sort:name,desc", ["u2", "u1"]),
+ ("-sort:name,asc", ["u2", "u1"]),
+ ("-sort:name,desc", ["u1", "u2"]),
+ ],
+)
def test_sort_by_name(
- verify_unpaged, input, expected_user_names, user_factory):
- db.session.add(user_factory(name='u2'))
- db.session.add(user_factory(name='u1'))
+ verify_unpaged, input, expected_user_names, user_factory
+):
+ db.session.add(user_factory(name="u2"))
+ db.session.add(user_factory(name="u1"))
db.session.flush()
verify_unpaged(input, expected_user_names)
-@pytest.mark.parametrize('input,expected_user_names', [
- ('', ['u1', 'u2', 'u3']),
- ('sort:creation-date', ['u3', 'u2', 'u1']),
- ('sort:creation-time', ['u3', 'u2', 'u1']),
- ('-sort:creation-date', ['u1', 'u2', 'u3']),
- ('sort:creation-date,asc', ['u1', 'u2', 'u3']),
- ('sort:creation-date,desc', ['u3', 'u2', 'u1']),
- ('-sort:creation-date,asc', ['u3', 'u2', 'u1']),
- ('-sort:creation-date,desc', ['u1', 'u2', 'u3']),
-])
+@pytest.mark.parametrize(
+ "input,expected_user_names",
+ [
+ ("", ["u1", "u2", "u3"]),
+ ("sort:creation-date", ["u3", "u2", "u1"]),
+ ("sort:creation-time", ["u3", "u2", "u1"]),
+ ("-sort:creation-date", ["u1", "u2", "u3"]),
+ ("sort:creation-date,asc", ["u1", "u2", "u3"]),
+ ("sort:creation-date,desc", ["u3", "u2", "u1"]),
+ ("-sort:creation-date,asc", ["u3", "u2", "u1"]),
+ ("-sort:creation-date,desc", ["u1", "u2", "u3"]),
+ ],
+)
def test_sort_by_creation_time(
- verify_unpaged, input, expected_user_names, user_factory):
- user1 = user_factory(name='u1')
- user2 = user_factory(name='u2')
- user3 = user_factory(name='u3')
+ verify_unpaged, input, expected_user_names, user_factory
+):
+ user1 = user_factory(name="u1")
+ user2 = user_factory(name="u2")
+ user3 = user_factory(name="u3")
user1.creation_time = datetime(1991, 1, 1)
user2.creation_time = datetime(1991, 1, 2)
user3.creation_time = datetime(1991, 1, 3)
@@ -213,18 +251,22 @@ def test_sort_by_creation_time(
verify_unpaged(input, expected_user_names)
-@pytest.mark.parametrize('input,expected_user_names', [
- ('', ['u1', 'u2', 'u3']),
- ('sort:last-login-date', ['u3', 'u2', 'u1']),
- ('sort:last-login-time', ['u3', 'u2', 'u1']),
- ('sort:login-date', ['u3', 'u2', 'u1']),
- ('sort:login-time', ['u3', 'u2', 'u1']),
-])
+@pytest.mark.parametrize(
+ "input,expected_user_names",
+ [
+ ("", ["u1", "u2", "u3"]),
+ ("sort:last-login-date", ["u3", "u2", "u1"]),
+ ("sort:last-login-time", ["u3", "u2", "u1"]),
+ ("sort:login-date", ["u3", "u2", "u1"]),
+ ("sort:login-time", ["u3", "u2", "u1"]),
+ ],
+)
def test_sort_by_last_login_time(
- verify_unpaged, input, expected_user_names, user_factory):
- user1 = user_factory(name='u1')
- user2 = user_factory(name='u2')
- user3 = user_factory(name='u3')
+ verify_unpaged, input, expected_user_names, user_factory
+):
+ user1 = user_factory(name="u1")
+ user2 = user_factory(name="u2")
+ user3 = user_factory(name="u3")
user1.last_login_time = datetime(1991, 1, 1)
user2.last_login_time = datetime(1991, 1, 2)
user3.last_login_time = datetime(1991, 1, 3)
@@ -234,39 +276,43 @@ def test_sort_by_last_login_time(
def test_random_sort(executor, user_factory):
- user1 = user_factory(name='u1')
- user2 = user_factory(name='u2')
- user3 = user_factory(name='u3')
+ user1 = user_factory(name="u1")
+ user2 = user_factory(name="u2")
+ user3 = user_factory(name="u3")
db.session.add_all([user3, user1, user2])
db.session.flush()
actual_count, actual_users = executor.execute(
- 'sort:random', offset=0, limit=100)
+ "sort:random", offset=0, limit=100
+ )
actual_user_names = [u.name for u in actual_users]
assert actual_count == 3
assert len(actual_user_names) == 3
- assert 'u1' in actual_user_names
- assert 'u2' in actual_user_names
- assert 'u3' in actual_user_names
+ assert "u1" in actual_user_names
+ assert "u2" in actual_user_names
+ assert "u3" in actual_user_names
-@pytest.mark.parametrize('input,expected_error', [
- ('creation-date:..', errors.SearchError),
- ('creation-date-min:..', errors.ValidationError),
- ('creation-date-min:..2014-01-01', errors.ValidationError),
- ('creation-date-min:2014-01-01..', errors.ValidationError),
- ('creation-date-max:..2014-01-01', errors.ValidationError),
- ('creation-date-max:2014-01-01..', errors.ValidationError),
- ('creation-date-max:yesterday,today', errors.ValidationError),
- ('creation-date:bad..', errors.ValidationError),
- ('creation-date:..bad', errors.ValidationError),
- ('creation-date:bad..bad', errors.ValidationError),
- ('sort:', errors.SearchError),
- ('sort:nam', errors.SearchError),
- ('sort:name,as', errors.SearchError),
- ('sort:name,asc,desc', errors.SearchError),
- ('bad:x', errors.SearchError),
- ('special:unsupported', errors.SearchError),
-])
+@pytest.mark.parametrize(
+ "input,expected_error",
+ [
+ ("creation-date:..", errors.SearchError),
+ ("creation-date-min:..", errors.ValidationError),
+ ("creation-date-min:..2014-01-01", errors.ValidationError),
+ ("creation-date-min:2014-01-01..", errors.ValidationError),
+ ("creation-date-max:..2014-01-01", errors.ValidationError),
+ ("creation-date-max:2014-01-01..", errors.ValidationError),
+ ("creation-date-max:yesterday,today", errors.ValidationError),
+ ("creation-date:bad..", errors.ValidationError),
+ ("creation-date:..bad", errors.ValidationError),
+ ("creation-date:bad..bad", errors.ValidationError),
+ ("sort:", errors.SearchError),
+ ("sort:nam", errors.SearchError),
+ ("sort:name,as", errors.SearchError),
+ ("sort:name,asc,desc", errors.SearchError),
+ ("bad:x", errors.SearchError),
+ ("special:unsupported", errors.SearchError),
+ ],
+)
def test_bad_tokens(executor, input, expected_error):
with pytest.raises(expected_error):
executor.execute(input, offset=0, limit=100)
diff --git a/server/szurubooru/tests/search/test_executor.py b/server/szurubooru/tests/search/test_executor.py
index e1b2dacb..4530beec 100644
--- a/server/szurubooru/tests/search/test_executor.py
+++ b/server/szurubooru/tests/search/test_executor.py
@@ -1,23 +1,27 @@
import unittest.mock
+
import pytest
+
from szurubooru import search
from szurubooru.func import cache
def test_retrieving_from_cache():
config = unittest.mock.MagicMock()
- with unittest.mock.patch('szurubooru.func.cache.has'), \
- unittest.mock.patch('szurubooru.func.cache.get'):
+ with unittest.mock.patch("szurubooru.func.cache.has"), unittest.mock.patch(
+ "szurubooru.func.cache.get"
+ ):
cache.has.side_effect = lambda *args: True
executor = search.Executor(config)
- executor.execute('test:whatever', 1, 10)
+ executor.execute("test:whatever", 1, 10)
assert cache.get.called
def test_putting_equivalent_queries_into_cache():
config = search.configs.PostSearchConfig()
- with unittest.mock.patch('szurubooru.func.cache.has'), \
- unittest.mock.patch('szurubooru.func.cache.put'):
+ with unittest.mock.patch("szurubooru.func.cache.has"), unittest.mock.patch(
+ "szurubooru.func.cache.put"
+ ):
hashes = []
def appender(key, _value):
@@ -26,20 +30,21 @@ def test_putting_equivalent_queries_into_cache():
cache.has.side_effect = lambda *args: False
cache.put.side_effect = appender
executor = search.Executor(config)
- executor.execute('safety:safe test', 1, 10)
- executor.execute('safety:safe test', 1, 10)
- executor.execute('safety:safe test ', 1, 10)
- executor.execute(' safety:safe test', 1, 10)
- executor.execute(' SAFETY:safe test', 1, 10)
- executor.execute('test safety:safe', 1, 10)
+ executor.execute("safety:safe test", 1, 10)
+ executor.execute("safety:safe test", 1, 10)
+ executor.execute("safety:safe test ", 1, 10)
+ executor.execute(" safety:safe test", 1, 10)
+ executor.execute(" SAFETY:safe test", 1, 10)
+ executor.execute("test safety:safe", 1, 10)
assert len(hashes) == 6
assert len(set(hashes)) == 1
def test_putting_non_equivalent_queries_into_cache():
config = search.configs.PostSearchConfig()
- with unittest.mock.patch('szurubooru.func.cache.has'), \
- unittest.mock.patch('szurubooru.func.cache.put'):
+ with unittest.mock.patch("szurubooru.func.cache.has"), unittest.mock.patch(
+ "szurubooru.func.cache.put"
+ ):
hashes = []
def appender(key, _value):
@@ -49,42 +54,42 @@ def test_putting_non_equivalent_queries_into_cache():
cache.put.side_effect = appender
executor = search.Executor(config)
args = [
- ('', 1, 10),
- ('creation-time:2016', 1, 10),
- ('creation-time:2015', 1, 10),
- ('creation-time:2016-01', 1, 10),
- ('creation-time:2016-02', 1, 10),
- ('creation-time:2016-01-01', 1, 10),
- ('creation-time:2016-01-02', 1, 10),
- ('tag-count:1,3', 1, 10),
- ('tag-count:1,2', 1, 10),
- ('tag-count:1', 1, 10),
- ('tag-count:1..3', 1, 10),
- ('tag-count:1..4', 1, 10),
- ('tag-count:2..3', 1, 10),
- ('tag-count:1..', 1, 10),
- ('tag-count:2..', 1, 10),
- ('tag-count:..3', 1, 10),
- ('tag-count:..4', 1, 10),
- ('-tag-count:1..3', 1, 10),
- ('-tag-count:1..4', 1, 10),
- ('-tag-count:2..3', 1, 10),
- ('-tag-count:1..', 1, 10),
- ('-tag-count:2..', 1, 10),
- ('-tag-count:..3', 1, 10),
- ('-tag-count:..4', 1, 10),
- ('safety:safe', 1, 10),
- ('safety:safe', 1, 20),
- ('safety:safe', 2, 10),
- ('safety:sketchy', 1, 10),
- ('safety:safe test', 1, 10),
- ('-safety:safe', 1, 10),
- ('-safety:safe', 1, 20),
- ('-safety:safe', 2, 10),
- ('-safety:sketchy', 1, 10),
- ('-safety:safe test', 1, 10),
- ('safety:safe -test', 1, 10),
- ('-test', 1, 10),
+ ("", 1, 10),
+ ("creation-time:2016", 1, 10),
+ ("creation-time:2015", 1, 10),
+ ("creation-time:2016-01", 1, 10),
+ ("creation-time:2016-02", 1, 10),
+ ("creation-time:2016-01-01", 1, 10),
+ ("creation-time:2016-01-02", 1, 10),
+ ("tag-count:1,3", 1, 10),
+ ("tag-count:1,2", 1, 10),
+ ("tag-count:1", 1, 10),
+ ("tag-count:1..3", 1, 10),
+ ("tag-count:1..4", 1, 10),
+ ("tag-count:2..3", 1, 10),
+ ("tag-count:1..", 1, 10),
+ ("tag-count:2..", 1, 10),
+ ("tag-count:..3", 1, 10),
+ ("tag-count:..4", 1, 10),
+ ("-tag-count:1..3", 1, 10),
+ ("-tag-count:1..4", 1, 10),
+ ("-tag-count:2..3", 1, 10),
+ ("-tag-count:1..", 1, 10),
+ ("-tag-count:2..", 1, 10),
+ ("-tag-count:..3", 1, 10),
+ ("-tag-count:..4", 1, 10),
+ ("safety:safe", 1, 10),
+ ("safety:safe", 1, 20),
+ ("safety:safe", 2, 10),
+ ("safety:sketchy", 1, 10),
+ ("safety:safe test", 1, 10),
+ ("-safety:safe", 1, 10),
+ ("-safety:safe", 1, 20),
+ ("-safety:safe", 2, 10),
+ ("-safety:sketchy", 1, 10),
+ ("-safety:safe test", 1, 10),
+ ("safety:safe -test", 1, 10),
+ ("-test", 1, 10),
]
for arg in args:
executor.execute(*arg)
@@ -92,18 +97,22 @@ def test_putting_non_equivalent_queries_into_cache():
assert len(set(hashes)) == len(args)
-@pytest.mark.parametrize('input', [
- 'special:fav',
- 'special:liked',
- 'special:disliked',
- '-special:fav',
- '-special:liked',
- '-special:disliked',
-])
+@pytest.mark.parametrize(
+ "input",
+ [
+ "special:fav",
+ "special:liked",
+ "special:disliked",
+ "-special:fav",
+ "-special:liked",
+ "-special:disliked",
+ ],
+)
def test_putting_auth_dependent_queries_into_cache(user_factory, input):
config = search.configs.PostSearchConfig()
- with unittest.mock.patch('szurubooru.func.cache.has'), \
- unittest.mock.patch('szurubooru.func.cache.put'):
+ with unittest.mock.patch("szurubooru.func.cache.has"), unittest.mock.patch(
+ "szurubooru.func.cache.put"
+ ):
hashes = []
def appender(key, _value):