Updated tests suite.

misago/acl/algebra.py

@@ -8,9 +8,6 @@ def _roles_acls(key_name, roles):
 
 
 def sum_acls(result_acl, acls=None, roles=None, key=None, **permissions):
-    if not key:
-        raise ValueError('You have to provide "key" argument')
-
     if acls and roles:
         raise ValueError(
             'You can not provide both "acls" and "roles" arguments')
@@ -20,6 +17,9 @@ def sum_acls(result_acl, acls=None, roles=None, key=None, **permissions):
             'You have to provide either "acls" and "roles" argument')
 
     if roles is not None:
+        if not key:
+            raise ValueError('You have to provide "key" argument if '
+                             'you are passing roles instead of acls')
         acls = _roles_acls(key, roles)
 
     for permission, compare in permissions.items():

misago/acl/tests/test_acl_algebra.py

@@ -5,7 +5,6 @@ from misago.acl import algebra
 class ComparisionsTests(TestCase):
     def test_greater(self):
         """greater permission wins test"""
-
         self.assertEqual(algebra.greater(1, 3), 3)
         self.assertEqual(algebra.greater(4, 2), 4)
         self.assertEqual(algebra.greater(2, 2), 2)
@@ -13,7 +12,6 @@ class ComparisionsTests(TestCase):
 
     def test_greater_or_zero(self):
         """greater or zero permission wins test"""
-
         self.assertEqual(algebra.greater_or_zero(1, 3), 3)
         self.assertEqual(algebra.greater_or_zero(4, 2), 4)
         self.assertEqual(algebra.greater_or_zero(2, 2), 2)
@@ -24,7 +22,6 @@ class ComparisionsTests(TestCase):
 
     def test_lower(self):
         """lower permission wins test"""
-
         self.assertEqual(algebra.lower(1, 3), 1)
         self.assertEqual(algebra.lower(4, 2), 2)
         self.assertEqual(algebra.lower(2, 2), 2)
@@ -34,7 +31,6 @@ class ComparisionsTests(TestCase):
 class SumACLTests(TestCase):
     def test_sum_acls(self):
         """acls are summed"""
