Пример #1
0
    def test_private_list_order_topics(self):
        """
        private topic list ordered by last active
        """
        private_a = utils.create_private_topic(user=self.user)
        private_b = utils.create_private_topic(user=self.user)
        private_c = utils.create_private_topic(user=self.user)

        Topic.objects.filter(pk=private_a.topic.pk).update(last_active=timezone.now() - datetime.timedelta(days=10))
        Topic.objects.filter(pk=private_c.topic.pk).update(last_active=timezone.now() - datetime.timedelta(days=5))

        utils.login(self)
        response = self.client.get(reverse('spirit:private-list'))
        self.assertQuerysetEqual(response.context['topics'], map(repr, [private_b.topic, private_c.topic,
                                                                        private_a.topic]))
Пример #2
0
    def test_private_list_order_topics(self):
        """
        private topic list ordered by last active
        """
        private_a = utils.create_private_topic(user=self.user)
        private_b = utils.create_private_topic(user=self.user)
        private_c = utils.create_private_topic(user=self.user)

        Topic.objects.filter(pk=private_a.topic.pk).update(last_active=timezone.now() - datetime.timedelta(days=10))
        Topic.objects.filter(pk=private_c.topic.pk).update(last_active=timezone.now() - datetime.timedelta(days=5))

        utils.login(self)
        response = self.client.get(reverse('spirit:private-list'))
        self.assertQuerysetEqual(response.context['topics'], map(repr, [private_b.topic, private_c.topic,
                                                                        private_a.topic]))
Пример #3
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'], [])
Пример #4
0
    def test_private_join_access_pre_create_signal(self):
        """
        send topic_private_access_pre_create signal
        """
        def topic_private_access_pre_create_handler(sender, topic, user,
                                                    **kwargs):
            self._topic = repr(topic)
            self._user_pk = user.pk

        topic_private_access_pre_create.connect(
            topic_private_access_pre_create_handler)

        private = utils.create_private_topic(user=self.user)
        private.delete()

        utils.login(self)
        form_data = {}
        response = self.client.post(
            reverse('spirit:private-join',
                    kwargs={
                        'topic_id': private.topic.pk,
                    }), form_data)
        self.assertEqual(response.status_code, 302)
        self.assertEqual(self._topic, repr(private.topic))
        self.assertEqual(self._user_pk, self.user.pk)
Пример #5
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'], [])
Пример #6
0
    def test_profile_topics_dont_show_removed_or_private(self):
        """
        dont show private topics or removed
        """
        Topic.objects.all().delete()

        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,
                                     user=self.user2,
                                     is_removed=True)
        topic_c = utils.create_topic(category=category_removed,
                                     user=self.user2)
        topic_d = utils.create_topic(category=subcategory, user=self.user2)
        topic_e = utils.create_topic(category=subcategory_removed,
                                     user=self.user2)

        utils.login(self)
        response = self.client.get(
            reverse("spirit:profile-topics",
                    kwargs={
                        'pk': self.user2.pk,
                        'slug': self.user2.slug
                    }))
        self.assertQuerysetEqual(response.context['topics'], [])
Пример #7
0
    def test_topic_notification_has_notifications_dont_count_topic_removed_or_no_access(self):
        """
        dont show private topics if user has no access or is removed
        """
        TopicNotification.objects.all().delete()

        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()
        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)
        unread_a = TopicNotification.objects.create(user=self.user, topic=topic_a.topic,
                                                    comment=self.comment, is_active=True, action=COMMENT)
        unread_b = TopicNotification.objects.create(user=self.user, topic=topic_b,
                                                    comment=self.comment, is_active=True, action=COMMENT)
        unread_c = TopicNotification.objects.create(user=self.user, topic=topic_c,
                                                    comment=self.comment, is_active=True, action=COMMENT)
        unread_d = TopicNotification.objects.create(user=self.user, topic=topic_d,
                                                    comment=self.comment, is_active=True, action=COMMENT)
        unread_e = TopicNotification.objects.create(user=self.user, topic=topic_e,
                                                    comment=self.comment, is_active=True, action=COMMENT)

        self.assertEqual(len(TopicNotification.objects.filter(user=self.user, is_active=True, is_read=False)), 5)
        self.assertFalse(has_topic_notifications(self.user))
