#410: Added tests for some list helpers

misago/threads/models/post.py

@@ -33,6 +33,9 @@ class Post(models.Model):
     is_hidden = models.BooleanField(default=False)
     is_protected = models.BooleanField(default=False)
 
+    def __unicode__(self):
+        return '%s...' % self.original[10:].strip()
+
     def delete(self, *args, **kwargs):
         from misago.threads.signals import delete_post
         delete_post.send(sender=self)

misago/threads/models/thread.py

@@ -54,10 +54,13 @@ class Thread(models.Model):
         index_together = [
             ['forum', 'weight'],
             ['forum', 'weight', 'id'],
-            ['forum', 'weight', 'last_post'],
+            ['forum', 'weight', 'last_post_on'],
             ['forum', 'weight', 'replies'],
         ]
 
+    def __unicode__(self):
+        return self.title
+
     def delete(self, *args, **kwargs):
         from misago.threads.signals import delete_thread
         delete_thread.send(sender=self)

misago/threads/tests/test_forum_threads_view.py

@@ -1,13 +1,270 @@
+from django.contrib.auth import get_user_model
 from django.core.urlresolvers import reverse
+from django.test import TestCase
+from django.utils.translation import ugettext as _
 
+from misago.acl import add_acl
 from misago.acl.testutils import override_acl
-from misago.admin.testutils import AdminTestCase
 from misago.forums.models import Forum
+from misago.users.testutils import AuthenticatedUserTestCase
 
 from misago.threads import testutils