-
         test_acls = [
             {
                 'can_see': 0,

misago/acl/testutils.py

@@ -2,7 +2,6 @@ from hashlib import md5
 from time import time
 
 from misago.core import threadstore
-from misago.core.cache import cache
 
 from misago.acl.forms import get_permissions_forms
 from misago.acl.models import Role
@@ -27,19 +26,11 @@ def fake_post_data(target, data_dict):
 
 def override_acl(user, new_acl):
     """overrides user permissions with specified ones"""
-    test_role = Role(name='Fake %s' % user.pk)
-    test_role.permissions = new_acl
-    test_role.save()
+    final_cache = user.acl
+    final_cache.update(new_acl)
 
-    user.rank.roles.clear()
-
-    user.roles.clear()
-    user.roles.add(test_role)
-    user.acl_key = md5(test_role.name).hexdigest()[:12]
+    user._acl_cache = final_cache
+    user.acl_key = md5(unicode(user.pk)).hexdigest()[:8]
     user.save()
 
-    if hasattr(user, '_acl_cache'):
-        del user._acl_cache
-
-    threadstore.clear()
-    cache.clear()
+    threadstore.set('acl_%s' % user.acl_key, final_cache)

misago/forums/lists.py

@@ -3,7 +3,13 @@ from misago.acl import add_acl
 from misago.forums.models import Forum
 
 
+__all__ = ['get_forums_list', 'get_forum_path']
+
+
 def get_forums_list(user, parent=None):
+    if not user.acl['visible_forums']:
+        return []
+
     if parent:
         queryset = parent.get_descendants().order_by('lft')
     else:

misago/forums/tests/test_forum_model.py

@@ -1,6 +1,5 @@
-from django.core.exceptions import ValidationError
 from django.test import TestCase
-from misago.forums.models import Forum
+from misago.forums.models import FORUMS_TREE_ID, Forum
 
 
 class ForumManagerTests(TestCase):
@@ -34,3 +33,13 @@ class ForumManagerTests(TestCase):
 
         self.assertIn(test_forum_a, all_forums_from_db)
         self.assertIn(test_forum_b, all_forums_from_db)
+
+    def test_get_forums_dict_from_db(self):
+        """get_forums_dict_from_db returns dict with forums"""
+        test_dict = Forum.objects.get_forums_dict_from_db()
+
+        for forum in Forum.objects.all():
+            if forum.tree_id == FORUMS_TREE_ID:
+                self.assertIn(forum.id, test_dict)
+            else:
+                self.assertNotIn(forum.id, test_dict)

misago/forums/tests/test_forums_admin_views.py

@@ -1,5 +1,7 @@
 from django.core.urlresolvers import reverse
+
 from misago.admin.testutils import AdminTestCase
+
 from misago.forums.models import Forum
 
 

misago/forums/tests/test_forums_views.py

@@ -0,0 +1,116 @@
+from django.core.urlresolvers import reverse
+
+from misago.acl.testutils import override_acl
+from misago.admin.testutils import AdminTestCase
+
+from misago.forums.lists import get_forums_list
+from misago.forums.models import Forum
+
+
+class ForumViewsTests(AdminTestCase):
+    def test_index(self):
+        """index contains forums list"""
+        response = self.client.get(reverse('misago:index'))
+
+        for node in get_forums_list(self.test_admin):
+            self.assertIn(node.name, response.content)
+            if node.level > 1:
+                self.assertIn(node.get_absolute_url(), response.content)
+
+    def test_index_no_perms(self):
+        """index contains no visible forums"""
+        override_acl(self.test_admin, {'visible_forums': []})
+        response = self.client.get(reverse('misago:index'))
+
+        for node in get_forums_list(self.test_admin):
+            self.assertNotIn(node.name, response.content)
+            if node.level > 1:
+                self.assertNotIn(node.get_absolute_url(), response.content)
+
+
+class CategoryViewsTests(AdminTestCase):
+    def setUp(self):
+        super(CategoryViewsTests, self).setUp()
+        categories_qs = Forum.objects.all_forums().filter(role='category')
+        master_category = categories_qs[:1][0]
+
+        self.category = Forum(role='category',
+                              name='Test category',
+                              slug='test-category')
+        self.category.insert_at(master_category, save=True)
+
+    def test_cant_see_category(self):
+        """can't see category"""
+        override_acl(self.test_admin, {'visible_forums': []})
+
+        response = self.client.get(self.category.get_absolute_url())
+        self.assertEqual(response.status_code, 404)
+
+    def test_cant_browse_category(self):
+        """can't see category"""
+        override_acl(self.test_admin, {
+            'visible_forums': [self.category.parent_id, self.category.pk],
+            'forums': {
+                self.category.parent_id: {'can_see': 1, 'can_browse': 1},
+                self.category.pk: {'can_see': 1, 'can_browse': 0},
+            }
+        })
+
+        response = self.client.get(self.category.get_absolute_url())
+        self.assertEqual(response.status_code, 403)
+
+    def test_can_browse_category(self):
+        """can see category contents"""
+        override_acl(self.test_admin, {
+            'visible_forums': [self.category.parent_id, self.category.pk],
+            'forums': {
+                self.category.parent_id: {'can_see': 1, 'can_browse': 1},
+                self.category.pk: {'can_see': 1, 'can_browse': 1},
+            }
+        })
+
+        response = self.client.get(self.category.get_absolute_url())
+        self.assertEqual(response.status_code, 200)
+
+
+class RedirectViewsTests(AdminTestCase):
+    def setUp(self):
+        super(RedirectViewsTests, self).setUp()
+        redirects_qs = Forum.objects.all_forums().filter(role='redirect')
+        self.redirect = redirects_qs[:1][0]
+
+    def test_cant_see_redirect(self):
+        """can't see redirect"""
+        override_acl(self.test_admin, {'visible_forums': []})
+
+        response = self.client.get(self.redirect.get_absolute_url())
+        self.assertEqual(response.status_code, 404)
+
+    def test_can_follow_redirect(self):
+        """can see redirect"""
+        override_acl(self.test_admin, {
+            'visible_forums': [self.redirect.parent_id, self.redirect.pk],
+            'forums': {
+                self.redirect.parent_id: {'can_see': 1, 'can_browse': 1},
+                self.redirect.pk: {'can_see': 1, 'can_browse': 1},
+            }
+        })
+
+        response = self.client.get(self.redirect.get_absolute_url())
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(response['location'], 'http://misago-project.org')
+
+        # Redirects count increased
+        updated_redirect = Forum.objects.get(id=self.redirect.pk)
+        self.assertEqual(updated_redirect.redirects_count,
+                         self.redirect.redirects_count + 1)
+
+        # Session keeps track of clicks spam
+        self.client.get(self.redirect.get_absolute_url())
+        self.client.get(self.redirect.get_absolute_url())
+        self.client.get(self.redirect.get_absolute_url())
+        self.client.get(self.redirect.get_absolute_url())
+
+        updated_redirect = Forum.objects.get(id=self.redirect.pk)
+        self.assertEqual(updated_redirect.redirects_count,
+                         self.redirect.redirects_count + 1)

misago/forums/tests/test_lists.py

@@ -0,0 +1,26 @@
+from django.test import TestCase
+
+from misago.admin.testutils import AdminTestCase
+
+from misago.forums.lists import get_forums_list, get_forum_path
+from misago.forums.models import Forum
+
+
+class GetForumListTests(AdminTestCase):
+    def test_root_forums_list_no_parent(self):
+        """get_forums_list returns all children of root nodes"""
+        self.assertEqual(len(get_forums_list(self.test_admin)), 3)
+
+    def test_root_forums_list_no_parent(self):
+        """get_forums_list returns all children of given node"""
+        for i, node in enumerate(get_forums_list(self.test_admin)):
+            child_nodes = len(get_forums_list(self.test_admin, node))
+            self.assertEqual(child_nodes, 3 - 1)
+
+
+class GetForumPathTests(TestCase):
+    def get_forum_path(self):
+        """get_forums_list returns all children of root nodes"""
+        for node in get_forums_list(self.test_admin):
+            parent_nodes = len(get_forum_path(self.test_admin, node))
+            self.assertEqual(parent_nodes, node.level - 1)

misago/forums/views/__init__.py

@@ -24,6 +24,7 @@ def forum_view(role):
 
 @forum_view('category')
 def category(request, forum):
+    allow_browse_forum(request.user, forum)
     if forum.level == 1:
         return dj_redirect(forum.get_absolute_url())
     forums = get_forums_list(request.user, forum)

misago/templates/misago/forums/category.html

@@ -35,7 +35,7 @@
     {% include "misago/forums/subforums.html" %}
   {% else %}
   <p class="lead">
-    {% trans "No forums are set or you don't have permission to see them." %}
+    {% trans "No forums are set in this category or you don't have permission to see them." %}
   </p>
   {% endif %}
 </div>

misago/users/tests/test_lists_views.py

@@ -11,9 +11,7 @@ class UsersListTestCase(AdminTestCase):
     def setUp(self):
         super(UsersListTestCase, self).setUp()
         override_acl(self.test_admin, {
-            'misago.users.permissions.profiles': {
-                'can_browse_users_list': 1
-            }
+            'can_browse_users_list': 1,
         })
 
 
@@ -21,9 +19,7 @@ class UsersListLanderTests(UsersListTestCase):
     def test_lander_no_permission(self):
         """lander returns 403 if user has no permission"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.profiles': {
-                'can_browse_users_list': 0
-            }
+            'can_browse_users_list': 0,
         })
 
         response = self.client.get(reverse('misago:users'))
@@ -64,10 +60,8 @@ class OnlineUsersTests(UsersListTestCase):
     def test_no_permission(self):
         """online list returns 403 if user has no permission"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.profiles': {
-                'can_browse_users_list': 1,
-                'can_see_users_online_list': 0,
-            }
+            'can_browse_users_list': 1,
+            'can_see_users_online_list': 0,
         })
 
         response = self.client.get(reverse('misago:users_online'))