Пример #8
0
    def test_topic_notification_list_show_private_topic(self):
        """
        topic private in notification list
        """
        TopicNotification.objects.all().delete()

        topic_a = utils.create_private_topic(user=self.user)
        topic_notif = TopicNotification.objects.create(user=self.user,
                                                       topic=topic_a.topic,
                                                       comment=self.comment,
                                                       is_active=True,
                                                       action=COMMENT)

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

        # list unread should behave the same
        response = self.client.get(
            reverse('spirit:topic-notification-list-unread'))
        self.assertQuerysetEqual(response.context['page'],
                                 map(repr, [
                                     topic_notif,
                                 ]))

        # ajax list should behave the same
        response = self.client.get(reverse('spirit:topic-notification-ajax'),
                                   HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        res = json.loads(response.content)
        self.assertEqual(len(res['n']), 1)
Пример #9
0
    def test_private_access_create_pre_create_signal(self):
        """
        send topic_private_access_pre_create signal
        """
        def topic_private_access_pre_create_handler(sender, topic, user,
                                                    **kwargs):
            self._topic = repr(topic)
            self._user = repr(user)

        topic_private_access_pre_create.connect(
            topic_private_access_pre_create_handler)

        utils.login(self)
        private = utils.create_private_topic(user=self.user)
        form_data = {
            'user': self.user2.username,
        }
        response = self.client.post(
            reverse('spirit:private-access-create',
                    kwargs={
                        'topic_id': private.topic.pk,
                    }), form_data)
        self.assertEqual(response.status_code, 302)
        self.assertEqual(self._topic, repr(private.topic))
        self.assertEqual(self._user, repr(self.user2))
Пример #10
0
 def test_private_detail(self):
     """
     private topic detail
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user)
     response = self.client.get(reverse("spirit:private-detail", kwargs={"topic_id": private.topic.pk}))
     self.assertEqual(response.context["topic"], private.topic)
Пример #11
0
 def test_private_detail(self):
     """
     private topic detail
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user)
     response = self.client.get(reverse('spirit:private-detail', kwargs={'topic_id': private.topic.pk, }))
     self.assertEqual(response.context['topic'], private.topic)
Пример #12
0
    def test_private_join(self):
        """
        re-join private topic if user is the creator
        """
        private = utils.create_private_topic(user=self.user)
        private.delete()

        form_data = {}
        form = TopicPrivateJoinForm(user=self.user, topic=private.topic, data=form_data)
        self.assertTrue(form.is_valid())
        private_topic = form.save()
        self.assertEqual(repr(private_topic.topic), repr(private.topic))
        self.assertEqual(repr(private_topic.user), repr(private.user))

        # topic private exists
        private = utils.create_private_topic(user=self.user)
        form = TopicPrivateJoinForm(user=self.user, topic=private.topic, data=form_data)
        self.assertFalse(form.is_valid())
