Misago/misago/threads/tests/test_post_mentions.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.contrib.auth import get_user_model
from django.core.urlresolvers import reverse
from django.test.client import BOUNDARY, MULTIPART_CONTENT, encode_multipart

from misago.acl.testutils import override_acl
from misago.categories.models import Category
from misago.markup.mentions import MENTIONS_LIMIT
from misago.users.testutils import AuthenticatedUserTestCase

from .. import testutils


class PostMentionsTests(AuthenticatedUserTestCase):
    def setUp(self):
        super(PostMentionsTests, self).setUp()

        self.category = Category.objects.get(slug='first-category')
        self.thread = testutils.post_thread(category=self.category)
        self.override_acl()

        self.post_link = reverse('misago:api:thread-post-list', kwargs={
            'thread_pk': self.thread.pk
        })

    def override_acl(self):
        new_acl = self.user.acl
        new_acl['categories'][self.category.pk].update({
            'can_see': 1,
            'can_browse': 1,
            'can_start_threads': 1,
            'can_reply_threads': 1,
            'can_edit_posts': 1
        })

        override_acl(self.user, new_acl)

    def put(self, url, data=None):
        content = encode_multipart(BOUNDARY, data or {})
        return self.client.put(url, content, content_type=MULTIPART_CONTENT)

    def test_mention_noone(self):
        """endpoint handles no mentions in post"""
        response = self.client.post(self.post_link, data={
            'post': "This is test response!"
        })
        self.assertEqual(response.status_code, 200)

        post = self.user.post_set.order_by('-id')[:1][0]
        self.assertEqual(post.mentions.count(), 0)

    def test_mention_nonexistant(self):
        """endpoint handles nonexistant mention"""
        response = self.client.post(self.post_link, data={
            'post': "This is test response, @InvalidUser!"
        })
        self.assertEqual(response.status_code, 200)

        post = self.user.post_set.order_by('-id')[:1][0]
        self.assertEqual(post.mentions.count(), 0)

    def test_mention_self(self):
        """endpoint mentions author"""
        response = self.client.post(self.post_link, data={
            'post': "This is test response, @{}!".format(self.user)
        })
        self.assertEqual(response.status_code, 200)

        post = self.user.post_set.order_by('-id')[:1][0]

        self.assertEqual(post.mentions.count(), 1)
        self.assertEqual(post.mentions.all()[0], self.user)

    def test_mention_limit(self):
        """endpoint mentions limits mentions to 24 users"""
        users = []

        User = get_user_model()
        for i in range(MENTIONS_LIMIT + 5):
            users.append(User.objects.create_user(
                'Mention{}'.format(i),
                'mention{}@bob.com'.format(i),
                'pass123'
            ))

        mentions = ['@{}'.format(u) for u in users]
        response = self.client.post(self.post_link, data={
            'post': "This is test response, {}!".format(', '.join(mentions))
        })
        self.assertEqual(response.status_code, 200)

        post = self.user.post_set.order_by('-id')[:1][0]

        self.assertEqual(post.mentions.count(), 24)
        self.assertEqual(list(post.mentions.order_by('id')), users[:24])

    def test_mention_update(self):
        """edit post endpoint updates mentions"""
        User = get_user_model()
        user_a = User.objects.create_user('Mention', 'mention@test.com', 'pass123')
        user_b = User.objects.create_user('MentionB', 'mentionb@test.com', 'pass123')

        response = self.client.post(self.post_link, data={
            'post': "This is test response, @{}!".format(user_a)
        })
        self.assertEqual(response.status_code, 200)

        post = self.user.post_set.order_by('-id')[:1][0]

        self.assertEqual(post.mentions.count(), 1)
        self.assertEqual(post.mentions.all()[0], user_a)

        # add mention to post
        edit_link = reverse('misago:api:thread-post-detail', kwargs={
            'thread_pk': self.thread.pk,
            'pk': post.pk
        })

        self.override_acl()
        response = self.put(edit_link, data={
            'post': "This is test response, @{} and @{}!".format(user_a, user_b)
        })
        self.assertEqual(response.status_code, 200)

        self.assertEqual(post.mentions.count(), 2)
        self.assertEqual(list(post.mentions.all()), [user_a, user_b])

        # remove first mention from post - should preserve mentions
        self.override_acl()
        response = self.put(edit_link, data={
            'post': "This is test response, @{}!".format(user_b)
        })
        self.assertEqual(response.status_code, 200)

        self.assertEqual(post.mentions.count(), 2)
        self.assertEqual(list(post.mentions.all()), [user_a, user_b])

        # remove mentions from post - should preserve mentions
        self.override_acl()
        response = self.put(edit_link, data={
            'post': "This is test response!"
        })
        self.assertEqual(response.status_code, 200)

        self.assertEqual(post.mentions.count(), 2)
        self.assertEqual(list(post.mentions.all()), [user_a, user_b])

    def test_mentions_merge(self):
        """posts merge sums mentions"""
        User = get_user_model()
        user_a = User.objects.create_user('Mention', 'mention@test.com', 'pass123')
        user_b = User.objects.create_user('MentionB', 'mentionb@test.com', 'pass123')

        response = self.client.post(self.post_link, data={
            'post': "This is test response, @{}!".format(user_a)
        })
        self.assertEqual(response.status_code, 200)

        post_a = self.user.post_set.order_by('-id')[:1][0]

        self.assertEqual(post_a.mentions.count(), 1)
        self.assertEqual(list(post_a.mentions.all()), [user_a])

        # post second reply
        self.user.last_post_on = None
        self.user.save()

        response = self.client.post(self.post_link, data={
            'post': "This is test response, @{} and @{}!".format(user_a, user_b)
        })
        self.assertEqual(response.status_code, 200)

        post_b = self.user.post_set.order_by('-id')[:1][0]

        # merge posts and validate that post A has all mentions
        post_b.merge(post_a)

        self.assertEqual(post_a.mentions.count(), 2)
        self.assertEqual(list(post_a.mentions.all()), [user_a, user_b])