def test_private_node_logged_out_user_cannot_see_deleted_comment(self):
     self._set_up_private_project_with_comment()
     comment = CommentFactory(node=self.private_project, target=self.private_project, user=self.user)
     comment.is_deleted = True
     comment.save()
     url = '/{}comments/{}/'.format(API_BASE, comment._id)
     res = self.app.get(url, expect_errors=True)
     assert_equal(res.status_code, 401)

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 = OSFLogEntry.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 = OSFLogEntry.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 test_private_node_logged_out_user_cannot_see_deleted_file_comment(self):
     self._set_up_private_project_with_file_comment()
     comment = CommentFactory(node=self.private_project, target=self.file, user=self.user)
     comment.is_deleted = True
     comment.save()
     url = '/{}comments/{}/'.format(API_BASE, comment._id)
     res = self.app.get(url, expect_errors=True)
     assert_equal(res.status_code, 401)
     assert_equal(res.json['errors'][0]['detail'], 'Authentication credentials were not provided.')

 def test_private_node_contributor_cannot_see_other_users_deleted_file_comment(self):
     self._set_up_private_project_with_file_comment()
     comment = CommentFactory(node=self.private_project, target=self.file, user=self.user)
     comment.is_deleted = True
     comment.save()
     url = '/{}comments/{}/'.format(API_BASE, comment._id)
     res = self.app.get(url, auth=self.contributor.auth)
     assert_equal(res.status_code, 200)
     assert_is_none(res.json['data']['attributes']['content'])

 def test_public_node_non_contributor_cannot_view_other_users_deleted_comment(self):
     public_project = ProjectFactory(is_public=True, creator=self.user)
     comment = CommentFactory(node=public_project, target=public_project, user=self.user)
     comment.is_deleted = True
     comment.save()
     url = '/{}comments/{}/'.format(API_BASE, comment._id)
     res = self.app.get(url, auth=self.non_contributor.auth)
     assert_equal(res.status_code, 200)
     assert_is_none(res.json['data']['attributes']['content'])

 def test_private_node_only_logged_in_commenter_can_view_deleted_comment(self):
     self._set_up_private_project_with_comment()
     comment = CommentFactory(node=self.private_project, target=self.private_project, user=self.user)
     comment.is_deleted = True
     comment.save()
     url = '/{}comments/{}/'.format(API_BASE, comment._id)
     res = self.app.get(url, auth=self.user.auth)
     assert_equal(res.status_code, 200)
     assert_equal(res.json['data']['attributes']['content'], comment.content)

 def test_public_node_logged_out_user_cannot_view_deleted_file_comments(self):
     self._set_up_public_project_with_file_comment()
     comment = CommentFactory(node=self.public_project, target=self.public_file, user=self.user)
     comment.is_deleted = True
     comment.save()
     url = '/{}comments/{}/'.format(API_BASE, comment._id)
     res = self.app.get(url)
     assert_equal(res.status_code, 200)
     assert_is_none(res.json['data']['attributes']['content'])

 def test_private_node_only_logged_in_contributor_commenter_can_undelete_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)
     reply.is_deleted = True
     reply.save()
     payload = self._set_up_payload(reply._id, has_content=False)
     res = self.app.patch_json_api(reply_url, payload, auth=self.user.auth)
     assert_equal(res.status_code, 200)
     assert_false(res.json['data']['attributes']['deleted'])
     assert_equal(res.json['data']['attributes']['content'], reply.content)

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 test_public_node_private_comment_level_non_contributor_cannot_see_reports(self):
     project = ProjectFactory(is_public=True, creator=self.user, comment_level="private")
     comment = CommentFactory(node=project, target=project, user=self.user)
     comment.reports = dict()
     comment.reports[self.user._id] = {
         "category": "spam",
         "text": "This is spam",
         "date": datetime.utcnow(),
         "retracted": False,
     }
     comment.save()
     url = "/{}comments/{}/reports/".format(API_BASE, comment._id)
     res = self.app.get(url, 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_public_node_private_comment_level_non_contributor_cannot_see_reports(self):
     project = ProjectFactory(is_public=True, creator=self.user, comment_level='private')
     comment = CommentFactory(node=project, user=self.user)
     comment.reports = dict()
     comment.reports[self.user._id] = {
         'category': 'spam',
         'text': 'This is spam',
         'date': datetime.utcnow(),
         'retracted': False,
     }
     comment.save()
     url = '/{}comments/{}/reports/'.format(API_BASE, comment._id)
     res = self.app.get(url, 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 _set_up_public_project_with_file_comment(self):
     self.public_project = ProjectFactory.build(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, 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 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 _set_up_public_project_comment_reports(self):
     self.public_project = ProjectFactory.build(is_public=True, creator=self.user)
     self.public_project.add_contributor(contributor=self.contributor, save=True)
     self.public_comment = CommentFactory.build(node=self.public_project, target=self.public_project, user=self.contributor)
     self.public_comment.reports = {self.user._id: {'category': 'spam', 'text': 'This is spam'}}
     self.public_comment.save()
     self.public_url = '/{}comments/{}/reports/{}/'.format(API_BASE, self.public_comment._id, self.user._id)

 def test_public_node_reporting_contributor_can_delete_detail(self):
     self._set_up_public_project_file_comment_reports()
     comment = CommentFactory.build(node=self.public_project, target=self.public_file, user=self.contributor)
     comment.reports = {self.user._id: {'category': 'spam', 'text': 'This is spam'}}
     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 test_public_node_logged_in_non_contributor_reporter_can_view_report_detail(self):
     project = ProjectFactory(is_public=True, comment_level='public')
     comment = CommentFactory.build(node=project, user=project.creator)
     comment.reports = {self.non_contributor._id: {'category': 'spam', 'text': 'This is spam'}}
     comment.save()
     url = '/{}comments/{}/reports/{}/'.format(API_BASE, comment._id, self.non_contributor._id)
     res = self.app.get(url, auth=self.non_contributor.auth)
     assert_equal(res.status_code, 200)

    def test_find_unread_includes_edited_comments(self):
        project = ProjectFactory()
        user = AuthUserFactory()
        project.add_contributor(user)
        project.save()
        comment = CommentFactory(node=project, user=project.creator)

        url = project.api_url_for("update_comments_timestamp")
        payload = {"page": "node", "rootId": project._id}
        res = self.app.put_json(url, payload, auth=user.auth)
        user.reload()
        n_unread = Comment.find_n_unread(user=user, node=project, page="node")
        assert_equal(n_unread, 0)

        # Edit previously read comment
        comment.edit(auth=Auth(project.creator), content="edited", save=True)
        n_unread = Comment.find_n_unread(user=user, node=project, page="node")
        assert_equal(n_unread, 1)

 def _set_up_private_project_file_comment_reports(self):
     self.private_project = ProjectFactory.build(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, user=self.contributor)
     self.comment.reports = self.comment.reports or {}
     self.comment.reports[self.user._id] = {'category': 'spam', 'text': 'This is spam'}
     self.comment.save()
     self.private_url = '/{}comments/{}/reports/'.format(API_BASE, self.comment._id)

class TestEmailFormView(AdminTestCase):
    def setUp(self):
        super(TestEmailFormView, 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()
        self.view = EmailFormView()
        self.form = EmailForm(data={
            'author': 'Nemo',
            'message': 'A message for spammers.',
            'subject': 'stop spamming',
            'email': ('[email protected]', '[email protected]')
        })
        self.view = setup_form_view(self.view, self.request, self.form,
                                    spam_id=self.comment._id)

    @mock.patch('admin.spam.views.render')
    def test_get_context_data(self, mock_render):
        res = self.view.get_context_data()
        nt.assert_equal(res['status'], '1')
        nt.assert_equal(res['page_number'], '1')
        nt.assert_is_instance(res['comment'], dict)

    def test_get_context_data_bad_id(self):
        view = setup_view(EmailFormView(), self.request, spam_id='a1')
        with nt.assert_raises(Http404):
            view.get_context_data()

    @mock.patch('admin.spam.views.render')
    def test_get_initial(self, mock_render):
        self.view.get_initial()
        res = self.view.initial
        nt.assert_is_instance(res, dict)
        nt.assert_is_instance(res['email'], list)
        nt.assert_is_instance(res['email'][0], tuple)

    def test_get_initial_bad_id(self):
        view = setup_view(EmailFormView(), self.request, spam_id='a1')
        with nt.assert_raises(Http404):
            view.get_initial()

    def setUp(self):
        super(TestCommentFiltering, self).setUp()
        self.user = AuthUserFactory()
        self.project = ProjectFactory(creator=self.user)
        self.comment = CommentFactory(node=self.project, user=self.user)
        self.deleted_comment = CommentFactory(node=self.project, user=self.user, is_deleted=True)
        self.base_url = "/{}nodes/{}/comments/".format(API_BASE, self.project._id)

        self.formatted_date_created = self.comment.date_created.strftime("%Y-%m-%dT%H:%M:%S.%f")
        self.comment.edit("Edited comment", auth=core.Auth(self.user), save=True)
        self.formatted_date_modified = self.comment.date_modified.strftime("%Y-%m-%dT%H:%M:%S.%f")