ChatMemberTests.test_update_forbidden2() - Code Metrics - Inspection of "App chat" - ProjetSigma/backend - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#29)

unknown

created 2016-11-27 18:49 UTC

ChatMemberTests.test_update_forbidden2() A

↳ Parent: ChatMemberTests

Complexity

Conditions

Size

Total Lines

Duplication

Lines	6
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	6
loc	6
rs	9.4285
cc	1

from rest_framework import status
from rest_framework.test import APITestCase, force_authenticate

from sigma_core.tests.factories import UserFactory, AdminUserFactory

from sigma_chat.tests.factories import ChatFactory, ChatMemberFactory

from sigma_chat.models.chat_member import ChatMember


def reload(obj):
    return obj.__class__.objects.get(pk=obj.pk)


class ChatMemberTests(APITestCase):
    def setUp(self):
        # Summary: 6 users + 1 admin, 2 chats
        # User #7 is Sigma admin
        # User #1 is creator of chat #1, User #3 is member of chat #1, User #4 is admin of chat #1, User #5 has been banned from chat #1, User#6 has left chat #1
        # User #2 is creator of chat #2

        super(ChatMemberTests, self).setUpTestData()
        self.users = UserFactory.create_batch(7) + [AdminUserFactory()]
        self.chats = ChatFactory.create_batch(2)
        self.chatmembers = [
            ChatMemberFactory(is_creator=True, is_admin=True, chat=self.chats[0], user=self.users[0]),
            ChatMemberFactory(is_creator=True, is_admin=True, chat=self.chats[1], user=self.users[1]),
            ChatMemberFactory(is_creator=False, is_admin=False, chat=self.chats[0], user=self.users[2]),
            ChatMemberFactory(is_creator=False, is_admin=True, chat=self.chats[0], user=self.users[3]),
            ChatMemberFactory(is_creator=False, is_admin=False, is_member=False, is_banned=True, chat=self.chats[0], user=self.users[4]),
            ChatMemberFactory(is_creator=False, is_admin=False, is_member=False, chat=self.chats[0], user=self.users[5])
        ]

        self.chatmembers_url = "/chatmember/"
        self.chatmember_url = self.chatmembers_url + "%d/"
        self.create_chatmember_url = "/chat/{0}/add_member/"
        self.change_role_chatmember_url = "/chat/{0}/change_role/"

        self.new_chatmember_data = {"user": self.users[0].id, "chat": self.chats[1].id, "is_creator": False, "is_admin": False}
        self.new_chatmember_data_right_way = {"user_id": self.users[0].id}

        self.new_chatmember_data = {"user": self.users[0].id, "chat": self.chats[1].id, "is_creator": False, "is_admin": False}
        self.new_chatmember_data_right_way = {"user_id": self.users[0].id}


#### Model methods test
    def test_model_chatmember(self):
        self.assertEqual(len(self.chatmembers), 6)
        self.assertEqual(len(self.chats[0].chatmember.all()), 5)
        self.assertEqual(len(self.chats[1].chatmember.all()), 1)
        # Test that user 1 is creator of chat 1
        self.assertTrue(self.chats[0].chatmember.get(pk=1).is_creator)
        self.assertTrue(self.chats[0].chatmember.get(pk=1).is_admin)
        self.assertTrue(self.chats[0].chatmember.get(pk=1).is_member)
        self.assertFalse(self.chats[0].chatmember.get(pk=1).is_banned)
        # Test that user 2 is creator of chat 2
        self.assertTrue(self.chats[1].chatmember.get(pk=2).is_creator)
        self.assertTrue(self.chats[1].chatmember.get(pk=2).is_admin)
        self.assertTrue(self.chats[1].chatmember.get(pk=2).is_member)
        self.assertFalse(self.chats[1].chatmember.get(pk=2).is_banned)
        # Test that user 2 is only member of chat 2
        self.assertFalse(self.chats[0].chatmember.get(pk=3).is_creator)
        self.assertFalse(self.chats[0].chatmember.get(pk=3).is_admin)
        self.assertTrue(self.chats[0].chatmember.get(pk=3).is_member)
        self.assertFalse(self.chats[0].chatmember.get(pk=3).is_banned)

