def test_create_paper_uploaded_by_non_orcid_author_increases_rep_1(self):
user = create_random_default_user('Ronald the Author')
paper = create_paper(uploaded_by=user)
paper.authors.add(user.author_profile)
user.refresh_from_db()
self.assertEqual(user.reputation, self.start_rep + 1)
def test_different_users_can_open_multiple_claims_for_same_author(self):
claiming_user1 = create_random_default_user('claiming_user')
claiming_user2 = create_random_default_user('claiming_user')
paper = create_paper(
title='some title',
uploaded_by=None,
)
self.client.force_authenticate(claiming_user1)
response = self.client.post(
"/api/author_claim_case/", {
"case_type": "PAPER_CLAIM",
"creator": claiming_user1.id,
"requestor": claiming_user1.id,
"provided_email": "*****@*****.**",
"target_paper_id": paper.id,
"target_author_name": "random author",
})
self.client.force_authenticate(claiming_user2)
response = self.client.post(
"/api/author_claim_case/", {
"case_type": "PAPER_CLAIM",
"creator": claiming_user2.id,
"requestor": claiming_user2.id,
"provided_email": "*****@*****.**",
"target_paper_id": paper.id,
"target_author_name": "random author",
})
self.assertEqual(response.status_code, 201)
def setUp(self):
self.base_url = '/api/summary/'
self.user = create_random_authenticated_user('summary_user')
self.paper = create_paper(title='Summary Permissions Tests')
self.summary_text = 'This is a summary for the permissions tests'
self.summary = create_summary(self.summary_text, self.user,
self.paper.id)
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_close_claim_does_not_require_paper_to_be_set(self):
moderator = create_moderator(first_name='moderator',
last_name='moderator')
claiming_user = create_random_default_user('claiming_user')
self.client.force_authenticate(claiming_user)
paper = create_paper(
title='some title',
uploaded_by=None,
)
# Update Claim status
claim = AuthorClaimCase.objects.create(
case_type="PAPER_CLAIM",
status="OPEN",
creator=claiming_user,
requestor=claiming_user,
provided_email="*****@*****.**",
)
# Close claim
self.client.force_authenticate(moderator)
response = self.client.post("/api/author_claim_case/moderator/", {
"case_id": claim.id,
"notify_user": False,
"update_status": 'DENIED',
})
self.assertEqual(response.status_code, 200)
def test_comment_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')
paper = create_paper(uploaded_by=submitter)
thread = create_thread(paper=paper, created_by=thread_creator)
comment = create_comment(thread=thread, created_by=comment_creator)
self.assertFalse(comment_creator in comment.users_to_notify)
def test_submitter_who_also_creates_a_thread_should_not_receive_notifications(self):
submitter = create_random_default_user('Submitter')
thread_creator = create_random_default_user('ThreadCreator')
paper = create_paper(uploaded_by=submitter)
thread = create_thread(paper=paper, created_by=submitter)
self.assertTrue(submitter not in thread.users_to_notify)
def test_can_propose_first_summary_if_user_is_uploader(self):
uploader = create_random_authenticated_user_with_reputation(
'uploader', 0)
paper = create_paper(title='Summary Paper With Uploader',
uploaded_by=uploader)
response = self.get_first_summary_post_response(uploader,
paper_id=paper.id)
self.assertEqual(response.status_code, 201)
def test_creating_thread_should_not_notify_thread_creator(self):
submitter = create_random_default_user('Submitter')
thread_creator = create_random_default_user('ThreadCreator')
paper = create_paper(uploaded_by=submitter)
thread = create_thread(paper=paper, created_by=submitter)
self.assertTrue(thread_creator not in thread.users_to_notify)
def test_create_thread_creates_action_with_paper_hubs(self):
user = create_random_default_user('nacho')
hub = create_hub(name='Nacho Libre')
paper = create_paper()
paper.hubs.add(hub)
create_thread(paper=paper, created_by=user)
action = user.actions.all()[0]
self.assertIn(hub, action.hubs.all())
def setUp(self):
SEED = "paper"
self.random_generator = random.Random(SEED)
self.base_url = "/api/paper/"
self.paper = create_paper()
self.user = create_random_authenticated_user("paper_views_user")
self.trouble_maker = create_random_authenticated_user("trouble_maker")
self.flag = create_flag(created_by=self.user, paper=self.paper)
self.flag_reason = "Inappropriate"
def test_uploader_can_patch_approved_summary_without_approver(self):
user = create_random_authenticated_user('patch_uploader')
paper = create_paper(uploaded_by=user)
approver = None
summary = self.create_approved_summary(user,
approver,
paper_id=paper.id)
response = self.get_summary_patch_response(user, summary=summary)
self.assertEqual(response.status_code, 200)
def test_can_NOT_patch_summary_if_approved_by_user(self):
user = create_random_authenticated_user('fail_patch')
paper = create_paper(uploaded_by=user)
approver = self.user
summary = self.create_approved_summary(user,
approver,
paper_id=paper.id)
response = self.get_summary_patch_response(user, summary=summary)
self.assertEqual(response.status_code, 403)
def test_authors_field_is_optional(self):
hub_1 = create_hub(name='Hub 1')
hub_2 = create_hub(name='Hub 2')
paper = helpers.create_paper(title='Serialized Paper Title')
paper.hubs.add(hub_1)
paper.hubs.add(hub_2)
paper_dict = model_to_dict(paper)
serialized = PaperSerializer(data=paper_dict)
self.assertTrue(serialized.is_valid())
def create_vote(created_by, item, vote_type):
if created_by is None:
created_by = create_random_default_user('voter')
if item is None:
item = create_paper()
if vote_type is None:
vote_type = Vote.UPVOTE
vote = Vote(item=item, created_by=created_by, vote_type=vote_type)
vote.save()
return vote
def handle(self, *args, **options):
alice = create_random_authenticated_user('alice')
paper = create_paper()
paper.authors.add(alice.author_profile)
alice.emailrecipient.paper_subscription.none = True
alice.emailrecipient.paper_subscription.save()
bob = create_random_authenticated_user('bob')
create_thread(paper=paper, created_by=bob)
User.objects.get(pk=alice.id).delete()
User.objects.get(pk=bob.id).delete()
def test_creating_comment_should_not_notify_comment_creator(self):
submitter = create_random_default_user('Submitter')
thread_creator = create_random_default_user('ThreadCreator')
comment_creator = create_random_default_user('Commenter')
paper = create_paper(uploaded_by=submitter)
thread = create_thread(paper=paper, created_by=thread_creator)
comment = create_comment(thread=thread, created_by=comment_creator)
self.assertTrue(comment_creator not in comment.users_to_notify)
self.assertTrue(thread_creator in comment.users_to_notify)
def test_create_summary_creates_action(self):
user = create_random_default_user('summary_proposer')
paper = create_paper()
create_summary('proposed_summary', user, paper.id)
user.refresh_from_db()
actions = user.actions.all()
self.assertEqual(len(actions), 1)
action_item = actions[0].item
self.assertTrue(isinstance(action_item, Summary))
def test_create_paper_uploaded_by_orcid_author_increases_rep_10(self):
user = create_random_default_user('Ronald the ORCID Author')
social = create_social_account(OrcidProvider.id, user)
user.author_profile.orcid_id = social.uid
user.author_profile.save()
paper = create_paper(uploaded_by=user)
paper.authors.add(user.author_profile)
user.refresh_from_db()
self.assertEqual(user.reputation, self.start_rep + 10)
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_vote_on_paper_ONLY_increases_rep_below_200_new_user(self):
recipient = create_random_default_user('Xenophilius')
upvote_paper(self.paper, recipient)
recipient.refresh_from_db()
recipient.date_joined = timezone.now() - timedelta(
days=NEW_USER_BONUS_DAYS_LIMIT)
recipient.save()
paper = create_paper(title='Rep increase once paper')
upvote_paper(paper, recipient)
recipient.refresh_from_db()
self.assertEqual(recipient.reputation, self.start_rep + 1)
def setUp(self):
self.user = create_random_default_user('Molly')
self.recipient = create_random_default_user('Harry')
self.paper = create_paper(title='Signal Test Paper')
self.author = create_random_authenticated_user('Dumbledore')
self.paper.authors.add(Author.objects.get(user=self.author))
self.paper.save()
self.sign_up_bonus = 25
self.start_rep = 100 + self.sign_up_bonus
self.new_user_create_rep = 1
self.author_create_rep = (self.new_user_create_rep +
distributions.CreateAuthoredPaper.amount)
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 test_comment_by_paper_non_orcid_author_upvoted_increases_rep_1(self):
recipient = create_random_default_user('Winky the Author')
paper = create_paper()
paper.authors.add(recipient.author_profile)
thread = create_thread(paper=paper)
comment = create_comment(thread=thread, created_by=recipient)
upvote_discussion(comment, self.user)
recipient.refresh_from_db()
self.assertEqual(recipient.reputation,
self.start_rep + self.new_user_create_rep + 1)
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_comment_by_paper_orcid_author_upvoted_increases_rep_5(self):
recipient = create_random_default_user('Winky the ORCID 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, created_by=recipient)
upvote_discussion(comment, self.user)
recipient.refresh_from_db()
self.assertEqual(recipient.reputation,
self.start_rep + self.new_user_create_rep + 5)
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 create_thread(paper=None,
post=None,
hypothesis=None,
created_by=None,
title=TestData.thread_title,
text=TestData.thread_text):
if paper is None and post is None and hypothesis is None:
paper = create_paper()
if created_by is None:
created_by = create_random_default_user('thread')
thread = Thread.objects.create(paper=paper,
post=post,
hypothesis=hypothesis,
created_by=created_by,
title=title,
text=text)
return thread
def test_claim_without_valid_paper_id_throws_error(self):
claiming_user = create_random_default_user('claiming_user')
self.client.force_authenticate(claiming_user)
paper = create_paper(
title='some title',
uploaded_by=None,
)
response = self.client.post(
"/api/author_claim_case/", {
"case_type": "PAPER_CLAIM",
"creator": claiming_user.id,
"requestor": claiming_user.id,
"provided_email": "*****@*****.**",
"target_author_name": "some paper author",
})
self.assertGreaterEqual(response.status_code, 400)