@@ -76,10 +70,8 @@ class OnlineUsersTests(UsersListTestCase):
     def test_with_permission(self):
         """online list returns 200 if user has permission"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.profiles': {
-                'can_browse_users_list': 1,
-                'can_see_users_online_list': 1,
-            }
+            'can_browse_users_list': 1,
+            'can_see_users_online_list': 1,
         })
 
         response = self.client.get(reverse('misago:users_online'))

misago/users/tests/test_moderation_views.py

@@ -16,12 +16,15 @@ class UserModerationTestCase(AdminTestCase):
 
 
 class RenameUserTests(UserModerationTestCase):
+    def allow_rename(self):
+        override_acl(self.test_admin, {
+            'can_rename_users': 1,
+        })
+
     def test_no_rename_permission(self):
         """user with no permission fails to rename other user"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.moderation': {
-                'can_rename_users': 0,
-            },
+            'can_rename_users': 0,
         })
 
         response = self.client.get(
@@ -32,34 +35,33 @@ class RenameUserTests(UserModerationTestCase):
 
     def test_rename_user(self):
         """user with permission renames other user"""
-        override_acl(self.test_admin, {
-            'misago.users.permissions.moderation': {
-                'can_rename_users': 1,
-            }
-        })
-
+        self.allow_rename()
         response = self.client.get(
             reverse('misago:rename_user', kwargs=self.link_kwargs))
-
         self.assertEqual(response.status_code, 200)
 
+        self.allow_rename()
         response = self.client.post(
             reverse('misago:rename_user', kwargs=self.link_kwargs),
             data={'new_username': 'LoremIpsum'})
         self.assertEqual(response.status_code, 302)
 
+        self.allow_rename()
         response = self.client.post(reverse('misago:index'))
         self.assertEqual(response.status_code, 200)
         self.assertIn('Bob's username has been changed.', response.content)
 
 
 class ModerateAvatarTests(UserModerationTestCase):
-    def test_no_rename_permission(self):
+    def allow_avatar_mod(self):
+        override_acl(self.test_admin, {
+            'can_moderate_avatars': 1,
+        })
+
+    def test_no_avatar_mod_permission(self):
         """user with no permission fails to mod other user avatar"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.moderation': {
-                'can_moderate_avatars': 0,
-            },
+            'can_moderate_avatars': 0,
         })
 
         response = self.client.get(
@@ -68,18 +70,14 @@ class ModerateAvatarTests(UserModerationTestCase):
         self.assertEqual(response.status_code, 403)
         self.assertIn("You can't moderate avatars.", response.content)
 
-    def test_rename_user(self):
+    def test_mod_avatar(self):
         """user with permission moderates other user avatar"""
-        override_acl(self.test_admin, {
-            'misago.users.permissions.moderation': {
-                'can_moderate_avatars': 1,
-            }
-        })
-
+        self.allow_avatar_mod()
         response = self.client.get(
             reverse('misago:moderate_avatar', kwargs=self.link_kwargs))
         self.assertEqual(response.status_code, 200)
 
+        self.allow_avatar_mod()
         response = self.client.post(
             reverse('misago:moderate_avatar', kwargs=self.link_kwargs),
             data={
@@ -98,6 +96,7 @@ class ModerateAvatarTests(UserModerationTestCase):
         self.assertEqual(updated_user.avatar_lock_staff_message,
                          'Test st4ff message')
 
+        self.allow_avatar_mod()
         response = self.client.get(
             reverse('misago:moderate_avatar', kwargs=self.link_kwargs))
         self.assertEqual(response.status_code, 200)
@@ -106,12 +105,15 @@ class ModerateAvatarTests(UserModerationTestCase):
 
 
 class ModerateSignatureTests(UserModerationTestCase):
-    def test_no_rename_permission(self):
+    def allow_signature_mod(self):
+        override_acl(self.test_admin, {
+            'can_moderate_signatures': 1,
+        })
+
+    def test_no_signature_mod_permission(self):
         """user with no permission fails to mod other user signature"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.moderation': {
-                'can_moderate_signatures': 0,
-            },
+            'can_moderate_signatures': 0,
         })
 
         response = self.client.get(
@@ -120,18 +122,14 @@ class ModerateSignatureTests(UserModerationTestCase):
         self.assertEqual(response.status_code, 403)
         self.assertIn("You can't moderate signatures.", response.content)
 
-    def test_rename_user(self):
+    def test_mod_signature(self):
         """user with permission moderates other user signature"""
-        override_acl(self.test_admin, {
-            'misago.users.permissions.moderation': {
-                'can_moderate_signatures': 1,
-            }
-        })
-
+        self.allow_signature_mod()
         response = self.client.get(
             reverse('misago:moderate_signature', kwargs=self.link_kwargs))
         self.assertEqual(response.status_code, 200)
 
+        self.allow_signature_mod()
         response = self.client.post(
             reverse('misago:moderate_signature', kwargs=self.link_kwargs),
             data={
@@ -152,6 +150,7 @@ class ModerateSignatureTests(UserModerationTestCase):
         self.assertEqual(updated_user.signature_lock_staff_message,
                          'Test st4ff message')
 
+        self.allow_signature_mod()
         response = self.client.get(
             reverse('misago:moderate_signature', kwargs=self.link_kwargs))
         self.assertEqual(response.status_code, 200)
@@ -160,12 +159,16 @@ class ModerateSignatureTests(UserModerationTestCase):
 
 
 class BanUserTests(UserModerationTestCase):
+    def allow_ban_user(self):
+        override_acl(self.test_admin, {
+            'can_ban_users': 1,
+            'max_ban_length': 0,
+        })
+
     def test_no_ban_permission(self):
         """user with no permission fails to ban other user"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.moderation': {
-                'can_ban_users': 0,
-            },
+            'can_ban_users': 0,
         })
 
         response = self.client.get(
@@ -176,21 +179,17 @@ class BanUserTests(UserModerationTestCase):
 
     def test_ban_user(self):
         """user with permission bans other user"""
-        override_acl(self.test_admin, {
-            'misago.users.permissions.moderation': {
-                'can_ban_users': 1,
-                'max_ban_length': 0,
-            }
-        })
-
+        self.allow_ban_user()
         response = self.client.get(
             reverse('misago:ban_user', kwargs=self.link_kwargs))
         self.assertEqual(response.status_code, 200)
 
+        self.allow_ban_user()
         response = self.client.post(
             reverse('misago:ban_user', kwargs=self.link_kwargs))
         self.assertEqual(response.status_code, 302)
 
+        self.allow_ban_user()
         response = self.client.post(reverse('misago:index'))
         self.assertEqual(response.status_code, 200)
         self.assertIn('Bob has been banned.', response.content)
@@ -199,13 +198,17 @@ class BanUserTests(UserModerationTestCase):
 
 
 class LiftUserBanTests(UserModerationTestCase):
+    def allow_lift_ban(self):
+        override_acl(self.test_admin, {
+            'can_lift_bans': 1,
+            'max_lifted_ban_length': 0,
+        })
+
     def test_no_lift_ban_permission(self):
         """user with no permission fails to lift user ban"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.moderation': {
-                'can_lift_bans': 0,
-                'max_lifted_ban_length': 0,
-            },
+            'can_lift_bans': 0,
+            'max_lifted_ban_length': 0,
         })
 
         Ban.objects.create(banned_value=self.test_user.username)