#### List requests
    def test_get_chatmembers_list_unauthed(self):
        # Client not authenticated
        response = self.client.get(self.chatmembers_url)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_get_chatmembers_list_limited(self):
        # Client authenticated and can see limited list of chatmembers
        self.client.force_authenticate(user=self.users[0])
        response = self.client.get(self.chatmembers_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data), 5)

    def test_get_chatmembers_list_limited2(self):
        # Client authenticated and can see limited list of chatmembers
        self.client.force_authenticate(user=self.users[1])
        response = self.client.get(self.chatmembers_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data), 1)

    def test_get_chatmembers_list_limited3(self):
        # Client authenticated and can see limited list of chatmembers
        self.client.force_authenticate(user=self.users[2])
        response = self.client.get(self.chatmembers_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data), 5)

    def test_get_chatmembers_list_limited4(self):
        # Client authenticated and can see limited list of chatmembers
        self.client.force_authenticate(user=self.users[6])
        response = self.client.get(self.chatmembers_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data), 0)

    def test_get_chatmembers_list_admin(self):
        # Admin authenticated and can see limited list of chatmembers
        self.client.force_authenticate(user=self.users[-1])
        response = self.client.get(self.chatmembers_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data), 0)

#### Get requests
    def test_get_chatmember_unauthed(self):
        # Client is not authenticated
        response = self.client.get(self.chatmember_url % self.chats[0].id)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_get_chatmember_self(self):
        # Client can see its chatmembers
        self.client.force_authenticate(user=self.users[0])
        response = self.client.get(self.chatmember_url % self.chatmembers[0].id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data), 8) # ChatMember has 8 fields

    def test_get_chatmember_not_self(self):
        # Client cannot see chatmember if he's not a member of the chat it belongs to
        self.client.force_authenticate(user=self.users[1])
        response = self.client.get(self.chatmember_url % self.chats[0].id)
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

#### Create requests
    def test_create_unauthed(self):
        # Client is not authenticated
        response = self.client.post(self.chatmembers_url, self.new_chatmember_data)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))

    # Only admin on the chat can create a chatmember for this chat, but on the chat's page
    def test_create_chatmember_not_admin_wrong_way(self):
        self.client.force_authenticate(user=self.users[0])
        response = self.client.post(self.chatmembers_url, self.new_chatmember_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))

    def test_create_chatmember_not_member_wrong_way(self):
        self.client.force_authenticate(user=self.users[2])
        response = self.client.post(self.chatmembers_url, self.new_chatmember_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))

    def test_create_chatmember_admin_wrong_way(self):
        self.client.force_authenticate(user=self.users[1])
        response = self.client.post(self.chatmembers_url, self.new_chatmember_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))


    def test_create_chatmember_wrong_method_right_way(self):
        self.client.force_authenticate(user=self.users[0])
        response = self.client.get(self.create_chatmember_url.format(self.chats[1].id))
        self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))

    def test_create_chatmember_non_existent_chat_right_way(self):
        self.client.force_authenticate(user=self.users[0])
        response = self.client.post(self.create_chatmember_url.format(10), self.new_chatmember_data_right_way)
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))

    def test_create_chatmember_non_existent_user_right_way(self):
        self.client.force_authenticate(user=self.users[0])
        self.new_chatmember_data_right_way['user_id'] = 10
        response = self.client.post(self.create_chatmember_url.format(self.chats[1].id), self.new_chatmember_data_right_way)
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))

    def test_create_chatmember_not_admin_right_way(self):
        self.client.force_authenticate(user=self.users[0])
        response = self.client.post(self.create_chatmember_url.format(self.chats[1].id), self.new_chatmember_data_right_way)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))

    def test_create_chatmember_not_member_right_way(self):
        self.client.force_authenticate(user=self.users[2])
        response = self.client.post(self.create_chatmember_url.format(self.chats[1].id), self.new_chatmember_data_right_way)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))

    def test_create_chatmember_already_member_right_way(self):
        self.client.force_authenticate(user=self.users[1])
        self.new_chatmember_data_right_way['user_id'] = self.users[1].id
        response = self.client.post(self.create_chatmember_url.format(self.chats[1].id), self.new_chatmember_data_right_way)
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))

    def test_create_chatmember_admin_right_way(self):
        self.client.force_authenticate(user=self.users[1])
        response = self.client.post(self.create_chatmember_url.format(self.chats[1].id), self.new_chatmember_data_right_way)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers) + 1)

