def test_submission_search(db, term, n_results):
user = db_utils.create_user()
tag1 = db_utils.create_tag('walrus')
tag2 = db_utils.create_tag('penguin')
s1 = db_utils.create_submission(user, rating=ratings.GENERAL.code)
db_utils.create_submission_tag(tag1, s1)
db_utils.create_submission_tag(tag2, s1)
s2 = db_utils.create_submission(user, rating=ratings.EXPLICIT.code)
db_utils.create_submission_tag(tag1, s2)
s3 = db_utils.create_submission(user, rating=ratings.GENERAL.code)
db_utils.create_submission_tag(tag2, s3)
s4 = db_utils.create_submission(user, rating=ratings.GENERAL.code)
db_utils.create_submission_tag(tag2, s4)
results, _, _ = search.select(search=search.Query.parse(term, 'submit'),
userid=user,
rating=ratings.EXPLICIT.code,
limit=100,
cat=None,
subcat=None,
within='',
backid=None,
nextid=None)
assert len(results) == n_results
def test_blocked_tag(self):
user1 = db_utils.create_user()
user2 = db_utils.create_user()
# submission s1 has a walrus in it, but user2 does not like walruses
s1 = db_utils.create_submission(user1, rating=ratings.GENERAL.code)
tag1 = db_utils.create_tag("walrus")
db_utils.create_submission_tag(tag1, s1)
db_utils.create_blocktag(user2, tag1, ratings.GENERAL.code)
self.assertEqual(
0, len(submission.select_list(user2, ratings.GENERAL.code, 10)))
# submission s2 has a penguin in it. user2 does not want to see penguins in
# adult circumstances, but s2 is general, so visibility is OK
s2 = db_utils.create_submission(user1, rating=ratings.GENERAL.code)
tag2 = db_utils.create_tag("penguin")
db_utils.create_submission_tag(tag2, s2)
db_utils.create_blocktag(user2, tag2, ratings.EXPLICIT.code)
self.assertEqual(
1, len(submission.select_list(user2, ratings.EXPLICIT.code, 10)))
# submission s3 has penguins on it in adult situations, but User2
# is okay with that if it's one of User2's own submissions.
s3 = db_utils.create_submission(user2, rating=ratings.EXPLICIT.code)
db_utils.create_submission_tag(tag2, s3)
self.assertEqual(
2, len(submission.select_list(user2, ratings.EXPLICIT.code, 10)))
def test_blocked_tag(self):
user1 = db_utils.create_user()
user2 = db_utils.create_user()
# submission s1 has a walrus in it, but user2 does not like walruses
s1 = db_utils.create_submission(user1, rating=ratings.GENERAL.code)
tag1 = db_utils.create_tag("walrus")
db_utils.create_submission_tag(tag1, s1)
db_utils.create_blocktag(user2, tag1, ratings.GENERAL.code)
self.assertEqual(
0, len(submission.select_list(user2, ratings.GENERAL.code, 10)))
# submission s2 has a penguin in it. user2 does not want to see penguins in
# adult circumstances, but s2 is general, so visibility is OK
s2 = db_utils.create_submission(user1, rating=ratings.GENERAL.code)
tag2 = db_utils.create_tag("penguin")
db_utils.create_submission_tag(tag2, s2)
db_utils.create_blocktag(user2, tag2, ratings.EXPLICIT.code)
self.assertEqual(
1, len(submission.select_list(user2, ratings.EXPLICIT.code, 10)))
# submission s3 has penguins on it in adult situations, but User2
# is okay with that if it's one of User2's own submissions.
s3 = db_utils.create_submission(user2, rating=ratings.EXPLICIT.code)
db_utils.create_submission_tag(tag2, s3)
self.assertEqual(
2, len(submission.select_list(user2, ratings.EXPLICIT.code, 10)))
def test_search_blocked_tags(db, rating, block_rating):
owner = db_utils.create_user()
viewer = db_utils.create_user()
allowed_tag = db_utils.create_tag('walrus')
blocked_tag = db_utils.create_tag('penguin')
db_utils.create_blocktag(viewer, blocked_tag, block_rating.code)
s1 = db_utils.create_submission(owner, rating=rating.code)
db_utils.create_submission_tag(allowed_tag, s1)
db_utils.create_submission_tag(blocked_tag, s1)
s2 = db_utils.create_submission(owner, rating=rating.code)
db_utils.create_submission_tag(allowed_tag, s2)
s3 = db_utils.create_submission(owner, rating=rating.code)
db_utils.create_submission_tag(blocked_tag, s3)
def check(term, n_results):
results, _, _ = search.select(
search=search.Query.parse(term, 'submit'),
userid=viewer, rating=ratings.EXPLICIT.code, limit=100,
cat=None, subcat=None, within='', backid=None, nextid=None)
assert len(results) == n_results
if rating < block_rating:
check(u'walrus', 2)
check(u'penguin', 2)
else:
check(u'walrus', 1)
check(u'penguin', 0)
def test_blacklist_homepage(app):
"""
Assert that changes to the blacklist apply to the home page immediately.
"""
submitting_user = db_utils.create_user()
viewing_user = db_utils.create_user()
tag1 = db_utils.create_tag('walrus')
tag2 = db_utils.create_tag('penguin')
s1 = db_utils.create_submission(submitting_user, rating=ratings.GENERAL.code, subtype=1010)
db_utils.create_submission_tag(tag1, s1)
s2 = db_utils.create_submission(submitting_user, rating=ratings.GENERAL.code, subtype=1010)
db_utils.create_submission_tag(tag2, s2)
cookie = db_utils.create_session(viewing_user)
resp = app.get('/', headers={'Cookie': cookie})
assert len(resp.html.select('#home-art .thumb')) == 2
app.post('/manage/tagfilters',
{'title': 'walrus', 'rating': str(ratings.GENERAL.code), 'do': 'create'},
headers={'Cookie': cookie}, status=303)
resp = app.get('/', headers={'Cookie': cookie})
assert len(resp.html.select('#home-art .thumb')) == 1
app.post('/manage/tagfilters',
{'title': 'walrus', 'rating': str(ratings.GENERAL.code), 'do': 'remove'},
headers={'Cookie': cookie}, status=303)
resp = app.get('/', headers={'Cookie': cookie})
assert len(resp.html.select('#home-art .thumb')) == 2
def test_recently_popular(self):
owner = db_utils.create_user()
now = arrow.now()
sub1 = db_utils.create_submission(owner,
rating=ratings.GENERAL.code,
unixtime=now -
datetime.timedelta(days=6))
sub2 = db_utils.create_submission(owner,
rating=ratings.GENERAL.code,
unixtime=now -
datetime.timedelta(days=4))
sub3 = db_utils.create_submission(owner,
rating=ratings.GENERAL.code,
unixtime=now -
datetime.timedelta(days=2))
sub4 = db_utils.create_submission(owner,
rating=ratings.GENERAL.code,
unixtime=now)
tag = db_utils.create_tag(u'tag')
for s in [sub1, sub2, sub3, sub4]:
db_utils.create_submission_tag(tag, s)
for i in range(100):
favoriter = db_utils.create_user()
db_utils.create_favorite(favoriter, submitid=sub2, unixtime=now)
recently_popular = submission.select_recently_popular()
self.assertEqual([item['submitid'] for item in recently_popular],
[sub2, sub4, sub3, sub1])
def test_search_pagination(db):
owner = db_utils.create_user()
submissions = [db_utils.create_submission(owner, rating=ratings.GENERAL.code) for i in range(30)]
tag = db_utils.create_tag('penguin')
search_query = search.Query.parse(u'penguin', 'submit')
for submission in submissions:
db_utils.create_submission_tag(tag, submission)
result, next_count, back_count = search.select(
search=search_query,
userid=owner, rating=ratings.EXPLICIT.code, limit=_page_limit,
cat=None, subcat=None, within='', backid=None, nextid=None)
assert back_count == 0
assert next_count == search.COUNT_LIMIT
assert [item['submitid'] for item in result] == submissions[:-_page_limit - 1:-1]
result, next_count, back_count = search.select(
search=search_query,
userid=owner, rating=ratings.EXPLICIT.code, limit=_page_limit,
cat=None, subcat=None, within='', backid=None, nextid=submissions[-_page_limit])
assert back_count == _page_limit
assert next_count == search.COUNT_LIMIT
assert [item['submitid'] for item in result] == submissions[-_page_limit - 1:-2 * _page_limit - 1:-1]
result, next_count, back_count = search.select(
search=search_query,
userid=owner, rating=ratings.EXPLICIT.code, limit=_page_limit,
cat=None, subcat=None, within='', backid=submissions[_page_limit - 1], nextid=None)
assert back_count == search.COUNT_LIMIT
assert next_count == _page_limit
assert [item['submitid'] for item in result] == submissions[2 * _page_limit - 1:_page_limit - 1:-1]
def test_search_pagination(db):
owner = db_utils.create_user()
submissions = [
db_utils.create_submission(owner, rating=ratings.GENERAL.code)
for i in range(30)
]
tag = db_utils.create_tag('penguin')
search_query = search.Query.parse(u'penguin', 'submit')
for submission in submissions:
db_utils.create_submission_tag(tag, submission)
result, next_count, back_count = search.select(
search=search_query,
userid=owner,
rating=ratings.EXPLICIT.code,
limit=_page_limit,
cat=None,
subcat=None,
within='',
backid=None,
nextid=None)
assert back_count == 0
assert next_count == search.COUNT_LIMIT
assert [item['submitid']
for item in result] == submissions[:-_page_limit - 1:-1]
result, next_count, back_count = search.select(
search=search_query,
userid=owner,
rating=ratings.EXPLICIT.code,
limit=_page_limit,
cat=None,
subcat=None,
within='',
backid=None,
nextid=submissions[-_page_limit])
assert back_count == _page_limit
assert next_count == search.COUNT_LIMIT
assert [item['submitid'] for item in result
] == submissions[-_page_limit - 1:-2 * _page_limit - 1:-1]
result, next_count, back_count = search.select(
search=search_query,
userid=owner,
rating=ratings.EXPLICIT.code,
limit=_page_limit,
cat=None,
subcat=None,
within='',
backid=submissions[_page_limit - 1],
nextid=None)
assert back_count == search.COUNT_LIMIT
assert next_count == _page_limit
assert [item['submitid'] for item in result
] == submissions[2 * _page_limit - 1:_page_limit - 1:-1]
def test_search_blocked_tags(db, rating, block_rating):
owner = db_utils.create_user()
viewer = db_utils.create_user()
allowed_tag = db_utils.create_tag('walrus')
blocked_tag = db_utils.create_tag('penguin')
db_utils.create_blocktag(viewer, blocked_tag, block_rating.code)
s1 = db_utils.create_submission(owner, rating=rating.code)
db_utils.create_submission_tag(allowed_tag, s1)
db_utils.create_submission_tag(blocked_tag, s1)
s2 = db_utils.create_submission(owner, rating=rating.code)
db_utils.create_submission_tag(allowed_tag, s2)
s3 = db_utils.create_submission(owner, rating=rating.code)
db_utils.create_submission_tag(blocked_tag, s3)
def check(term, n_results):
results, _, _ = search.select(search=search.Query.parse(
term, 'submit'),
userid=viewer,
rating=ratings.EXPLICIT.code,
limit=100,
cat=None,
subcat=None,
within='',
backid=None,
nextid=None)
assert len(results) == n_results
if rating < block_rating:
check(u'walrus', 2)
check(u'penguin', 2)
else:
check(u'walrus', 1)
check(u'penguin', 0)
def test_can_see_own_blocktag_journal(self):
"""
Can see your own journal in a listing even with a blocked tag.
"""
block_tagid = db_utils.create_tag("blocked")
db_utils.create_blocktag(self.user1, block_tagid, ratings.GENERAL.code)
journalid = db_utils.create_journal(self.user1, "My blocktag journal")
db_utils.create_journal_tag(block_tagid, journalid)
# A journal that we should NOT see.
other_journalid = db_utils.create_journal(self.user2, "Other user's blocktag journal")
db_utils.create_journal_tag(block_tagid, other_journalid)
self.assertEqual(
journalid,
journal.select_user_list(self.user1, ratings.GENERAL.code, 100)[0]['journalid'])
def test_can_see_own_blocktag_character(self):
"""
Can see your own character in a listing even with a blocked tag.
"""
block_tagid = db_utils.create_tag("blocked")
db_utils.create_blocktag(self.user1, block_tagid, ratings.GENERAL.code)
charid = db_utils.create_character(self.user1, name="My blocktag character")
db_utils.create_character_tag(block_tagid, charid)
# A journal that we should NOT see.
other_charid = db_utils.create_character(self.user2, name="Other user's blocktag character")
db_utils.create_character_tag(block_tagid, other_charid)
self.assertEqual(
charid,
character.select_list(self.user1, ratings.GENERAL.code, 100)[0]['charid'])
def test_can_see_own_blocktag_character(self):
"""
Can see your own character in a listing even with a blocked tag.
"""
block_tagid = db_utils.create_tag("blocked")
db_utils.create_blocktag(self.user1, block_tagid, ratings.GENERAL.code)
charid = db_utils.create_character(self.user1, name="My blocktag character")
db_utils.create_character_tag(block_tagid, charid)
# A journal that we should NOT see.
other_charid = db_utils.create_character(self.user2, name="Other user's blocktag character")
db_utils.create_character_tag(block_tagid, other_charid)
self.assertEqual(
charid,
character.select_list(self.user1, ratings.GENERAL.code, 100)[0]['charid'])
def test_submission_search(db, term, n_results):
user = db_utils.create_user()
tag1 = db_utils.create_tag('walrus')
tag2 = db_utils.create_tag('penguin')
s1 = db_utils.create_submission(user, rating=ratings.GENERAL.code)
db_utils.create_submission_tag(tag1, s1)
db_utils.create_submission_tag(tag2, s1)
s2 = db_utils.create_submission(user, rating=ratings.EXPLICIT.code)
db_utils.create_submission_tag(tag1, s2)
s3 = db_utils.create_submission(user, rating=ratings.GENERAL.code)
db_utils.create_submission_tag(tag2, s3)
s4 = db_utils.create_submission(user, rating=ratings.GENERAL.code)
db_utils.create_submission_tag(tag2, s4)
results, _, _ = search.select(
search=search.Query.parse(term, 'submit'),
userid=user, rating=ratings.EXPLICIT.code, limit=100,
cat=None, subcat=None, within='', backid=None, nextid=None)
assert len(results) == n_results
def test_can_see_own_blocktag_journal(self):
"""
Can see your own journal in a listing even with a blocked tag.
"""
block_tagid = db_utils.create_tag("blocked")
db_utils.create_blocktag(self.user1, block_tagid, ratings.GENERAL.code)
journalid = db_utils.create_journal(self.user1, "My blocktag journal")
db_utils.create_journal_tag(block_tagid, journalid)
# A journal that we should NOT see.
other_journalid = db_utils.create_journal(
self.user2, "Other user's blocktag journal")
db_utils.create_journal_tag(block_tagid, other_journalid)
self.assertEqual(
journalid,
journal.select_user_list(self.user1, ratings.GENERAL.code,
100)[0]['journalid'])
def test_recently_popular(self):
owner = db_utils.create_user()
now = arrow.now()
sub1 = db_utils.create_submission(owner, rating=ratings.GENERAL.code, unixtime=now - datetime.timedelta(days=6))
sub2 = db_utils.create_submission(owner, rating=ratings.GENERAL.code, unixtime=now - datetime.timedelta(days=4))
sub3 = db_utils.create_submission(owner, rating=ratings.GENERAL.code, unixtime=now - datetime.timedelta(days=2))
sub4 = db_utils.create_submission(owner, rating=ratings.GENERAL.code, unixtime=now)
tag = db_utils.create_tag(u'tag')
for s in [sub1, sub2, sub3, sub4]:
db_utils.create_submission_tag(tag, s)
for i in range(100):
favoriter = db_utils.create_user()
db_utils.create_favorite(favoriter, sub2, 's', unixtime=now)
recently_popular = submission.select_recently_popular()
self.assertEqual(
[item['submitid'] for item in recently_popular],
[sub2, sub4, sub3, sub1])
