tests suite for starting private thread

misago/templates/misago/profile/header.html

@@ -20,7 +20,7 @@
     {% trans "Message" %}
   </button>
   {% elif not is_authenticated_user %}
-  <button class="btn btn-default tooltip-bottom pull-left" disabled="disabled" title="{{ cant_message_reason }}">
+  <button class="btn btn-default btn-message tooltip-bottom pull-left" disabled="disabled" title="{{ cant_message_reason }}">
     <span class="fa fa-envelope-o"></span>
     {% trans "Message" %}
   </button>

misago/templates/misago/thread/post.html

@@ -87,7 +87,7 @@
         <div class="panel-body">
           <article class="post-body misago-markup">
             {{ post.parsed|safe }}
-          <article>
+          </article>
         </div>
         {% else %}
         <div class="alert alert-danger">

misago/threads/permissions/privatethreads.py

@@ -176,7 +176,7 @@ def allow_message_user(user, target):
     if not user.acl['can_start_private_threads']:
         raise PermissionDenied(_("You can't start private threads."))
 
-    message_format = {'user': user.username}
+    message_format = {'user': target.username}
 
     if not can_use_private_threads(target):
         message = _("%(user)s can't participate in private threads.")

misago/threads/tests/test_messageuser_view.py

@@ -0,0 +1,225 @@
+import json
+
+from django.contrib.auth import get_user_model
+from django.core.urlresolvers import reverse
+
+from misago.acl.testutils import override_acl
+from misago.users.testutils import AuthenticatedUserTestCase
+
+from misago.threads.models import ThreadParticipant
+
+
+class MessageUserTests(AuthenticatedUserTestCase):
+    ajax_header = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
+    field_name = ('misago.threads.posting.participants.'
+                  'ThreadParticipantsFormMiddleware-users')
+
+    def setUp(self):
+        super(MessageUserTests, self).setUp()
+
+        User = get_user_model()
+        self.test_user = User.objects.create_user(
+            "Bob", "bob@boberson.com", "Pass.123")
+
+    def override_acl(self, user, acl=None):
+        base_acl = {
+            'can_use_private_threads': True,
+            'can_start_private_threads': True
+        }
+        if acl:
+            base_acl.update(acl)
+        override_acl(user, base_acl)
+
+    def test_empty_form_handling(self):
+        """empty form isn't borking"""
+        self.override_acl(self.user)
+        response = self.client.post(
+            reverse('misago:start_private_thread'),
+            data={'submit': '1'},
+            **self.ajax_header)
+        self.assertEqual(response.status_code, 200)
+
+    def test_cant_message_self(self):
+        """user cant message himself"""
+        self.override_acl(self.user)
+        response = self.client.get(self.user.get_absolute_url())
+        self.assertEqual(response.status_code, 200)
+        self.assertNotIn('btn-message', response.content)
+        self.assertNotIn(reverse('misago:start_private_thread'),
+                         response.content)
+
+        self.override_acl(self.user)
+        response = self.client.post(
+            reverse('misago:start_private_thread'),
+            data={
+                'title': 'Jingo Jango!',
+                'post': 'Lorem ipsum dolor met.',
+                self.field_name: self.user.username,
+                'submit': '1',
+            },
+            **self.ajax_header)
+        self.assertEqual(response.status_code, 200)
+
+        response_json = json.loads(response.content)
+        self.assertEqual("You can't addres message to yourself.",
+                         response_json['errors'][0])
+
+    def test_cant_message_nobody(self):
+        """user cant message nobody"""
+        self.override_acl(self.user)
+        response = self.client.post(
+            reverse('misago:start_private_thread'),
+            data={
+                'title': 'Jingo Jango!',
+                'post': 'Lorem ipsum dolor met.',
+                self.field_name: '',
+                'submit': '1',
+            },
+            **self.ajax_header)
+        self.assertEqual(response.status_code, 200)
+
+        response_json = json.loads(response.content)
+        self.assertEqual("You have to specify message recipients.",
+                         response_json['errors'][0])
+
+    def test_cant_message_other_user(self):
+        """cant message user that can't use private threads"""
+        self.override_acl(self.user)
+        self.override_acl(self.test_user, {'can_use_private_threads': False})
+
+        response = self.client.get(self.test_user.get_absolute_url())
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('btn-message', response.content)
+        self.assertIn('participate in private threads.', response.content)
+        self.assertNotIn(reverse('misago:start_private_thread'),
+                         response.content)
+
+        self.override_acl(self.user)
+        self.override_acl(self.test_user, {'can_use_private_threads': False})
+        response = self.client.post(
+            reverse('misago:start_private_thread'),
+            data={
+                'title': 'Jingo Jango!',
+                'post': 'Lorem ipsum dolor met.',
+                self.field_name: self.test_user.username,
+                'submit': '1',
+            },
+            **self.ajax_header)
+        self.assertEqual(response.status_code, 200)
+
+        response_json = json.loads(response.content)
+        self.assertEqual("Bob can't participate in private threads.",
+                         response_json['errors'][0])
+
+    def test_cant_message_blocking_user(self):
+        """cant message user that blocks us"""
+        self.override_acl(self.user, {
+            'can_add_everyone_to_private_threads': False
+        })
+        self.override_acl(self.test_user)
+
+        self.test_user.blocks.add(self.user)
+
+        response = self.client.get(self.test_user.get_absolute_url())
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('btn-message', response.content)
+        self.assertIn('Bob is blocking you.', response.content)
+        self.assertNotIn(reverse('misago:start_private_thread'),
+                         response.content)
+
+        self.override_acl(self.user, {
+            'can_add_everyone_to_private_threads': False
+        })
+        self.override_acl(self.test_user)
+        response = self.client.post(
+            reverse('misago:start_private_thread'),
+            data={
+                'title': 'Jingo Jango!',
+                'post': 'Lorem ipsum dolor met.',
+                self.field_name: self.test_user.username,
+                'submit': '1',
+            },
+            **self.ajax_header)
+        self.assertEqual(response.status_code, 200)
+
+        response_json = json.loads(response.content)
+        self.assertEqual("Bob is blocking you.",
+                         response_json['errors'][0])
+
+    def test_cant_message_nonexistant_users(self):
+        """cant message users that don't exist"""
+        self.override_acl(self.user)
+        response = self.client.post(
+            reverse('misago:start_private_thread'),
+            data={
+                'title': 'Jingo Jango!',
+                'post': 'Lorem ipsum dolor met.',
+                self.field_name: 'hatsune, miku',
+                'submit': '1',
+            },
+            **self.ajax_header)
+        self.assertEqual(response.status_code, 200)
+
+        response_json = json.loads(response.content)
+        self.assertEqual("One or more message recipients could "
+                         "not be found: hatsune, miku",
+                         response_json['errors'][0])
+
+    def test_cant_message_too_many_users(self):
+        """cant message too many users"""
+        self.override_acl(self.user, {'max_private_thread_participants': 2})
+        response = self.client.post(
+            reverse('misago:start_private_thread'),
+            data={
+                'title': 'Jingo Jango!',
+                'post': 'Lorem ipsum dolor met.',
+                self.field_name: 'hatsune, miku, yui',
+                'submit': '1',
+            },
+            **self.ajax_header)
+        self.assertEqual(response.status_code, 200)
+
+        response_json = json.loads(response.content)
+        self.assertEqual("You can't start private thread "
+                         "with more than than 2 users.",
+                         response_json['errors'][0])
+
+    def test_can_message_other_user(self):
+        """can message other user"""
+        self.override_acl(self.user)
+        self.override_acl(self.test_user)
+
+        response = self.client.get(self.test_user.get_absolute_url())
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('btn-message', response.content)
+        self.assertIn(reverse('misago:start_private_thread'), response.content)
+
+        self.override_acl(self.user)
+        self.override_acl(self.test_user)
+        response = self.client.post(
+            reverse('misago:start_private_thread'),
+            data={
+                'title': 'Jingo Jango!',
+                'post': 'Lorem ipsum dolor met.',
+                self.field_name: self.test_user.username,
+                'submit': '1',
+            },
+            **self.ajax_header)
+        self.assertEqual(response.status_code, 200)
+
+        response_json = json.loads(response.content)
+        post_url = response_json['post_url']
+
+        self.override_acl(self.user)
+        response = self.client.get(post_url)
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('Jingo Jango!', response.content)
+        self.assertIn('Lorem ipsum dolor met.', response.content)
+
+        thread = self.user.thread_set.order_by('-id').last()
+        self.assertEqual(thread.title, 'Jingo Jango!')
+
+        self.assertEqual(self.user,
+                         thread.threadparticipant_set.get(is_owner=True).user)
+        self.assertEqual(self.test_user,
+                         thread.threadparticipant_set.get(is_owner=False).user)