#### Modification requests
    def test_update_wrong_way(self):

        # Has to use the change_role function to change a ChatMember
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.chatmember_url % self.chatmembers[2].id, {'role': "admin", "chatmember_id": 3})
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(reload(self.chatmembers[2]), self.chatmembers[2])

    def test_update_unauthed(self):
        # Unauthed client cannot update a chatmember
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 3})
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
        self.assertEqual(reload(self.chatmembers[2]), self.chatmembers[2])

    def test_update_forbidden(self):

        # Client cannot update a chatmember if he isn't admin of the associated chat
        self.client.force_authenticate(user=self.users[2])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 3})
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
        self.assertEqual(reload(self.chatmembers[2]), self.chatmembers[2])

    def test_update_forbidden2(self):

        # Client cannot update a chatmember if it is the creator of the associated chat
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 1})
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(reload(self.chatmembers[0]), self.chatmembers[0])

    def test_update_forbidden3(self):

        # Client cannot update a chatmember if it is not a member of the right chat
        self.client.force_authenticate(user=self.users[1])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 3})
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
        self.assertEqual(reload(self.chatmembers[2]), self.chatmembers[2])

    def test_update_non_existent_chat(self):
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.change_role_chatmember_url.format(10), {'role': "admin", "chatmember_id": 3})
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
        self.assertEqual(reload(self.chatmembers[2]), self.chatmembers[2])

    def test_update_non_existent_chatmember(self):
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 10})
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

    def test_update_ok_admin(self):

        # Client can update a chatmember if he has clearance
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 3})
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertFalse(reload(self.chatmembers[2]).is_creator)
        self.assertTrue(reload(self.chatmembers[2]).is_admin)
        self.assertTrue(reload(self.chatmembers[2]).is_member)
        self.assertFalse(reload(self.chatmembers[2]).is_banned)

    def test_update_ok_member_from_admin(self):

        # Client can update a chatmember if he has clearance
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "member", "chatmember_id": 4})
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertFalse(reload(self.chatmembers[3]).is_creator)
        self.assertFalse(reload(self.chatmembers[3]).is_admin)
        self.assertTrue(reload(self.chatmembers[3]).is_member)
        self.assertFalse(reload(self.chatmembers[3]).is_banned)

    def test_update_ok_ragequit(self):

        # Client can update a chatmember if he has clearance
        self.client.force_authenticate(user=self.users[2])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "leave", "chatmember_id": 3})
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertFalse(reload(self.chatmembers[2]).is_creator)
        self.assertFalse(reload(self.chatmembers[2]).is_admin)
        self.assertFalse(reload(self.chatmembers[2]).is_member)
        self.assertFalse(reload(self.chatmembers[2]).is_banned)

    def test_update_not_self_ragequit(self):
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "leave", "chatmember_id": 3})
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_update_ok_come_back(self):

        # Client can update a chatmember if he has clearance
        self.client.force_authenticate(user=self.users[5])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "member", "chatmember_id": 6})
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertFalse(reload(self.chatmembers[5]).is_creator)
        self.assertFalse(reload(self.chatmembers[5]).is_admin)
        self.assertTrue(reload(self.chatmembers[5]).is_member)
        self.assertFalse(reload(self.chatmembers[5]).is_banned)

    def test_update_not_self_come_back(self):
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "member", "chatmember_id": 6})
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_update_ok_unban(self):

        # Client can update a chatmember if he has clearance
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "member", "chatmember_id": 5})
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertFalse(reload(self.chatmembers[4]).is_creator)
        self.assertFalse(reload(self.chatmembers[4]).is_admin)
        self.assertTrue(reload(self.chatmembers[4]).is_member)
        self.assertFalse(reload(self.chatmembers[4]).is_banned)