+from misago.threads.models import Label
+from misago.threads.views.generic.forum import ForumFiltering, ForumThreads
 
 
-class ForumThreadsAuthenticatedTests(AdminTestCase):
+class ForumViewHelperTestCase(AuthenticatedUserTestCase):
+    def setUp(self):
+        super(ForumViewHelperTestCase, self).setUp()
+
+        self.forum = Forum.objects.all_forums().filter(role="forum")[:1][0]
+        self.forum.labels = []
+
+    def override_acl(self, new_acl):
+        new_acl.update({'can_browse': True})
+
+        forums_acl = self.user.acl
+        forums_acl['visible_forums'].append(self.forum.pk)
+        forums_acl['forums'][self.forum.pk] = new_acl
+        override_acl(self.user, forums_acl)
+        add_acl(self.user, self.forum)
+
+
+class ForumFilteringTests(ForumViewHelperTestCase):
+    def test_get_available_filters(self):
+        """get_available_filters returns filters varying on forum acl"""
+        default_acl = {
+            'can_see_all_threads': False,
+            'can_see_reports': False,
+            'can_review_moderated_content': False,
+        }
+
+        cases = (
+            ('can_see_all_threads', 'my-threads'),
+            ('can_see_reports', 'reported'),
+            ('can_review_moderated_content', 'moderated-threads'),
+        )
+
+        for permission, filter_type in cases:
+            self.override_acl(default_acl)
+            filtering = ForumFiltering(self.forum, 'misago:forum', {
+                'forum_id': self.forum.id,
+                'forum_slug': self.forum.slug,
+            })
+
+            available_filters = filtering.get_available_filters()
+            available_filters = [f['type'] for f in available_filters]
+            self.assertNotIn(filter_type, available_filters)
+
+            acl = default_acl.copy()
+            acl[permission] = True
+            self.override_acl(acl)
+
+            filtering = ForumFiltering(self.forum, 'misago:forum', {
+                'forum_id': self.forum.id,
+                'forum_slug': self.forum.slug,
+            })
+
+            available_filters = filtering.get_available_filters()
+            available_filters = [f['type'] for f in available_filters]
+            self.assertIn(filter_type, available_filters)
+
+        self.forum.labels = [
+            Label(name='Label A', slug='label-a'),
+            Label(name='Label B', slug='label-b'),
+            Label(name='Label C', slug='label-c'),
+            Label(name='Label D', slug='label-d'),
+        ]
+
+        self.override_acl(default_acl)
+        ForumFiltering(self.forum, 'misago:forum', {
+                'forum_id': self.forum.id,
+                'forum_slug': self.forum.slug,
+            })
+
+        available_filters = filtering.get_available_filters()
+        available_filters = [f['type'] for f in available_filters]
+
+        self.assertEqual(len(available_filters), len(self.forum.labels))
+        for label in self.forum.labels:
+            self.assertIn(label.slug, available_filters)
+
+    def test_clean_kwargs(self):
+        """clean_kwargs cleans kwargs"""
+        self.override_acl({
+            'can_see_all_threads': True,
+            'can_see_reports': True,
+            'can_review_moderated_content': True,
+        })
+
+        filtering = ForumFiltering(self.forum, 'misago:forum', {
+            'forum_id': self.forum.id,
+            'forum_slug': self.forum.slug,
+        })
+
+        available_filters = filtering.get_available_filters()
+        available_filters = [f['type'] for f in available_filters]
+
+        clean_kwargs = filtering.clean_kwargs({'test': 'kwarg'})
+        self.assertEqual(clean_kwargs, {'test': 'kwarg'})
+
+        clean_kwargs = filtering.clean_kwargs({
+            'test': 'kwarg',
+            'show': 'everything-hue-hue',
+        })
+        self.assertEqual(clean_kwargs, {'test': 'kwarg'})
+        self.assertFalse(filtering.is_active)
+        self.assertIsNone(filtering.show)
+
+        for filter_type in available_filters:
+            clean_kwargs = filtering.clean_kwargs({
+                'test': 'kwarg',
+                'show': filter_type,
+            })
+
+            self.assertEqual(clean_kwargs, {
+                'test': 'kwarg',
+                'show': filter_type,
+            })
+            self.assertTrue(filtering.is_active)
+            self.assertEqual(filtering.show, filter_type)
+
+    def test_current(self):
+        """current returns dict with current filter"""
+        self.override_acl({
+            'can_see_all_threads': True,
+            'can_see_reports': True,
+            'can_review_moderated_content': True,
+        })
+
+        test_cases = (
+            ('my-threads', _("My threads")),
+            ('reported', _("With reported posts")),
+            ('moderated-threads', _("Moderated threads")),
+            ('moderated-posts', _("With moderated posts")),
+        )
+
+        for filter_type, name in test_cases:
+            filtering = ForumFiltering(self.forum, 'misago:forum', {
+                'forum_id': self.forum.id,
+                'forum_slug': self.forum.slug,
+            })
+            filtering.clean_kwargs({'show': filter_type})
+            self.assertEqual(filtering.current['name'], name)
+
+    def test_choices(self):
+        """choices returns list of dicts with available filters"""
+        self.override_acl({
+            'can_see_all_threads': True,
+            'can_see_reports': True,
+            'can_review_moderated_content': True,
+        })
+
+        test_cases = (
+            'my-threads',
+            'reported',
+            'moderated-threads',
+            'moderated-posts',
+        )
+
+        for filter_type in test_cases:
+            filtering = ForumFiltering(self.forum, 'misago:forum', {
+                'forum_id': self.forum.id,
+                'forum_slug': self.forum.slug,
+            })
+            filtering.clean_kwargs({'show': filter_type})
+
+            choices = [choice['type'] for choice in filtering.choices()]
+            self.assertNotIn(filter_type, choices)
+
+
+class ForumThreadsTests(ForumViewHelperTestCase):
+    def test_empty_list(self):
+        """list returns empty list of items"""
+        self.override_acl({
+            'can_see_all_threads': True,
+            'can_review_moderated_content': False
+        })
+
+        threads = ForumThreads(self.user, self.forum)
+        threads_list = threads.list()
+
+        self.assertEqual(threads_list, [])
+
+    def test_list_exception(self):
+        """
+        uninitialized list raises exceptions when
+        page and paginator attributes are accessed
+        """
+        self.override_acl({
+            'can_see_all_threads': False,
+            'can_review_moderated_content': False
+        })
+
+        threads = ForumThreads(self.user, self.forum)
+
+        with self.assertRaises(AttributeError):
+            threads.page
+
+        with self.assertRaises(AttributeError):
+            threads.paginator
+
+    def test_list_with_threads(self):
+        """list returns list of visible threads"""
+        test_threads = [
+            testutils.post_thread(
+                forum=self.forum,
+                title="Hello, I am thread",
+                is_moderated=False,
+                poster=self.user),
+            testutils.post_thread(
+                forum=self.forum,
+                title="Hello, I am moderated thread",
+                is_moderated=True,
+                poster=self.user),
+            testutils.post_thread(
+                forum=self.forum,
+                title="Hello, I am other user thread",
+                is_moderated=False,
+                poster="Bob"),
+            testutils.post_thread(
+                forum=self.forum,
+                title="Hello, I am other user moderated thread",
+                is_moderated=True,
+                poster="Bob"),
+        ]
+
+        self.override_acl({
+            'can_see_all_threads': False,
+            'can_review_moderated_content': False
+        })
+
+        threads = ForumThreads(self.user, self.forum)
+        self.assertEqual(threads.list(), [test_threads[1], test_threads[0]])
+
+        self.override_acl({
+            'can_see_all_threads': True,
+            'can_review_moderated_content': False
+        })
+
+        threads = ForumThreads(self.user, self.forum)
+        self.assertEqual(threads.list(),
+                         [test_threads[2], test_threads[1], test_threads[0]])
+
+        self.override_acl({
+            'can_see_all_threads': True,
+            'can_review_moderated_content': True
+        })
+
+        threads = ForumThreads(self.user, self.forum)
+        test_threads.reverse()
+        self.assertEqual(threads.list(), test_threads)
+
+        self.assertTrue(threads.page)
+        self.assertTrue(threads.paginator)
+
+
+class ForumThreadsAuthenticatedTests(AuthenticatedUserTestCase):
     def setUp(self):
         super(ForumThreadsAuthenticatedTests, self).setUp()
 
