def test_get_post_thumbnail_url(input_mime_type, config_injector):
config_injector({'data_url': 'http://example.com/'})
post = db.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_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 = db.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)
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
def test_update_post_relations(post_factory):
relation1 = post_factory()
relation2 = post_factory()
db.session.add_all([relation1, relation2])
db.session.flush()
post = db.Post()
posts.update_post_relations(post, [relation1.post_id, relation2.post_id])
assert len(post.relations) == 2
assert post.relations[0].post_id == relation1.post_id
assert post.relations[1].post_id == relation2.post_id
def test_update_post_tags(tag_factory):
post = db.Post()
with unittest.mock.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=db.Post.SAFETY_SAFE,
type=db.Post.TYPE_IMAGE,
checksum='...'):
post = db.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.datetime(1996, 1, 1)
return post
def create_post(content, tag_names, user):
post = db.Post()
post.safety = db.Post.SAFETY_SAFE
post.user = user
post.creation_time = datetime.datetime.now()
post.flags = []
# we'll need post ID
post.type = ''
post.checksum = ''
post.mime_type = ''
db.session.add(post)
db.session.flush()
update_post_content(post, content)
update_post_tags(post, tag_names)
return post
def test_update_post_notes():
post = db.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_get_post_thumbnail_path(input_mime_type):
post = db.Post()
post.post_id = 1
post.mime_type = input_mime_type
assert posts.get_post_thumbnail_path(post) == 'generated-thumbnails/1.jpg'
def test_update_post_non_existing_relations():
post = db.Post()
with pytest.raises(posts.InvalidPostRelationError):
posts.update_post_relations(post, [100])
def test_get_post_thumbnail_backup_path(input_mime_type):
post = db.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_flags():
post = db.Post()
posts.update_post_flags(post, ['loop'])
assert post.flags == ['loop']
def test_update_post_source():
post = db.Post()
posts.update_post_source(post, 'x')
assert post.source == 'x'
def test_update_post_invalid_safety():
post = db.Post()
with pytest.raises(posts.InvalidPostSafetyError):
posts.update_post_safety(post, 'bad')
def test_update_post_safety(input_safety, expected_safety):
post = db.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/'})
post = db.Post()
post.post_id = 1
post.mime_type = input_mime_type
assert posts.get_post_content_url(post) == expected_url
def test_update_post_invalid_notes(input):
post = db.Post()
with pytest.raises(posts.InvalidPostNoteError):
posts.update_post_notes(post, input)
def test_update_post_invalid_source():
post = db.Post()
with pytest.raises(posts.InvalidPostSourceError):
posts.update_post_source(post, 'x' * 1000)
def test_update_post_invalid_flags():
post = db.Post()
with pytest.raises(posts.InvalidPostFlagError):
posts.update_post_flags(post, ['invalid'])
def test_update_post_invalid_content(input_content):
post = db.Post()
with pytest.raises(posts.InvalidPostContentError):
posts.update_post_content(post, input_content)
def test_serialize_post(post_factory, user_factory, tag_factory):
with unittest.mock.patch('szurubooru.func.users.serialize_user'), \
unittest.mock.patch('szurubooru.func.posts.files.has', return_value=True):
users.serialize_user.side_effect = lambda user, auth_user: user.name
auth_user = user_factory(name='auth user')
post = db.Post()
post.post_id = 1
post.creation_time = datetime.datetime(1997, 1, 1)
post.last_edit_time = datetime.datetime(1998, 1, 1)
post.tags = [
tag_factory(names=['tag1', 'tag2']),
tag_factory(names=['tag3'])
]
post.safety = db.Post.SAFETY_SAFE
post.source = '4gag'
post.type = db.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([
db.PostFavorite(post=post,
user=user_factory(name='fav1'),
time=datetime.datetime(1800, 1, 1)),
db.PostFeature(post=post,
user=user_factory(),
time=datetime.datetime(1999, 1, 1)),
db.PostScore(post=post,
user=auth_user,
score=-1,
time=datetime.datetime(1800, 1, 1)),
db.PostScore(post=post,
user=user_factory(),
score=1,
time=datetime.datetime(1800, 1, 1)),
db.PostScore(post=post,
user=user_factory(),
score=1,
time=datetime.datetime(1800, 1, 1))
])
db.session.flush()
result = posts.serialize_post(post, auth_user)
assert result == {
'id': 1,
'creationTime': datetime.datetime(1997, 1, 1),
'lastEditTime': datetime.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,
'ownScore': -1,
'featureCount': 1,
'lastFeatureTime': datetime.datetime(1999, 1, 1),
'favoritedBy': ['fav1'],
'hasCustomThumbnail': True,
}
def test_get_post_content_path(input_mime_type, expected_path):
post = db.Post()
post.post_id = 1
post.mime_type = input_mime_type
assert posts.get_post_content_path(post) == expected_path