1		from rest_framework import status
2		from rest_framework.test import APITestCase, force_authenticate
3
4		from sigma_core.tests.factories import UserFactory, AdminUserFactory
5
6		from sigma_chat.tests.factories import ChatFactory, ChatMemberFactory
7
8		from sigma_chat.models.chat_member import ChatMember
9
10
11		def reload(obj):
12		return obj.__class__.objects.get(pk=obj.pk)
13
14
15		class ChatMemberTests(APITestCase):
16		def setUp(self):
17		# Summary: 6 users + 1 admin, 2 chats
18		# User #7 is Sigma admin
19		# User #1 is creator of chat #1, User #3 is member of chat #1, User #4 is admin of chat #1, User #5 has been banned from chat #1, User#6 has left chat #1
20		# User #2 is creator of chat #2
21
22		super(ChatMemberTests, self).setUpTestData()
23		self.users = UserFactory.create_batch(7) + [AdminUserFactory()]
24		self.chats = ChatFactory.create_batch(2)
25		self.chatmembers = [
26		ChatMemberFactory(is_creator=True, is_admin=True, chat=self.chats[0], user=self.users[0]),
27		ChatMemberFactory(is_creator=True, is_admin=True, chat=self.chats[1], user=self.users[1]),
28		ChatMemberFactory(is_creator=False, is_admin=False, chat=self.chats[0], user=self.users[2]),
29		ChatMemberFactory(is_creator=False, is_admin=True, chat=self.chats[0], user=self.users[3]),
30		ChatMemberFactory(is_creator=False, is_admin=False, is_member=False, is_banned=True, chat=self.chats[0], user=self.users[4]),
31		ChatMemberFactory(is_creator=False, is_admin=False, is_member=False, chat=self.chats[0], user=self.users[5])
32		]
33
34		self.chatmembers_url = "/chatmember/"
35		self.chatmember_url = self.chatmembers_url + "%d/"
36		self.create_chatmember_url = "/chat/{0}/add_member/"
37		self.change_role_chatmember_url = "/chat/{0}/change_role/"
38
39		self.new_chatmember_data = {"user": self.users[0].id, "chat": self.chats[1].id, "is_creator": False, "is_admin": False}
40		self.new_chatmember_data_right_way = {"user_id": self.users[0].id}
41
42		self.new_chatmember_data = {"user": self.users[0].id, "chat": self.chats[1].id, "is_creator": False, "is_admin": False}
43		self.new_chatmember_data_right_way = {"user_id": self.users[0].id}
44
45
46		#### Model methods test
47		def test_model_chatmember(self):
48		self.assertEqual(len(self.chatmembers), 6)
49		self.assertEqual(len(self.chats[0].chatmember.all()), 5)
50		self.assertEqual(len(self.chats[1].chatmember.all()), 1)
51		# Test that user 1 is creator of chat 1
52		self.assertTrue(self.chats[0].chatmember.get(pk=1).is_creator)
53		self.assertTrue(self.chats[0].chatmember.get(pk=1).is_admin)
54		self.assertTrue(self.chats[0].chatmember.get(pk=1).is_member)
55		self.assertFalse(self.chats[0].chatmember.get(pk=1).is_banned)
56		# Test that user 2 is creator of chat 2
57		self.assertTrue(self.chats[1].chatmember.get(pk=2).is_creator)
58		self.assertTrue(self.chats[1].chatmember.get(pk=2).is_admin)
59		self.assertTrue(self.chats[1].chatmember.get(pk=2).is_member)
60		self.assertFalse(self.chats[1].chatmember.get(pk=2).is_banned)
61		# Test that user 2 is only member of chat 2
62		self.assertFalse(self.chats[0].chatmember.get(pk=3).is_creator)
63		self.assertFalse(self.chats[0].chatmember.get(pk=3).is_admin)
64		self.assertTrue(self.chats[0].chatmember.get(pk=3).is_member)
65		self.assertFalse(self.chats[0].chatmember.get(pk=3).is_banned)
66
67		#### List requests
68		def test_get_chatmembers_list_unauthed(self):
69		# Client not authenticated
70		response = self.client.get(self.chatmembers_url)
71		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
72
73		def test_get_chatmembers_list_limited(self):
74		# Client authenticated and can see limited list of chatmembers
75		self.client.force_authenticate(user=self.users[0])
76		response = self.client.get(self.chatmembers_url)
77		self.assertEqual(response.status_code, status.HTTP_200_OK)
78		self.assertEqual(len(response.data), 5)
79
80		def test_get_chatmembers_list_limited2(self):
81		# Client authenticated and can see limited list of chatmembers
82		self.client.force_authenticate(user=self.users[1])
83		response = self.client.get(self.chatmembers_url)
84		self.assertEqual(response.status_code, status.HTTP_200_OK)
85		self.assertEqual(len(response.data), 1)
86
87		def test_get_chatmembers_list_limited3(self):
88		# Client authenticated and can see limited list of chatmembers
89		self.client.force_authenticate(user=self.users[2])
90		response = self.client.get(self.chatmembers_url)
91		self.assertEqual(response.status_code, status.HTTP_200_OK)
92		self.assertEqual(len(response.data), 5)
93
94		def test_get_chatmembers_list_limited4(self):
95		# Client authenticated and can see limited list of chatmembers
96		self.client.force_authenticate(user=self.users[6])
97		response = self.client.get(self.chatmembers_url)
98		self.assertEqual(response.status_code, status.HTTP_200_OK)
99		self.assertEqual(len(response.data), 0)
100
101		def test_get_chatmembers_list_admin(self):
102		# Admin authenticated and can see limited list of chatmembers
103		self.client.force_authenticate(user=self.users[-1])
104		response = self.client.get(self.chatmembers_url)
105		self.assertEqual(response.status_code, status.HTTP_200_OK)
106		self.assertEqual(len(response.data), 0)
107
108		#### Get requests
109		def test_get_chatmember_unauthed(self):
110		# Client is not authenticated
111		response = self.client.get(self.chatmember_url % self.chats[0].id)
112		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
113
114		def test_get_chatmember_self(self):
115		# Client can see its chatmembers
116		self.client.force_authenticate(user=self.users[0])
117		response = self.client.get(self.chatmember_url % self.chatmembers[0].id)
118		self.assertEqual(response.status_code, status.HTTP_200_OK)
119		self.assertEqual(len(response.data), 8) # ChatMember has 8 fields
120
121		def test_get_chatmember_not_self(self):
122		# Client cannot see chatmember if he's not a member of the chat it belongs to
123		self.client.force_authenticate(user=self.users[1])
124		response = self.client.get(self.chatmember_url % self.chats[0].id)
125		self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
126
127		#### Create requests
128		def test_create_unauthed(self):
129		# Client is not authenticated
130		response = self.client.post(self.chatmembers_url, self.new_chatmember_data)
131		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
132		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))
133
134		# Only admin on the chat can create a chatmember for this chat, but on the chat's page
135		def test_create_chatmember_not_admin_wrong_way(self):
136		self.client.force_authenticate(user=self.users[0])
137		response = self.client.post(self.chatmembers_url, self.new_chatmember_data)
138		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
139		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))
140
141		def test_create_chatmember_not_member_wrong_way(self):
142		self.client.force_authenticate(user=self.users[2])
143		response = self.client.post(self.chatmembers_url, self.new_chatmember_data)
144		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
145		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))
146
147		def test_create_chatmember_admin_wrong_way(self):
148		self.client.force_authenticate(user=self.users[1])
149		response = self.client.post(self.chatmembers_url, self.new_chatmember_data)
150		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
151		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))
152
153
154		def test_create_chatmember_wrong_method_right_way(self):
155		self.client.force_authenticate(user=self.users[0])
156		response = self.client.get(self.create_chatmember_url.format(self.chats[1].id))
157		self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
158		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))
159
160		def test_create_chatmember_non_existent_chat_right_way(self):
161		self.client.force_authenticate(user=self.users[0])
162		response = self.client.post(self.create_chatmember_url.format(10), self.new_chatmember_data_right_way)
163		self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
164		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))
165
166		def test_create_chatmember_non_existent_user_right_way(self):
167		self.client.force_authenticate(user=self.users[0])
168		self.new_chatmember_data_right_way['user_id'] = 10
169		response = self.client.post(self.create_chatmember_url.format(self.chats[1].id), self.new_chatmember_data_right_way)
170		self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
171		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))
172
173		def test_create_chatmember_not_admin_right_way(self):
174		self.client.force_authenticate(user=self.users[0])
175		response = self.client.post(self.create_chatmember_url.format(self.chats[1].id), self.new_chatmember_data_right_way)
176		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
177		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))
178
179		def test_create_chatmember_not_member_right_way(self):
180		self.client.force_authenticate(user=self.users[2])
181		response = self.client.post(self.create_chatmember_url.format(self.chats[1].id), self.new_chatmember_data_right_way)
182		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
183		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))
184
185		def test_create_chatmember_already_member_right_way(self):
186		self.client.force_authenticate(user=self.users[1])
187		self.new_chatmember_data_right_way['user_id'] = self.users[1].id
188		response = self.client.post(self.create_chatmember_url.format(self.chats[1].id), self.new_chatmember_data_right_way)
189		self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
190		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers))
191
192		def test_create_chatmember_admin_right_way(self):
193		self.client.force_authenticate(user=self.users[1])
194		response = self.client.post(self.create_chatmember_url.format(self.chats[1].id), self.new_chatmember_data_right_way)
195		self.assertEqual(response.status_code, status.HTTP_200_OK)
196		self.assertEqual(ChatMember.objects.all().count(), len(self.chatmembers) + 1)
197
198		#### Modification requests
199	View Code Duplication	def test_update_wrong_way(self):
		0 ignored issues – show Duplication introduced 2016-11-27 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