Пример #13
0
 def test_private_detail(self):
     """
     private topic detail
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user)
     response = self.client.get(reverse('spirit:private-detail', kwargs={'topic_id': private.topic.pk,
                                                                         'slug': private.topic.slug}))
     self.assertEqual(response.context['topic'], private.topic)
Пример #14
0
    def test_private_join(self):
        """
        re-join private topic if user is the creator
        """
        private = utils.create_private_topic(user=self.user)
        private.delete()

        form_data = {}
        form = TopicPrivateJoinForm(user=self.user, topic=private.topic, data=form_data)
        self.assertTrue(form.is_valid())
        private_topic = form.save()
        self.assertEqual(repr(private_topic.topic), repr(private.topic))
        self.assertEqual(repr(private_topic.user), repr(private.user))

        # topic private exists
        private = utils.create_private_topic(user=self.user)
        form = TopicPrivateJoinForm(user=self.user, topic=private.topic, data=form_data)
        self.assertFalse(form.is_valid())
Пример #15
0
    def test_index_queryset_excludes_private_topics(self):
        """
        index_queryset should exclude private topics
        """
        private = utils.create_private_topic()
        self.assertEqual(len(TopicIndex().index_queryset()), 0)

        category = utils.create_category()
        topic = utils.create_topic(category)
        self.assertEqual(len(TopicIndex().index_queryset()), 1)
Пример #16
0
    def test_private_join_invalid_not_owner(self):
        """
        Only topic creators/owners can rejoin
        """
        private = utils.create_private_topic(user=self.user2)

        utils.login(self)
        form_data = {}
        response = self.client.post(reverse("spirit:private-join", kwargs={"topic_id": private.topic.pk}), form_data)
        self.assertEqual(response.status_code, 404)
Пример #17
0
    def test_index_queryset_excludes_private_topics(self):
        """
        index_queryset should exclude private topics
        """
        private = utils.create_private_topic()
        self.assertEqual(len(TopicIndex().index_queryset()), 0)

        category = utils.create_category()
        topic = utils.create_topic(category)
        self.assertEqual(len(TopicIndex().index_queryset()), 1)
Пример #18
0
 def test_private_access_delete_invalid(self):
     """
     Only the topic owner should be able to remove accesses
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user2)
     TopicPrivate.objects.create(user=self.user, topic=private.topic)
     form_data = {}
     response = self.client.post(reverse("spirit:private-access-remove", kwargs={"pk": private.pk}), form_data)
     self.assertEqual(response.status_code, 404)
Пример #19
0
 def test_private_access_delete_invalid(self):
     """
     Only the topic owner should be able to remove accesses
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user2)
     TopicPrivate.objects.create(user=self.user, topic=private.topic)
     form_data = {}
     response = self.client.post(reverse('spirit:private-access-remove', kwargs={'pk': private.pk, }),
                                 form_data)
     self.assertEqual(response.status_code, 404)
Пример #20
0
    def test_private_created_list(self):
        """
        private topic created list, shows only the private topics the user is no longer participating
        """
        category = utils.create_category()
        regular_topic = utils.create_topic(category, user=self.user)
        # it's the owner, left the topic
        private = utils.create_private_topic(user=self.user)
        private.delete()
        # has access and is the owner
        private2 = utils.create_private_topic(user=self.user)
        # does not has access
        private3 = utils.create_private_topic(user=self.user2)
        # has access but it's not owner
        private4 = utils.create_private_topic(user=self.user2)
        TopicPrivate.objects.create(user=self.user, topic=private4.topic)

        utils.login(self)
        response = self.client.get(reverse("spirit:private-created-list"))
        self.assertQuerysetEqual(response.context["topics"], map(repr, [private.topic]))
Пример #21
0
    def test_topic_notification_create_no_access(self):
        """
        raise Http404 if topic is private and user has no access
        """
        private = utils.create_private_topic()

        utils.login(self)
        form_data = {'is_active': True, }
        response = self.client.post(reverse('spirit:topic-notification-create', kwargs={'topic_id': private.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)
Пример #22
0
 def test_private_access_delete(self):
     """
     private topic access deletion
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user)
     private2 = TopicPrivate.objects.create(user=self.user2, topic=private.topic)
     form_data = {}
     response = self.client.post(reverse("spirit:private-access-remove", kwargs={"pk": private2.pk}), form_data)
     expected_url = private.get_absolute_url()
     self.assertRedirects(response, expected_url, status_code=302)
