def test_get_post_thumbnail_url(input_mime_type, config_injector):
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")
def test_get_post_thumbnail_url(input_mime_type, config_injector):
config_injector({'data_url': 'http://example.com/'})
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.jpg'
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"
)
def test_update_post_content_with_invalid_content(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)
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"
)
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'])
assert len(post.tags) == 2
assert post.tags[0].names[0].name == 'tag1'
assert post.tags[1].names[0].name == 'tag2'
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"])
assert len(post.tags) == 2
assert post.tags[0].names[0].name == "tag1"
assert post.tags[1].names[0].name == "tag2"
def factory(id=None,
safety=model.Post.SAFETY_SAFE,
type=model.Post.TYPE_IMAGE,
checksum='...'):
post = model.Post()
post.post_id = id
post.safety = safety
post.type = type
post.checksum = checksum
post.flags = []
post.mime_type = 'application/octet-stream'
post.creation_time = datetime(1996, 1, 1)
return post
def test_update_post_notes():
post = model.Post()
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'},
])
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[1].polygon == [[0, 0], [0, 1], [1, 0], [0, 0]]
assert post.notes[1].text == 'text2'
def test_update_post_notes():
post = model.Post()
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"},
],
)
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[1].polygon == [[0, 0], [0, 1], [1, 0], [0, 0]]
assert post.notes[1].text == "text2"
def create_post(
content: bytes, tag_names: List[str],
user: Optional[model.User]) -> Tuple[model.Post, List[model.Tag]]:
post = model.Post()
post.safety = model.Post.SAFETY_SAFE
post.user = user
post.creation_time = datetime.utcnow()
post.flags = []
post.type = ''
post.checksum = ''
post.mime_type = ''
db.session.add(post)
update_post_content(post, content)
new_tags = update_post_tags(post, tag_names)
return (post, new_tags)
def test_saving_post(post_factory, user_factory, tag_factory):
user = user_factory()
tag1 = tag_factory()
tag2 = tag_factory()
related_post1 = post_factory()
related_post2 = post_factory()
post = model.Post()
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'
db.session.add_all([user, tag1, tag2, related_post1, related_post2, post])
post.user = user
post.tags.append(tag1)
post.tags.append(tag2)
post.relations.append(related_post1)
post.relations.append(related_post2)
db.session.commit()
db.session.refresh(post)
db.session.refresh(related_post1)
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.creation_time == datetime(1997, 1, 1)
assert post.last_edit_time == datetime(1998, 1, 1)
assert len(post.relations) == 2
# relation bidirectionality is realized on business level in func.posts
assert len(related_post1.relations) == 0
assert len(related_post2.relations) == 0
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"):
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)
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"),
),
tag_factory(names=["tag3"],
category=tag_category_factory("test-cat2")),
]
post.safety = model.Post.SAFETY_SAFE
post.source = "4gag"
post.type = model.Post.TYPE_IMAGE
post.checksum = "deadbeef"
post.mime_type = "image/jpeg"
post.file_size = 100
post.user = user_factory(name="post author")
post.canvas_width = 200
post.canvas_height = 300
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.flush()
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.last_edit_time = datetime(1998, 1, 1)
pool2.posts.append(post)
db.session.add_all([pool1, pool2])
db.session.flush()
result = posts.serialize_post(post, auth_user)
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": [
{
"names": ["tag1", "tag2"],
"category": "test-cat1",
"usages": 1,
},
{
"names": ["tag3"],
"category": "test-cat2",
"usages": 1,
},
],
"relations": [],
"notes": [],
"pools": [
{
"id": 1,
"names": ["pool1", "pool2"],
"description": "desc",
"category": "test-cat1",
"postCount": 1,
},
{
"id": 2,
"names": ["pool3"],
"description": "desc2",
"category": "test-cat2",
"postCount": 1,
},
],
"user":
"******",
"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_update_post_flags_with_invalid_content():
post = model.Post()
with pytest.raises(posts.InvalidPostFlagError):
posts.update_post_flags(post, ["invalid"])
def test_update_post_flags():
post = model.Post()
posts.update_post_flags(post, ["loop"])
assert post.flags == ["loop"]
def test_update_post_notes_with_invalid_content(input):
post = model.Post()
with pytest.raises(posts.InvalidPostNoteError):
posts.update_post_notes(post, input)
def test_update_post_relations_with_nonexisting_posts():
post = model.Post()
with pytest.raises(posts.InvalidPostRelationError):
posts.update_post_relations(post, [100])
def test_get_post_content_path(input_mime_type, expected_path):
post = model.Post()
post.post_id = 1
post.mime_type = input_mime_type
assert posts.get_post_content_path(post) == expected_path
def test_get_post_url(input_mime_type, expected_url, config_injector):
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
def test_update_post_source():
post = model.Post()
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)
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.jpg'
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.dat'
def test_update_post_safety(input_safety, expected_safety):
post = model.Post()
posts.update_post_safety(post, input_safety)
assert post.safety == expected_safety
def test_get_post_url(input_mime_type, expected_url, config_injector):
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
def test_update_post_content_with_invalid_content(input_content):
post = model.Post()
with pytest.raises(posts.InvalidPostContentError):
posts.update_post_content(post, input_content)
def test_update_post_safety_with_invalid_string():
post = model.Post()
with pytest.raises(posts.InvalidPostSafetyError):
posts.update_post_safety(post, "bad")
def test_serialize_post(
user_factory, comment_factory, tag_factory, config_injector):
config_injector({'data_url': 'http://example.com/'})
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
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']),
tag_factory(names=['tag3'])
]
post.safety = model.Post.SAFETY_SAFE
post.source = '4gag'
post.type = model.Post.TYPE_IMAGE
post.checksum = 'deadbeef'
post.mime_type = 'image/jpeg'
post.file_size = 100
post.user = user_factory(name='post author')
post.canvas_width = 200
post.canvas_height = 300
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.flush()
result = posts.serialize_post(post, auth_user)
result['tags'].sort()
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.jpg',
'thumbnailUrl': 'http://example.com/generated-thumbnails/1.jpg',
'flags': ['loop'],
'tags': ['tag1', 'tag3'],
'relations': [],
'notes': [],
'user': '******',
'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'],
}
