def test_category_order_by_title(self):
Category.objects.all().delete()
cat1 = utils.create_category(title="1", sort=2)
cat2 = utils.create_category(title="2", sort=1)
self.assertEqual(list(Category.objects.all()), [cat1, cat2])
form = CategoryForm(data=None)
self.assertEqual(list(form.fields['parent'].queryset), [cat1, cat2])
def test_category_title_order(self):
utils.default_categories().delete()
cat1 = utils.create_category(title="1", sort=2)
cat2 = utils.create_category(title="2", sort=1)
cat3 = utils.create_category(title="3", sort=3)
cat0 = utils.create_category(title="0", sort=0)
form = TopicForm(self.user, data=None)
self.assertEqual(list(form.fields['category'].queryset),
[cat0, cat1, cat2, cat3])
def test_index_active_ordered(self):
utils.default_categories().delete()
cat1 = utils.create_category(title="1", sort=2)
cat2 = utils.create_category(title="2", sort=1)
response = self.client.get(reverse('spirit:topic:index-active'))
self.assertEqual(list(response.context['categories']), [cat2, cat1])
cat1.sort = 0
cat1.save()
response = self.client.get(reverse('spirit:topic:index-active'))
self.assertEqual(list(response.context['categories']), [cat1, cat2])
def test_category_ordered(self):
utils.default_categories().delete()
cat1 = utils.create_category(title="1", sort=2)
cat2 = utils.create_category(title="2", sort=1)
form = TopicForm(self.user, data=None)
self.assertEqual(list(form.fields['category'].queryset), [cat2, cat1])
cat1.sort = 0
cat1.save()
form = TopicForm(self.user, data=None)
self.assertEqual(list(form.fields['category'].queryset), [cat1, cat2])
def test_category_list(self):
"""
Categories, excludes Topic Private and subcats
"""
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:index'))
self.assertEqual(list(response.context['categories']),
list(categories))
def test_topic_active_view_dont_show_not_global(self):
"""
Should not display non-global categories topics
"""
# Global subcategories from non-global categories should be displayed
category_non_global = utils.create_category(is_global=False)
subcategory_global = utils.create_category(parent=category_non_global)
utils.create_topic(category=category_non_global)
topic = utils.create_topic(category=subcategory_global)
response = self.client.get(reverse('spirit:topic:index-active'))
self.assertEqual(list(response.context['topics']), [topic])
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)
TopicNotification.objects.create(user=self.user,
topic=topic_a.topic,
comment=self.comment,
is_active=True,
action=COMMENT)
TopicNotification.objects.create(user=self.user,
topic=topic_b,
comment=self.comment,
is_active=True,
action=COMMENT)
TopicNotification.objects.create(user=self.user,
topic=topic_c,
comment=self.comment,
is_active=True,
action=COMMENT)
TopicNotification.objects.create(user=self.user,
topic=topic_d,
comment=self.comment,
is_active=True,
action=COMMENT)
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_detail_viewed(self):
"""
Calls utils.topic_viewed
"""
def mocked_topic_viewed(request, topic):
self._user = request.user
self._topic = topic
org_viewed, utils_topic.topic_viewed = (utils_topic.topic_viewed,
mocked_topic_viewed)
try:
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.assertEqual(self._topic, topic)
self.assertEqual(self._user, self.user)
finally:
utils_topic.topic_viewed = org_viewed
def test_topic_publish(self):
"""
POST, create topic
"""
self.assertEqual(len(Topic.objects.all()), 0)
utils.login(self)
category = utils.create_category()
form_data = {
'comment': 'foo',
'title': 'foobar',
'category': category.pk
}
response = self.client.post(reverse('spirit:topic:publish'), form_data)
topic = Topic.objects.last()
expected_url = topic.get_absolute_url()
self.assertRedirects(response, expected_url, status_code=302)
self.assertEqual(len(Topic.objects.all()), 1)
# ratelimit
response = self.client.post(reverse('spirit:topic:publish'), form_data)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(Topic.objects.all()), 1)
# get
response = self.client.get(reverse('spirit:topic:publish'))
self.assertEqual(response.status_code, 200)
def test_notification_creation(self):
"""
create notification
"""
# Should be ready to suscribe (true)
form = NotificationCreationForm()
self.assertEqual(form.fields['is_active'].initial, True)
category = utils.create_category()
topic = utils.create_topic(category)
comment = utils.create_comment(topic=topic)
form_data = {
'is_active': True,
}
form = NotificationCreationForm(data=form_data)
form.user = self.user
form.topic = topic
self.assertEqual(form.is_valid(), True)
TopicNotification.objects.create(user=self.user,
topic=topic,
comment=comment,
is_active=True,
action=COMMENT)
form = NotificationCreationForm(data=form_data)
form.user = self.user
form.topic = topic
self.assertEqual(form.is_valid(), False)
def setUp(self):
utils.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.comment2 = utils.create_comment(topic=self.topic2)
self.topic_subscrption = TopicNotification.objects.create(
user=self.user,
topic=self.topic2,
comment=self.comment2,
is_active=True)
def setUp(self):
utils.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_category_move_up_down(self):
"""Should order the category when moving up/down"""
utils.login(self)
self.another_category = utils.create_category()
response = self.client.post(
reverse('spirit:admin:category:move_dn',
kwargs={
"category_id": self.category.pk,
}))
expected_url = reverse("spirit:admin:category:index")
self.assertRedirects(response, expected_url, status_code=302)
self.category.refresh_from_db()
self.another_category.refresh_from_db()
self.assertTrue(self.category.sort > self.another_category.sort)
response = self.client.post(
reverse('spirit:admin:category:move_up',
kwargs={
"category_id": self.category.pk,
}))
expected_url = reverse("spirit:admin:category:index")
self.assertRedirects(response, expected_url, status_code=302)
self.category.refresh_from_db()
self.another_category.refresh_from_db()
self.assertTrue(self.category.sort < self.another_category.sort)
def test_topic_has_new_comments(self):
"""
Should return True when there are new replies
"""
utils.login(self)
category = utils.create_category()
topic = utils.create_topic(category=category,
user=self.user,
comment_count=1)
self.assertFalse(
Topic.objects.filter(pk=topic.pk).with_bookmarks(
self.user).first().has_new_comments)
CommentBookmark.objects.create(topic=topic,
user=self.user,
comment_number=1)
self.assertFalse(
Topic.objects.filter(pk=topic.pk).with_bookmarks(
self.user).first().has_new_comments)
Topic.objects.filter(pk=topic.pk).update(comment_count=2)
self.assertTrue(
Topic.objects.filter(pk=topic.pk).with_bookmarks(
self.user).first().has_new_comments)
def test_topic_new_comments_count(self):
"""
Should return the new replies count
"""
utils.login(self)
category = utils.create_category()
topic = utils.create_topic(category=category,
user=self.user,
comment_count=1)
self.assertEqual(
Topic.objects.filter(pk=topic.pk).with_bookmarks(
self.user).first().new_comments_count, 0)
CommentBookmark.objects.create(topic=topic,
user=self.user,
comment_number=1)
self.assertEqual(
Topic.objects.filter(pk=topic.pk).with_bookmarks(
self.user).first().new_comments_count, 0)
Topic.objects.filter(pk=topic.pk).update(comment_count=2)
self.assertEqual(
Topic.objects.filter(pk=topic.pk).with_bookmarks(
self.user).first().new_comments_count, 1)
# topic.comment_count greater than bookmark.comment_number
# should return 0
Topic.objects.filter(pk=topic.pk).update(comment_count=0)
self.assertEqual(
Topic.objects.filter(pk=topic.pk).with_bookmarks(
self.user).first().new_comments_count, 0)
def test_topic_get_bookmark_url(self):
"""
Should return the bookmark url
"""
utils.login(self)
category = utils.create_category()
topic = utils.create_topic(category=category, user=self.user)
# No bookmark
topic_with_bookmark = (Topic.objects.filter(
pk=topic.pk).with_bookmarks(self.user).first())
self.assertEqual(topic_with_bookmark.get_bookmark_url(),
topic_with_bookmark.get_absolute_url())
# With bookmark
CommentBookmark.objects.create(topic=topic,
user=self.user,
comment_number=1)
topic_with_bookmark2 = (Topic.objects.filter(
pk=topic.pk).with_bookmarks(self.user).first())
self.assertEqual(topic_with_bookmark2.get_bookmark_url(),
topic_with_bookmark2.bookmark.get_absolute_url())
# With bookmark and new comment
Topic.objects.filter(pk=topic.pk).update(comment_count=2)
topic_with_bookmark3 = (Topic.objects.filter(
pk=topic.pk).with_bookmarks(self.user).first())
self.assertEqual(topic_with_bookmark3.get_bookmark_url(),
topic_with_bookmark3.bookmark.get_new_comment_url())
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)
def setUp(self):
utils.cache_clear()
self.user = utils.create_user()
self.user.st.is_administrator = True
self.user.st.save()
self.category = utils.create_category()
self.topic = utils.create_topic(self.category, user=self.user)
def test_topic_viewed(self):
"""
* Should update/create the comment bookmark
* Should mark the topic notification as read
* Should create or mark the topic (unread) as read
* Should increase the view_counter
"""
req = RequestFactory().get('/?page=1')
req.user = self.user
category = utils.create_category()
topic = utils.create_topic(category=category, user=self.user)
comment = utils.create_comment(topic=topic)
notification = TopicNotification.objects.create(user=topic.user,
topic=topic,
comment=comment,
is_read=False)
unread = TopicUnread.objects.create(user=topic.user,
topic=topic,
is_read=False)
utils_topic.topic_viewed(req, topic)
self.assertEqual(
len(CommentBookmark.objects.filter(user=self.user, topic=topic)),
1)
self.assertTrue(
TopicNotification.objects.get(pk=notification.pk).is_read)
self.assertTrue(TopicUnread.objects.get(pk=unread.pk).is_read)
self.assertEqual(Topic.objects.get(pk=topic.pk).view_count, 1)
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)
utils.create_private_topic()
utils.create_topic(category=category, is_removed=True)
utils.create_topic(category=category_removed)
utils.create_topic(category=subcategory)
utils.create_topic(category=subcategory_removed)
response = self.client.get(reverse('spirit:topic:index-active'))
self.assertEqual(list(response.context['topics']), [])
def test_topic_get_category(self):
"""
Should return the category
"""
category = utils.create_category()
form_data = {'title': 'foobar', 'category': category.pk}
form = TopicForm(self.user, data=form_data)
self.assertTrue(form.is_valid())
self.assertEqual(form.get_category(), category)
def test_topic_update_not_moderator(self):
category = utils.create_category()
topic = utils.create_topic(category)
self.user.st.is_moderator = False
self.user.st.save()
form = TopicForm(self.user, data=None, instance=topic)
self.assertNotIn('category', form.fields)
form = TopicForm(self.user, data=None)
self.assertIn('category', form.fields)
def test_topic_update_create_moderation_action(self):
"""
POST, topic moved to category
"""
utils.login(self)
self.user.st.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}
self.client.post(
reverse('spirit:topic:update', kwargs={'pk': topic.pk}), form_data)
self.assertEqual(
len(
Comment.objects.filter(user=self.user,
topic_id=topic.pk,
action=Comment.MOVED)), 1)
def test_index_active_categories(self):
default_cats = list(utils.default_categories())
cat1 = utils.create_category()
utils.create_category(parent=cat1)
utils.create_category(is_private=True)
utils.create_category(is_removed=True)
response = self.client.get(reverse('spirit:topic:index-active'))
self.assertEqual(set(response.context['categories']),
set(default_cats + [cat1]))
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_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)
def test_topic_publish_long_title(self):
"""
POST, create topic with long title
"""
utils.login(self)
category = utils.create_category()
title = "a" * 255
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])
def test_topic_active_view_paginate(self):
"""
topics ordered by activity paginated
"""
category = utils.create_category()
topic_a = utils.create_topic(category=category)
topic_b = utils.create_topic(category=category,
user=self.user,
view_count=10)
response = self.client.get(reverse('spirit:topic:index-active'))
self.assertEqual(list(response.context['topics']), [topic_b])
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)
def test_topic_get_topic_hash(self):
"""
Should return the topic hash
"""
category = utils.create_category()
title = 'title foobar'
form_data = {'title': title, 'category': category.pk}
form = TopicForm(self.user, data=form_data)
self.assertTrue(form.is_valid())
self.assertEqual(
form.get_topic_hash(),
hashlib.md5('{}category-{}'.format(
title, category.pk).encode('utf-8')).hexdigest())
def test_viewtopic(app):
user = utils.create_user()
category = utils.create_category()
topic = utils.create_topic(category=category, user=user)
PhpBBForumRefs.objects.create(category=category, phpbb_forum_id=1)
PhpBBTopicRefs.objects.create(topic=topic, phpbb_forum_id=1, phpbb_topic_id=2)
# Test success
app.get('/forum/viewforum.php?f=1')
app.get('/forum/viewtopic.php?f=1&t=2')
# Test 404
app.get('/forum/viewforum.php?f=2', status=404)
app.get('/forum/viewtopic.php?f=1&t=3', status=404)
# Test NaN's
app.get('/forum/viewtopic.php?f=NaN', status=404)
app.get('/forum/viewtopic.php?t=42NaN', status=404)
app.get('/forum/viewforum.php?f=42Nan', status=404)