Пример #23
0
    def test_private_created_list(self):
        """
        private topic created list, shows only the private topics the user is no longer participating
        """
        category = utils.create_category()
        regular_topic = utils.create_topic(category, user=self.user)
        # it's the owner, left the topic
        private = utils.create_private_topic(user=self.user)
        private.delete()
        # has access and is the owner
        private2 = utils.create_private_topic(user=self.user)
        # does not has access
        private3 = utils.create_private_topic(user=self.user2)
        # has access but it's not owner
        private4 = utils.create_private_topic(user=self.user2)
        TopicPrivate.objects.create(user=self.user, topic=private4.topic)

        utils.login(self)
        response = self.client.get(reverse('spirit:private-created-list'))
        self.assertQuerysetEqual(response.context['topics'], map(repr, [private.topic, ]))
Пример #24
0
    def test_indexing_excludes_private_topics(self):
        """
        rebuild_index command should exclude private topics
        """
        private = utils.create_private_topic()
        category = utils.create_category()
        topic = utils.create_topic(category)
        call_command("rebuild_index", interactive=False)

        sqs = SearchQuerySet().models(Topic)
        self.assertQuerysetEqual([s.object for s in sqs], map(repr, [topic, ]))
Пример #25
0
    def test_private_join_invalid_not_owner(self):
        """
        Only topic creators/owners can rejoin
        """
        private = utils.create_private_topic(user=self.user2)

        utils.login(self)
        form_data = {}
        response = self.client.post(reverse('spirit:private-join', kwargs={'topic_id': private.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)
Пример #26
0
    def test_topic_unread_list_show_private_topic(self):
        """
        topic private in unread list
        """
        TopicUnread.objects.all().delete()

        topic_a = utils.create_private_topic(user=self.user)
        TopicUnread.objects.create(user=self.user, topic=topic_a.topic, is_read=False)

        utils.login(self)
        response = self.client.get(reverse('spirit:topic-unread-list'))
        self.assertQuerysetEqual(response.context['page'], map(repr, [topic_a.topic, ]))
Пример #27
0
 def test_private_access_delete_leave(self):
     """
     user should be able to remove himself
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user2)
     private2_leave = TopicPrivate.objects.create(user=self.user, topic=private.topic)
     form_data = {}
     response = self.client.post(reverse('spirit:private-access-remove', kwargs={'pk': private2_leave.pk, }),
                                 form_data)
     expected_url = reverse("spirit:private-list")
     self.assertRedirects(response, expected_url, status_code=302)
Пример #28
0
 def test_private_access_create(self):
     """
     private topic access creation
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user)
     form_data = {'user': self.user2.username, }
     response = self.client.post(reverse('spirit:private-access-create', kwargs={'topic_id': private.topic.pk, }),
                                 form_data)
     expected_url = private.get_absolute_url()
     self.assertRedirects(response, expected_url, status_code=302)
     self.assertEqual(len(TopicPrivate.objects.filter(user=self.user2, topic=private.topic)), 1)
Пример #29
0
 def test_private_access_delete_leave(self):
     """
     user should be able to remove himself
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user2)
     private2_leave = TopicPrivate.objects.create(user=self.user, topic=private.topic)
     form_data = {}
     response = self.client.post(reverse('spirit:private-access-remove', kwargs={'pk': private2_leave.pk, }),
                                 form_data)
     expected_url = reverse("spirit:private-list")
     self.assertRedirects(response, expected_url, status_code=302)
Пример #30
0
 def test_private_access_create_invalid(self):
     """
     Only the topic owner should be able to invite
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user2)
     TopicPrivate.objects.create(user=self.user, topic=private.topic)
     user = utils.create_user()
     form_data = {'user': user.username, }
     response = self.client.post(reverse('spirit:private-access-create', kwargs={'topic_id': private.topic.pk, }),
                                 form_data)
     self.assertEqual(response.status_code, 404)
