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)