@@ -218,19 +221,14 @@ class LiftUserBanTests(UserModerationTestCase):
 
     def test_lift_user_ban(self):
         """user with permission lifts other user ban"""
-        override_acl(self.test_admin, {
-            'misago.users.permissions.moderation': {
-                'can_lift_bans': 1,
-                'max_lifted_ban_length': 0,
-            }
-        })
-
         test_ban = Ban.objects.create(banned_value=self.test_user.username)
 
+        self.allow_lift_ban()
         response = self.client.post(
             reverse('misago:lift_user_ban', kwargs=self.link_kwargs))
         self.assertEqual(response.status_code, 302)
 
+        self.allow_lift_ban()
         response = self.client.post(reverse('misago:index'))
         self.assertEqual(response.status_code, 200)
         self.assertIn('ban has been lifted.', response.content)
@@ -243,10 +241,8 @@ class DeleteUserTests(UserModerationTestCase):
     def test_no_delete_permission(self):
         """user with no permission fails to delete other user"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.delete': {
-                'can_delete_users_newer_than': 0,
-                'can_delete_users_with_less_posts_than': 0,
-            },
+            'can_delete_users_newer_than': 0,
+            'can_delete_users_with_less_posts_than': 0,
         })
 
         response = self.client.post(
@@ -258,10 +254,8 @@ class DeleteUserTests(UserModerationTestCase):
     def test_delete_user(self):
         """user with permission deletes other user"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.delete': {
