def setUp(self):
SEED = 'discussion'
self.random_generator = random.Random(SEED)
self.base_url = '/api/'
self.user = create_random_authenticated_user('hub_permissions')
self.hub = create_hub()
self.trouble_maker = create_random_authenticated_user('trouble_maker')
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 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 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_ONLY_staff_can_delete(self):
bullet_point = create_bullet_point()
user = create_random_authenticated_user('E')
staff = create_random_authenticated_user('E_staff')
staff.is_staff = True
staff.save()
response = self.get_delete_response(user, bullet_point.id)
self.assertContains(response, 'permission', status_code=403)
response = self.get_delete_response(staff, bullet_point.id)
self.assertContains(response, '', status_code=204)
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 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 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_flag_creator_can_delete_flag(self):
user = create_random_authenticated_user('flagger')
thread_flag = create_flag(created_by=user, item=self.thread)
thread_response = self.get_thread_flag_delete_response(user)
self.assertContains(
thread_response,
thread_flag.reason,
status_code=200
)
comment_flag = create_flag(created_by=user, item=self.comment)
comment_response = self.get_comment_flag_delete_response(user)
self.assertContains(
comment_response,
comment_flag.reason,
status_code=200
)
reply_flag = create_flag(created_by=user, item=self.reply)
reply_response = self.get_reply_flag_delete_response(user)
self.assertContains(reply_response, reply_flag.reason, status_code=200)
def test_serializer_shows_user_is_subscribed_when_they_are(self):
user = create_random_authenticated_user('subscribed')
subscribe(self.hub, user)
response = self.get_hub_response(user)
self.assertContains(response,
'"user_is_subscribed":true',
status_code=200)
def test_moderator_can_delete_hub(self):
mod = create_random_authenticated_user('mod', moderator=True)
self.client.force_authenticate(mod)
hub = create_hub(name="some hub")
response = self.client.delete(f"/api/hub/{hub.id}/censor/")
self.assertTrue(response.status_code, 200)
def test_actions_route_responds_with_all_actions(self):
user = create_random_authenticated_user('action_oriented_user')
create_comment(created_by=user)
response = self.get_actions_response(user)
count = '"count":1'
self.assertContains(response, count)
content_type = '"content_type":"comment"'
self.assertContains(response, content_type)
def test_basic_user_cannot_delete_hub(self):
basic_user = create_random_authenticated_user('basic_user')
self.client.force_authenticate(basic_user)
hub = create_hub(name="some hub")
response = self.client.delete(f"/api/hub/{hub.id}/censor/")
self.assertTrue(response.status_code, 401)
def test_ONLY_moderators_can_update_ordinal_lock(self):
user = create_random_authenticated_user('C')
response = self.get_lock_ordinal_response(user, self.bullet_point.id)
self.assertContains(response, 'permission', status_code=403)
self.paper.moderators.add(user)
response = self.get_lock_ordinal_response(user, self.bullet_point.id)
text = 'ordinal_is_locked":true'
self.assertContains(response, text, status_code=200)
def test_user_can_create_bullet_point_with_at_least_1_rep(self):
user = create_random_authenticated_user('A')
data = {
'paper': self.paper.id,
'created_by': 2,
'bullet_type': 'LIMITATION'
}
response = self.get_post_response(user, data=data)
self.assertContains(response, 'id', status_code=201)
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_create_first_summary_increases_rep_by_5(self):
user = create_random_authenticated_user('Lavender first summary')
paper = create_paper(uploaded_by=user)
self.get_first_summary_post_response(user, paper.id)
earned_rep = (
self.new_user_create_rep # paper
+ self.new_user_create_rep # summary
+ 5 # first summary
)
user.refresh_from_db()
self.assertEqual(user.reputation, self.start_rep + earned_rep)
next_user = create_random_authenticated_user('Brown next user')
self.get_summary_post_response(next_user, paper.id)
next_user.refresh_from_db()
self.assertEqual(next_user.reputation,
self.start_rep + self.new_user_create_rep)
def test_can_NOT_set_created_by(self):
user = create_random_authenticated_user('Ba')
data = {
'paper': self.paper.id,
'created_by': 2,
'bullet_type': 'LIMITATION'
}
response = self.get_post_response(user, data=data)
self.assertContains(response, 'created_by":{', status_code=201)
response = self.get_patch_response(user, self.bullet_point.id, data)
self.assertContains(response, 'permission', status_code=400)
def test_set_has_seen_first_coin_modal(self):
user = create_random_authenticated_user('first_coin_viewser')
self.assertFalse(user.has_seen_first_coin_modal)
url = '/api/user/has_seen_first_coin_modal/'
response = get_authenticated_patch_response(
user, url, data={}, content_type='application/json')
self.assertContains(response,
'has_seen_first_coin_modal":true',
status_code=200)
user.refresh_from_db()
self.assertTrue(user.has_seen_first_coin_modal)
def test_ONLY_moderators_can_update_is_removed(self):
user = create_random_authenticated_user('D')
response = self.get_remove_response(user,
self.bullet_point.id,
remove=False)
self.assertContains(response, 'permission', status_code=403)
self.paper.moderators.add(user)
response = self.get_remove_response(user,
self.bullet_point.id,
remove=False)
text = 'is_removed":false'
self.assertContains(response, text, status_code=200)
def test_basic_user_cannot_edit_hub(self):
basic_user = create_random_authenticated_user('basic_user')
self.client.force_authenticate(basic_user)
hub = create_hub(name="some hub")
response = self.client.put(f"/api/hub/{hub.id}/", {
"name": "updated name",
"id": hub.id,
"description": "description",
})
h = Hub.objects.get(id=hub.id)
self.assertNotEqual(h.name, "updated name")
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_ONLY_flag_creator_can_delete_flag(self):
user = create_random_authenticated_user('flagger1')
create_flag(created_by=user, item=self.thread)
response = self.get_thread_flag_delete_response(self.trouble_maker)
self.assertEqual(response.status_code, 400)
create_flag(created_by=user, item=self.comment)
response = self.get_comment_flag_delete_response(self.trouble_maker)
self.assertEqual(response.status_code, 400)
create_flag(created_by=user, item=self.reply)
response = self.get_reply_flag_delete_response(self.trouble_maker)
self.assertEqual(response.status_code, 400)
def test_ONLY_endorsement_creator_can_delete_endorsement(self):
user = create_random_authenticated_user('endorser1')
self.paper.authors.add(Author.objects.get(user=user))
create_endorsement(
created_by=self.author,
item=self.thread
)
thread_response = self.get_thread_endorsement_delete_response(
user
)
self.assertEqual(
thread_response.status_code,
400
)
create_endorsement(
created_by=self.author,
item=self.comment
)
comment_response = self.get_comment_endorsement_delete_response(
user
)
self.assertEqual(
comment_response.status_code,
400
)
create_endorsement(
created_by=self.author,
item=self.reply
)
reply_response = self.get_reply_endorsement_delete_response(
user
)
self.assertEqual(
reply_response.status_code,
400
)
def test_can_NOT_put_unapproved_summary_when_not_proposer(self):
user = create_random_authenticated_user('not_put_proposer')
response = self.get_summary_put_response(user)
self.assertEqual(response.status_code, 403)
def test_can_put_unapproved_summary_when_user_is_proposer(self):
proposer = create_random_authenticated_user('put_proposer')
summary = create_summary('put summary', proposer, self.paper.id)
response = self.get_summary_put_response(proposer, summary=summary)
self.assertEqual(response.status_code, 200)
def test_can_NOT_patch_approved_summary_without_approver(self):
user = create_random_authenticated_user('fail_patch_uploader')
approver = None
summary = self.create_approved_summary(user, approver)
response = self.get_summary_patch_response(user, summary=summary)
self.assertEqual(response.status_code, 403)
def test_actions_route_responds_with_empty_results_without_actions(self):
user = create_random_authenticated_user('inactive_user')
response = self.get_actions_response(user)
text = '"results":[]'
self.assertContains(response, text)
def setUp(self):
self.user = create_random_authenticated_user('discussion_views')
self.paper = create_paper(uploaded_by=self.user)
