Пример #1
0
    def test_comment_move_signal(self):
        """
        move comments, emit signal
        """
        self._comments = []

        def comment_posted_handler(sender, comment, **kwargs):
            self._comments.append(comment)
        comment_posted.connect(comment_posted_handler)

        def comment_moved_handler(sender, comments, topic_from, **kwargs):
            self._comment_count = len(comments)
            self._topic_from = topic_from
        comment_moved.connect(comment_moved_handler)

        utils.login(self)
        self.user.is_moderator = True
        self.user.save()

        comment = utils.create_comment(user=self.user, topic=self.topic)
        comment2 = utils.create_comment(user=self.user, topic=self.topic)
        to_topic = utils.create_topic(self.category)

        form_data = {'topic': to_topic.pk,
                     'comments': [comment.pk, comment2.pk], }
        response = self.client.post(reverse('spirit:comment-move', kwargs={'topic_id': self.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 302)
        self.assertListEqual(self._comments, [comment2, comment])
        self.assertEqual(self._comment_count, 2)
        self.assertEqual(repr(self._topic_from), repr(self.topic))
Пример #2
0
    def test_profile_likes_dont_show_removed_or_private(self):
        """
        dont show private topics or removed
        """
        category = utils.create_category()
        category_removed = utils.create_category(is_removed=True)
        subcategory = utils.create_category(parent=category_removed)
        subcategory_removed = utils.create_category(parent=category, is_removed=True)
        topic_a = utils.create_private_topic(user=self.user2)
        topic_b = utils.create_topic(category=category, is_removed=True)
        topic_c = utils.create_topic(category=category_removed)
        topic_d = utils.create_topic(category=subcategory)
        topic_e = utils.create_topic(category=subcategory_removed)
        comment_a = utils.create_comment(user=self.user2, topic=topic_a.topic)
        comment_b = utils.create_comment(user=self.user, topic=topic_b)
        comment_c = utils.create_comment(user=self.user, topic=topic_c)
        comment_d = utils.create_comment(user=self.user, topic=topic_d)
        comment_e = utils.create_comment(user=self.user, topic=topic_e)
        like_a = CommentLike.objects.create(user=self.user2, comment=comment_a)
        like_b = CommentLike.objects.create(user=self.user2, comment=comment_b)
        like_c = CommentLike.objects.create(user=self.user2, comment=comment_c)
        like_d = CommentLike.objects.create(user=self.user2, comment=comment_d)
        like_e = CommentLike.objects.create(user=self.user2, comment=comment_e)

        utils.login(self)
        response = self.client.get(reverse("spirit:profile-likes", kwargs={'pk': self.user2.pk,
                                                                            'slug': self.user2.slug}))
        self.assertQuerysetEqual(response.context['comments'], [])
Пример #3
0
    def test_profile_likes_order(self):
        """
        comments ordered by date
        """
        comment_a = utils.create_comment(user=self.user, topic=self.topic)
        comment_b = utils.create_comment(user=self.user, topic=self.topic)
        comment_c = utils.create_comment(user=self.user, topic=self.topic)
        like_a = CommentLike.objects.create(user=self.user2, comment=comment_a)
        like_b = CommentLike.objects.create(user=self.user2, comment=comment_b)
        like_c = CommentLike.objects.create(user=self.user2, comment=comment_c)

        CommentLike.objects.filter(pk=like_a.pk).update(
            date=timezone.now() - datetime.timedelta(days=10))
        CommentLike.objects.filter(pk=like_c.pk).update(
            date=timezone.now() - datetime.timedelta(days=5))

        utils.login(self)
        response = self.client.get(
            reverse("spirit:profile-likes",
                    kwargs={
                        'pk': self.user2.pk,
                        'slug': self.user2.slug
                    }))
        self.assertQuerysetEqual(response.context['comments'],
                                 map(repr, [comment_b, comment_c, comment_a]))
Пример #4
0
    def test_profile_likes_dont_show_removed_or_private(self):
        """
        dont show private topics or removed
        """
        category = utils.create_category()
        category_removed = utils.create_category(is_removed=True)
        subcategory = utils.create_category(parent=category_removed)
        subcategory_removed = utils.create_category(parent=category,
                                                    is_removed=True)
        topic_a = utils.create_private_topic(user=self.user2)
        topic_b = utils.create_topic(category=category, is_removed=True)
        topic_c = utils.create_topic(category=category_removed)
        topic_d = utils.create_topic(category=subcategory)
        topic_e = utils.create_topic(category=subcategory_removed)
        comment_a = utils.create_comment(user=self.user2, topic=topic_a.topic)
        comment_b = utils.create_comment(user=self.user, topic=topic_b)
        comment_c = utils.create_comment(user=self.user, topic=topic_c)
        comment_d = utils.create_comment(user=self.user, topic=topic_d)
        comment_e = utils.create_comment(user=self.user, topic=topic_e)
        like_a = CommentLike.objects.create(user=self.user2, comment=comment_a)
        like_b = CommentLike.objects.create(user=self.user2, comment=comment_b)
        like_c = CommentLike.objects.create(user=self.user2, comment=comment_c)
        like_d = CommentLike.objects.create(user=self.user2, comment=comment_d)
        like_e = CommentLike.objects.create(user=self.user2, comment=comment_e)

        utils.login(self)
        response = self.client.get(
            reverse("spirit:profile-likes",
                    kwargs={
                        'pk': self.user2.pk,
                        'slug': self.user2.slug
                    }))
        self.assertQuerysetEqual(response.context['comments'], [])
Пример #5
0
    def setUp(self):
        cache.clear()
        self.user = utils.create_user()
        self.category = utils.create_category()
        self.topic = utils.create_topic(category=self.category, user=self.user)

        for _ in xrange(settings.ST_COMMENTS_PER_PAGE * 4):  # 4 pages
            utils.create_comment(user=self.user, topic=self.topic)
Пример #6
0
 def test_topic_comment_moved_handler(self):
     """
     comment_moved_handler signal
     """
     comment = utils.create_comment(topic=self.topic)
     comment2 = utils.create_comment(topic=self.topic)
     Topic.objects.filter(pk=self.topic.pk).update(comment_count=10)
     comment_moved.send(sender=comment.__class__, comments=[comment, comment2], topic_from=self.topic)
     self.assertEqual(Topic.objects.get(pk=self.topic.pk).comment_count, 8)
Пример #7
0
    def setUp(self):
        cache.clear()
        self.user = utils.create_user()
        self.topic = utils.create_topic(utils.create_category())

        for _ in xrange(300):
            utils.create_comment(user=self.user, topic=self.topic)

        self.queryset = Comment.objects.all().order_by("-pk")
Пример #8
0
 def test_comments_move(self):
     comment = utils.create_comment(user=self.user, topic=self.topic)
     comment2 = utils.create_comment(user=self.user, topic=self.topic)
     to_topic = utils.create_topic(category=self.category)
     form_data = {'topic': to_topic.pk,
                  'comments': [comment.pk, comment2.pk], }
     form = CommentMoveForm(topic=self.topic, data=form_data)
     self.assertEqual(form.is_valid(), True)
     self.assertEqual(form.save(), list(Comment.objects.filter(topic=to_topic)))
Пример #9
0
    def setUp(self):
        cache.clear()
        self.user = utils.create_user()
        self.topic = utils.create_topic(utils.create_category())

        for _ in xrange(300):
            utils.create_comment(user=self.user, topic=self.topic)

        self.queryset = Comment.objects.all()
Пример #10
0
 def test_comments_move(self):
     comment = utils.create_comment(user=self.user, topic=self.topic)
     comment2 = utils.create_comment(user=self.user, topic=self.topic)
     to_topic = utils.create_topic(category=self.category)
     form_data = {'topic': to_topic.pk,
                  'comments': [comment.pk, comment2.pk], }
     form = CommentMoveForm(topic=self.topic, data=form_data)
     self.assertEqual(form.is_valid(), True)
     self.assertEqual(form.save(), list(Comment.objects.filter(topic=to_topic)))
Пример #11
0
    def get(self, request, *args, **kwargs):
        try:
            self.object = self.get_object()
        except:
            messages.error(self.request, 'That issue was not found.')
            return redirect("/")

        if self.request.GET.get('paymentId'):
            import paypalrestsdk
            paypalrestsdk.configure({
                'mode': settings.MODE,
                'client_id': settings.CLIENT_ID,
                'client_secret': settings.CLIENT_SECRET
            })

            payment = paypalrestsdk.Payment.find(
                self.request.GET.get('paymentId'))

            custom = payment.transactions[0].custom

            if payment.execute({"payer_id": self.request.GET.get('PayerID')}):
                send_mail(
                    'Processed Payment PayerID' +
                    self.request.GET.get('PayerID') + " paymentID" +
                    self.request.GET.get('paymentId'),
                    "payment occured",
                    '*****@*****.**',
                    ['*****@*****.**'],
                    html_message="payment occured",
                )
                for obj in serializers.deserialize("json",
                                                   custom,
                                                   ignorenonexistent=True):
                    obj.object.created = datetime.datetime.now()
                    obj.object.checkout_id = self.request.GET.get(
                        'checkout_id')
                    obj.save()
                    action.send(self.request.user,
                                verb='placed a $' + str(obj.object.price) +
                                ' bounty on ',
                                target=obj.object.issue)
                    post_to_slack(obj.object)
                    if not settings.DEBUG:
                        create_comment(obj.object.issue)
            else:
                messages.error(request, payment.error)
                send_mail(
                    'Payment error: PayerID' +
                    self.request.GET.get('PayerID') + " paymentID" +
                    self.request.GET.get('paymentId'),
                    "payment error",
                    '*****@*****.**',
                    ['*****@*****.**'],
                    html_message="payment error",
                )

        return super(IssueDetailView, self).get(request, *args, **kwargs)
Пример #12
0
    def get(self, request, *args, **kwargs):
        try:
            self.object = self.get_object()
        except Http404:
            messages.error(self.request, "That issue was not found.")
            return redirect("/")

        if self.request.GET.get("paymentId"):
            import paypalrestsdk

            paypalrestsdk.configure(
                {"mode": settings.MODE, "client_id": settings.CLIENT_ID, "client_secret": settings.CLIENT_SECRET}
            )

            payment = paypalrestsdk.Payment.find(self.request.GET.get("paymentId"))

            custom = payment.transactions[0].custom

            if payment.execute({"payer_id": self.request.GET.get("PayerID")}):
                send_mail(
                    "Processed Payment PayerID"
                    + self.request.GET.get("PayerID")
                    + " paymentID"
                    + self.request.GET.get("paymentId"),
                    "payment occured",
                    "*****@*****.**",
                    ["*****@*****.**"],
                    html_message="payment occured",
                )
                for obj in serializers.deserialize("json", custom, ignorenonexistent=True):
                    obj.object.created = datetime.datetime.now()
                    obj.object.checkout_id = self.request.GET.get("checkout_id")
                    obj.save()
                    action.send(
                        self.request.user,
                        verb="placed a $" + str(obj.object.price) + " bounty on ",
                        target=obj.object.issue,
                    )
                    post_to_slack(obj.object)
                    if not settings.DEBUG:
                        create_comment(obj.object.issue)
            else:
                messages.error(request, payment.error)
                send_mail(
                    "Payment error: PayerID"
                    + self.request.GET.get("PayerID")
                    + " paymentID"
                    + self.request.GET.get("paymentId"),
                    "payment error",
                    "*****@*****.**",
                    ["*****@*****.**"],
                    html_message="payment error",
                )

        return super(IssueDetailView, self).get(request, *args, **kwargs)
Пример #13
0
 def test_topic_comment_moved_handler(self):
     """
     comment_moved_handler signal
     """
     comment = utils.create_comment(topic=self.topic)
     comment2 = utils.create_comment(topic=self.topic)
     Topic.objects.filter(pk=self.topic.pk).update(comment_count=10)
     comment_moved.send(sender=comment.__class__,
                        comments=[comment, comment2],
                        topic_from=self.topic)
     self.assertEqual(Topic.objects.get(pk=self.topic.pk).comment_count, 8)
Пример #14
0
 def test_profile_comments(self):
     """
     profile user's comments
     """
     utils.login(self)
     comment = utils.create_comment(user=self.user2, topic=self.topic)
     comment2 = utils.create_comment(user=self.user, topic=self.topic)
     response = self.client.get(reverse("spirit:profile-detail", kwargs={'pk': self.user2.pk,
                                                                         'slug': self.user2.slug}))
     self.assertEqual(response.status_code, 200)
     self.assertQuerysetEqual(response.context['comments'], [repr(comment), ])
     self.assertEqual(repr(response.context['p_user']), repr(self.user2))
Пример #15
0
    def test_flag_closed(self):
        """
        Open flags
        """
        comment = utils.create_comment(topic=self.topic)
        comment2 = utils.create_comment(topic=self.topic)
        flag_closed = CommentFlag.objects.create(comment=comment2, is_closed=True)
        flag_ = CommentFlag.objects.create(comment=comment)

        utils.login(self)
        response = self.client.get(reverse('spirit:admin-flag-closed'))
        self.assertQuerysetEqual(response.context['flags'], map(repr, [flag_closed, ]))
Пример #16
0
    def test_profile_comments_order(self):
        """
        comments ordered by date
        """
        comment_a = utils.create_comment(user=self.user2, topic=self.topic)
        comment_b = utils.create_comment(user=self.user2, topic=self.topic)
        comment_c = utils.create_comment(user=self.user2, topic=self.topic)

        Comment.objects.filter(pk=comment_a.pk).update(date=timezone.now() - datetime.timedelta(days=10))
        Comment.objects.filter(pk=comment_c.pk).update(date=timezone.now() - datetime.timedelta(days=5))

        utils.login(self)
        response = self.client.get(reverse("spirit:profile-detail", kwargs={'pk': self.user2.pk,
                                                                            'slug': self.user2.slug}))
        self.assertQuerysetEqual(response.context['comments'], map(repr, [comment_b, comment_c, comment_a]))
Пример #17
0
    def get(self, request, *args, **kwargs):
        try:
            self.object = self.get_object()
        except Http404:
            messages.error(self.request, 'That issue was not found.')
            return redirect("/")
        context = self.get_context_data(object=self.object)
        return self.render_to_response(context)
        if self.request.GET.get('paymentId'):
            import paypalrestsdk
            paypalrestsdk.configure({
                'mode': settings.MODE,
                'client_id': settings.CLIENT_ID,
                'client_secret': settings.CLIENT_SECRET
            })

            payment = paypalrestsdk.Payment.find(self.request.GET.get('paymentId'))

            custom = payment.transactions[0].custom

            if payment.execute({"payer_id": self.request.GET.get('PayerID')}):
                for obj in serializers.deserialize("json", custom, ignorenonexistent=True):
                    obj.object.created = datetime.datetime.now()
                    obj.object.checkout_id = self.request.GET.get('checkout_id')
                    obj.save()
                    action.send(self.request.user, verb='placed a $' + str(obj.object.price) + ' bounty on ', target=obj.object.issue)
                    post_to_slack(obj.object)
                    if not settings.DEBUG:
                        create_comment(obj.object.issue)
            else:
                messages.error(request, payment.error)

        if self.request.GET.get('checkout_id'):
            wepay = WePay(settings.WEPAY_IN_PRODUCTION, settings.WEPAY_ACCESS_TOKEN)
            wepay_data = wepay.call('/checkout/', {
                'checkout_id': self.request.GET.get('checkout_id'),
            })

            for obj in serializers.deserialize("xml", wepay_data['long_description'], ignorenonexistent=True):
                obj.object.created = datetime.datetime.now()
                obj.object.checkout_id = self.request.GET.get('checkout_id')
                obj.save()
                action.send(self.request.user, verb='placed a $' + str(obj.object.price) + ' bounty on ', target=obj.object.issue)
                post_to_slack(obj.object)
                if not settings.DEBUG:
                    create_comment(obj.object.issue)

        return super(IssueDetailView, self).get(request, *args, **kwargs)
Пример #18
0
    def get(self, request, *args, **kwargs):
        try:
            self.object = self.get_object()
        except Http404:
            messages.error(self.request, 'That issue was not found.')
            return redirect("/")
        context = self.get_context_data(object=self.object)
        return self.render_to_response(context)
        if self.request.GET.get('paymentId'):
            import paypalrestsdk
            paypalrestsdk.configure({
                'mode': settings.MODE,
                'client_id': settings.CLIENT_ID,
                'client_secret': settings.CLIENT_SECRET
            })

            payment = paypalrestsdk.Payment.find(self.request.GET.get('paymentId'))

            custom = payment.transactions[0].custom

            if payment.execute({"payer_id": self.request.GET.get('PayerID')}):
                for obj in serializers.deserialize("json", custom, ignorenonexistent=True):
                    obj.object.created = datetime.datetime.now()
                    obj.object.checkout_id = self.request.GET.get('checkout_id')
                    obj.save()
                    action.send(self.request.user, verb='placed a $' + str(obj.object.price) + ' bounty on ', target=obj.object.issue)
                    post_to_slack(obj.object)
                    if not settings.DEBUG:
                        create_comment(obj.object.issue)
            else:
                messages.error(request, payment.error)

        if self.request.GET.get('checkout_id'):
            wepay = WePay(settings.WEPAY_IN_PRODUCTION, settings.WEPAY_ACCESS_TOKEN)
            wepay_data = wepay.call('/checkout/', {
                'checkout_id': self.request.GET.get('checkout_id'),
            })

            for obj in serializers.deserialize("xml", wepay_data['long_description'], ignorenonexistent=True):
                obj.object.created = datetime.datetime.now()
                obj.object.checkout_id = self.request.GET.get('checkout_id')
                obj.save()
                action.send(self.request.user, verb='placed a $' + str(obj.object.price) + ' bounty on ', target=obj.object.issue)
                post_to_slack(obj.object)
                if not settings.DEBUG:
                    create_comment(obj.object.issue)

        return super(IssueDetailView, self).get(request, *args, **kwargs)
Пример #19
0
    def test_topic_notification_list_unread(self):
        """
        topic notification list
        """
        topic = utils.create_topic(self.category, user=self.user2)
        comment = utils.create_comment(topic=topic, user=self.user2)
        topic_notification = TopicNotification.objects.create(user=self.user,
                                                              topic=topic,
                                                              comment=comment,
                                                              is_active=True,
                                                              action=COMMENT)

        utils.login(self)
        response = self.client.get(
            reverse('spirit:topic-notification-list-unread'))
        self.assertQuerysetEqual(
            response.context['page'],
            map(repr, [topic_notification, self.topic_notification]))

        # fake next page
        response = self.client.get(
            reverse('spirit:topic-notification-list-unread') + "?notif=" +
            str(topic_notification.pk))
        self.assertQuerysetEqual(response.context['page'],
                                 map(repr, [
                                     self.topic_notification,
                                 ]))
Пример #20
0
    def test_comment_update_signal(self):
        """
        update comment, emit signal
        """
        def comment_pre_update_handler(sender, comment, **kwargs):
            self._comment_old = comment

        comment_pre_update.connect(comment_pre_update_handler)

        def comment_post_update_handler(sender, comment, **kwargs):
            self._comment_new = comment

        comment_post_update.connect(comment_post_update_handler)

        utils.login(self)
        comment_posted = utils.create_comment(user=self.user, topic=self.topic)
        form_data = {
            'comment': 'barfoo',
        }
        response = self.client.post(
            reverse('spirit:comment-update',
                    kwargs={
                        'pk': comment_posted.pk,
                    }), form_data)
        self.assertEqual(repr(self._comment_new),
                         repr(Comment.objects.get(pk=comment_posted.pk)))
        self.assertEqual(repr(self._comment_old), repr(comment_posted))
Пример #21
0
    def test_topic_notification_ajax_order(self):
        """
        order by is_read=False first then by date
        """
        user = utils.create_user()

        for _ in xrange(10):
            topic = utils.create_topic(self.category, user=user)
            comment = utils.create_comment(topic=topic, user=user)
            TopicNotification.objects.create(user=self.user,
                                             topic=topic,
                                             comment=comment,
                                             is_active=True,
                                             action=COMMENT)

        TopicNotification.objects.filter(user=self.user).update(is_read=True)
        old_date = timezone.now() - datetime.timedelta(days=10)
        TopicNotification.objects.filter(pk=self.topic_notification.pk).update(
            is_read=False, date=old_date)

        utils.login(self)
        response = self.client.get(reverse('spirit:topic-notification-ajax'),
                                   HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        res = json.loads(response.content)
        self.assertFalse(res['n'][0]['is_read'])
        self.assertTrue(res['n'][1]['is_read'])
Пример #22
0
 def test_comment_comment_like_post_create_handler(self):
     """
     Increase like_count on comment like
     """
     comment = utils.create_comment(topic=self.topic)
     comment_like_post_create.send(sender=comment.__class__, comment=comment)
     self.assertEqual(Comment.objects.get(pk=comment.pk).likes_count, 1)
Пример #23
0
    def test_comment_undelete(self):
        """
        comment undelete
        """
        self.user = utils.create_user(is_moderator=True)
        comment = utils.create_comment(user=self.user,
                                       topic=self.topic,
                                       is_removed=True)

        utils.login(self)
        form_data = {}
        response = self.client.post(
            reverse('spirit:comment-undelete', kwargs={
                'pk': comment.pk,
            }), form_data)
        expected_url = comment.get_absolute_url()
        self.assertRedirects(response,
                             expected_url,
                             status_code=302,
                             target_status_code=302)

        response = self.client.get(
            reverse('spirit:comment-undelete', kwargs={
                'pk': comment.pk,
            }))
        self.assertEqual(response.status_code, 200)
Пример #24
0
 def test_comment_comment_like_post_create_handler(self):
     """
     Increase like_count on comment like
     """
     comment = utils.create_comment(topic=self.topic)
     comment_like_post_create.send(sender=comment.__class__, comment=comment)
     self.assertEqual(Comment.objects.get(pk=comment.pk).likes_count, 1)
Пример #25
0
def show_page(request, pseudo_link):
    _user = get_valid_user(request)
    _page = get_page_by_pseudo_name(pseudo_link)
    if request.method == "GET":
        return render(request, 'showpage.html', {
            'current_user': _user,
            'page': _page
        })
    elif _user:
        # comment
        comment_page_id = request.POST.get("pid")
        comment_page = Page.objects.get(id=comment_page_id)
        if _page == comment_page:
            content = request.POST.get("content", "")[0:100]
            create_comment(_page, _user, content)
    return HttpResponseRedirect('/content/' + pseudo_link)
Пример #26
0
 def test_comment_comment_post_update_handler(self):
     """
     Increase modified_count on updated comment
     """
     comment = utils.create_comment(topic=self.topic)
     comment_post_update.send(sender=comment.__class__, comment=comment)
     self.assertEqual(Comment.objects.get(pk=comment.pk).modified_count, 1)
Пример #27
0
 def test_comment_comment_post_update_handler(self):
     """
     Increase modified_count on updated comment
     """
     comment = utils.create_comment(topic=self.topic)
     comment_post_update.send(sender=comment.__class__, comment=comment)
     self.assertEqual(Comment.objects.get(pk=comment.pk).modified_count, 1)
Пример #28
0
    def test_comment_update(self):
        """
        update comment
        """
        comment = utils.create_comment(user=self.user, topic=self.topic)

        utils.login(self)
        form_data = {
            'comment': 'barfoo',
        }
        response = self.client.post(
            reverse('spirit:comment-update', kwargs={
                'pk': comment.pk,
            }), form_data)
        expected_url = reverse('spirit:comment-find', kwargs={
            'pk': 1,
        })
        self.assertRedirects(response,
                             expected_url,
                             status_code=302,
                             target_status_code=302)
        self.assertEqual(Comment.objects.get(pk=comment.pk).comment, 'barfoo')

        # next
        form_data.update({
            'next': '/fakepath/',
        })
        response = self.client.post(
            reverse('spirit:comment-update', kwargs={
                'pk': comment.pk,
            }), form_data)
        self.assertRedirects(response,
                             '/fakepath/',
                             status_code=302,
                             target_status_code=404)
Пример #29
0
    def test_flag_closed(self):
        """
        Open flags
        """
        comment = utils.create_comment(topic=self.topic)
        comment2 = utils.create_comment(topic=self.topic)
        flag_closed = CommentFlag.objects.create(comment=comment2,
                                                 is_closed=True)
        flag_ = CommentFlag.objects.create(comment=comment)

        utils.login(self)
        response = self.client.get(reverse('spirit:admin-flag-closed'))
        self.assertQuerysetEqual(response.context['flags'],
                                 map(repr, [
                                     flag_closed,
                                 ]))
Пример #30
0
    def setUp(self):
        cache.clear()
        self.user = utils.create_user()
        self.user2 = utils.create_user()
        self.category = utils.create_category()
        self.topic = utils.create_topic(self.category)
        self.comment = utils.create_comment(topic=self.topic)

        # comment notification
        self.topic_notification = TopicNotification.objects.create(
            user=self.user,
            topic=self.topic,
            comment=self.comment,
            is_active=True,
            action=COMMENT)
        self.topic_notification2 = TopicNotification.objects.create(
            user=self.user2,
            topic=self.topic,
            comment=self.comment,
            is_active=True,
            action=COMMENT)

        # subscription to topic
        self.topic2 = utils.create_topic(self.category)
        self.topic_subscrption = TopicNotification.objects.create(
            user=self.user, topic=self.topic2, is_active=True)
Пример #31
0
 def test_topic_notification_comment_handler(self):
     """
     set is_read=False when a comment is posted
     """
     comment = utils.create_comment(topic=self.topic)
     comment_posted.send(sender=self.topic.__class__, comment=comment, mentions=None)
     self.assertFalse(TopicNotification.objects.get(pk=self.topic_notification.pk).is_read)
Пример #32
0
 def test_topic_comment_posted_handler(self):
     """
     comment_posted_handler signal
     """
     comment = utils.create_comment(topic=self.topic)
     comment_posted.send(sender=self.topic.__class__, comment=comment, mentions=None)
     self.assertEqual(Topic.objects.get(pk=self.topic.pk).comment_count, 1)
     self.assertGreater(Topic.objects.get(pk=self.topic.pk).last_active, self.topic.last_active)
Пример #33
0
 def test_topic_notification_comment_handler_unactive(self):
     """
     do nothing if notification is_active=False
     """
     TopicNotification.objects.filter(pk=self.topic_notification.pk).update(is_active=False)
     comment = utils.create_comment(topic=self.topic_notification.topic)
     comment_posted.send(sender=self.topic.__class__, comment=comment, mentions=None)
     self.assertTrue(TopicNotification.objects.get(pk=self.topic_notification.pk).is_read)
Пример #34
0
 def test_comment_find(self):
     """
     comment absolute and lazy url
     """
     comment = utils.create_comment(user=self.user, topic=self.topic)
     response = self.client.post(reverse('spirit:comment-find', kwargs={'pk': comment.pk, }))
     expected_url = comment.topic.get_absolute_url() + "#c%d" % comment.pk
     self.assertRedirects(response, expected_url, status_code=302)
Пример #35
0
 def test_comment_find(self):
     """
     comment absolute and lazy url
     """
     comment = utils.create_comment(user=self.user, topic=self.topic)
     response = self.client.post(reverse('spirit:comment-find', kwargs={'pk': comment.pk, }))
     expected_url = comment.topic.get_absolute_url() + "#c%d" % comment.pk
     self.assertRedirects(response, expected_url, status_code=302)
Пример #36
0
    def test_comment_history_detail_removed(self):
        """
        return Http404 if comment is removed
        """
        utils.login(self)

        # comment removed
        comment = utils.create_comment(user=self.user,
                                       topic=self.topic,
                                       is_removed=True)
        comment_history = CommentHistory.objects.create(
            comment_fk=comment, comment_html=comment.comment_html)
        response = self.client.get(
            reverse('spirit:comment-history',
                    kwargs={
                        'comment_id': comment.pk,
                    }))
        self.assertEqual(response.status_code, 404)

        # topic removed
        topic = utils.create_topic(category=self.category,
                                   user=self.user,
                                   is_removed=True)
        comment = utils.create_comment(user=self.user, topic=topic)
        comment_history = CommentHistory.objects.create(
            comment_fk=comment, comment_html=comment.comment_html)
        response = self.client.get(
            reverse('spirit:comment-history',
                    kwargs={
                        'comment_id': comment.pk,
                    }))
        self.assertEqual(response.status_code, 404)

        # category removed
        category = utils.create_category(is_removed=True)
        topic = utils.create_topic(category=category, user=self.user)
        comment = utils.create_comment(user=self.user, topic=topic)
        comment_history = CommentHistory.objects.create(
            comment_fk=comment, comment_html=comment.comment_html)
        response = self.client.get(
            reverse('spirit:comment-history',
                    kwargs={
                        'comment_id': comment.pk,
                    }))
        self.assertEqual(response.status_code, 404)
Пример #37
0
 def test_topic_unread_bulk_handler(self):
     """
     mark as unread when comment posted
     """
     TopicUnread.objects.all().update(is_read=True)
     comment = utils.create_comment(user=self.user, topic=self.topic)
     comment_posted.send(sender=self.topic.__class__, comment=comment, mentions=None)
     self.assertTrue(TopicUnread.objects.get(user=self.user, topic=self.topic).is_read)
     self.assertFalse(TopicUnread.objects.get(user=self.user2, topic=self.topic).is_read)
Пример #38
0
 def test_comment_move(self):
     """
     comment move to another topic
     """
     utils.login(self)
     self.user.is_moderator = True
     self.user.save()
     comment = utils.create_comment(user=self.user, topic=self.topic)
     comment2 = utils.create_comment(user=self.user, topic=self.topic)
     to_topic = utils.create_topic(category=self.category)
     form_data = {'topic': to_topic.pk,
                  'comments': [comment.pk, comment2.pk], }
     response = self.client.post(reverse('spirit:comment-move', kwargs={'topic_id': self.topic.pk, }),
                                 form_data)
     expected_url = self.topic.get_absolute_url()
     self.assertRedirects(response, expected_url, status_code=302)
     self.assertEqual(Comment.objects.filter(topic=to_topic.pk).count(), 2)
     self.assertEqual(Comment.objects.filter(topic=self.topic.pk).count(), 0)
Пример #39
0
 def test_comment_history_comment_post_update_handler(self):
     comment = utils.create_comment(topic=self.topic)
     comment_post_update.send(sender=comment.__class__, comment=comment)
     self.assertEqual(
         CommentHistory.objects.get(comment_fk=comment.pk).comment_html,
         comment.comment_html)
     comment_post_update.send(sender=comment.__class__, comment=comment)
     self.assertEqual(
         len(CommentHistory.objects.filter(comment_fk=comment.pk)), 2)
Пример #40
0
 def test_profile_comments(self):
     """
     profile user's comments
     """
     utils.login(self)
     comment = utils.create_comment(user=self.user2, topic=self.topic)
     comment2 = utils.create_comment(user=self.user, topic=self.topic)
     response = self.client.get(
         reverse("spirit:profile-detail",
                 kwargs={
                     'pk': self.user2.pk,
                     'slug': self.user2.slug
                 }))
     self.assertEqual(response.status_code, 200)
     self.assertQuerysetEqual(response.context['comments'], [
         repr(comment),
     ])
     self.assertEqual(repr(response.context['p_user']), repr(self.user2))
Пример #41
0
 def test_comment_move(self):
     """
     comment move to another topic
     """
     utils.login(self)
     self.user.is_moderator = True
     self.user.save()
     comment = utils.create_comment(user=self.user, topic=self.topic)
     comment2 = utils.create_comment(user=self.user, topic=self.topic)
     to_topic = utils.create_topic(category=self.category)
     form_data = {'topic': to_topic.pk,
                  'comments': [comment.pk, comment2.pk], }
     response = self.client.post(reverse('spirit:comment-move', kwargs={'topic_id': self.topic.pk, }),
                                 form_data)
     expected_url = self.topic.get_absolute_url()
     self.assertRedirects(response, expected_url, status_code=302)
     self.assertEqual(Comment.objects.filter(topic=to_topic.pk).count(), 2)
     self.assertEqual(Comment.objects.filter(topic=self.topic.pk).count(), 0)
Пример #42
0
 def test_comment_publish_quote(self):
     """
     create comment quote
     """
     utils.login(self)
     comment = utils.create_comment(topic=self.topic)
     response = self.client.get(reverse('spirit:comment-publish', kwargs={'topic_id': self.topic.pk,
                                                                          'pk': comment.pk}))
     self.assertEqual(response.context['form'].initial['comment'],
                      markdown.quotify(comment.comment, comment.user.username))
Пример #43
0
    def setUp(self):
        cache.clear()
        self.user = utils.create_user()
        self.category = utils.create_category()
        self.topic = utils.create_topic(self.category)
        self.comment = utils.create_comment(topic=self.topic)

        self.topic_notification = TopicNotification.objects.create(user=self.user, topic=self.topic,
                                                                   comment=self.comment, is_active=True,
                                                                   action=COMMENT)
Пример #44
0
 def test_topic_notification_mention_handler(self):
     """
     create notification on mention
     """
     topic = utils.create_topic(self.category)
     mentions = {self.user.username: self.user, }
     comment = utils.create_comment(topic=topic)
     comment_posted.send(sender=self.topic.__class__, comment=comment, mentions=mentions)
     self.assertEqual(TopicNotification.objects.get(user=self.user, comment=comment).action, MENTION)
     self.assertFalse(TopicNotification.objects.get(user=self.user, comment=comment).is_read)
Пример #45
0
 def test_comment_publish_quote(self):
     """
     create comment quote
     """
     utils.login(self)
     comment = utils.create_comment(topic=self.topic)
     response = self.client.get(reverse('spirit:comment-publish', kwargs={'topic_id': self.topic.pk,
                                                                          'pk': comment.pk}))
     self.assertEqual(response.context['form'].initial['comment'],
                      markdown.quotify(comment.comment, comment.user.username))
Пример #46
0
 def test_topic_notification_comment_handler(self):
     """
     set is_read=False when a comment is posted
     """
     comment = utils.create_comment(topic=self.topic)
     comment_posted.send(sender=self.topic.__class__,
                         comment=comment,
                         mentions=None)
     self.assertFalse(
         TopicNotification.objects.get(
             pk=self.topic_notification.pk).is_read)
Пример #47
0
 def test_topic_notification_mention_handler_unactive(self):
     """
     set is_read=False when user gets mentioned
     even if is_active=False
     """
     TopicNotification.objects.filter(pk=self.topic_notification.pk).update(is_active=False)
     mentions = {self.user.username: self.user, }
     comment = utils.create_comment(topic=self.topic_notification.topic)
     comment_posted.send(sender=self.topic.__class__, comment=comment, mentions=mentions)
     self.assertEqual(TopicNotification.objects.get(pk=self.topic_notification.pk).action, MENTION)
     self.assertFalse(TopicNotification.objects.get(pk=self.topic_notification.pk).is_read)
Пример #48
0
    def test_flag(self):
        """
        flag
        """
        comment = utils.create_comment(topic=self.topic)
        comment_flag = CommentFlag.objects.create(comment=comment)

        form_data = {"is_closed": True, }
        form = CommentFlagForm(user=self.user, data=form_data, instance=comment_flag)
        self.assertEqual(form.is_valid(), True)
        self.assertEqual(repr(form.save().moderator), repr(self.user))
Пример #49
0
    def test_comment_update_not_moderator(self):
        """
        non moderators can not update other people comments
        """
        user = utils.create_user()
        comment = utils.create_comment(user=user, topic=self.topic)

        utils.login(self)
        form_data = {'comment': 'barfoo', }
        response = self.client.post(reverse('spirit:comment-update', kwargs={'pk': comment.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)
Пример #50
0
    def test_comment_history_detail(self):
        """
        history comment
        """
        comment = utils.create_comment(user=self.user, topic=self.topic)
        comment_history = CommentHistory.objects.create(
            comment_fk=comment, comment_html=comment.comment_html)
        comment2 = utils.create_comment(user=self.user, topic=self.topic)
        comment_history2 = CommentHistory.objects.create(
            comment_fk=comment2, comment_html=comment2.comment_html)

        utils.login(self)
        response = self.client.get(
            reverse('spirit:comment-history',
                    kwargs={
                        'comment_id': comment.pk,
                    }))
        self.assertQuerysetEqual(response.context['comments'],
                                 map(repr, [
                                     comment_history,
                                 ]))
Пример #51
0
    def test_comment_update_not_moderator(self):
        """
        non moderators can not update other people comments
        """
        user = utils.create_user()
        comment = utils.create_comment(user=user, topic=self.topic)

        utils.login(self)
        form_data = {'comment': 'barfoo', }
        response = self.client.post(reverse('spirit:comment-update', kwargs={'pk': comment.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)
Пример #52
0
    def setUp(self):
        cache.clear()
        self.user = utils.create_user()
        self.category = utils.create_category()
        self.topic = utils.create_topic(self.category)
        self.comment = utils.create_comment(topic=self.topic)

        self.topic_notification = TopicNotification.objects.create(
            user=self.user,
            topic=self.topic,
            comment=self.comment,
            is_active=True,
            action=COMMENT)
Пример #53
0
 def setUp(self):
     cache.clear()
     self.user = utils.create_user()
     self.category = utils.create_category()
     self.topic = utils.create_topic(category=self.category, user=self.user)
     utils.create_comment(topic=self.topic)
     utils.create_comment(topic=self.topic)
     utils.create_comment(topic=self.topic)
Пример #54
0
    def test_flag_detail(self):
        """
        flag detail
        """
        comment = utils.create_comment(topic=self.topic)
        comment_flag = CommentFlag.objects.create(comment=comment)
        flag_ = Flag.objects.create(comment=comment, user=self.user, reason=0)

        comment2 = utils.create_comment(topic=self.topic)
        comment_flag2 = CommentFlag.objects.create(comment=comment2)
        flag_2 = Flag.objects.create(comment=comment2, user=self.user, reason=0)

        utils.login(self)
        form_data = {"is_closed": True, }
        response = self.client.post(reverse('spirit:admin-flag-detail', kwargs={'pk': comment_flag.pk, }),
                                    form_data)
        expected_url = reverse('spirit:admin-flag')
        self.assertRedirects(response, expected_url, status_code=302)

        response = self.client.get(reverse('spirit:admin-flag-detail', kwargs={'pk': comment_flag.pk, }))
        self.assertEqual(response.status_code, 200)
        self.assertEqual(repr(response.context['flag']), repr(comment_flag))
        self.assertQuerysetEqual(response.context['flags'], map(repr, [flag_, ]))
Пример #55
0
    def test_comment_update_moderator(self):
        """
        moderators can update other people comments
        """
        User.objects.filter(pk=self.user.pk).update(is_moderator=True)
        user = utils.create_user()
        comment = utils.create_comment(user=user, topic=self.topic)

        utils.login(self)
        form_data = {'comment': 'barfoo', }
        response = self.client.post(reverse('spirit:comment-update', kwargs={'pk': comment.pk, }),
                                    form_data)
        expected_url = reverse('spirit:comment-find', kwargs={'pk': 1, })
        self.assertRedirects(response, expected_url, status_code=302, target_status_code=302)
        self.assertEqual(Comment.objects.get(pk=comment.pk).comment, 'barfoo')
Пример #56
0
 def test_topic_private_post_create_handler(self):
     """
     create notifications on topic private created
     """
     private = utils.create_private_topic()
     private2 = TopicPrivate.objects.create(user=self.user, topic=private.topic)
     comment = utils.create_comment(topic=private.topic)
     topic_private_post_create.send(sender=private.__class__,
                                    topics_private=[private, private2],
                                    comment=comment)
     self.assertEqual(len(TopicNotification.objects.filter(user=private.user, topic=private.topic)), 0)
     notification = TopicNotification.objects.get(user=private2.user, topic=private2.topic)
     self.assertTrue(notification.is_active)
     self.assertFalse(notification.is_read)
     self.assertEqual(repr(notification.comment), repr(comment))
Пример #57
0
    def test_topic_notification_ajax_limit(self):
        """
        get first N notifications
        """
        user = utils.create_user()
        topic = utils.create_topic(self.category, user=user)
        comment = utils.create_comment(topic=topic, user=user)
        TopicNotification.objects.create(user=self.user, topic=topic, comment=comment,
                                         is_active=True, action=COMMENT)

        utils.login(self)
        response = self.client.get(reverse('spirit:topic-notification-ajax'),
                                   HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        res = json.loads(response.content)
        self.assertGreater(TopicNotification.objects.filter(user=self.user), 1)
        self.assertEqual(len(res['n']), 1)
Пример #58
0
    def test_comment_undelete(self):
        """
        comment undelete
        """
        self.user = utils.create_user(is_moderator=True)
        comment = utils.create_comment(user=self.user, topic=self.topic, is_removed=True)

        utils.login(self)
        form_data = {}
        response = self.client.post(reverse('spirit:comment-undelete', kwargs={'pk': comment.pk, }),
                                    form_data)
        expected_url = comment.get_absolute_url()
        self.assertRedirects(response, expected_url, status_code=302, target_status_code=302)

        response = self.client.get(reverse('spirit:comment-undelete', kwargs={'pk': comment.pk, }))
        self.assertEqual(response.status_code, 200)