def factory(post=None, user=None, score=1):
if user is None:
user = user_factory()
if post is None:
post = post_factory()
return model.PostScore(
post=post, user=user, score=score, time=datetime(1999, 1, 1))
def factory(post, user=None, score=1):
return model.PostScore(
post=post,
user=user or user_factory(),
time=datetime.utcnow(),
score=score,
)
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'])
post = post_factory(id=1)
related_post1 = post_factory(id=2)
related_post2 = post_factory(id=3)
db.session.add_all([user, tag1, tag2, post, related_post1, related_post2])
db.session.flush()
score = model.PostScore()
score.post = post
score.user = user
score.time = datetime(1997, 1, 1)
score.score = 1
favorite = model.PostFavorite()
favorite.post = post
favorite.user = user
favorite.time = datetime(1997, 1, 1)
feature = model.PostFeature()
feature.post = post
feature.user = user
feature.time = datetime(1997, 1, 1)
note = model.PostNote()
note.post = post
note.polygon = [(1, 1), (200, 1), (200, 200), (1, 200)]
note.text = 'some text'
db.session.add_all([score])
db.session.flush()
post.user = user
post.checksum = 'deadbeef'
post.source = 'example.com'
post.tags.append(tag1)
post.tags.append(tag2)
post.relations.append(related_post1)
post.relations.append(related_post2)
post.scores.append(score)
post.favorited_by.append(favorite)
post.features.append(feature)
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'],
}
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"])
post = post_factory(id=1)
related_post1 = post_factory(id=2)
related_post2 = post_factory(id=3)
db.session.add_all([user, tag1, tag2, post, related_post1, related_post2])
db.session.flush()
score = model.PostScore()
score.post = post
score.user = user
score.time = datetime(1997, 1, 1)
score.score = 1
favorite = model.PostFavorite()
favorite.post = post
favorite.user = user
favorite.time = datetime(1997, 1, 1)
feature = model.PostFeature()
feature.post = post
feature.user = user
feature.time = datetime(1997, 1, 1)
note = model.PostNote()
note.post = post
note.polygon = [(1, 1), (200, 1), (200, 200), (1, 200)]
note.text = "some text"
db.session.add_all([score])
db.session.flush()
post.user = user
post.checksum = "deadbeef"
post.source = "example.com"
post.tags.append(tag1)
post.tags.append(tag2)
post.relations.append(related_post1)
post.relations.append(related_post2)
post.scores.append(score)
post.favorited_by.append(favorite)
post.features.append(feature)
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"],
}
def test_disliked_post_count(user_factory, post_factory):
user1 = user_factory()
user2 = user_factory()
db.session.add_all([user1, user2])
db.session.flush()
assert user1.liked_post_count == 0
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.flush()
db.session.refresh(user1)
assert user1.liked_post_count == 0
assert user1.disliked_post_count == 1
def test_filter_by_score(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)
for post in [post1, post2, post3]:
db.session.add(
model.PostScore(score=post.post_id,
time=datetime.utcnow(),
post=post,
user=user_factory()))
db.session.add_all([post1, post2, post3])
db.session.flush()
verify_unpaged(input, expected_post_ids)
def test_get_liked_post_count(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())
db.session.add_all([post, user, score])
db.session.flush()
actual_liked_post_count = users.get_liked_post_count(user, auth_user)
actual_disliked_post_count = users.get_disliked_post_count(user, auth_user)
assert actual_liked_post_count == expected_liked_post_count
assert actual_disliked_post_count == expected_disliked_post_count
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_cascade_deletions(post_factory, user_factory, comment_factory):
user = user_factory()
post = post_factory()
post.user = user
post_score = model.PostScore()
post_score.post = post
post_score.user = user
post_score.time = datetime(1997, 1, 1)
post_score.score = 1
post.scores.append(post_score)
post_favorite = model.PostFavorite()
post_favorite.post = post
post_favorite.user = user
post_favorite.time = datetime(1997, 1, 1)
post.favorited_by.append(post_favorite)
post_feature = model.PostFeature()
post_feature.post = post
post_feature.user = user
post_feature.time = datetime(1997, 1, 1)
post.features.append(post_feature)
comment = comment_factory(post=post, user=user)
comment_score = model.CommentScore()
comment_score.comment = comment
comment_score.user = user
comment_score.time = datetime(1997, 1, 1)
comment_score.score = 1
comment.scores.append(comment_score)
snapshot = model.Snapshot()
snapshot.user = user
snapshot.creation_time = datetime(1997, 1, 1)
snapshot.resource_type = "-"
snapshot.resource_pkey = 1
snapshot.resource_name = "-"
snapshot.operation = "-"
db.session.add_all([user, post, comment, snapshot])
db.session.commit()
assert not db.session.dirty
assert post.user is not None and post.user.user_id is not None
assert db.session.query(model.User).count() == 1
assert db.session.query(model.Post).count() == 1
assert db.session.query(model.PostScore).count() == 1
assert db.session.query(model.PostFeature).count() == 1
assert db.session.query(model.PostFavorite).count() == 1
assert db.session.query(model.Comment).count() == 1
assert db.session.query(model.CommentScore).count() == 1
assert db.session.query(model.Snapshot).count() == 1
db.session.delete(user)
db.session.commit()
assert not db.session.dirty
assert db.session.query(model.User).count() == 0
assert db.session.query(model.Post).count() == 1
assert db.session.query(model.Post)[0].user is None
assert db.session.query(model.PostScore).count() == 0
assert db.session.query(model.PostFeature).count() == 0
assert db.session.query(model.PostFavorite).count() == 0
assert db.session.query(model.Comment).count() == 1
assert db.session.query(model.Comment)[0].user is None
assert db.session.query(model.CommentScore).count() == 0
assert db.session.query(model.Snapshot).count() == 1
assert db.session.query(model.Snapshot)[0].user is None
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'],
}
def test_cascade_deletions(post_factory, user_factory, tag_factory,
comment_factory):
user = user_factory()
tag1 = tag_factory()
tag2 = tag_factory()
related_post1 = post_factory()
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.flush()
score = model.PostScore()
score.post = post
score.user = user
score.time = datetime(1997, 1, 1)
score.score = 1
favorite = model.PostFavorite()
favorite.post = post
favorite.user = user
favorite.time = datetime(1997, 1, 1)
feature = model.PostFeature()
feature.post = post
feature.user = user
feature.time = datetime(1997, 1, 1)
note = model.PostNote()
note.post = post
note.polygon = ''
note.text = ''
db.session.add_all([score, favorite, feature, note])
db.session.flush()
post.user = user
post.tags.append(tag1)
post.tags.append(tag2)
post.relations.append(related_post1)
related_post2.relations.append(post)
post.scores.append(score)
post.favorited_by.append(favorite)
post.features.append(feature)
post.notes.append(note)
db.session.commit()
assert not db.session.dirty
assert post.user is not None and post.user.user_id is not None
assert len(post.relations) == 1
assert db.session.query(model.User).count() == 1
assert db.session.query(model.Tag).count() == 2
assert db.session.query(model.Post).count() == 3
assert db.session.query(model.PostTag).count() == 2
assert db.session.query(model.PostRelation).count() == 2
assert db.session.query(model.PostScore).count() == 1
assert db.session.query(model.PostNote).count() == 1
assert db.session.query(model.PostFeature).count() == 1
assert db.session.query(model.PostFavorite).count() == 1
assert db.session.query(model.Comment).count() == 1
db.session.delete(post)
db.session.commit()
assert not db.session.dirty
assert db.session.query(model.User).count() == 1
assert db.session.query(model.Tag).count() == 2
assert db.session.query(model.Post).count() == 2
assert db.session.query(model.PostTag).count() == 0
assert db.session.query(model.PostRelation).count() == 0
assert db.session.query(model.PostScore).count() == 0
assert db.session.query(model.PostNote).count() == 0
assert db.session.query(model.PostFeature).count() == 0
assert db.session.query(model.PostFavorite).count() == 0
assert db.session.query(model.Comment).count() == 0