200		# Has to use the change_role function to change a ChatMember
201		self.client.force_authenticate(user=self.users[0])
202		response = self.client.put(self.chatmember_url % self.chatmembers[2].id, {'role': "admin", "chatmember_id": 3})
203		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
204		self.assertEqual(reload(self.chatmembers[2]), self.chatmembers[2])
205
206		def test_update_unauthed(self):
207		# Unauthed client cannot update a chatmember
208		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 3})
209		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
210		self.assertEqual(reload(self.chatmembers[2]), self.chatmembers[2])
211
212	View Code Duplication	def test_update_forbidden(self):
		0 ignored issues – show Duplication introduced 2016-11-27 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
213		# Client cannot update a chatmember if he isn't admin of the associated chat
214		self.client.force_authenticate(user=self.users[2])
215		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 3})
216		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
217		self.assertEqual(reload(self.chatmembers[2]), self.chatmembers[2])
218
219	View Code Duplication	def test_update_forbidden2(self):
		0 ignored issues – show Duplication introduced 2016-11-27 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
220		# Client cannot update a chatmember if it is the creator of the associated chat
221		self.client.force_authenticate(user=self.users[0])
222		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 1})
223		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
224		self.assertEqual(reload(self.chatmembers[0]), self.chatmembers[0])
225
226	View Code Duplication	def test_update_forbidden3(self):
		0 ignored issues – show Duplication introduced 2016-11-27 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