@@ -16,13 +273,13 @@ class ForumThreadsAuthenticatedTests(AdminTestCase):
         self.forum.delete_content()
 
     def override_acl(self, new_acl):
-        forums_acl = self.test_admin.acl
+        forums_acl = self.user.acl
         if new_acl['can_see']:
             forums_acl['visible_forums'].append(self.forum.pk)
         else:
             forums_acl['visible_forums'].remove(self.forum.pk)
         forums_acl['forums'][self.forum.pk] = new_acl
-        override_acl(self.test_admin, forums_acl)
+        override_acl(self.user, forums_acl)
 
     def test_cant_see(self):
         """has no permission to see forum"""
@@ -77,13 +334,13 @@ class ForumThreadsAuthenticatedTests(AdminTestCase):
         testutils.post_thread(
             forum=self.forum,
             title=owned_title,
-            poster=self.test_admin)
+            poster=self.user)
 
         owned_moderated_title = "Test authenticated user moderated thread"
         testutils.post_thread(
             forum=self.forum,
             title=owned_moderated_title,
-            poster=self.test_admin,
+            poster=self.user,
             is_moderated=True)
 
         self.override_acl(test_acl)
@@ -118,7 +375,7 @@ class ForumThreadsAuthenticatedTests(AdminTestCase):
             forum=self.forum,
             title=test_title,
             is_moderated=True,
-            poster=self.test_admin)
+            poster=self.user)
 
         self.override_acl(test_acl)
         response = self.client.get(self.link)
@@ -145,13 +402,13 @@ class ForumThreadsAuthenticatedTests(AdminTestCase):
         testutils.post_thread(
             forum=self.forum,
             title=owned_title,
-            poster=self.test_admin)
+            poster=self.user)
 
         owned_moderated_title = "Test authenticated user moderated thread"
         testutils.post_thread(
             forum=self.forum,
             title=owned_moderated_title,
-            poster=self.test_admin,
+            poster=self.user,
             is_moderated=True)
 
         self.override_acl(test_acl)
@@ -197,7 +454,7 @@ class ForumThreadsAuthenticatedTests(AdminTestCase):
             forum=self.forum,
             title=visible_title,
             is_moderated=True,
-            poster=self.test_admin)
+            poster=self.user)
 
         self.override_acl(test_acl)
         response = self.client.get(self.link)

misago/threads/views/generic/forum.py

@@ -137,6 +137,9 @@ class ForumThreads(Threads):
         self.user = user
         self.forum = forum
 
+        self.filter_by = None
+        self.sort_by = ('-weight', '-last_post_on')
+
     def filter(self, filter_by):
         self.filter_by = filter_by
 
@@ -199,18 +202,18 @@ class ForumThreads(Threads):
                      "pagination data will be available")
 
     @property
-    def page(self):
+    def paginator(self):
         try:
-            return self._page
+            return self._paginator
         except AttributeError:
-            raise RuntimeError(error_message)
+            raise AttributeError(self.error_message)
 
     @property
-    def paginator(self):
+    def page(self):
         try:
-            return self._paginator
+            return self._page
         except AttributeError:
-            raise RuntimeError(error_message)
+            raise AttributeError(self.error_message)
 
 
 class ForumView(ThreadsView):

misago/threads/views/generic/threads.py

@@ -41,12 +41,12 @@ class Sorting(Helper):
         {
             'method': 'recently-replied',
             'name': ugettext_lazy("Recently replied"),
-            'order_by': '-last_post',
+            'order_by': '-last_post_on',
         },
         {
             'method': 'last-replied',
             'name': ugettext_lazy("Last replied"),
-            'order_by': 'last_post',
+            'order_by': 'last_post_on',
         },
         {
             'method': 'most-replied',