Пример #31
0
 def test_private_access_create_invalid(self):
     """
     Only the topic owner should be able to invite
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user2)
     TopicPrivate.objects.create(user=self.user, topic=private.topic)
     user = utils.create_user()
     form_data = {'user': user.username, }
     response = self.client.post(reverse('spirit:private-access-create', kwargs={'topic_id': private.topic.pk, }),
                                 form_data)
     self.assertEqual(response.status_code, 404)
Пример #32
0
 def test_private_access_create(self):
     """
     private topic access creation
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user)
     form_data = {'user': self.user2.username, }
     response = self.client.post(reverse('spirit:private-access-create', kwargs={'topic_id': private.topic.pk, }),
                                 form_data)
     expected_url = private.get_absolute_url()
     self.assertRedirects(response, expected_url, status_code=302)
     self.assertEqual(len(TopicPrivate.objects.filter(user=self.user2, topic=private.topic)), 1)
Пример #33
0
    def test_comment_publish_no_access(self):
        """
        should not be able to create a comment on a private topic if has no access
        """
        private = utils.create_private_topic(user=self.user)
        private.delete()

        utils.login(self)
        form_data = {'comment': 'foobar', }
        response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': private.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)
Пример #34
0
    def test_comment_publish_no_access(self):
        """
        should not be able to create a comment on a private topic if has no access
        """
        private = utils.create_private_topic(user=self.user)
        private.delete()

        utils.login(self)
        form_data = {'comment': 'foobar', }
        response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': private.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)
Пример #35
0
 def test_private_access_delete(self):
     """
     private topic access deletion
     """
     utils.login(self)
     private = utils.create_private_topic(user=self.user)
     private2 = TopicPrivate.objects.create(user=self.user2, topic=private.topic)
     form_data = {}
     response = self.client.post(reverse('spirit:private-access-remove', kwargs={'pk': private2.pk, }),
                                 form_data)
     expected_url = private.get_absolute_url()
     self.assertRedirects(response, expected_url, status_code=302)
Пример #36
0
 def test_topic_viewed_handler(self):
     """
     mark notification as read when the user visits the topic
     """
     req = RequestFactory().get('/')
     req.user = self.user
     private = utils.create_private_topic()
     TopicNotification.objects.create(user=private.user, topic=private.topic, is_read=False)
     topic_viewed.send(sender=private.__class__,
                       topic=private.topic,
                       request=req)
     notification = TopicNotification.objects.get(user=private.user, topic=private.topic)
     self.assertFalse(notification.is_read)
Пример #37
0
    def test_topic_notification_create_has_access(self):
        """
        create notification for private topic if user has access
        """
        TopicNotification.objects.all().delete()
        private = utils.create_private_topic(user=self.user)

        utils.login(self)
        form_data = {'is_active': True, }
        response = self.client.post(reverse('spirit:topic-notification-create', kwargs={'topic_id': private.topic.pk, }),
                                    form_data)
        self.assertRedirects(response, private.topic.get_absolute_url(), status_code=302)
        self.assertEqual(len(TopicNotification.objects.all()), 1)
Пример #38
0
    def test_comment_publish_on_private(self):
        """
        create comment on private topic
        """
        private = utils.create_private_topic(user=self.user)

        utils.login(self)
        form_data = {'comment': 'foobar', }
        response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': private.topic.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(len(Comment.objects.all()), 1)
Пример #39
0
    def test_comment_publish_on_private(self):
        """
        create comment on private topic
        """
        private = utils.create_private_topic(user=self.user)

        utils.login(self)
        form_data = {'comment': 'foobar', }
        response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': private.topic.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(len(Comment.objects.all()), 1)
Пример #40
0
    def test_indexing_excludes_private_topics(self):
        """
        rebuild_index command should exclude private topics
        """
        private = utils.create_private_topic()
        category = utils.create_category()
        topic = utils.create_topic(category)
        call_command("rebuild_index", interactive=False)

        sqs = SearchQuerySet().models(Topic)
        self.assertQuerysetEqual([s.object for s in sqs], map(repr, [
            topic,
        ]))
