Misago/misago/threads/tests/test_post_mentions.py

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

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

UserModel = get_user_model()


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

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

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

    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').last()
        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').last()
        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, @%s!" % self.user,
            }
        )
        self.assertEqual(response.status_code, 200)

        post = self.user.post_set.order_by('id').last()

        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 = []

        for i in range(MENTIONS_LIMIT + 5):
            users.append(
                UserModel.objects.
                create_user('Mention%s' % i, 'mention%s@bob.com' % i, 'pass123')
            )

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

        post = self.user.post_set.order_by('id').last()

        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_a = UserModel.objects.create_user('Mention', 'mention@test.com', 'pass123')
        user_b = UserModel.objects.create_user('MentionB', 'mentionb@test.com', 'pass123')

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

        post = self.user.post_set.order_by('id').last()

        self.assertEqual(post.mentions.count(), 1)
        self.assertEqual(post.mentions.order_by('id')[0], user_a)

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

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

        self.assertEqual(post.mentions.count(), 2)
        self.assertEqual(list(post.mentions.order_by('id')), [user_a, user_b])

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

        self.assertEqual(post.mentions.count(), 2)
        self.assertEqual(list(post.mentions.order_by('id')), [user_a, user_b])

        # remove mentions from post - should preserve mentions
        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.order_by('id')), [user_a, user_b])

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

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

        post_a = self.user.post_set.order_by('id').last()

        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, @%s and @%s!" % (user_a, user_b),
            }
        )
        self.assertEqual(response.status_code, 200)

        post_b = self.user.post_set.order_by('id').last()

        # 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.order_by('id')), [user_a, user_b])