def test_friends_only(self):
user1 = db_utils.create_user()
user2 = db_utils.create_user()
db_utils.create_submission(user1,
rating=ratings.GENERAL.code,
settings=CharSettings({'friends-only'}, {},
{}))
# poster can view their submission
self.assertEqual(
1, len(submission.select_list(user1, ratings.GENERAL.code, 10)))
# but a non-friend or a non-logged in user cannot
self.assertEqual(
0, len(submission.select_list(None, ratings.GENERAL.code, 10)))
self.assertEqual(
0, len(submission.select_list(user2, ratings.GENERAL.code, 10)))
# user with a pending friendship cannot view
db_utils.create_friendship(user1,
user2,
settings=CharSettings({'pending'}, {}, {}))
self.assertEqual(
0, len(submission.select_list(user2, ratings.GENERAL.code, 10)))
# but a friend can
d.sessionmaker().query(users.Friendship).delete()
db_utils.create_friendship(user1, user2)
self.assertEqual(
1, len(submission.select_list(user2, ratings.GENERAL.code, 10)))
def test_retag_no_owner_remove(self):
config = CharSettings({'disallow-others-tag-removal'}, {}, {})
owner = db_utils.create_user(config=config)
tagger = db_utils.create_user()
s = db_utils.create_submission(owner, rating=ratings.GENERAL.code)
searchtag.associate(owner, {'orange'}, submitid=s)
self.assertEqual(
submission.select_view(owner, s, ratings.GENERAL.code)['tags'],
['orange'])
searchtag.associate(tagger, {'apple', 'tomato'}, submitid=s)
self.assertEqual(
submission.select_view(owner, s, ratings.GENERAL.code)['tags'],
['apple', 'orange', 'tomato'])
searchtag.associate(tagger, {'tomato'}, submitid=s)
self.assertEqual(
submission.select_view(owner, s, ratings.GENERAL.code)['tags'],
['orange', 'tomato'])
searchtag.associate(owner, {'kale'}, submitid=s)
self.assertEqual(
submission.select_view(owner, s, ratings.GENERAL.code)['tags'],
['kale'])
def test_profile_user(app):
user = db_utils.create_user(config=CharSettings(
frozenset(), {}, {'tagging-level': 'max-rating-mature'}))
cookie = db_utils.create_session(user)
resp = app.get('/~journal_test', headers={'Cookie': cookie})
assert resp.html.find(id='user-journal').h4.string == u'Restricted journal'
def test_cannot_see_non_friends_character(self):
"""
Should not be able to see a non-friend's friends-ony character in a listing.
"""
db_utils.create_character(self.user2, settings=CharSettings({"friends-only"}, {}, {}))
self.assertEqual(
self.count,
character.select_count(self.user1, ratings.GENERAL.code))
def test_user_search_ordering(db):
config = CharSettings({'use-only-tag-blacklist'}, {}, {})
db_utils.create_user("user_aa", username="******", config=config)
db_utils.create_user("user_ba", username="******", config=config)
db_utils.create_user("user_Ab", username="******", config=config)
db_utils.create_user("user_Bb", username="******", config=config)
results = search.select_users(u"user")
assert [user["title"] for user in results] == ["user_aa", "user_Ab", "user_ba", "user_Bb"]
def test_cannot_see_non_friends_journal(self):
"""
Should not be able to see a non-friend's journal in a listing.
"""
db_utils.create_journal(self.user2,
'Friends only journal',
settings=CharSettings({"friends-only"}, {},
{}))
self.assertEqual(self.count,
select_user_count(self.user1, ratings.GENERAL.code))
def test_friends_only_submission(self):
"""
Submissions uploaded as friends-only should be visible only to friends.
"""
s = db_utils.create_submission(self.owner,
settings=CharSettings({'friends-only'},
{}, {}))
welcome.submission_insert(self.owner, s, settings='f')
self.assertEqual(1, self._notification_count(self.friend))
self.assertEqual(0, self._notification_count(self.nonfriend))
self.assertEqual(0, self._notification_count(self.ignored))
def test_see_friends_character(self):
"""
Should be able to see a friend's friends-only character in a listing.
"""
c = db_utils.create_character(self.friend1, settings=CharSettings({"friends-only"}, {}, {}))
self.assertEqual(
self.count + 1,
character.select_count(self.user1, ratings.GENERAL.code))
self.assertEqual(
c,
character.select_list(self.user1, ratings.GENERAL.code, 100)[0]['charid'])
def test_feature_page_filter(self):
user1 = db_utils.create_user()
folder = db_utils.create_folder(
user1, settings=CharSettings({"featured-filter"}, {}, {}))
db_utils.create_submissions(9, user1, ratings.GENERAL.code)
db_utils.create_submission(user1, ratings.GENERAL.code, folderid=folder)
self.assertEqual(
10, len(submission.select_list(user1, ratings.GENERAL.code, 10)))
self.assertEqual(
1, len(submission.select_list(user1, ratings.GENERAL.code, 10,
featured_filter=True)))
def test_user_search(db, term, n_results):
config = CharSettings({'use-only-tag-blacklist'}, {}, {})
db_utils.create_user("Sam Peacock", username="******", config=config)
db_utils.create_user("LionCub", username="******", config=config)
db_utils.create_user("Samantha Wildlife", username="******", config=config)
db_utils.create_user("Ryan Otherkin", username="******", config=config)
db_utils.create_user("Pawsome", username="******", config=config)
db_utils.create_user("Twisted Calvin", username="******", config=config)
db_utils.create_user("JasonAG", username="******", config=config)
db_utils.create_user("Twisted Mindset", username="******", config=config)
db_utils.create_user("Martha", config=config)
results = search.select_users(term)
assert len(results) == n_results
def test_see_friends_journal(self):
"""
Should be able to see a friend's journal in a listing.
"""
j = db_utils.create_journal(self.friend1,
'Friends only journal',
settings=CharSettings({"friends-only"}, {},
{}))
self.assertEqual(self.count + 1,
select_user_count(self.user1, ratings.GENERAL.code))
self.assertEqual(
j,
journal.select_user_list(self.user1, ratings.GENERAL.code,
100)[0]['journalid'])
def _journals(journal_user):
db_utils.create_journal(journal_user,
title=u'Test journal',
unixtime=arrow.get(1),
content=u'A test journal')
db_utils.create_journal(journal_user,
title=u'Public journal',
unixtime=arrow.get(2),
content=u'A public journal')
db_utils.create_journal(journal_user,
title=u'Hidden journal',
unixtime=arrow.get(3),
content=u'A hidden journal',
settings=CharSettings({'hidden'}, {}, {}))
db_utils.create_journal(journal_user,
title=u'Restricted journal',
rating=ratings.MATURE.code,
unixtime=arrow.get(4),
content=u'A journal with a non-General rating')
db_utils.create_journal(journal_user,
title=u'Recent journal',
unixtime=arrow.get(5),
content=u'The most recent journal',
settings=CharSettings({'friends-only'}, {}, {}))
def test_filters(self):
# Test filters of the following:
# userid, folderid, category, hidden
user1 = db_utils.create_user()
user2 = db_utils.create_user()
folder = db_utils.create_folder(user1)
db_utils.create_submission(user1, rating=ratings.GENERAL.code, folderid=folder)
db_utils.create_submission(user1, rating=ratings.GENERAL.code, subtype=1010)
db_utils.create_submission(user1, rating=ratings.GENERAL.code, settings=CharSettings({'hidden'}, {}, {}))
db_utils.create_submission(user2, rating=ratings.GENERAL.code)
self.assertEqual(3, len(submission.select_list(user1, ratings.EXPLICIT.code, 10)))
self.assertEqual(1, len(submission.select_list(user1, ratings.EXPLICIT.code, 10, otherid=user2)))
self.assertEqual(1, len(submission.select_list(user1, ratings.EXPLICIT.code, 10, folderid=folder)))
self.assertEqual(1, len(submission.select_list(user1, ratings.EXPLICIT.code, 10, subcat=1010)))
def set_tags(self, new_tags, done_by_artist=False):
new_tags = set(new_tags)
current_tags = SubmissionTag.query.filter_by(
targetid=self.submitid).all()
current_tags_set = {t.tag for t in current_tags}
tags_to_add = new_tags - current_tags_set
tags_to_remove = current_tags_set - new_tags
if tags_to_add:
entered_tags = Tag.query.filter(Tag.title.in_(tags_to_add)).all()
else:
entered_tags = []
entered_tags_set = {t.title for t in entered_tags}
tag_ids_to_add = {t.tagid for t in entered_tags}
tags_to_enter = tags_to_add - entered_tags_set
if tags_to_enter:
q = (Tag.__table__.insert().values([{
'title': t
} for t in tags_to_enter]).returning(Tag.tagid))
tag_ids_to_add.update(
t for t, in self.dbsession.execute(q).fetchall())
if tag_ids_to_add:
settings = CharSettings(set(), {}, {})
if done_by_artist:
settings.mutable_settings.add('artist-tag')
q = (SubmissionTag.__table__.insert().values([{
'targetid': self.submitid,
'tagid': t,
'settings': settings
} for t in tag_ids_to_add]))
self.dbsession.execute(q)
if tags_to_remove:
tag_ids_to_remove = {
t.tagid
for t in current_tags if t.tag in tags_to_remove
}
q = (SubmissionTag.__table__.delete().where(
SubmissionTag.targetid == self.submitid).where(
SubmissionTag.tagid.in_(tag_ids_to_remove)))
self.dbsession.execute(q)
def test_associate_return_values():
"""
``associate()`` returns a dict, of the following format:
return {"add_failure_restricted_tags": add_failure_restricted_tags,
"remove_failure_owner_set_tags": remove_failure_owner_set_tags}
/OR/ None
add_failure_restricted_tags is None if no tags failed to be added during the associate call,
when due to a tag being on the user or globally restricted tags list. Otherwise, it contains
a space-separated list of tags which failed to be added to the content item.
remove_failure_owner_set_tags is None if no tags failed to be removed during the associate call.
Otherwise, it contains the same space-separated list as above, however containing tags which the
content owner added and has opted to not permit others to remove.
If neither element of the dict is set, ``associate()`` returns None.
"""
config = CharSettings({'disallow-others-tag-removal'}, {}, {})
userid_owner = db_utils.create_user(config=config)
userid_tag_adder = db_utils.create_user()
submitid = db_utils.create_submission(userid_owner)
journalid = db_utils.create_journal(userid_owner)
charid = db_utils.create_character(userid_owner)
""" Test the None result (no failures), then manually clear the tags afterwards. """
result = searchtag.associate(userid_tag_adder, tags, submitid=submitid)
assert result is None
result = searchtag.associate(userid_tag_adder, tags, journalid=journalid)
assert result is None
result = searchtag.associate(userid_tag_adder, tags, journalid=journalid)
assert result is None
searchtag.associate(userid_tag_adder, set(), submitid=submitid)
searchtag.associate(userid_tag_adder, set(), journalid=journalid)
searchtag.associate(userid_tag_adder, set(), journalid=journalid)
""" Test the result:None variant (restricted tags added, no tags removed) """
restricted_tag = searchtag.parse_restricted_tags("pearl")
searchtag.edit_user_tag_restrictions(userid_owner, restricted_tag)
result = searchtag.associate(userid_tag_adder, tags, submitid=submitid)
assert "pearl" in result["add_failure_restricted_tags"]
assert result["remove_failure_owner_set_tags"] is None
result = searchtag.associate(userid_tag_adder, tags, charid=charid)
assert "pearl" in result["add_failure_restricted_tags"]
assert result["remove_failure_owner_set_tags"] is None
result = searchtag.associate(userid_tag_adder, tags, journalid=journalid)
assert "pearl" in result["add_failure_restricted_tags"]
assert result["remove_failure_owner_set_tags"] is None
searchtag.associate(userid_owner, set(), submitid=submitid)
searchtag.associate(userid_owner, set(), charid=charid)
searchtag.associate(userid_owner, set(), journalid=journalid)
searchtag.edit_user_tag_restrictions(userid_owner, set())
"""Test the None:result variant (no restricted tags added, tag removal blocked)
- Submission items will return None in this case (different method of preventing tag removal)
- Character and journal items should return the None:result variant, as expected"""
searchtag.associate(userid_owner, tags, submitid=submitid)
searchtag.associate(userid_owner, tags, charid=charid)
searchtag.associate(userid_owner, tags, journalid=journalid)
result = searchtag.associate(userid_tag_adder, tags_two, submitid=submitid)
assert result is None
result = searchtag.associate(userid_tag_adder, tags_two, charid=charid)
assert result["add_failure_restricted_tags"] is None
assert "pearl" in result["remove_failure_owner_set_tags"]
result = searchtag.associate(userid_tag_adder, tags_two, journalid=journalid)
assert result["add_failure_restricted_tags"] is None
assert "pearl" in result["remove_failure_owner_set_tags"]
searchtag.associate(userid_owner, set(), submitid=submitid)
searchtag.associate(userid_owner, set(), charid=charid)
searchtag.associate(userid_owner, set(), journalid=journalid)
"""Test the result:result variant (restricted tags added, tag removal blocked)
- Submission items will behave in the result:None variant
- Character/Journal items will behave in the result:result manner"""
restricted_tag = searchtag.parse_restricted_tags("profanity")
searchtag.edit_user_tag_restrictions(userid_owner, restricted_tag)
searchtag.associate(userid_owner, tags, submitid=submitid)
searchtag.associate(userid_owner, tags, charid=charid)
searchtag.associate(userid_owner, tags, journalid=journalid)
# Effect upon adding this set: Remove user-set tag "pearl"; add restricted tag "profanity"
tags_three = tags_two | {"profanity"}
result = searchtag.associate(userid_tag_adder, tags_three, submitid=submitid)
assert "profanity" in result["add_failure_restricted_tags"]
assert result["remove_failure_owner_set_tags"] is None
result = searchtag.associate(userid_tag_adder, tags_three, charid=charid)
assert "profanity" in result["add_failure_restricted_tags"]
assert "pearl" in result["remove_failure_owner_set_tags"]
result = searchtag.associate(userid_tag_adder, tags_three, journalid=journalid)
assert "profanity" in result["add_failure_restricted_tags"]
assert "pearl" in result["remove_failure_owner_set_tags"]
def test_setting_alias_succeeds_when_previous_alias_exists():
config = CharSettings({'premium'}, {}, {})
user_id = db_utils.create_user(config=config)
useralias.set(user_id, "previousalias")
useralias.set(user_id, "alias")
assert useralias.select(userid=user_id) == "alias"