ProjetSigma /
backend
| Total Complexity | 36 |
| Total Lines | 288 |
| Duplicated Lines | 23.96 % |
| Changes | 1 | ||
| Bugs | 0 | Features | 0 |
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
| 1 | from rest_framework import status |
||
| 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): |
|
|
Duplication
introduced
by
|
|||
| 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): |
|
| 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): |
|
| 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): |
|
| 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): |
|
| 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): |
|
| 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): |
|
| 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): |
|
| 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): |
|
| 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 |
Loading history...