Пример #1
0
    def test_topic_update_signal(self):
        """
        POST, topic moved to category
        """
        def topic_post_moderate_handler(sender, user, topic, action, **kwargs):
            self._moderate = [repr(user._wrapped), repr(topic), action]

        topic_post_moderate.connect(topic_post_moderate_handler)

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

        category = utils.create_category()
        topic = utils.create_topic(category=category, user=self.user)
        category2 = utils.create_category()
        form_data = {'title': 'foobar', 'category': category2.pk}
        response = self.client.post(
            reverse('spirit:topic-update', kwargs={
                'pk': topic.pk,
            }), form_data)
        self.assertSequenceEqual(
            self._moderate,
            [repr(self.user),
             repr(Topic.objects.get(pk=topic.pk)), MOVED])
Пример #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_category_invalid_parent(self):
        """
        invalid parent
        """
        # parent can not be a subcategory, only one level subcat is allowed
        subcategory = utils.create_category(parent=self.category)
        form_data = {"parent": subcategory.pk, }
        form = CategoryForm(data=form_data)
        self.assertEqual(form.is_valid(), False)
        self.assertNotIn('parent', form.cleaned_data)

        # parent can not be set to a category with childrens
        category_ = utils.create_category()
        form_data = {"parent": category_.pk, }
        form = CategoryForm(data=form_data, instance=self.category)
        self.assertEqual(form.is_valid(), False)
        self.assertNotIn('parent', form.cleaned_data)

        # parent can not be removed
        category_ = utils.create_category(is_removed=True)
        form_data = {"parent": category_.pk, }
        form = CategoryForm(data=form_data)
        self.assertEqual(form.is_valid(), False)
        self.assertNotIn('parent', form.cleaned_data)

        # parent can not be private
        category_ = utils.create_category(is_private=True)
        form_data = {"parent": category_.pk, }
        form = CategoryForm(data=form_data)
        self.assertEqual(form.is_valid(), False)
        self.assertNotIn('parent', form.cleaned_data)
Пример #4
0
 def setUp(self):
     cache.clear()
     self.category_1 = utils.create_category(title="cat1")
     self.subcategory_1 = utils.create_subcategory(self.category_1)
     self.category_2 = utils.create_category(title="cat2")
     self.category_removed = utils.create_category(title="cat3",
                                                   is_removed=True)
Пример #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_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))
Пример #7
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'], [])
Пример #8
0
 def test_form(self):
     """
     NestedModelChoiceField
     """
     category = test_utils.create_category()
     category2 = test_utils.create_category()
     subcategory = test_utils.create_subcategory(category)
     field = NestedModelChoiceField(queryset=Category.objects.all(),
                                    related_name='category_set',
                                    parent_field='parent_id',
                                    label_field='title')
     self.assertSequenceEqual(list(field.choices), [(1, u'%s' % category.title),
                                                    (3, u'--- %s' % subcategory.title),
                                                    (2, u'%s' % category2.title)])
Пример #9
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))
Пример #10
0
 def test_nested_model_choise_form(self):
     """
     NestedModelChoiceField
     """
     category = test_utils.create_category()
     category2 = test_utils.create_category()
     subcategory = test_utils.create_subcategory(category)
     field = NestedModelChoiceField(queryset=Category.objects.all(),
                                    related_name='category_set',
                                    parent_field='parent_id',
                                    label_field='title')
     self.assertSequenceEqual(list(field.choices), [('', u'---------'),
                                                    (1, u'%s' % category.title),
                                                    (3, u'--- %s' % subcategory.title),
                                                    (2, u'%s' % category2.title)])
Пример #11
0
    def test_profile_topics_order(self):
        """
        topics ordered by date
        """
        Topic.objects.all().delete()

        category = utils.create_category()
        topic_a = utils.create_topic(category=category, user=self.user2)
        topic_b = utils.create_topic(category=category, user=self.user2)
        topic_c = utils.create_topic(category=category, user=self.user2)

        Topic.objects.filter(pk=topic_a.pk).update(date=timezone.now() -
                                                   datetime.timedelta(days=10))
        Topic.objects.filter(pk=topic_c.pk).update(date=timezone.now() -
                                                   datetime.timedelta(days=5))

        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'],
                                 map(repr, [topic_b, topic_c, topic_a]))
Пример #12
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, user=self.user2)
     self.topic2 = utils.create_topic(self.category)