-                'can_delete_users_newer_than': 5,
-                'can_delete_users_with_less_posts_than': 5,
-            }
+            'can_delete_users_newer_than': 5,
+            'can_delete_users_with_less_posts_than': 5,
         })
 
         response = self.client.post(

misago/users/tests/test_profile_views.py

@@ -152,9 +152,7 @@ class UserProfileViewsTests(AdminTestCase):
     def test_user_ban(self):
         """user ban details page has no showstoppers"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.profiles': {
-                'can_see_ban_details': 0,
-            },
+            'can_see_ban_details': 0,
         })
 
         User = get_user_model()
@@ -166,9 +164,7 @@ class UserProfileViewsTests(AdminTestCase):
         self.assertEqual(response.status_code, 404)
 
         override_acl(self.test_admin, {
-            'misago.users.permissions.profiles': {
-                'can_see_ban_details': 1,
-            },
+            'can_see_ban_details': 1,
         })
 
         test_ban = Ban.objects.create(banned_value=test_user.username,

misago/users/tests/test_usercp_views.py

@@ -193,9 +193,7 @@ class EditSignatureTests(AdminTestCase):
     def test_signature_no_permission(self):
         """edit signature view with no ACL returns 404"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.account': {
-                'can_have_signature': 0,
-            }
+            'can_have_signature': 0,
         })
 
         response = self.client.get(self.view_link)
