def test_update_wiki_updates_contributor_comments_viewed_timestamp(self):
contributor = AuthUserFactory()
project = ProjectFactory(creator=self.user, is_public=True)
project.add_contributor(contributor)
project.save()
wiki_page = WikiFactory(node=project, page_name='test')
wiki = WikiVersionFactory(wiki_page=wiki_page)
comment = CommentFactory(node=project, target=Guid.load(wiki_page._id), user=self.user)
# user views comments -- sets user.comments_viewed_timestamp
url = project.api_url_for('update_comments_timestamp')
res = self.app.put_json(url, {
'page': 'wiki',
'rootId': wiki_page._id
}, auth=self.user.auth)
assert res.status_code == 200
self.user.reload()
assert wiki_page._id in self.user.comments_viewed_timestamp
# contributor views comments -- sets contributor.comments_viewed_timestamp
res = self.app.put_json(url, {
'page': 'wiki',
'rootId': wiki_page._id
}, auth=contributor.auth)
contributor.reload()
assert wiki_page._id in contributor.comments_viewed_timestamp
# user updates the wiki
project.update_node_wiki('test', 'Updating wiki', self.auth)
comment.reload()
contributor.reload()
new_version_id = project.get_wiki_version('test')._id
assert wiki_page._id in contributor.comments_viewed_timestamp
assert comment.target.referent._id == wiki_page._id
class TestSpamDetail(AdminTestCase):
def setUp(self):
super(TestSpamDetail, self).setUp()
self.comment = CommentFactory()
self.comment.report_abuse(user=AuthUserFactory(), save=True,
category='spam')
self.request = RequestFactory().post('/fake_path')
self.request.user = UserFactory()
def test_confirm_spam(self):
form_data = {'confirm': str(SpamStatus.SPAM)}
form = ConfirmForm(data=form_data)
nt.assert_true(form.is_valid())
view = SpamDetail()
view = setup_form_view(
view, self.request, form, spam_id=self.comment._id)
with transaction.atomic():
view.form_valid(form)
obj = AdminLogEntry.objects.latest(field_name='action_time')
nt.assert_equal(obj.object_id, self.comment._id)
nt.assert_in('Confirmed SPAM:', obj.message())
def test_confirm_ham(self):
form_data = {'confirm': str(SpamStatus.HAM)}
form = ConfirmForm(data=form_data)
nt.assert_true(form.is_valid())
view = SpamDetail()
view = setup_form_view(
view, self.request, form, spam_id=self.comment._id)
with transaction.atomic():
view.form_valid(form)
obj = AdminLogEntry.objects.latest(field_name='action_time')
nt.assert_equal(obj.object_id, self.comment._id)
nt.assert_in('Confirmed HAM:', obj.message())
def test_form_valid_bad_id(self):
form = ConfirmForm()
view = SpamDetail()
view = setup_form_view(view, self.request, form, spam_id='a1')
with nt.assert_raises(Http404):
view.form_valid(form)
def test_get_context_data(self):
view = SpamDetail()
view = setup_view(view, self.request, spam_id=self.comment._id)
res = view.get_context_data()
nt.assert_equal(res['status'], '1')
nt.assert_equal(res['page_number'], '1')
nt.assert_is_instance(res['comment'], dict)
nt.assert_equal(res['SPAM_STATUS'].UNKNOWN, SpamStatus.UNKNOWN)
nt.assert_equal(res['SPAM_STATUS'].SPAM, SpamStatus.SPAM)
nt.assert_equal(res['SPAM_STATUS'].HAM, SpamStatus.HAM)
nt.assert_equal(res['SPAM_STATUS'].FLAGGED, SpamStatus.FLAGGED)
def test_get_context_data_bad_id(self):
view = setup_view(SpamDetail(), self.request, spam_id='a1')
with nt.assert_raises(Http404):
view.get_context_data()
def public_comment(self, user, contributor, public_project):
public_comment = CommentFactory(node=public_project, user=contributor)
public_comment.reports = {user._id: {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}}
public_comment.save()
return public_comment
class TestEmailView(AdminTestCase):
def setUp(self):
super(TestEmailView, self).setUp()
self.comment = CommentFactory()
self.comment.report_abuse(user=AuthUserFactory(), save=True,
category='spam')
self.request = RequestFactory().post('/fake_path')
self.request.user = UserFactory()
def test_get_object_bad_id(self):
view = setup_view(EmailView(), self.request, spam_id='a1')
with nt.assert_raises(Http404):
view.get_object()
def comment(self, user, contributor, private_project, file):
comment = CommentFactory(
node=private_project,
target=file.get_guid(),
user=contributor)
comment.reports = {user._id: {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}}
comment.save()
return comment
def test_private_node_only_logged_in_contributor_commenter_can_undelete_own_reply(
self, app, user, private_project, comment, set_up_payload):
reply_target = Guid.load(comment._id)
reply = CommentFactory(
node=private_project,
target=reply_target, user=user
)
reply_url = '/{}comments/{}/'.format(API_BASE, reply._id)
reply.is_deleted = True
reply.save()
payload = set_up_payload(reply._id, has_content=False)
res = app.patch_json_api(reply_url, payload, auth=user.auth)
assert res.status_code == 200
assert not res.json['data']['attributes']['deleted']
assert res.json['data']['attributes']['content'] == reply.content
def setUp(self):
super(TestEmailView, self).setUp()
self.comment = CommentFactory()
self.comment.report_abuse(user=AuthUserFactory(), save=True,
category='spam')
self.request = RequestFactory().post('/fake_path')
self.request.user = UserFactory()
def _set_up_public_project_with_comment(self):
self.public_project = ProjectFactory.create(is_public=True,
creator=self.user,
comment_level='private')
self.public_project.add_contributor(self.contributor, save=True)
self.public_file = test_utils.create_test_file(self.public_project,
self.user)
self.public_comment = CommentFactory(
node=self.public_project,
target=self.public_file.get_guid(),
user=self.user)
reply_target = Guid.load(self.public_comment._id)
self.public_comment_reply = CommentFactory(node=self.public_project,
target=reply_target,
user=self.user)
self.public_url = '/{}comments/{}/'.format(API_BASE,
self.public_comment._id)
self.public_comment_payload = self._set_up_payload(
self.public_comment._id)
def test_public_node_non_contributor_commenter_can_delete_wiki_comment(
self):
project = ProjectFactory(is_public=True, comment_level='public')
test_wiki = NodeWikiFactory(node=project, user=self.user)
comment = CommentFactory(node=project,
target=Guid.load(test_wiki._id),
user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
res = self.app.delete_json_api(url, auth=self.non_contributor.auth)
assert_equal(res.status_code, 204)
def test_public_node_non_contributor_commenter_can_delete_file_comment(
self):
project = ProjectFactory(is_public=True, comment_level='public')
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project,
target=test_file.get_guid(),
user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
res = self.app.delete_json_api(url, auth=self.non_contributor.auth)
assert_equal(res.status_code, 204)
def test_private_node_only_logged_in_contributor_commenter_can_delete_own_reply(
self):
self._set_up_private_project_with_comment()
reply_target = Guid.load(self.comment._id)
reply = CommentFactory(node=self.private_project,
target=reply_target,
user=self.user)
reply_url = '/{}comments/{}/'.format(API_BASE, reply._id)
res = self.app.delete_json_api(reply_url, auth=self.user.auth)
assert_equal(res.status_code, 204)
def test_redirects(self, app, project, registration, user):
# test_redirect_to_node_view
url = '/{}guids/{}/'.format(API_BASE, project._id)
res = app.get(url, auth=user.auth)
redirect_url = '{}{}nodes/{}/'.format(API_DOMAIN, API_BASE,
project._id)
assert res.status_code == 302
assert res.location == redirect_url
# test_redirect_to_registration_view
url = '/{}guids/{}/'.format(API_BASE, registration._id)
res = app.get(url, auth=user.auth)
redirect_url = '{}{}registrations/{}/'.format(API_DOMAIN, API_BASE,
registration._id)
assert res.status_code == 302
assert res.location == redirect_url
# test_redirect_to_collections_view
collection = CollectionFactory()
url = '/{}guids/{}/'.format(API_BASE, collection._id)
res = app.get(url, auth=user.auth)
redirect_url = '{}{}collections/{}/'.format(API_DOMAIN, API_BASE,
collection._id)
assert res.status_code == 302
assert res.location == redirect_url
# test_redirect_to_file_view
test_file = OsfStorageFile.create(
target=ProjectFactory(),
path='/test',
name='test',
materialized_path='/test',
)
test_file.save()
guid = test_file.get_guid(create=True)
url = '/{}guids/{}/'.format(API_BASE, guid._id)
res = app.get(url, auth=user.auth)
redirect_url = '{}{}files/{}/'.format(API_DOMAIN, API_BASE,
test_file._id)
assert res.status_code == 302
assert res.location == redirect_url
# test_redirect_to_comment_view
comment = CommentFactory()
url = '/{}guids/{}/'.format(API_BASE, comment._id)
res = app.get(url, auth=user.auth)
redirect_url = '{}{}comments/{}/'.format(API_DOMAIN, API_BASE,
comment._id)
assert res.status_code == 302
assert res.location == redirect_url
# test_redirect_throws_404_for_invalid_guids
url = '/{}guids/{}/'.format(API_BASE, 'fakeguid')
res = app.get(url, auth=user.auth, expect_errors=True)
assert res.status_code == 404
def _set_up_public_project_with_comment(self):
self.public_project = ProjectFactory.create(is_public=True,
creator=self.user,
comment_level='private')
self.public_project.add_contributor(self.contributor, save=True)
with mock.patch('osf.models.AbstractNode.update_search'):
self.public_wiki = NodeWikiFactory(node=self.public_project,
user=self.user)
self.public_comment = CommentFactory(node=self.public_project,
target=Guid.load(
self.public_wiki._id),
user=self.user)
reply_target = Guid.load(self.public_comment._id)
self.public_comment_reply = CommentFactory(node=self.public_project,
target=reply_target,
user=self.user)
self.public_url = '/{}comments/{}/'.format(API_BASE,
self.public_comment._id)
self.public_comment_payload = self._set_up_payload(
self.public_comment._id)
def test_public_node_non_contributor_commenter_can_update_comment(self):
project = ProjectFactory(is_public=True, comment_level='public')
comment = CommentFactory(node=project, user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url,
payload,
auth=self.non_contributor.auth)
assert_equal(res.status_code, 200)
assert_equal(payload['data']['attributes']['content'],
res.json['data']['attributes']['content'])
def test_redirect_when_viewing_private_project_comment_through_view_only_link(
self):
project = ProjectFactory()
view_only_link = self._add_private_link(project)
comment = CommentFactory(node=project)
url = '/{}guids/{}/?view_only={}'.format(API_BASE, comment._id,
view_only_link.key)
res = self.app.get(url, auth=AuthUserFactory().auth)
redirect_url = '{}{}comments/{}/?view_only={}'.format(
API_DOMAIN, API_BASE, comment._id, view_only_link.key)
assert_equal(res.status_code, 302)
assert_equal(res.location, redirect_url)
def test_wiki_has_comments_link(self):
self._set_up_public_project_with_wiki_page()
res = self.app.get(self.public_url)
assert_equal(res.status_code, 200)
url = res.json['data']['relationships']['comments']['links'][
'related']['href']
comment = CommentFactory(node=self.public_project,
target=Guid.load(self.public_wiki._id),
user=self.user)
res = self.app.get(url)
assert_equal(res.status_code, 200)
assert_equal(res.json['data'][0]['type'], 'comments')
def setUp(self):
super(TestUserSpamListView, self).setUp()
self.project = ProjectFactory(is_public=True)
self.user_1 = AuthUserFactory()
self.user_2 = AuthUserFactory()
self.project.add_contributor(self.user_1)
self.project.add_contributor(self.user_2)
self.project.save()
self.user_1.save()
self.user_2.save()
self.comment_1 = CommentFactory(node=self.project, user=self.user_1)
self.comment_2 = CommentFactory(node=self.project, user=self.user_1)
self.comment_3 = CommentFactory(node=self.project, user=self.user_1)
self.comment_4 = CommentFactory(node=self.project, user=self.user_1)
self.comment_5 = CommentFactory(node=self.project, user=self.user_2)
self.comment_6 = CommentFactory(node=self.project, user=self.user_2)
self.comment_1.report_abuse(user=self.user_2, save=True,
category='spam')
self.comment_2.report_abuse(user=self.user_2, save=True,
category='spam')
self.comment_3.report_abuse(user=self.user_2, save=True,
category='spam')
self.comment_4.report_abuse(user=self.user_2, save=True,
category='spam')
self.comment_5.report_abuse(user=self.user_1, save=True,
category='spam')
self.comment_6.report_abuse(user=self.user_1, save=True,
category='spam')
self.request = RequestFactory().get('/fake_path')
self.view = UserSpamList()
self.view = setup_view(self.view, self.request, user_id=self.user_1._id)
def _set_up_public_project_comment_reports(self, comment_level='public'):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level=comment_level)
self.public_project.add_contributor(contributor=self.contributor, save=True)
self.public_comment = CommentFactory.build(node=self.public_project, user=self.contributor)
self.public_comment.reports = self.public_comment.reports or {}
self.public_comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/'.format(API_BASE, self.public_comment._id)
def _set_up_public_project_comment_reports(self, comment_level='public'):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level=comment_level)
self.public_project.add_contributor(contributor=self.contributor, save=True)
self.public_comment = CommentFactory.build(node=self.public_project, user=self.contributor)
self.public_comment.reports = self.public_comment.reports or {}
self.public_comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/'.format(API_BASE, self.public_comment._id)
def test_update_wiki_updates_contributor_comments_viewed_timestamp(self):
contributor = AuthUserFactory()
project = ProjectFactory(creator=self.user, is_public=True)
project.add_contributor(contributor)
project.save()
wiki = NodeWikiFactory(node=project, page_name='test')
comment = CommentFactory(node=project,
target=Guid.load(wiki._id),
user=self.user)
# user views comments -- sets user.comments_viewed_timestamp
url = project.api_url_for('update_comments_timestamp')
res = self.app.put_json(url, {
'page': 'wiki',
'rootId': wiki._id
},
auth=self.user.auth)
assert res.status_code == 200
self.user.reload()
assert wiki._id in self.user.comments_viewed_timestamp
# contributor views comments -- sets contributor.comments_viewed_timestamp
res = self.app.put_json(url, {
'page': 'wiki',
'rootId': wiki._id
},
auth=contributor.auth)
contributor.reload()
assert wiki._id in contributor.comments_viewed_timestamp
# user updates the wiki
project.update_node_wiki('test', 'Updating wiki', self.auth)
comment.reload()
contributor.reload()
new_version_id = project.wiki_pages_current['test']
assert new_version_id in contributor.comments_viewed_timestamp
assert wiki._id not in contributor.comments_viewed_timestamp
assert comment.target.referent._id == new_version_id
def test_public_node_non_contrib_commenter_can_update_wiki_comment(
self, app, user, non_contrib, set_up_payload):
project = ProjectFactory(is_public=True)
test_wiki = NodeWikiFactory(node=project, user=user)
comment = CommentFactory(node=project,
target=Guid.load(test_wiki._id),
user=non_contrib)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = set_up_payload(comment._id)
res = app.put_json_api(url, payload, auth=non_contrib.auth)
assert res.status_code == 200
assert payload['data']['attributes']['content'] == res.json['data'][
'attributes']['content']
def test_update_wiki_updates_comments_and_user_comments_viewed_timestamp(self):
project = ProjectFactory(creator=self.user, is_public=True)
wiki_page = WikiFactory(node=project, page_name='test')
wiki = WikiVersionFactory(wiki_page=wiki_page)
comment = CommentFactory(node=project, target=Guid.load(wiki_page._id), user=UserFactory())
# user views comments -- sets user.comments_viewed_timestamp
url = project.api_url_for('update_comments_timestamp')
res = self.app.put_json(url, {
'page': 'wiki',
'rootId': wiki_page._id
}, auth=self.user.auth)
assert res.status_code == 200
self.user.reload()
assert wiki_page._id in self.user.comments_viewed_timestamp
# user updates the wiki
wiki_page.update(self.user, 'Updating wiki')
comment.reload()
self.user.reload()
assert wiki_page._id in self.user.comments_viewed_timestamp
assert comment.target.referent._id == wiki_page._id
def test_update_wiki_updates_comments_and_user_comments_viewed_timestamp(self):
project = ProjectFactory(creator=self.user, is_public=True)
wiki_page = WikiFactory(node=project, page_name='test')
wiki = WikiVersionFactory(wiki_page=wiki_page)
comment = CommentFactory(node=project, target=Guid.load(wiki_page._id), user=UserFactory())
# user views comments -- sets user.comments_viewed_timestamp
url = project.api_url_for('update_comments_timestamp')
res = self.app.put_json(url, {
'page': 'wiki',
'rootId': wiki_page._id
}, auth=self.user.auth)
assert res.status_code == 200
self.user.reload()
assert wiki_page._id in self.user.comments_viewed_timestamp
# user updates the wiki
project.update_node_wiki('test', 'Updating wiki', self.auth)
comment.reload()
self.user.reload()
assert wiki_page._id in self.user.comments_viewed_timestamp
assert comment.target.referent._id == wiki_page._id
def test_public_node_non_contrib_commenter_can_delete_wiki_comment(
self, app, user, non_contrib):
project = ProjectFactory(is_public=True, comment_level='public')
wiki_page = WikiFactory(
user=user,
node=project,
)
comment = CommentFactory(node=project,
target=Guid.load(wiki_page._id),
user=non_contrib)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
res = app.delete_json_api(url, auth=non_contrib.auth)
assert res.status_code == 204
def test_public_node_non_contrib_commenter_can_update_file_comment(
self, app, non_contrib, set_up_payload):
project = ProjectFactory(is_public=True)
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project,
target=test_file.get_guid(),
user=non_contrib)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = set_up_payload(comment._id)
res = app.put_json_api(url, payload, auth=non_contrib.auth)
assert res.status_code == 200
assert payload['data']['attributes']['content'] == res.json['data'][
'attributes']['content']
def _set_up_private_project_comment_reports(self):
self.private_project = ProjectFactory.create(is_public=False, creator=self.user)
self.private_project.add_contributor(contributor=self.contributor, save=True)
self.file = test_utils.create_test_file(self.private_project, self.user)
self.comment = CommentFactory.build(node=self.private_project, target=self.file.get_guid(), user=self.contributor)
self.comment.reports = self.comment.reports or {}
self.comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}
self.comment.save()
self.private_url = '/{}comments/{}/reports/'.format(API_BASE, self.comment._id)
def test_public_node_non_contrib_commenter_cannot_update_own_comment_if_comment_level_private(
self, app, non_contrib, set_up_payload):
project = ProjectFactory(is_public=True, comment_level='public')
comment = CommentFactory(node=project, user=non_contrib)
project.comment_level = 'private'
project.save()
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = set_up_payload(comment._id)
res = app.put_json_api(
url, payload, auth=non_contrib.auth,
expect_errors=True
)
assert res.status_code == 403
assert res.json['errors'][0]['detail'] == exceptions.PermissionDenied.default_detail
def _set_up_private_project_comment_reports(self):
self.private_project = ProjectFactory.create(is_public=False, creator=self.user)
self.private_project.add_contributor(contributor=self.contributor, save=True)
self.file = test_utils.create_test_file(self.private_project, self.user)
self.comment = CommentFactory.build(node=self.private_project, target=self.file.get_guid(), user=self.contributor)
self.comment.reports = self.comment.reports or {}
self.comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}
self.comment.save()
self.private_url = '/{}comments/{}/reports/'.format(API_BASE, self.comment._id)
def test_file_has_correct_unread_comments_count(self):
contributor = AuthUserFactory()
self.node.add_contributor(contributor, auth=Auth(self.user), save=True)
comment = CommentFactory(node=self.node,
target=self.file.get_guid(create=True),
user=contributor,
page='files')
res = self.app.get('/{}files/{}/?related_counts=True'.format(
API_BASE, self.file._id),
auth=self.user.auth)
assert_equal(res.status_code, 200)
unread_comments = res.json['data']['relationships']['comments'][
'links']['related']['meta']['unread']
assert_equal(unread_comments, 1)
def test_file_has_correct_unread_comments_count(self, app, user, file,
node):
contributor = AuthUserFactory()
node.add_contributor(contributor, auth=Auth(user), save=True)
CommentFactory(node=node,
target=file.get_guid(create=True),
user=contributor,
page='files')
res = app.get('/{}files/{}/?related_counts=True'.format(
API_BASE, file._id),
auth=user.auth)
assert res.status_code == 200
unread_comments = res.json['data']['relationships']['comments'][
'links']['related']['meta']['unread']
assert unread_comments == 1
def test_public_node_non_contributor_commenter_can_update_file_comment(
self):
project = ProjectFactory(is_public=True)
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project,
target=test_file.get_guid(),
user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url,
payload,
auth=self.non_contributor.auth)
assert_equal(res.status_code, 200)
assert_equal(payload['data']['attributes']['content'],
res.json['data']['attributes']['content'])
def _set_up_public_project_comment_reports(self, comment_level='public'):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level=comment_level)
self.public_project.add_contributor(contributor=self.contributor, save=True)
with mock.patch('osf.models.AbstractNode.update_search'):
self.public_wiki = NodeWikiFactory(node=self.public_project, user=self.user)
self.public_comment = CommentFactory.build(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.contributor)
self.public_comment.reports = self.public_comment.reports or {}
self.public_comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/'.format(API_BASE, self.public_comment._id)
def _set_up_public_project_comment_reports(self, comment_level='public'):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level=comment_level)
self.public_project.add_contributor(contributor=self.contributor, save=True)
with mock.patch('osf.models.AbstractNode.update_search'):
self.public_wiki = NodeWikiFactory(node=self.public_project, user=self.user)
self.public_comment = CommentFactory.build(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.contributor)
self.public_comment.reports = self.public_comment.reports or {}
self.public_comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/'.format(API_BASE, self.public_comment._id)
def test_public_node_non_contributor_commenter_cannot_update_own_comment_if_comment_level_private(
self):
project = ProjectFactory(is_public=True, comment_level='public')
comment = CommentFactory(node=project, user=self.non_contributor)
project.comment_level = 'private'
project.save()
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url,
payload,
auth=self.non_contributor.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'],
'You do not have permission to perform this action.')
def test_private_node_report_comment_auth_misc(self, app, user, contributor, non_contrib, private_project, private_url, comment, payload):
# test_private_node_logged_out_user_cannot_report_comment
res = app.post_json_api(private_url, payload, expect_errors=True)
assert res.status_code == 401
# test_private_node_logged_in_non_contrib_cannot_report_comment
res = app.post_json_api(private_url, payload, auth=non_contrib.auth, expect_errors=True)
assert res.status_code == 403
# test_private_node_logged_in_contributor_can_report_comment
comment_new = CommentFactory(node=private_project, user=contributor, target=comment.target)
url = '/{}comments/{}/reports/'.format(API_BASE, comment_new._id)
res = app.post_json_api(url, payload, auth=user.auth)
assert res.status_code == 201
assert res.json['data']['id'] == user._id
def test_report_comment_allow_blank_message(self, app, user, contributor, private_project, comment):
comment_new = CommentFactory(node=private_project, user=contributor, target=comment.target)
url = '/{}comments/{}/reports/'.format(API_BASE, comment_new._id)
payload = {
'data': {
'type': 'comment_reports',
'attributes': {
'category': 'spam',
'message': ''
}
}
}
res = app.post_json_api(url, payload, auth=user.auth)
assert res.status_code == 201
assert res.json['data']['id'] == user._id
assert res.json['data']['attributes']['message'] == payload['data']['attributes']['message']
def test_report_comment_allow_blank_message(self):
self._set_up_private_project_comment_reports()
comment = CommentFactory(node=self.private_project, user=self.contributor, target=self.comment.target)
url = '/{}comments/{}/reports/'.format(API_BASE, comment._id)
payload = {
'data': {
'type': 'comment_reports',
'attributes': {
'category': 'spam',
'message': ''
}
}
}
res = self.app.post_json_api(url, payload, auth=self.user.auth)
assert_equal(res.status_code, 201)
assert_equal(res.json['data']['id'], self.user._id)
assert_equal(res.json['data']['attributes']['message'], payload['data']['attributes']['message'])
def setUp(self):
super(TestSpamListView, self).setUp()
Comment.objects.all().delete()
self.project = ProjectFactory(is_public=True)
self.user_1 = AuthUserFactory()
self.user_2 = AuthUserFactory()
self.project.add_contributor(self.user_1)
self.project.add_contributor(self.user_2)
self.project.save()
self.user_1.save()
self.user_2.save()
date = timezone.now()
self.comment_1 = CommentFactory(node=self.project, user=self.user_1)
self.comment_2 = CommentFactory(node=self.project, user=self.user_1)
self.comment_3 = CommentFactory(node=self.project, user=self.user_1)
self.comment_4 = CommentFactory(node=self.project, user=self.user_1)
self.comment_5 = CommentFactory(node=self.project, user=self.user_2)
self.comment_6 = CommentFactory(node=self.project, user=self.user_2)
self.comment_1.report_abuse(
user=self.user_2,
save=True,
category='spam',
date=date - timedelta(seconds=5)
)
self.comment_2.report_abuse(
user=self.user_2,
save=True,
category='spam',
date=date - timedelta(seconds=4)
)
self.comment_3.report_abuse(
user=self.user_2,
save=True,
category='spam',
date=date - timedelta(seconds=3)
)
self.comment_4.report_abuse(
user=self.user_2,
save=True,
category='spam',
date=date - timedelta(seconds=2)
)
self.comment_5.report_abuse(
user=self.user_1,
save=True,
category='spam',
date=date - timedelta(seconds=1)
)
self.comment_6.report_abuse(user=self.user_1, save=True,
category='spam')
self.request = RequestFactory().get('/fake_path')
self.view = SpamList()
self.view = setup_view(self.view, self.request, user_id=self.user_1._id)
def test_private_node_reporting_contributor_can_delete_report_detail(self):
self._set_up_private_project_comment_reports()
comment = CommentFactory.build(node=self.private_project,
user=self.contributor,
target=self.comment.target)
comment.reports = {
self.user._id: {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}
}
comment.save()
url = '/{}comments/{}/reports/{}/'.format(API_BASE, comment._id,
self.user._id)
res = self.app.delete_json_api(url, auth=self.user.auth)
assert_equal(res.status_code, 204)
def _set_up_private_project_comment_reports(self):
self.private_project = ProjectFactory.create(is_public=False,
creator=self.user)
self.private_project.add_contributor(contributor=self.contributor,
save=True)
self.comment = CommentFactory.build(node=self.private_project,
user=self.contributor)
self.comment.reports = {
self.user._id: {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}
}
self.comment.save()
self.private_url = '/{}comments/{}/reports/{}/'.format(
API_BASE, self.comment._id, self.user._id)
def test_public_node_report_comment_auth_misc(self, app, user, contributor, non_contrib, public_project, public_url, public_comment, payload):
# def test_public_node_logged_out_user_cannot_report_comment(self):
res = app.post_json_api(public_url, payload, expect_errors=True)
assert res.status_code == 401
# def test_public_node_contributor_can_report_comment(self):
comment = CommentFactory(node=public_project, user=contributor, target=public_comment.target)
url = '/{}comments/{}/reports/'.format(API_BASE, comment._id)
res = app.post_json_api(url, payload, auth=user.auth)
assert res.status_code == 201
assert res.json['data']['id'] == user._id
# def test_public_node_non_contrib_can_report_comment(self):
""" Test that when a public project allows any osf user to
comment (comment_level == 'public), non-contributors
can also report comments.
"""
res = app.post_json_api(public_url, payload, auth=non_contrib.auth)
assert res.status_code == 201
assert res.json['data']['id'] == non_contrib._id
def test_redirects_through_view_only_link(self, app, project, user):
# test_redirect_when_viewing_private_project_through_view_only_link
view_only_link = PrivateLinkFactory(anonymous=False)
view_only_link.nodes.add(project)
view_only_link.save()
url = '/{}guids/{}/?view_only={}'.format(API_BASE, project._id,
view_only_link.key)
res = app.get(url, auth=user.auth)
redirect_url = '{}{}nodes/{}/?view_only={}'.format(
API_DOMAIN, API_BASE, project._id, view_only_link.key)
assert res.status_code == 302
assert res.location == redirect_url
# test_redirect_when_viewing_private_project_file_through_view_only_link
test_file = OsfStorageFile.create(
node=project,
path='/test',
name='test',
materialized_path='/test',
)
test_file.save()
guid = test_file.get_guid(create=True)
url = '/{}guids/{}/?view_only={}'.format(API_BASE, guid._id,
view_only_link.key)
res = app.get(url, auth=user.auth)
redirect_url = '{}{}files/{}/?view_only={}'.format(
API_DOMAIN, API_BASE, test_file._id, view_only_link.key)
assert res.status_code == 302
assert res.location == redirect_url
# test_redirect_when_viewing_private_project_comment_through_view_only_link
comment = CommentFactory(node=project)
url = '/{}guids/{}/?view_only={}'.format(API_BASE, comment._id,
view_only_link.key)
res = app.get(url, auth=AuthUserFactory().auth)
redirect_url = '{}{}comments/{}/?view_only={}'.format(
API_DOMAIN, API_BASE, comment._id, view_only_link.key)
assert res.status_code == 302
assert res.location == redirect_url
def test_private_node_delete_report_detail_auth_misc(
self, app, user, contributor, non_contrib,
private_project, private_url, comment
):
# test_private_node_reported_contributor_cannot_delete_report_detail
res = app.delete_json_api(
private_url, auth=contributor.auth,
expect_errors=True
)
assert res.status_code == 403
# test_private_node_logged_in_non_contrib_cannot_delete_report_detail
res = app.delete_json_api(
private_url, auth=non_contrib.auth,
expect_errors=True
)
assert res.status_code == 403
# test_private_node_logged_out_contributor_cannot_delete_detail
res = app.delete_json_api(private_url, expect_errors=True)
assert res.status_code == 401
# test_private_node_reporting_contributor_can_delete_report_detail
comment_new = CommentFactory.build(
node=private_project,
user=contributor,
target=comment.target
)
comment_new.reports = {user._id: {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}}
comment_new.save()
url = '/{}comments/{}/reports/{}/'.format(
API_BASE, comment_new._id, user._id)
res = app.delete_json_api(url, auth=user.auth)
assert res.status_code == 204
def test_private_node_delete_report_detail_auth_misc(
self, app, user, contributor, non_contrib, private_project,
private_url, comment):
# test_private_node_reported_contributor_cannot_delete_report_detail
res = app.delete_json_api(private_url,
auth=contributor.auth,
expect_errors=True)
assert res.status_code == 403
# test_private_node_logged_in_non_contrib_cannot_delete_report_detail
res = app.delete_json_api(private_url,
auth=non_contrib.auth,
expect_errors=True)
assert res.status_code == 403
# test_private_node_logged_out_contributor_cannot_delete_detail
res = app.delete_json_api(private_url, expect_errors=True)
assert res.status_code == 401
# test_private_node_reporting_contributor_can_delete_report_detail
comment_new = CommentFactory.build(node=private_project,
user=contributor,
target=comment.target)
comment_new.reports = {
user._id: {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}
}
comment_new.save()
url = '/{}comments/{}/reports/{}/'.format(API_BASE, comment_new._id,
user._id)
res = app.delete_json_api(url, auth=user.auth)
assert res.status_code == 204
class TestSpamListView(AdminTestCase):
def setUp(self):
super(TestSpamListView, self).setUp()
Comment.objects.all().delete()
self.project = ProjectFactory(is_public=True)
self.user_1 = AuthUserFactory()
self.user_2 = AuthUserFactory()
self.project.add_contributor(self.user_1)
self.project.add_contributor(self.user_2)
self.project.save()
self.user_1.save()
self.user_2.save()
date = timezone.now()
self.comment_1 = CommentFactory(node=self.project, user=self.user_1)
self.comment_2 = CommentFactory(node=self.project, user=self.user_1)
self.comment_3 = CommentFactory(node=self.project, user=self.user_1)
self.comment_4 = CommentFactory(node=self.project, user=self.user_1)
self.comment_5 = CommentFactory(node=self.project, user=self.user_2)
self.comment_6 = CommentFactory(node=self.project, user=self.user_2)
self.comment_1.report_abuse(
user=self.user_2,
save=True,
category='spam',
date=date - timedelta(seconds=5)
)
self.comment_2.report_abuse(
user=self.user_2,
save=True,
category='spam',
date=date - timedelta(seconds=4)
)
self.comment_3.report_abuse(
user=self.user_2,
save=True,
category='spam',
date=date - timedelta(seconds=3)
)
self.comment_4.report_abuse(
user=self.user_2,
save=True,
category='spam',
date=date - timedelta(seconds=2)
)
self.comment_5.report_abuse(
user=self.user_1,
save=True,
category='spam',
date=date - timedelta(seconds=1)
)
self.comment_6.report_abuse(user=self.user_1, save=True,
category='spam')
self.request = RequestFactory().get('/fake_path')
self.view = SpamList()
self.view = setup_view(self.view, self.request, user_id=self.user_1._id)
def test_get_spam(self):
res = list(self.view.get_queryset())
nt.assert_equal(len(res), 6)
response_list = [r._id for r in res]
should_be = [
self.comment_6._id,
self.comment_5._id,
self.comment_4._id,
self.comment_3._id,
self.comment_2._id,
self.comment_1._id
]
nt.assert_list_equal(should_be, response_list)
def test_get_context_data(self):
self.view.object_list = self.view.get_queryset()
res = self.view.get_context_data()
nt.assert_is_instance(res['spam'], list)
nt.assert_is_instance(res['spam'][0], dict)
nt.assert_equal(res['status'], '1')
nt.assert_equal(res['page_number'], 1)
def setUp(self):
super(TestSpamMixin, self).setUp()
self.comment = CommentFactory()
self.auth = Auth(user=self.comment.user)
class TestUserSpamListView(AdminTestCase):
def setUp(self):
super(TestUserSpamListView, self).setUp()
self.project = ProjectFactory(is_public=True)
self.user_1 = AuthUserFactory()
self.user_2 = AuthUserFactory()
self.project.add_contributor(self.user_1)
self.project.add_contributor(self.user_2)
self.project.save()
self.user_1.save()
self.user_2.save()
self.comment_1 = CommentFactory(node=self.project, user=self.user_1)
self.comment_2 = CommentFactory(node=self.project, user=self.user_1)
self.comment_3 = CommentFactory(node=self.project, user=self.user_1)
self.comment_4 = CommentFactory(node=self.project, user=self.user_1)
self.comment_5 = CommentFactory(node=self.project, user=self.user_2)
self.comment_6 = CommentFactory(node=self.project, user=self.user_2)
self.comment_1.report_abuse(user=self.user_2, save=True,
category='spam')
self.comment_2.report_abuse(user=self.user_2, save=True,
category='spam')
self.comment_3.report_abuse(user=self.user_2, save=True,
category='spam')
self.comment_4.report_abuse(user=self.user_2, save=True,
category='spam')
self.comment_5.report_abuse(user=self.user_1, save=True,
category='spam')
self.comment_6.report_abuse(user=self.user_1, save=True,
category='spam')
self.request = RequestFactory().get('/fake_path')
self.view = UserSpamList()
self.view = setup_view(self.view, self.request, user_id=self.user_1._id)
def test_get_user_spam(self):
res = list(self.view.get_queryset())
nt.assert_equal(len(res), 4)
def test_get_context_data(self):
self.view.object_list = self.view.get_queryset()
res = self.view.get_context_data()
nt.assert_is_instance(res['spam'], list)
nt.assert_is_instance(res['spam'][0], dict)
nt.assert_equal(res['status'], '1')
nt.assert_equal(res['page_number'], 1)
nt.assert_equal(res['user_id'], self.user_1._id)
class TestSpamMixin(OsfTestCase):
def setUp(self):
super(TestSpamMixin, self).setUp()
self.comment = CommentFactory()
self.auth = Auth(user=self.comment.user)
def test_report_abuse(self):
user = UserFactory()
time = timezone.now()
self.comment.report_abuse(
user, date=time, category='spam', text='ads', save=True)
assert_equal(self.comment.spam_status, SpamStatus.FLAGGED)
equivalent = dict(
date=time,
category='spam',
text='ads',
retracted=False
)
assert_in(user._id, self.comment.reports)
assert_equal(self.comment.reports[user._id], equivalent)
def test_report_abuse_own_comment(self):
with assert_raises(ValueError):
self.comment.report_abuse(
self.comment.user,
category='spam', text='ads',
save=True
)
assert_equal(self.comment.spam_status, SpamStatus.UNKNOWN)
def test_retract_report(self):
user = UserFactory()
time = timezone.now()
self.comment.report_abuse(
user, date=time, category='spam', text='ads', save=True
)
assert_equal(self.comment.spam_status, SpamStatus.FLAGGED)
self.comment.retract_report(user, save=True)
assert_equal(self.comment.spam_status, SpamStatus.UNKNOWN)
equivalent = {
'date': time,
'category': 'spam',
'text': 'ads',
'retracted': True
}
assert_in(user._id, self.comment.reports)
assert_equal(self.comment.reports[user._id], equivalent)
def test_retract_report_not_reporter(self):
reporter = UserFactory()
non_reporter = UserFactory()
self.comment.report_abuse(
reporter, category='spam', text='ads', save=True
)
with assert_raises(ValueError):
self.comment.retract_report(non_reporter, save=True)
assert_equal(self.comment.spam_status, SpamStatus.FLAGGED)
def test_retract_one_report_of_many(self):
user_1 = UserFactory()
user_2 = UserFactory()
time = timezone.now()
self.comment.report_abuse(
user_1, date=time, category='spam', text='ads', save=True
)
assert_equal(self.comment.spam_status, SpamStatus.FLAGGED)
self.comment.report_abuse(
user_2, date=time, category='spam', text='all', save=True
)
self.comment.retract_report(user_1, save=True)
equivalent = {
'date': time,
'category': 'spam',
'text': 'ads',
'retracted': True
}
assert_in(user_1._id, self.comment.reports)
assert_equal(self.comment.reports[user_1._id], equivalent)
assert_equal(self.comment.spam_status, SpamStatus.FLAGGED)
def test_flag_spam(self):
self.comment.flag_spam()
self.comment.save()
assert_equal(self.comment.spam_status, SpamStatus.FLAGGED)
def test_cannot_remove_flag_not_retracted(self):
user = UserFactory()
self.comment.report_abuse(
user, category='spam', text='ads', save=True
)
self.comment.remove_flag(save=True)
assert_equal(self.comment.spam_status, SpamStatus.FLAGGED)
def test_remove_flag(self):
self.comment.flag_spam()
self.comment.save()
assert_equal(self.comment.spam_status, SpamStatus.FLAGGED)
self.comment.remove_flag(save=True)
assert_equal(self.comment.spam_status, SpamStatus.UNKNOWN)
def test_confirm_ham(self):
self.comment.confirm_ham(save=True)
assert_equal(self.comment.spam_status, SpamStatus.HAM)
def test_confirm_spam(self):
self.comment.confirm_spam(save=True)
assert_equal(self.comment.spam_status, SpamStatus.SPAM)
def test_validate_reports_bad_key(self):
self.comment.reports[None] = {'category': 'spam', 'text': 'ads'}
with assert_raises(ValidationError):
self.comment.save()
def test_validate_reports_bad_type(self):
self.comment.reports[self.comment.user._id] = 'not a dict'
with assert_raises(ValidationError):
self.comment.save()
def test_validate_reports_bad_value(self):
self.comment.reports[self.comment.user._id] = {'foo': 'bar'}
with assert_raises(ValidationError):
self.comment.save()