Пример #41
0
    def test_private_list(self):
        """
        private topic list
        """
        private = utils.create_private_topic(user=self.user)
        # dont show private topics from other users
        private2 = TopicPrivate.objects.create(user=self.user2, topic=private.topic)
        # dont show topics from other categories
        category = utils.create_category()
        topic = utils.create_topic(category, user=self.user)

        utils.login(self)
        response = self.client.get(reverse('spirit:private-list'))
        self.assertQuerysetEqual(response.context['topics'], [repr(private.topic), ])
Пример #42
0
    def test_private_list(self):
        """
        private topic list
        """
        private = utils.create_private_topic(user=self.user)
        # dont show private topics from other users
        private2 = TopicPrivate.objects.create(user=self.user2, topic=private.topic)
        # dont show topics from other categories
        category = utils.create_category()
        topic = utils.create_topic(category, user=self.user)

        utils.login(self)
        response = self.client.get(reverse("spirit:private-list"))
        self.assertQuerysetEqual(response.context["topics"], [repr(private.topic)])
Пример #43
0
    def test_topic_notification_has_notifications_dont_count_topic_removed_or_no_access(
            self):
        """
        dont show private topics if user has no access or is removed
        """
        TopicNotification.objects.all().delete()

        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()
        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)
        unread_a = TopicNotification.objects.create(user=self.user,
                                                    topic=topic_a.topic,
                                                    comment=self.comment,
                                                    is_active=True,
                                                    action=COMMENT)
        unread_b = TopicNotification.objects.create(user=self.user,
                                                    topic=topic_b,
                                                    comment=self.comment,
                                                    is_active=True,
                                                    action=COMMENT)
        unread_c = TopicNotification.objects.create(user=self.user,
                                                    topic=topic_c,
                                                    comment=self.comment,
                                                    is_active=True,
                                                    action=COMMENT)
        unread_d = TopicNotification.objects.create(user=self.user,
                                                    topic=topic_d,
                                                    comment=self.comment,
                                                    is_active=True,
                                                    action=COMMENT)
        unread_e = TopicNotification.objects.create(user=self.user,
                                                    topic=topic_e,
                                                    comment=self.comment,
                                                    is_active=True,
                                                    action=COMMENT)

        self.assertEqual(
            len(
                TopicNotification.objects.filter(user=self.user,
                                                 is_active=True,
                                                 is_read=False)), 5)
        self.assertFalse(has_topic_notifications(self.user))
Пример #44
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))
Пример #45
0
    def test_private_join(self):
        """
        private topic join
        """
        private = utils.create_private_topic(user=self.user)
        private.delete()

        utils.login(self)
        form_data = {}
        response = self.client.post(reverse("spirit:private-join", kwargs={"topic_id": private.topic.pk}), form_data)
        expected_url = private.get_absolute_url()
        self.assertRedirects(response, expected_url, status_code=302)

        response = self.client.get(reverse("spirit:private-join", kwargs={"topic_id": private.topic.pk}))
        self.assertEqual(response.status_code, 200)
Пример #46
0
 def test_topic_viewed_handler(self):
     """
     mark notification as read when the user visits the topic
     """
     req = RequestFactory().get('/')
     req.user = self.user
     private = utils.create_private_topic()
     TopicNotification.objects.create(user=private.user,
                                      topic=private.topic,
                                      is_read=False)
     topic_viewed.send(sender=private.__class__,
                       topic=private.topic,
                       request=req)
     notification = TopicNotification.objects.get(user=private.user,
                                                  topic=private.topic)
     self.assertFalse(notification.is_read)
Пример #47
0
    def test_topic_notification_create_no_access(self):
        """
        raise Http404 if topic is private and user has no access
        """
        private = utils.create_private_topic()

        utils.login(self)
        form_data = {
            'is_active': True,
        }
        response = self.client.post(
            reverse('spirit:topic-notification-create',
                    kwargs={
                        'topic_id': private.topic.pk,
                    }), form_data)
        self.assertEqual(response.status_code, 404)