@@ -204,9 +202,7 @@ class EditSignatureTests(AdminTestCase):
     def test_signature_locked(self):
         """locked edit signature view returns 200"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.account': {
-                'can_have_signature': 1,
-            }
+            'can_have_signature': 1,
         })
 
         self.test_admin.is_signature_locked = True
@@ -220,9 +216,7 @@ class EditSignatureTests(AdminTestCase):
     def test_signature_change(self):
         """GET to usercp change options view returns 200"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.account': {
-                'can_have_signature': 1,
-            }
+            'can_have_signature': 1,
         })
 
         self.test_admin.is_signature_locked = False

misago/users/tests/test_warnings_views.py

@@ -28,6 +28,7 @@ class WarningTestCase(AdminTestCase):
         threadstore.clear()
 
     def warn_user(self, reason):
+        override_acl(self.test_admin, {'can_warn_users': 1})
         response = self.client.post(
             reverse('misago:warn_user', kwargs=self.link_kwargs),
             data={'reason': reason})
@@ -37,15 +38,11 @@ class WarnUserTests(WarningTestCase):
     def test_no_permission(self):
         """fail to warn due to permissions"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 0,
-            }
+            'can_warn_users': 0,
         })
 
         override_acl(self.test_user, {
-            'misago.users.permissions.warnings': {
-                'can_be_warned': 1,
-            }
+            'can_be_warned': 1,
         })
 
         response = self.client.get(reverse('misago:warn_user',
@@ -55,15 +52,11 @@ class WarnUserTests(WarningTestCase):
     def test_protected_user(self):
         """fail to warn due to user's can_be_warned"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 1,
