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)
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_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_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]))
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'], [])
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, ]))
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.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)
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))
def test_category_detail_subcategory(self):
"""
should display all topics in subcategory
"""
topic = utils.create_topic(category=self.category_1)
topic2 = utils.create_topic(category=self.subcategory_1, title="topic_subcat1")
response = self.client.get(reverse('spirit:category-detail', kwargs={'pk': self.subcategory_1.pk, }))
self.assertQuerysetEqual(response.context['topics'], [repr(topic2), ])
self.assertQuerysetEqual(response.context['categories'], [])
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)
def test_category_detail_view_removed_topics(self):
"""
should not display removed topics or from other categories
"""
subcategory_removed = utils.create_subcategory(self.category_1, is_removed=True)
topic_removed = utils.create_topic(category=subcategory_removed)
topic_removed2 = utils.create_topic(category=self.category_1, is_removed=True)
topic_bad = utils.create_topic(category=self.category_2)
response = self.client.get(reverse('spirit:category-detail', kwargs={'pk': self.category_1.pk, }))
self.assertQuerysetEqual(response.context['topics'], [])
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)
def test_category_detail_view_order(self):
"""
should display all topics order by pinned and last active
"""
topic_a = utils.create_topic(category=self.category_1, is_pinned=True)
topic_b = utils.create_topic(category=self.category_1)
topic_c = utils.create_topic(category=self.category_1, is_pinned=True, is_removed=True)
# show pinned first
Topic.objects.filter(pk=topic_a.pk).update(last_active=timezone.now() - datetime.timedelta(days=10))
response = self.client.get(reverse('spirit:category-detail', kwargs={'pk': self.category_1.pk, }))
self.assertQuerysetEqual(response.context['topics'], map(repr, [topic_a, topic_b, ]))
def test_category_detail_view(self):
"""
should display all topics in the category and its subcategories
ordered by last active first
"""
topic = utils.create_topic(category=self.category_1)
topic2 = utils.create_topic(category=self.subcategory_1)
topic3 = utils.create_topic(category=self.category_1)
Topic.objects.filter(pk=topic.pk).update(last_active=timezone.now() - datetime.timedelta(days=10))
Topic.objects.filter(pk=topic3.pk).update(last_active=timezone.now() - datetime.timedelta(days=5))
response = self.client.get(reverse('spirit:category-detail', kwargs={'pk': self.category_1.pk, }))
self.assertQuerysetEqual(response.context['topics'], [repr(topic2), repr(topic3), repr(topic)])
def test_topic_active_view(self):
"""
topics ordered by activity
"""
category = utils.create_category()
topic_a = utils.create_topic(category=category)
topic_b = utils.create_topic(category=category, user=self.user, view_count=10)
topic_c = utils.create_topic(category=category)
Topic.objects.filter(pk=topic_a.pk).update(last_active=timezone.now() - datetime.timedelta(days=10))
Topic.objects.filter(pk=topic_c.pk).update(last_active=timezone.now() - datetime.timedelta(days=5))
response = self.client.get(reverse('spirit:topic-active'))
self.assertQuerysetEqual(response.context['topics'], map(repr, [topic_b, topic_c, topic_a]))
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))
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_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_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)
def test_category_detail_subcategory(self):
"""
should display all topics in subcategory
"""
topic = utils.create_topic(category=self.category_1)
topic2 = utils.create_topic(category=self.subcategory_1,
title="topic_subcat1")
response = self.client.get(
reverse('spirit:category-detail',
kwargs={
'pk': self.subcategory_1.pk,
}))
self.assertQuerysetEqual(response.context['topics'], [
repr(topic2),
])
self.assertQuerysetEqual(response.context['categories'], [])
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)])
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])
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_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])
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)
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)
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'], [])
def test_category_detail_view_removed_topics(self):
"""
should not display removed topics or from other categories
"""
subcategory_removed = utils.create_subcategory(self.category_1,
is_removed=True)
topic_removed = utils.create_topic(category=subcategory_removed)
topic_removed2 = utils.create_topic(category=self.category_1,
is_removed=True)
topic_bad = utils.create_topic(category=self.category_2)
response = self.client.get(
reverse('spirit:category-detail',
kwargs={
'pk': self.category_1.pk,
}))
self.assertQuerysetEqual(response.context['topics'], [])
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 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_pinned(self):
"""
Pinned topics
"""
topic_ = utils.create_topic(self.category, is_pinned=True)
utils.login(self)
response = self.client.get(reverse('spirit:admin-topic-pinned'))
self.assertQuerysetEqual(response.context['topics'], map(repr, [topic_, ]))
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_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 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_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)
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]))
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 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 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)
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 test_private_create(self):
"""
create single private topic access
"""
category = Category.objects.get(pk=settings.ST_TOPIC_PRIVATE_CATEGORY_PK)
topic = utils.create_topic(category=category, user=self.user)
form_data = {'user': self.user.username, }
form = TopicPrivateInviteForm(data=form_data)
form.topic = topic
self.assertEqual(form.is_valid(), True)
def test_private_create(self):
"""
create single private topic access
"""
category = Category.objects.get(pk=settings.ST_TOPIC_PRIVATE_CATEGORY_PK)
topic = utils.create_topic(category=category, user=self.user)
form_data = {"user": self.user.username}
form = TopicPrivateInviteForm(data=form_data)
form.topic = topic
self.assertEqual(form.is_valid(), True)
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)
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 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_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)
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_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)
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, ]))
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)
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)