Пример #48
0
    def test_topic_active_view_dont_show_private_or_removed(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()
        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)

        response = self.client.get(reverse('spirit:topic-active'))
        self.assertQuerysetEqual(response.context['topics'], [])
Пример #49
0
    def test_private_join(self):
        """
        private topic join
        """
        private = utils.create_private_topic(user=self.user)
        private.delete()

        utils.login(self)
        form_data = {}
        response = self.client.post(reverse('spirit:private-join', kwargs={'topic_id': private.topic.pk, }),
                                    form_data)
        expected_url = private.get_absolute_url()
        self.assertRedirects(response, expected_url, status_code=302)

        response = self.client.get(reverse('spirit:private-join', kwargs={'topic_id': private.topic.pk, }))
        self.assertEqual(response.status_code, 200)
Пример #50
0
    def test_comment_history_detail_private_topic(self):
        """
        history should work for private topics
        """
        private = utils.create_private_topic(user=self.user)
        comment = utils.create_comment(user=self.user, topic=private.topic)
        comment_history = CommentHistory.objects.create(
            comment_fk=comment, comment_html=comment.comment_html)

        utils.login(self)
        response = self.client.get(
            reverse('spirit:comment-history',
                    kwargs={
                        'comment_id': comment.pk,
                    }))
        self.assertEqual(response.status_code, 200)