-            }
+            'can_warn_users': 1,
         })
 
         override_acl(self.test_user, {
-            'misago.users.permissions.warnings': {
-                'can_be_warned': 0,
-            }
+            'can_be_warned': 0,
         })
 
         response = self.client.get(reverse('misago:warn_user',
@@ -73,15 +66,11 @@ class WarnUserTests(WarningTestCase):
     def test_warn_user(self):
         """can warn user to the roof"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 1,
-            }
+            'can_warn_users': 1,
         })
 
         override_acl(self.test_user, {
-            'misago.users.permissions.warnings': {
-                'can_be_warned': 1,
-            }
+            'can_be_warned': 1,
         })
 
         for level in self.warning_levels:
@@ -98,35 +87,30 @@ class WarnUserTests(WarningTestCase):
 
 
 class UserWarningsListTests(WarningTestCase):
-    def test_no_permission(self):
-        """can't see other user warnings"""
+    def allow_warning(self):
         override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 1,
-                'can_see_other_users_warnings': 0,
-            }
+            'can_warn_users': 1,
+            'can_see_other_users_warnings': 1,
+        })
+
+        override_acl(self.test_user, {
+            'can_be_warned': 1,
         })
 
+    def test_no_permission(self):
+        """can't see other user warnings"""
         self.warn_user('Test Warning!')
+
+        override_acl(self.test_admin, {
+            'can_see_other_users_warnings': 0,
+        })
         response = self.client.get(reverse('misago:user_warnings',
                                            kwargs=self.link_kwargs))
         self.assertEqual(response.status_code, 404)
 
     def test_see_user_warnings(self):
         """can see user warnings"""
-        override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 1,
-                'can_see_other_users_warnings': 1,
-            }
-        })
-
-        override_acl(self.test_user, {
-            'misago.users.permissions.warnings': {
-                'can_be_warned': 1,
-            }
-        })
-
+        self.allow_warning()
         response = self.client.get(reverse('misago:user_warnings',
                                            kwargs=self.link_kwargs))
         self.assertEqual(response.status_code, 200)
@@ -134,6 +118,7 @@ class UserWarningsListTests(WarningTestCase):
 
         self.warn_user('Test Warning!')
 
+        self.allow_warning()
         response = self.client.get(reverse('misago:user_warnings',
                                            kwargs=self.link_kwargs))
         self.assertEqual(response.status_code, 200)
@@ -141,14 +126,26 @@ class UserWarningsListTests(WarningTestCase):
 
 
 class CancelWarningTests(WarningTestCase):
+    def allow_cancel_owned_warning(self):
+        override_acl(self.test_admin, {
+            'can_warn_users': 1,
+            'can_see_other_users_warnings': 1,
+            'can_cancel_warnings': 1,
+        })
+
+    def allow_cancel_all_warnings(self):
+        override_acl(self.test_admin, {
+            'can_warn_users': 1,
+            'can_see_other_users_warnings': 1,
+            'can_cancel_warnings': 2,
+        })
+
     def test_no_permission(self):
         """can't cancel warnings"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 1,
-                'can_see_other_users_warnings': 1,
-                'can_cancel_warnings': 0,
-            }
+            'can_warn_users': 1,
+            'can_see_other_users_warnings': 1,
+            'can_cancel_warnings': 0,
         })
 
         warning = warn_user(self.test_admin, self.test_user)
@@ -163,15 +160,9 @@ class CancelWarningTests(WarningTestCase):
 
     def test_no_permission_other(self):
         """can't cancel other mod warnings"""
-        override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 1,
-                'can_see_other_users_warnings': 1,
-                'can_cancel_warnings': 1,
-            }
-        })
-
         warning = warn_user(self.test_user, self.test_user)
