def test_creating_reply_notifies_paper_submitter(self):
submitter = create_random_default_user('Submitter')
paper = create_paper(uploaded_by=submitter)
thread = create_thread(paper=paper)
comment = create_comment(thread=thread)
reply = create_reply(parent=comment)
self.assertTrue(submitter in reply.users_to_notify)
def test_multiple_reputation_distributions(self):
thread = create_thread(created_by=self.recipient)
current_rep = self.start_rep + self.new_user_create_rep
self.recipient.refresh_from_db()
self.assertEqual(self.recipient.reputation, current_rep)
comment = create_comment(thread=thread, created_by=self.recipient)
comment_vote = upvote_discussion(comment, self.user)
current_rep = current_rep + 1 + self.new_user_create_rep
self.recipient.refresh_from_db()
self.assertEqual(self.recipient.reputation, current_rep)
update_to_downvote(comment_vote)
current_rep = current_rep - 1
self.recipient.refresh_from_db()
self.assertEqual(self.recipient.reputation, current_rep)
reply = create_reply(parent=comment, created_by=self.recipient)
reply_vote = downvote_discussion(reply, self.user)
current_rep = current_rep - 1 + self.new_user_create_rep
self.recipient.refresh_from_db()
self.assertEqual(self.recipient.reputation, current_rep)
update_to_upvote(reply_vote)
current_rep += 1
self.recipient.refresh_from_db()
self.assertEqual(self.recipient.reputation, current_rep)
def test_create_thread_increases_rep_by_1_in_new_user(self):
user = create_random_default_user('Bellatrix')
create_thread(created_by=user)
user.refresh_from_db()
self.assertEqual(user.reputation, self.start_rep + 1)
old_user = create_random_default_user('Lestrange')
old_user.date_joined = timezone.now() - timedelta(
days=NEW_USER_BONUS_DAYS_LIMIT)
old_user.save()
create_reply(created_by=old_user)
old_user.refresh_from_db()
self.assertEqual(old_user.reputation + self.sign_up_bonus,
self.start_rep)
def test_reply_flagged_decreases_rep_by_2(self):
recipient = create_random_default_user('Edd')
reply = create_reply(created_by=recipient)
flag_discussion(reply, self.user)
recipient.refresh_from_db()
self.assertEqual(recipient.reputation,
self.start_rep + self.new_user_create_rep - 2)
def test_reply_downvoted_decreases_rep_by_1(self):
recipient = create_random_default_user('Bill')
reply = create_reply(created_by=recipient)
downvote_discussion(reply, self.user)
recipient.refresh_from_db()
self.assertEqual(recipient.reputation,
self.start_rep + self.new_user_create_rep - 1)
def test_reply_creator_not_receive_notification_on_own_contribution(self):
submitter = create_random_default_user('Submitter')
thread_creator = create_random_default_user('ThreadCreator')
comment_creator = create_random_default_user('Commenter')
reply_creator = create_random_default_user('ReplyCreator')
paper = create_paper(uploaded_by=submitter)
thread = create_thread(paper=paper, created_by=thread_creator)
comment = create_comment(thread=thread, created_by=comment_creator)
reply = create_reply(parent=comment, created_by=reply_creator)
self.assertFalse(reply_creator in reply.users_to_notify)
def test_creating_reply_notifies_hypothesis_creator(self):
creator = create_random_default_user('Creator')
thread_creator = create_random_default_user('ThreadCreator')
comment_creator = create_random_default_user('Commenter')
reply_creator = create_random_default_user('ReplyCreator')
hypothesis = create_hypothesis(created_by=creator)
thread = create_thread(hypothesis=hypothesis, created_by=creator)
comment = create_comment(thread=thread, created_by=comment_creator)
reply = create_reply(parent=comment, created_by=reply_creator)
self.assertTrue(creator in reply.users_to_notify)
def test_reply_upvoted_increases_rep_by_1(self):
recipient = create_random_default_user('George')
reply = create_reply(created_by=recipient)
upvote_discussion(reply, self.user)
earned_rep = distributions.ReplyUpvoted.amount
recipient.refresh_from_db()
self.assertEqual(
recipient.reputation,
self.start_rep + self.new_user_create_rep + earned_rep)
def setUp(self):
self.base_url = '/api/'
self.user = create_random_authenticated_user('discussion_views')
self.paper = create_paper(uploaded_by=self.user)
self.thread = create_thread(paper=self.paper, created_by=self.user)
self.comment = create_comment(thread=self.thread, created_by=self.user)
self.reply = create_reply(parent=self.comment, created_by=self.user)
self.trouble_maker = create_random_authenticated_user('trouble_maker')
self.author = create_random_authenticated_user('author')
self.paper.authors.add(Author.objects.get(user=self.author))
self.paper.save()
def test_creating_reply_should_not_notify_reply_creator(self):
submitter = create_random_default_user('Submitter')
thread_creator = create_random_default_user('ThreadCreator')
comment_creator = create_random_default_user('Commenter')
reply_creator = create_random_default_user('ReplyCreator')
paper = create_paper(uploaded_by=submitter)
thread = create_thread(paper=paper, created_by=thread_creator)
comment = create_comment(thread=thread, created_by=comment_creator)
reply = create_reply(parent=comment, created_by=reply_creator)
self.assertTrue(reply_creator not in reply.users_to_notify)
self.assertTrue(comment_creator in reply.users_to_notify)
def setUp(self):
SEED = 'discussion'
self.random_generator = random.Random(SEED)
self.user = create_random_authenticated_user('Tom Marvolo Riddle')
self.recipient = create_random_authenticated_user('Harry James Potter')
self.paper = create_paper(title='The Half Blood Prince',
uploaded_by=self.recipient)
self.thread = create_thread(paper=self.paper,
created_by=self.recipient)
self.comment = create_comment(thread=self.thread,
created_by=self.recipient)
self.reply = create_reply(parent=self.comment,
created_by=self.recipient)
def test_creating_reply_should_not_email_unsubscribed_users(self):
submitter = create_random_default_user('Submitter')
thread_creator = create_random_default_user('ThreadCreator')
comment_creator = create_random_default_user('Commenter')
reply_creator = create_random_default_user('ReplyCreator')
paper = create_paper(uploaded_by=submitter)
thread = create_thread(paper=paper, created_by=thread_creator)
comment = create_comment(thread=thread, created_by=comment_creator)
reply = create_reply(parent=comment, created_by=reply_creator)
comment_creator.emailrecipient.set_opted_out(True)
self.assertTrue(thread_creator in reply.users_to_notify)
self.assertTrue(comment_creator not in reply.users_to_notify)
def setUp(self):
SEED = 'discussion'
self.random_generator = random.Random(SEED)
self.base_url = '/api/'
self.user = create_random_authenticated_user('discussion_permissions')
self.paper = create_paper(uploaded_by=self.user)
self.thread = create_thread(paper=self.paper, created_by=self.user)
self.comment = create_comment(thread=self.thread, created_by=self.user)
self.reply = create_reply(parent=self.comment, created_by=self.user)
self.trouble_maker = create_random_authenticated_user('trouble_maker')
self.author = create_random_authenticated_user('author')
self.moderator = create_random_authenticated_user('moderator')
self.add_paper_author(Author.objects.get(user=self.author))
self.add_paper_moderator(self.moderator)
def test_reply_upvoted_increases_rep_1_created_by_non_orcid_author(self):
recipient = create_random_default_user('George the Author')
paper = create_paper()
paper.authors.add(recipient.author_profile)
thread = create_thread(paper=paper)
comment = create_comment(thread=thread)
reply = create_reply(parent=comment, created_by=recipient)
upvote_discussion(reply, self.user)
earned_rep = (distributions.ReplyUpvoted.amount)
recipient.refresh_from_db()
self.assertEqual(recipient.reputation, self.start_rep + earned_rep)
def test_creating_new_thread_notifies_hypothesis_contributors(self):
creator = create_random_default_user('Submitter')
thread_contributor = create_random_default_user('thread_contributor')
thread2_contributor = create_random_default_user('thread2_contributor')
comment_contributor = create_random_default_user('comment_contributor')
reply_contributor = create_random_default_user('reply_contributor')
hypothesis = create_hypothesis(created_by=creator)
thread1 = create_thread(hypothesis=hypothesis, created_by=thread_contributor)
thread2 = create_thread(hypothesis=hypothesis, created_by=thread2_contributor)
comment = create_comment(thread=thread1, created_by=comment_contributor)
comment2 = create_comment(thread=thread1, created_by=thread_contributor)
reply = create_reply(parent=comment, created_by=reply_contributor)
self.assertTrue(thread_contributor in thread2.users_to_notify)
self.assertTrue(comment_contributor in thread2.users_to_notify)
self.assertTrue(reply_contributor in thread2.users_to_notify)
def test_creating_new_thread_notifies_paper_contributors(self):
creator = create_random_default_user('Submitter')
thread_contributor = create_random_default_user('thread_contributor')
thread2_contributor = create_random_default_user('thread2_contributor')
comment_contributor = create_random_default_user('comment_contributor')
reply_contributor = create_random_default_user('reply_contributor')
paper = create_paper(uploaded_by=creator)
thread1 = create_thread(paper=paper, created_by=thread_contributor)
thread2 = create_thread(paper=paper, created_by=thread2_contributor)
comment = create_comment(thread=thread1, created_by=comment_contributor)
comment2 = create_comment(thread=thread1, created_by=thread_contributor)
reply = create_reply(parent=comment, created_by=reply_contributor)
self.assertTrue(thread_contributor in thread2.users_to_notify)
self.assertTrue(comment_contributor in thread2.users_to_notify)
self.assertTrue(reply_contributor in thread2.users_to_notify)
def test_reply_upvoted_increases_rep_5_created_by_paper_orcid_author(self):
recipient = create_random_default_user('George the Author')
social = create_social_account(OrcidProvider.id, recipient)
recipient.author_profile.orcid_id = social.uid
recipient.author_profile.save()
paper = create_paper()
paper.authors.add(recipient.author_profile)
thread = create_thread(paper=paper)
comment = create_comment(thread=thread)
reply = create_reply(parent=comment, created_by=recipient)
upvote_discussion(reply, self.user)
earned_rep = 0
recipient.refresh_from_db()
self.assertEqual(recipient.reputation, self.start_rep + earned_rep)
def test_moderator_can_endorse_reply(self):
reply = create_reply(text='M', parent=self.comment)
response = self.get_reply_endorsement_post_response(
self.moderator, reply)
self.assertContains(response, reply.id, status_code=201)
def test_reply_child_users_to_notify_excludes_reply_child_creator(self):
user = create_random_default_user('Namy')
reply_parent = create_reply()
reply_child = create_reply(parent=reply_parent, created_by=user)
self.assertFalse(user in reply_child.users_to_notify)
def test_reply_child_users_to_notify_includes_reply_parent_creator(self):
user = create_random_default_user('Mamy')
reply_parent = create_reply(created_by=user)
reply_child = create_reply(parent=reply_parent)
self.assertTrue(user in reply_child.users_to_notify)
def test_reply_users_to_notify_exlcudes_reply_creator(self):
user = create_random_default_user('Jamy')
reply = create_reply(created_by=user)
self.assertFalse(user in reply.users_to_notify)
def test_reply_users_to_notify_includes_comment_creator(self):
user = create_random_default_user('Iamy')
comment = create_comment(created_by=user)
reply = create_reply(parent=comment)
self.assertTrue(user in reply.users_to_notify)
def setUp(self):
self.paper = create_paper()
self.thread = create_thread(paper=self.paper)
self.comment = create_comment(thread=self.thread)
self.reply = create_reply(parent=self.comment)
def test_can_NOT_endorse_reply_if_not_author_or_moderator(self):
reply = create_reply(text='N', parent=self.comment)
response = self.get_reply_endorsement_post_response(self.user, reply)
self.assertEqual(response.status_code, 403)