Пример #13
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'], [])
Пример #14
0
    def test_topic_moderate_unpin(self):
        """
        topic unpin
        """
        def topic_post_moderate_handler(sender, user, topic, action, **kwargs):
            self._moderate = [repr(user._wrapped), repr(topic), action]

        topic_post_moderate.connect(topic_post_moderate_handler)

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

        category = utils.create_category()
        topic = utils.create_topic(category, is_pinned=True)
        form_data = {}
        response = self.client.post(
            reverse('spirit:topic-unpin', kwargs={
                'pk': topic.pk,
            }), form_data)
        expected_url = topic.get_absolute_url()
        self.assertRedirects(response, expected_url, status_code=302)
        self.assertFalse(Topic.objects.get(pk=topic.pk).is_pinned)
        self.assertEqual(
            self._moderate,
            [repr(self.user), repr(topic), UNPINNED])
Пример #15
0
    def test_comment_publish_on_removed_topic_or_category(self):
        """
        should not be able to create a comment
        """
        # removed category
        Category.objects.all().update(is_removed=True)

        utils.login(self)
        form_data = {'comment': 'foobar', }
        response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': self.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)

        # removed subcategory
        Category.objects.all().update(is_removed=False)
        subcategory = utils.create_category(parent=self.category, is_removed=True)
        topic2 = utils.create_topic(subcategory)

        utils.login(self)
        form_data = {'comment': 'foobar', }
        response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': topic2.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)

        # removed topic
        Category.objects.all().update(is_removed=False)
        Topic.objects.all().update(is_removed=True)

        utils.login(self)
        form_data = {'comment': 'foobar', }
        response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': self.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)
Пример #16
0
    def test_topic_publish_in_category(self):
        """
        POST, create topic in category
        """
        utils.login(self)
        category = utils.create_category()
        form_data = {
            'comment': 'foo',
            'title': 'foobar',
            'category': category.pk
        }
        response = self.client.post(
            reverse('spirit:topic-publish',
                    kwargs={
                        'category_id': category.pk,
                    }), form_data)
        topic = Topic.objects.last()
        expected_url = topic.get_absolute_url()
        self.assertRedirects(response, expected_url, status_code=302)

        # ratelimit
        response = self.client.post(
            reverse('spirit:topic-publish',
                    kwargs={
                        'category_id': category.pk,
                    }), form_data)
        self.assertEqual(response.status_code, 200)
Пример #17
0
    def test_topic_active_view_pinned(self):
        """
        pinned topics. Only show pinned topics from uncategorized category, even if the category is removed
        """
        category = utils.create_category()
        # show topic from regular category
        topic_a = utils.create_topic(category=category)
        # dont show pinned from regular category
        topic_b = utils.create_topic(category=category, is_pinned=True)

        uncat_category = Category.objects.get(pk=settings.ST_UNCATEGORIZED_CATEGORY_PK)
        # dont show pinned and removed
        topic_c = utils.create_topic(category=uncat_category, is_pinned=True, is_removed=True)
        # show topic from uncategorized category
        topic_d = utils.create_topic(category=uncat_category, is_pinned=True)
        # show pinned first
        Topic.objects.filter(pk=topic_d.pk).update(last_active=timezone.now() - datetime.timedelta(days=10))

        response = self.client.get(reverse('spirit:topic-active'))
        self.assertQuerysetEqual(response.context['topics'], map(repr, [topic_d, topic_a, ]))

        # show topic from uncategorized category even if it is removed
        Category.objects.filter(pk=uncat_category.pk).update(is_removed=True)
        response = self.client.get(reverse('spirit:topic-active'))
        self.assertQuerysetEqual(response.context['topics'], map(repr, [topic_d, topic_a, ]))
Пример #18
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, user=self.user2)
     self.topic2 = utils.create_topic(self.category)
Пример #19
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)
Пример #20
0
    def test_comment_publish_on_removed_topic_or_category(self):
        """
        should not be able to create a comment
        """
        # removed category
        Category.objects.all().update(is_removed=True)

        utils.login(self)
        form_data = {'comment': 'foobar', }
        response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': self.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)

        # removed subcategory
        Category.objects.all().update(is_removed=False)
        subcategory = utils.create_category(parent=self.category, is_removed=True)
        topic2 = utils.create_topic(subcategory)

        utils.login(self)
        form_data = {'comment': 'foobar', }
        response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': topic2.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)

        # removed topic
        Category.objects.all().update(is_removed=False)
        Topic.objects.all().update(is_removed=True)

        utils.login(self)
        form_data = {'comment': 'foobar', }
        response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': self.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)
