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))
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'], [])
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]))
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'], [])
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)
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)
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")
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)))
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()
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)
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)
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))
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, ]))
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]))
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)
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, ]))
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))
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'])
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)
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)
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)
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)
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)
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, ]))
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)
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)
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)
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)
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)
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)
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)
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)
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)
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))
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))
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)
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)
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)
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)
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))
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)
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, ]))
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)
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)
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_, ]))
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')
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))
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)
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)