+
+        self.allow_cancel_owned_warning()
         response = self.client.post(
             reverse('misago:cancel_warning', kwargs={
                 'user_slug': 'bob',
@@ -182,6 +173,7 @@ class CancelWarningTests(WarningTestCase):
         self.assertFalse(self.test_user.warnings.get(id=warning.pk).is_canceled)
 
         warning = warn_user(self.test_admin, self.test_user)
+        self.allow_cancel_owned_warning()
         response = self.client.post(
             reverse('misago:cancel_warning', kwargs={
                 'user_slug': 'bob',
@@ -195,15 +187,9 @@ class CancelWarningTests(WarningTestCase):
 
     def test_cancel_other_and_owned_warnings(self):
         """cancel everyone's warnings"""
-        override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 1,
-                'can_see_other_users_warnings': 1,
-                'can_cancel_warnings': 2,
-            }
-        })
-
         warning = warn_user(self.test_user, self.test_user)
+
+        self.allow_cancel_all_warnings()
         response = self.client.post(
             reverse('misago:cancel_warning', kwargs={
                 'user_slug': 'bob',
@@ -214,6 +200,8 @@ class CancelWarningTests(WarningTestCase):
         self.assertTrue(self.test_user.warnings.get(id=warning.pk).is_canceled)
 
         warning = warn_user(self.test_admin, self.test_user)
+
+        self.allow_cancel_all_warnings()
         response = self.client.post(
             reverse('misago:cancel_warning', kwargs={
                 'user_slug': 'bob',
@@ -225,14 +213,26 @@ class CancelWarningTests(WarningTestCase):
 
 
 class DeleteWarningTests(WarningTestCase):
+    def allow_delete_owned_warning(self):
+        override_acl(self.test_admin, {
+            'can_warn_users': 1,
+            'can_see_other_users_warnings': 1,
+            'can_delete_warnings': 1,
+        })
+
+    def allow_delete_all_warnings(self):
+        override_acl(self.test_admin, {
+            'can_warn_users': 1,
+            'can_see_other_users_warnings': 1,
+            'can_delete_warnings': 2,
+        })
+
     def test_no_permission(self):
         """can't delete warnings"""
         override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 1,
-                'can_see_other_users_warnings': 1,
-                'can_delete_warnings': 0,
-            }
+            'can_warn_users': 1,
+            'can_see_other_users_warnings': 1,
+            'can_delete_warnings': 0,
         })
 
         warning = warn_user(self.test_admin, self.test_user)
@@ -247,15 +247,9 @@ class DeleteWarningTests(WarningTestCase):
 
     def test_no_permission_other(self):
         """can't delete other mod warnings"""
-        override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 1,
-                'can_see_other_users_warnings': 1,
-                'can_delete_warnings': 1,
-            }
-        })
-
         warning = warn_user(self.test_user, self.test_user)
+
+        self.allow_delete_owned_warning()
         response = self.client.post(
             reverse('misago:delete_warning', kwargs={
                 'user_slug': 'bob',
@@ -266,6 +260,8 @@ class DeleteWarningTests(WarningTestCase):
         self.assertEqual(self.test_user.warnings.count(), 1)
 
         warning = warn_user(self.test_admin, self.test_user)
+
+        self.allow_delete_owned_warning()
         response = self.client.post(
             reverse('misago:delete_warning', kwargs={
                 'user_slug': 'bob',
@@ -275,17 +271,11 @@ class DeleteWarningTests(WarningTestCase):
         self.assertEqual(response.status_code, 302)
         self.assertEqual(self.test_user.warnings.count(), 1)
 
-    def test_cancel_other_and_owned_warnings(self):
+    def test_delete_other_and_owned_warnings(self):
         """delete everyone's warnings"""
-        override_acl(self.test_admin, {
-            'misago.users.permissions.warnings': {
-                'can_warn_users': 1,
-                'can_see_other_users_warnings': 1,
-                'can_delete_warnings': 2,
-            }
-        })
-
         warning = warn_user(self.test_user, self.test_user)
+
+        self.allow_delete_all_warnings()
         response = self.client.post(
             reverse('misago:delete_warning', kwargs={
                 'user_slug': 'bob',
@@ -296,6 +286,8 @@ class DeleteWarningTests(WarningTestCase):
         self.assertEqual(self.test_user.warnings.count(), 0)
 
         warning = warn_user(self.test_admin, self.test_user)
+
+        self.allow_delete_all_warnings()
         response = self.client.post(
             reverse('misago:delete_warning', kwargs={
                 'user_slug': 'bob',