227		# Client cannot update a chatmember if it is not a member of the right chat
228		self.client.force_authenticate(user=self.users[1])
229		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 3})
230		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
231		self.assertEqual(reload(self.chatmembers[2]), self.chatmembers[2])
232
233		def test_update_non_existent_chat(self):
234		self.client.force_authenticate(user=self.users[0])
235		response = self.client.put(self.change_role_chatmember_url.format(10), {'role': "admin", "chatmember_id": 3})
236		self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
237		self.assertEqual(reload(self.chatmembers[2]), self.chatmembers[2])
238
239		def test_update_non_existent_chatmember(self):
240		self.client.force_authenticate(user=self.users[0])
241		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 10})
242		self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
243
244	View Code Duplication	def test_update_ok_admin(self):
		0 ignored issues – show Duplication introduced 2016-11-27 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
245		# Client can update a chatmember if he has clearance
246		self.client.force_authenticate(user=self.users[0])
247		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "admin", "chatmember_id": 3})
248		self.assertEqual(response.status_code, status.HTTP_200_OK)
249		self.assertFalse(reload(self.chatmembers[2]).is_creator)
250		self.assertTrue(reload(self.chatmembers[2]).is_admin)
251		self.assertTrue(reload(self.chatmembers[2]).is_member)
252		self.assertFalse(reload(self.chatmembers[2]).is_banned)
253
254	View Code Duplication	def test_update_ok_member_from_admin(self):
		0 ignored issues – show Duplication introduced 2016-11-27 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
