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_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_block_user_homepage(app): """ Assert that changes to blocked users apply to the home page immediately. """ submitting_user1 = db_utils.create_user() submitting_user2 = db_utils.create_user() viewing_user = db_utils.create_user() db_utils.create_submission(submitting_user1, rating=ratings.GENERAL.code, subtype=1010) db_utils.create_submission(submitting_user2, rating=ratings.GENERAL.code, subtype=1010) cookie = db_utils.create_session(viewing_user) resp = app.get('/', headers={'Cookie': cookie}) assert len(resp.html.select('#home-art .thumb')) == 2 app.post('/ignoreuser', {'userid': str(submitting_user1), 'action': 'ignore'}, headers={'Cookie': cookie}, status=303) resp = app.get('/', headers={'Cookie': cookie}) assert len(resp.html.select('#home-art .thumb')) == 1 app.post('/ignoreuser', {'userid': str(submitting_user1), 'action': 'unignore'}, headers={'Cookie': cookie}, status=303) resp = app.get('/', headers={'Cookie': cookie}) assert len(resp.html.select('#home-art .thumb')) == 2
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_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_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_ratings_twittercard(self): user = db_utils.create_user() sub1 = db_utils.create_submission(user, rating=ratings.GENERAL.code) sub2 = db_utils.create_submission(user, rating=ratings.MATURE.code) sub3 = db_utils.create_submission(user, rating=ratings.EXPLICIT.code) card1 = submission.twitter_card(sub1) card2 = submission.twitter_card(sub2) card3 = submission.twitter_card(sub3) self.assertNotEqual('This image is rated 18+ and only viewable on weasyl.com', card1['description']) self.assertEqual('This image is rated 18+ and only viewable on weasyl.com', card2['description']) self.assertEqual('This image is rated 18+ and only viewable on weasyl.com', card3['description'])
def test_ignored_user(self): user1 = db_utils.create_user() user2 = db_utils.create_user() db_utils.create_submission(user1, rating=ratings.GENERAL.code) # can view the submission self.assertEqual( 1, len(submission.select_list(user2, ratings.GENERAL.code, 10))) # user2 blocks user1 db_utils.create_ignoreuser(user2, user1) # user2 can no longer view the submission self.assertEqual( 0, len(submission.select_list(user2, ratings.GENERAL.code, 10))) # but a non-logged in user can self.assertEqual( 1, len(submission.select_list(None, ratings.GENERAL.code, 10)))
def test_moderators_and_above_can_add_restricted_tags_successfully(monkeypatch): """ Moderators (and admins, technical, and directors) can add restricted tags to content. Developers are not included in this test, as they are for all intents and purposes just normal user accounts. """ userid_owner = db_utils.create_user() mod_tag_adder = db_utils.create_user() monkeypatch.setattr(staff, 'MODS', frozenset([mod_tag_adder])) journalid = db_utils.create_journal(userid_owner) charid = db_utils.create_character(userid_owner) submitid = db_utils.create_submission(userid_owner) restricted_tag = searchtag.parse_restricted_tags("pearl") searchtag.edit_user_tag_restrictions(userid_owner, restricted_tag) searchtag.associate(mod_tag_adder, tags, submitid=submitid) searchtag.associate(mod_tag_adder, tags, charid=charid) searchtag.associate(mod_tag_adder, tags, journalid=journalid) # Verify that all tags were added successfully. 'pearl' is restricted. submission_tags = searchtag.select(submitid=submitid) assert tags == set(submission_tags) character_tags = searchtag.select(charid=charid) assert tags == set(character_tags) journal_tags = searchtag.select(journalid=journalid) assert tags == set(journal_tags)
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_attempt_setting_tags_when_some_tags_have_been_restricted(): """ Verify that tags are excluded from being added to a submission's tags if the tag is restricted """ userid_owner = db_utils.create_user() userid_tag_adder = db_utils.create_user() journalid = db_utils.create_journal(userid_owner) charid = db_utils.create_character(userid_owner) submitid = db_utils.create_submission(userid_owner) restricted_tag = searchtag.parse_restricted_tags("pearl") searchtag.edit_user_tag_restrictions(userid_owner, restricted_tag) searchtag.associate(userid_tag_adder, tags, submitid=submitid) searchtag.associate(userid_tag_adder, tags, charid=charid) searchtag.associate(userid_tag_adder, tags, journalid=journalid) # Verify that the "pearl" tag was not added submission_tags = searchtag.select(submitid=submitid) assert tags_two == set(submission_tags) character_tags = searchtag.select(charid=charid) assert tags_two == set(character_tags) journal_tags = searchtag.select(journalid=journalid) assert tags_two == set(journal_tags)
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_simple_submission(self): """ Posting a submission should create notifications for all watchers. """ s = db_utils.create_submission(self.owner) welcome.submission_insert(self.owner, s) self.assertEquals(1, self._notification_count(self.friend)) self.assertEquals(1, self._notification_count(self.nonfriend)) self.assertEquals(1, self._notification_count(self.ignored))
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.assertEquals(1, self._notification_count(self.friend)) self.assertEquals(0, self._notification_count(self.nonfriend)) self.assertEquals(0, self._notification_count(self.ignored))
def create_commish_searchable_user(username, commish_status='o', commishclass='badge', minprice="10.00", maxprice="15.00", currency='', submittime=arrow.get(1)): user = db_utils.create_user(username=username) profile.edit_profile_settings( userid=user, set_commission=profile.get_exchange_setting(profile.EXCHANGE_TYPE_COMMISSION, commish_status) ) commishinfo.create_commission_class(user, commishclass) classid = commishinfo.select_list(user)["class"][0]["classid"] assert classid price = orm.CommishPrice() price.title = "test price" price.classid = classid price.amount_min = commishinfo.parse_currency(minprice) price.amount_max = commishinfo.parse_currency(maxprice) commishinfo.create_price(user, price, currency) db_utils.create_submission(user, unixtime=submittime) return user
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_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])
def test_block_user_homepage(app): """ Assert that changes to blocked users apply to the home page immediately. """ submitting_user1 = db_utils.create_user() submitting_user2 = db_utils.create_user() viewing_user = db_utils.create_user() db_utils.create_submission(submitting_user1, rating=ratings.GENERAL.code, subtype=1010) db_utils.create_submission(submitting_user2, rating=ratings.GENERAL.code, subtype=1010) cookie = db_utils.create_session(viewing_user) resp = app.get('/', headers={'Cookie': cookie}) assert len(resp.html.select('#home-art > .thumbnail-grid .thumb')) == 2 app.post('/ignoreuser', { 'userid': str(submitting_user1), 'action': 'ignore' }, headers={'Cookie': cookie}, status=303) resp = app.get('/', headers={'Cookie': cookie}) assert len(resp.html.select('#home-art > .thumbnail-grid .thumb')) == 1 app.post('/ignoreuser', { 'userid': str(submitting_user1), 'action': 'unignore' }, headers={'Cookie': cookie}, status=303) resp = app.get('/', headers={'Cookie': cookie}) assert len(resp.html.select('#home-art > .thumbnail-grid .thumb')) == 2
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 test_ratings(self): # Create a bunch of submissions with different ratings, check counts # Check that a user will see their own submissions even if the rating is off # Check that non-logged-in user will see only general ratings. user1 = db_utils.create_user() user2 = db_utils.create_user() db_utils.create_submission(user1, rating=ratings.GENERAL.code) db_utils.create_submission(user1, rating=ratings.MODERATE.code) db_utils.create_submission(user1, rating=ratings.MATURE.code) db_utils.create_submission(user1, rating=ratings.EXPLICIT.code) self.assertEqual( 4, len( submission.select_list(user2, ratings.EXPLICIT.code, 10, config="l"))) self.assertEqual( 3, len( submission.select_list(user2, ratings.MATURE.code, 10, config="l"))) self.assertEqual( 2, len( submission.select_list(user2, ratings.MODERATE.code, 10, config="l"))) self.assertEqual( 1, len( submission.select_list(user2, ratings.GENERAL.code, 10, config="l"))) # A user sees their own submissions regardless of the rating level self.assertEqual( 4, len( submission.select_list(user1, ratings.GENERAL.code, 10, otherid=user1)))
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_ratings_twittercard(self): # For tests, this isn't set. absolutify_url requires it, # so this test would fail if it wasn't set. web.ctx.realhome = 'https://lo.weasyl.com:8443' user = db_utils.create_user() sub1 = db_utils.create_submission(user, rating=ratings.GENERAL.code) sub2 = db_utils.create_submission(user, rating=ratings.MODERATE.code) sub3 = db_utils.create_submission(user, rating=ratings.MATURE.code) sub4 = db_utils.create_submission(user, rating=ratings.EXPLICIT.code) card1 = submission.twitter_card(sub1) card2 = submission.twitter_card(sub2) card3 = submission.twitter_card(sub3) card4 = submission.twitter_card(sub4) self.assertNotEqual('This image is rated 18+ and only viewable on weasyl.com', card1['description']) self.assertNotEqual('This image is rated 18+ and only viewable on weasyl.com', card2['description']) self.assertEqual('This image is rated 18+ and only viewable on weasyl.com', card3['description']) self.assertEqual('This image is rated 18+ and only viewable on weasyl.com', card4['description']) # Delete this so it cannot interfere with other things. del web.ctx.realhome
def test_submission_becomes_friends_only(self): """ Submissions becoming friends-only should be removed from non-friends' notification lists. """ # Initial behavior should match with normal. s = db_utils.create_submission(self.owner) welcome.submission_insert(self.owner, s) self.assertEqual(1, self._notification_count(self.friend)) self.assertEqual(1, self._notification_count(self.nonfriend)) self.assertEqual(1, self._notification_count(self.ignored)) welcome.submission_became_friends_only(s, self.owner) 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_submission_becomes_friends_only(self): """ Submissions becoming friends-only should be removed from non-friends' notification lists. """ # Initial behavior should match with normal. s = db_utils.create_submission(self.owner) welcome.submission_insert(self.owner, s) self.assertEquals(1, self._notification_count(self.friend)) self.assertEquals(1, self._notification_count(self.nonfriend)) self.assertEquals(1, self._notification_count(self.ignored)) welcome.submission_became_friends_only(s, self.owner) self.assertEquals(1, self._notification_count(self.friend)) self.assertEquals(0, self._notification_count(self.nonfriend)) self.assertEquals(0, self._notification_count(self.ignored))
def test_ratings(self): # Create a bunch of submissions with different ratings, check counts # Check that a user will see their own submissions even if the rating is off # Check that non-logged-in user will see only general ratings. user1 = db_utils.create_user() user2 = db_utils.create_user() db_utils.create_submission(user1, rating=ratings.GENERAL.code) db_utils.create_submission(user1, rating=ratings.MODERATE.code) db_utils.create_submission(user1, rating=ratings.MATURE.code) db_utils.create_submission(user1, rating=ratings.EXPLICIT.code) self.assertEqual(4, len(submission.select_list(user2, ratings.EXPLICIT.code, 10, config="l"))) self.assertEqual(3, len(submission.select_list(user2, ratings.MATURE.code, 10, config="l"))) self.assertEqual(2, len(submission.select_list(user2, ratings.MODERATE.code, 10, config="l"))) self.assertEqual(1, len(submission.select_list(user2, ratings.GENERAL.code, 10, config="l"))) # A user sees their own submissions regardless of the rating level self.assertEqual(4, len(submission.select_list( user1, ratings.GENERAL.code, 10, otherid=user1)))
def test_adding_tags_when_no_tags_previously_existed(): userid_owner = db_utils.create_user() userid_tag_adder = db_utils.create_user() journalid = db_utils.create_journal(userid_owner) charid = db_utils.create_character(userid_owner) submitid = db_utils.create_submission(userid_owner) searchtag.associate(userid_tag_adder, tags, submitid=submitid) searchtag.associate(userid_tag_adder, tags, charid=charid) searchtag.associate(userid_tag_adder, tags, journalid=journalid) submission_tags = searchtag.select(submitid=submitid) assert tags == set(submission_tags) character_tags = searchtag.select(charid=charid) assert tags == set(character_tags) journal_tags = searchtag.select(journalid=journalid) assert tags == set(journal_tags)
def test_contentOwnerIgnoredYou_WeasylError_if_user_ignored_by_item_owner(): # Set up for this test userid_owner = db_utils.create_user() userid_tag_adder = db_utils.create_user() journalid = db_utils.create_journal(userid_owner) charid = db_utils.create_character(userid_owner) submitid = db_utils.create_submission(userid_owner) db_utils.create_ignoreuser(userid_owner, userid_tag_adder) with pytest.raises(WeasylError) as err: searchtag.associate(userid_tag_adder, tags, submitid=submitid) assert err.value.value == "contentOwnerIgnoredYou" with pytest.raises(WeasylError) as err: searchtag.associate(userid_tag_adder, tags, charid=charid) assert err.value.value == "contentOwnerIgnoredYou" with pytest.raises(WeasylError) as err: searchtag.associate(userid_tag_adder, tags, journalid=journalid) assert err.value.value == "contentOwnerIgnoredYou"
def test_InsufficientPermissions_WeasylError_if_user_does_not_have_tagging_permissions(): # Set up for this test admin = db_utils.create_user() userid_owner = db_utils.create_user() userid_tag_adder = db_utils.create_user() journalid = db_utils.create_journal(userid_owner) charid = db_utils.create_character(userid_owner) submitid = db_utils.create_submission(userid_owner) profile.do_manage(admin, userid_tag_adder, permission_tag=False) with pytest.raises(WeasylError) as err: searchtag.associate(userid_tag_adder, tags, submitid=submitid) assert err.value.value == "InsufficientPermissions" with pytest.raises(WeasylError) as err: searchtag.associate(userid_tag_adder, tags, charid=charid) assert err.value.value == "InsufficientPermissions" with pytest.raises(WeasylError) as err: searchtag.associate(userid_tag_adder, tags, journalid=journalid) assert err.value.value == "InsufficientPermissions"
def test_removing_tags(): userid_owner = db_utils.create_user() userid_tag_adder = db_utils.create_user() journalid = db_utils.create_journal(userid_owner) charid = db_utils.create_character(userid_owner) submitid = db_utils.create_submission(userid_owner) searchtag.associate(userid_tag_adder, tags, submitid=submitid) searchtag.associate(userid_tag_adder, tags, charid=charid) searchtag.associate(userid_tag_adder, tags, journalid=journalid) # Remove the 'pearl' tag searchtag.associate(userid_tag_adder, tags_two, submitid=submitid) searchtag.associate(userid_tag_adder, tags_two, charid=charid) searchtag.associate(userid_tag_adder, tags_two, journalid=journalid) submission_tags = searchtag.select(submitid=submitid) assert tags_two == set(submission_tags) character_tags = searchtag.select(charid=charid) assert tags_two == set(character_tags) journal_tags = searchtag.select(journalid=journalid) assert tags_two == set(journal_tags)
def test_retag(self): owner = db_utils.create_user() 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', 'tomato']) searchtag.associate(tagger, {'tomato'}, submitid=s) self.assertEqual( submission.select_view(owner, s, ratings.GENERAL.code)['tags'], ['tomato']) searchtag.associate(owner, {'kale'}, submitid=s) self.assertEqual( submission.select_view(owner, s, ratings.GENERAL.code)['tags'], ['kale'])
def test_clearing_all_tags(): userid_owner = db_utils.create_user() userid_tag_adder = db_utils.create_user() journalid = db_utils.create_journal(userid_owner) charid = db_utils.create_character(userid_owner) submitid = db_utils.create_submission(userid_owner) searchtag.associate(userid_tag_adder, tags, submitid=submitid) searchtag.associate(userid_tag_adder, tags, charid=charid) searchtag.associate(userid_tag_adder, tags, journalid=journalid) # Clear all tags now that they were initially set empty_tags = set() searchtag.associate(userid_tag_adder, empty_tags, submitid=submitid) searchtag.associate(userid_tag_adder, empty_tags, charid=charid) searchtag.associate(userid_tag_adder, empty_tags, journalid=journalid) submitid_tags = searchtag.select(submitid=submitid) assert submitid_tags == [] charid_tags = searchtag.select(charid=charid) assert charid_tags == [] journalid_tags = searchtag.select(journalid=journalid) assert journalid_tags == []
def test_add_and_remove_submission(self): s = db_utils.create_submission(self.owner) self.add_and_remove_comments('submit', submitid=s)
def setUp(self): user1 = db_utils.create_user() self.folder_object = db_utils.create_folder(user1) self.submission = db_utils.create_submission( user1, ratings.GENERAL.code, folderid=self.folder_object)
def setUp(self): self.creator = db_utils.create_user() self.collector = db_utils.create_user() self.s = db_utils.create_submission(self.creator)
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"]