Пример #21
0
    def test_topic_detail_view_signals(self):
        """
        send topic view signal
        """
        def topic_viewed_handler(sender, request, topic, **kwargs):
            self._viewed = [
                request,
                repr(topic),
            ]

        topic_viewed.connect(topic_viewed_handler)

        utils.login(self)

        category = utils.create_category()
        topic = utils.create_topic(category=category, user=self.user)
        response = self.client.get(
            reverse('spirit:topic-detail',
                    kwargs={
                        'pk': topic.pk,
                        'slug': topic.slug
                    }))
        self.assertEqual(response.status_code, 200)
        self.assertSequenceEqual(self._viewed,
                                 [response.context['request'],
                                  repr(topic)])
Пример #22
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)
Пример #23
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)
Пример #24
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)
Пример #25
0
 def test_category_list(self):
     """
     Categories, excludes Topic Private and subcats
     """
     subcat = utils.create_category(parent=self.category)
     categories = Category.objects.filter(is_private=False, parent=None)
     utils.login(self)
     response = self.client.get(reverse('spirit:admin-category-list'))
     self.assertQuerysetEqual(response.context['categories'], map(repr, categories))
Пример #26
0
 def test_topic_update(self):
     """
     create update
     """
     category = utils.create_category()
     topic = utils.create_topic(category)
     form_data = {'title': 'foobar', }
     form = TopicForm(self.user, data=form_data, instance=topic)
     self.assertEqual(form.is_valid(), True)
Пример #27
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")
Пример #28
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()
Пример #29
0
 def test_topic_detail_view(self):
     """
     should display topic
     """
     utils.login(self)
     category = utils.create_category()
     topic = utils.create_topic(category=category)
     response = self.client.get(reverse('spirit:topic-detail', kwargs={'pk': topic.pk, }))
     self.assertEqual(response.context['topic'], topic)
Пример #30
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)
Пример #31
0
 def test_topic_detail_view_invalid_slug(self):
     """
     invalid slug
     """
     utils.login(self)
     category = utils.create_category()
     topic = utils.create_topic(category=category)
     response = self.client.get(reverse('spirit:topic-detail', kwargs={'pk': topic.pk,
                                                                        'slug': 'bar'}))
     self.assertRedirects(response, topic.get_absolute_url(), status_code=301)
Пример #32
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)
Пример #33
0
    def test_topic_update_signal(self):
        """
        POST, topic moved to category
        """
        def topic_post_moderate_handler(sender, user, topic, action, **kwargs):
            self._moderate = [repr(user._wrapped), repr(topic), action]
        topic_post_moderate.connect(topic_post_moderate_handler)

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

        category = utils.create_category()
        topic = utils.create_topic(category=category, user=self.user)
        category2 = utils.create_category()
        form_data = {'title': 'foobar', 'category': category2.pk}
        response = self.client.post(reverse('spirit:topic-update', kwargs={'pk': topic.pk, }),
                                    form_data)
        self.assertSequenceEqual(self._moderate, [repr(self.user), repr(Topic.objects.get(pk=topic.pk)), MOVED])
Пример #34
0
 def test_topic_publish(self):
     """
     create topic
     """
     category = utils.create_category()
     subcategory = utils.create_subcategory(category)
     form_data = {'comment': 'foo', 'title': 'foobar',
                  'category': subcategory.pk}
     form = TopicForm(self.user, data=form_data)
     self.assertEqual(form.is_valid(), True)
Пример #35
0
 def test_category_list(self):
     """
     Categories, excludes Topic Private and subcats
     """
     subcat = utils.create_category(parent=self.category)
     categories = Category.objects.filter(is_private=False, parent=None)
     utils.login(self)
     response = self.client.get(reverse('spirit:admin-category-list'))
     self.assertQuerysetEqual(response.context['categories'],
                              map(repr, categories))
Пример #36
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)
Пример #37
0
 def test_topic_update(self):
     """
     POST, update topic
     """
     utils.login(self)
     category = utils.create_category()
     topic = utils.create_topic(category=category, user=self.user)
     form_data = {'title': 'foobar', }
     response = self.client.post(reverse('spirit:topic-update', kwargs={'pk': topic.pk, }),
                                 form_data)
     self.assertRedirects(response, topic.get_absolute_url(), status_code=302)
Пример #38
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.topic2 = utils.create_topic(self.category, user=self.user)

        self.topic_unread = TopicUnread.objects.create(user=self.user, topic=self.topic)
        self.topic_unread2 = TopicUnread.objects.create(user=self.user, topic=self.topic2)
        self.topic_unread3 = TopicUnread.objects.create(user=self.user2, topic=self.topic)