Пример #51
0
    def test_private_access_create_pre_create_signal(self):
        """
        send topic_private_access_pre_create signal
        """
        def topic_private_access_pre_create_handler(sender, topic, user, **kwargs):
            self._topic = repr(topic)
            self._user = repr(user)
        topic_private_access_pre_create.connect(topic_private_access_pre_create_handler)

        utils.login(self)
        private = utils.create_private_topic(user=self.user)
        form_data = {'user': self.user2.username, }
        response = self.client.post(reverse('spirit:private-access-create', kwargs={'topic_id': private.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 302)
        self.assertEqual(self._topic, repr(private.topic))
        self.assertEqual(self._user, repr(self.user2))
Пример #52
0
    def test_comment_history_detail_no_access(self):
        """
        return Http404 if user has no access to the comment's topic
        """
        private = utils.create_private_topic(user=self.user)
        private.delete()

        comment = utils.create_comment(user=self.user, topic=private.topic)
        comment_history = CommentHistory.objects.create(
            comment_fk=comment, comment_html=comment.comment_html)

        utils.login(self)
        response = self.client.get(
            reverse('spirit:comment-history',
                    kwargs={
                        'comment_id': comment.pk,
                    }))
        self.assertEqual(response.status_code, 404)
Пример #53
0
    def test_private_join_access_pre_create_signal(self):
        """
        send topic_private_access_pre_create signal
        """
        def topic_private_access_pre_create_handler(sender, topic, user, **kwargs):
            self._topic = repr(topic)
            self._user_pk = user.pk
        topic_private_access_pre_create.connect(topic_private_access_pre_create_handler)

        private = utils.create_private_topic(user=self.user)
        private.delete()

        utils.login(self)
        form_data = {}
        response = self.client.post(reverse('spirit:private-join', kwargs={'topic_id': private.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 302)
        self.assertEqual(self._topic, repr(private.topic))
        self.assertEqual(self._user_pk, self.user.pk)
Пример #54
0
    def test_topic_private_access_pre_create_handler(self):
        """
        create notifications on topic private access created
        """
        private = utils.create_private_topic()
        comment = utils.create_comment(topic=private.topic)
        topic_private_access_pre_create.send(sender=private.__class__,
                                             topic=private.topic,
                                             user=private.user)
        notification = TopicNotification.objects.get(user=private.user, topic=private.topic)
        self.assertEqual(notification.action, COMMENT)
        self.assertTrue(notification.is_active)
        self.assertFalse(notification.is_read)
        self.assertEqual(repr(notification.comment), repr(comment))

        # creating the access again should do nothing
        topic_private_access_pre_create.send(sender=private.__class__,
                                             topic=private.topic,
                                             user=private.user)
Пример #55
0
    def test_profile_topics_dont_show_removed_or_private(self):
        """
        dont show private topics or removed
        """
        Topic.objects.all().delete()

        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, user=self.user2, is_removed=True)
        topic_c = utils.create_topic(category=category_removed, user=self.user2)
        topic_d = utils.create_topic(category=subcategory, user=self.user2)
        topic_e = utils.create_topic(category=subcategory_removed, user=self.user2)

        utils.login(self)
        response = self.client.get(reverse("spirit:profile-topics", kwargs={'pk': self.user2.pk,
                                                                            'slug': self.user2.slug}))
        self.assertQuerysetEqual(response.context['topics'], [])
Пример #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_private_access_pre_create_handler(self):
        """
        create notifications on topic private access created
        """
        private = utils.create_private_topic()
        comment = utils.create_comment(topic=private.topic)
        topic_private_access_pre_create.send(sender=private.__class__,
                                             topic=private.topic,
                                             user=private.user)
        notification = TopicNotification.objects.get(user=private.user,
                                                     topic=private.topic)
        self.assertEqual(notification.action, COMMENT)
        self.assertTrue(notification.is_active)
        self.assertFalse(notification.is_read)
        self.assertEqual(repr(notification.comment), repr(comment))

        # creating the access again should do nothing
        topic_private_access_pre_create.send(sender=private.__class__,
                                             topic=private.topic,
                                             user=private.user)
Пример #58
0
    def test_topic_notification_list_dont_show_topic_removed_or_no_access(self):
        """
        dont show private topics if user has no access or is removed
        """
        TopicNotification.objects.all().delete()

        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()
        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)
        unread_a = TopicNotification.objects.create(user=self.user, topic=topic_a.topic,
                                                    comment=self.comment, is_active=True, action=COMMENT)
        unread_b = TopicNotification.objects.create(user=self.user, topic=topic_b,
                                                    comment=self.comment, is_active=True, action=COMMENT)
        unread_c = TopicNotification.objects.create(user=self.user, topic=topic_c,
                                                    comment=self.comment, is_active=True, action=COMMENT)
        unread_d = TopicNotification.objects.create(user=self.user, topic=topic_d,
                                                    comment=self.comment, is_active=True, action=COMMENT)
        unread_e = TopicNotification.objects.create(user=self.user, topic=topic_e,
                                                    comment=self.comment, is_active=True, action=COMMENT)
        self.assertEqual(len(TopicNotification.objects.filter(user=self.user, is_active=True, is_read=False)), 5)

        utils.login(self)
        response = self.client.get(reverse('spirit:topic-notification-list'))
        self.assertQuerysetEqual(response.context['notifications'], [])

        # list unread should behave the same
        response = self.client.get(reverse('spirit:topic-notification-list-unread'))
        self.assertQuerysetEqual(response.context['page'], [])

        # ajax list should behave the same
        response = self.client.get(reverse('spirit:topic-notification-ajax'),
                                   HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        res = json.loads(response.content)
        self.assertEqual(len(res['n']), 0)
Пример #59
0
    def test_topic_notification_list_show_private_topic(self):
        """
        topic private in notification list
        """
        TopicNotification.objects.all().delete()

        topic_a = utils.create_private_topic(user=self.user)
        topic_notif = TopicNotification.objects.create(user=self.user, topic=topic_a.topic,
                                                       comment=self.comment, is_active=True, action=COMMENT)

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

        # list unread should behave the same
        response = self.client.get(reverse('spirit:topic-notification-list-unread'))
        self.assertQuerysetEqual(response.context['page'], map(repr, [topic_notif, ]))

        # ajax list should behave the same
        response = self.client.get(reverse('spirit:topic-notification-ajax'),
                                   HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        res = json.loads(response.content)
        self.assertEqual(len(res['n']), 1)