255		# Client can update a chatmember if he has clearance
256		self.client.force_authenticate(user=self.users[0])
257		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "member", "chatmember_id": 4})
258		self.assertEqual(response.status_code, status.HTTP_200_OK)
259		self.assertFalse(reload(self.chatmembers[3]).is_creator)
260		self.assertFalse(reload(self.chatmembers[3]).is_admin)
261		self.assertTrue(reload(self.chatmembers[3]).is_member)
262		self.assertFalse(reload(self.chatmembers[3]).is_banned)
263
264	View Code Duplication	def test_update_ok_ragequit(self):
		0 ignored issues – show Duplication introduced 2016-11-27 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
265		# Client can update a chatmember if he has clearance
266		self.client.force_authenticate(user=self.users[2])
267		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "leave", "chatmember_id": 3})
268		self.assertEqual(response.status_code, status.HTTP_200_OK)
269		self.assertFalse(reload(self.chatmembers[2]).is_creator)
270		self.assertFalse(reload(self.chatmembers[2]).is_admin)
271		self.assertFalse(reload(self.chatmembers[2]).is_member)
272		self.assertFalse(reload(self.chatmembers[2]).is_banned)
273
274		def test_update_not_self_ragequit(self):
275		self.client.force_authenticate(user=self.users[0])
276		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "leave", "chatmember_id": 3})
277		self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
278
279	View Code Duplication	def test_update_ok_come_back(self):
		0 ignored issues – show Duplication introduced 2016-11-27 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
280		# Client can update a chatmember if he has clearance
281		self.client.force_authenticate(user=self.users[5])
282		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "member", "chatmember_id": 6})
283		self.assertEqual(response.status_code, status.HTTP_200_OK)
284		self.assertFalse(reload(self.chatmembers[5]).is_creator)
285		self.assertFalse(reload(self.chatmembers[5]).is_admin)
286		self.assertTrue(reload(self.chatmembers[5]).is_member)
287		self.assertFalse(reload(self.chatmembers[5]).is_banned)
288
289		def test_update_not_self_come_back(self):
290		self.client.force_authenticate(user=self.users[0])
291		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "member", "chatmember_id": 6})
292		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
293
294	View Code Duplication	def test_update_ok_unban(self):
		0 ignored issues – show Duplication introduced 2016-11-27 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
295		# Client can update a chatmember if he has clearance
296		self.client.force_authenticate(user=self.users[0])
297		response = self.client.put(self.change_role_chatmember_url.format(self.chats[0].id), {'role': "member", "chatmember_id": 5})
298		self.assertEqual(response.status_code, status.HTTP_200_OK)
299		self.assertFalse(reload(self.chatmembers[4]).is_creator)
300		self.assertFalse(reload(self.chatmembers[4]).is_admin)
301		self.assertTrue(reload(self.chatmembers[4]).is_member)
302		self.assertFalse(reload(self.chatmembers[4]).is_banned)
303

ProjetSigma / backend

Pull Request — master (#29)

ChatMemberTests.test_update_forbidden2() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like