Пример #39
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'], [])
Пример #40
0
 def test_topic_update_invalid_user(self):
     """
     POST, update topic
     """
     utils.login(self)
     category = utils.create_category()
     topic = utils.create_topic(category=category)
     form_data = {'title': 'foobar', }
     response = self.client.post(reverse('spirit:topic-update', kwargs={'pk': topic.pk, }),
                                 form_data)
     self.assertEqual(response.status_code, 404)
Пример #41
0
    def test_private_join_invalid_regular_topic(self):
        """
        Only topics from the category private can be rejoined
        """
        category = utils.create_category()
        topic = utils.create_topic(category, user=self.user)

        utils.login(self)
        form_data = {}
        response = self.client.post(reverse("spirit:private-join", kwargs={"topic_id": topic.pk}), form_data)
        self.assertEqual(response.status_code, 404)
Пример #42
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, ]))
Пример #43
0
 def test_topic_publish_invalid_subcategory(self):
     """
     invalid subcategory
     """
     category = utils.create_category()
     subcategory = utils.create_subcategory(category, is_closed=True)
     form_data = {'comment': 'foo', 'title': 'foobar',
                  'category': subcategory.pk}
     form = TopicForm(self.user, data=form_data)
     self.assertEqual(form.is_valid(), False)
     self.assertNotIn('category', form.cleaned_data)
Пример #44
0
    def test_notification(self):
        """
        update notification
        """
        category = utils.create_category()
        topic = utils.create_topic(category)
        notification = TopicNotification.objects.create(user=self.user, topic=topic,
                                                        is_active=True, action=COMMENT)

        form_data = {'is_active': True, }
        form = NotificationForm(data=form_data, instance=notification)
        self.assertEqual(form.is_valid(), True)
Пример #45
0
 def test_topic_publish_long_title(self):
     """
     POST, create topic with long title
     """
     utils.login(self)
     category = utils.create_category()
     title = "a" * 75
     form_data = {'comment': 'foo', 'title': title, 'category': category.pk}
     response = self.client.post(reverse('spirit:topic-publish'), form_data)
     self.assertEqual(response.status_code, 302)
     self.assertEqual(len(Topic.objects.all()), 1)
     self.assertEqual(Topic.objects.last().slug, title[:50])
Пример #46
0
    def test_private_join_invalid_regular_topic(self):
        """
        Only topics from the category private can be rejoined
        """
        category = utils.create_category()
        topic = utils.create_topic(category, user=self.user)

        utils.login(self)
        form_data = {}
        response = self.client.post(reverse('spirit:private-join', kwargs={'topic_id': topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 404)
Пример #47
0
    def setUp(self):
        # TODO: simple backend wont work on django +1.6 coz of a bug on haystack 2.1
        #self.connections = haystack.connections
        #haystack.connections = haystack.loading.ConnectionHandler(HAYSTACK_TEST)

        cache.clear()
        self.user = utils.create_user()
        self.category = utils.create_category()
        self.topic = utils.create_topic(category=self.category, user=self.user, title="spirit search test")
        self.topic2 = utils.create_topic(category=self.category, user=self.user, title="foo")

        call_command("rebuild_index", interactive=False)
Пример #48
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)
Пример #49
0
 def test_topic_publish_long_title(self):
     """
     POST, create topic with long title
     """
     utils.login(self)
     category = utils.create_category()
     title = "a" * 75
     form_data = {'comment': 'foo', 'title': title, 'category': category.pk}
     response = self.client.post(reverse('spirit:topic-publish'),
                                 form_data)
     self.assertEqual(response.status_code, 302)
     self.assertEqual(len(Topic.objects.all()), 1)
     self.assertEqual(Topic.objects.last().slug, title[:50])
Пример #50
0
 def test_topic_publish_in_subcategory(self):
     """
     POST, create topic in subcategory
     """
     utils.login(self)
     category = utils.create_category()
     subcategory = utils.create_subcategory(category)
     form_data = {'comment': 'foo', 'title': 'foobar',
                  'category': subcategory.pk}
     response = self.client.post(reverse('spirit:topic-publish', kwargs={'category_id': subcategory.pk, }),
                                 form_data)
     topic = Topic.objects.last()
     expected_url = topic.get_absolute_url()
     self.assertRedirects(response, expected_url, status_code=302)