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"