GroupTests.test_invite_ok() - Code Metrics - Inspection of "Merge pull request #20 from ProjetSigma/feature/gr..." - ProjetSigma/backend - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d1397a...a78a43 )

unknown

created 2016-02-01 20:40 UTC

GroupTests.test_invite_ok() A

↳ Parent: GroupTests

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Metric	Value
cc	1
dl	0
loc	6
ccs	0
cts	0
cp	0
crap	2
rs	9.4285

import json

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

from sigma_core.models.group import Group
from sigma_core.serializers.group import GroupSerializer
from sigma_core.tests.factories import UserFactory, GroupFactory, GroupMemberFactory, SchoolFactory


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


class GroupTests(APITestCase):
    @classmethod
    def setUpTestData(self):
        super(GroupTests, self).setUpTestData()

        # Schools
        self.schools = SchoolFactory.create_batch(1)

        # Groups
        self.groups = GroupFactory.create_batch(2)
        self.groups[0].visibility = Group.VIS_PUBLIC
        self.groups[0].save()
        self.groups[1].visibility = Group.VIS_PRIVATE
        self.groups[1].req_rank_invite = 5
        self.groups[1].save()

        # Users
        self.users = UserFactory.create_batch(3)

        # Memberships
        self.member1 = GroupMemberFactory(user=self.users[1], group=self.groups[1], perm_rank=1)
        self.member2 = GroupMemberFactory(user=self.users[2], group=self.groups[1], perm_rank=Group.ADMINISTRATOR_RANK)
        self.student1 = GroupMemberFactory(user=self.users[0], group=self.schools[0], perm_rank=1)
        self.student2 = GroupMemberFactory(user=self.users[1], group=self.schools[0], perm_rank=Group.ADMINISTRATOR_RANK) # School admin
        self.student3 = GroupMemberFactory(user=self.users[2], group=self.schools[0], perm_rank=1)

        serializer = GroupSerializer(self.groups[0])
        self.group_data = serializer.data
        self.update_group_data = self.group_data.copy()
        self.update_group_data['name'] = "Another name"
        self.groups_url = "/group/"
        self.group_url = self.groups_url + "%d/"

        self.new_private_group_data = {"name": "New group", "type": Group.TYPE_BASIC, "visibility": Group.VIS_PRIVATE}
        self.new_association_group_data = {"name": "New group", "type": Group.TYPE_ASSO, "visibility": Group.VIS_PUBLIC, "resp_school": self.schools[0].id}
        self.invite_data = {"user": self.users[0].id}

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

    def test_get_groups_list_limited(self):

        # Client authenticated and can see public groups
        self.client.force_authenticate(user=self.users[0])
        response = self.client.get(self.groups_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertIn(self.groups[0].id, [d['id'] for d in response.data]) # User can only see groups[0]
        self.assertNotIn(self.groups[1].id, [d['id'] for d in response.data])

    def test_get_groups_list_ok(self):

        # Client has permissions
        self.client.force_authenticate(user=self.users[1])
        response = self.client.get(self.groups_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertIn(self.groups[0].id, [d['id'] for d in response.data]) # groups[0] is public and user is member of groups[1]
        self.assertIn(self.groups[1].id, [d['id'] for d in response.data])

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

    def test_get_group_forbidden(self):
        # Non-member wants to see a private group
        self.client.force_authenticate(user=self.users[0])
        response = self.client.get(self.group_url % self.groups[1].id)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_get_group_ok(self):
        # Client wants to see a public group
        self.client.force_authenticate(user=self.users[0])
        response = self.client.get(self.group_url % self.groups[0].id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data, self.group_data)

    #### Invitation requests
    def test_invite_unauthed(self):
        response = self.client.put((self.group_url + "invite/") % self.groups[1].id, self.invite_data)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_invite_forbidden(self):
        # Client has not perms to invite
        self.client.force_authenticate(user=self.users[1])
        response = self.client.put((self.group_url + "invite/") % self.groups[1].id, self.invite_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_invite_ok(self):
        # Client has perms to invite
        self.client.force_authenticate(user=self.users[2])
        response = self.client.put((self.group_url + "invite/") % self.groups[1].id, self.invite_data)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertIn(self.groups[1], reload(self.users[0]).invited_to_groups.all())

    def test_invite_duplicate(self):
        self.test_invite_ok()
        response = self.client.put((self.group_url + "invite/") % self.groups[1].id, self.invite_data)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    #### Create requests
    def test_create_unauthed(self):
        # Client is not authenticated
        response = self.client.post(self.groups_url, self.new_private_group_data)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_create_private_group(self):
        # Everybody can create a private group
        self.client.force_authenticate(user=self.users[0])
        response = self.client.post(self.groups_url, self.new_private_group_data)
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(response.data['name'], self.new_private_group_data['name'])
        self.assertEqual(response.data['visibility'], Group.VIS_PRIVATE)
        Group.objects.get(pk=response.data['id']).delete()

    def test_create_association_group_forbidden(self):
        # Only school andmins and Sigma admins can create association groups
        self.client.force_authenticate(user=self.users[0])
        response = self.client.post(self.groups_url, self.new_association_group_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_create_association_group_ok(self):
        # Only school andmins and Sigma admins can create association groups
        self.client.force_authenticate(user=self.users[1])
        response = self.client.post(self.groups_url, self.new_association_group_data)
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(response.data['type'], Group.TYPE_ASSO)
        self.assertEqual(response.data['visibility'], Group.VIS_PUBLIC)
        Group.objects.get(pk=response.data['id']).delete()

    #### Modification requests
    def test_update_unauthed(self):
        response = self.client.put(self.group_url % self.groups[1].id, self.update_group_data)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_update_forbidden(self):
        self.client.force_authenticate(user=self.users[1])
        response = self.client.put(self.group_url % self.groups[1].id, self.update_group_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_update_ok(self):
        self.client.force_authenticate(user=self.users[2])
        response = self.client.put(self.group_url % self.groups[1].id, self.update_group_data)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(reload(self.groups[1]).name, self.update_group_data['name'])

    #### Deletion requests


1	1	import json
2
3	1	from rest_framework import status
4	1	from rest_framework.test import APITestCase, force_authenticate
5
6	1	from sigma_core.models.group import Group
7	1	from sigma_core.serializers.group import GroupSerializer
8	1	from sigma_core.tests.factories import UserFactory, GroupFactory, GroupMemberFactory, SchoolFactory
9
10
11	1	def reload(obj):
12	1	return obj.__class__.objects.get(pk=obj.pk)
13
14	1
15		class GroupTests(APITestCase):
16	1	@classmethod
17	1	def setUpTestData(self):
18		super(GroupTests, self).setUpTestData()
19	1
20	1	# Schools
21	1	self.schools = SchoolFactory.create_batch(1)
22
23	1	# Groups
24		self.groups = GroupFactory.create_batch(2)
25	1	self.groups[0].visibility = Group.VIS_PUBLIC
26		self.groups[0].save()
27		self.groups[1].visibility = Group.VIS_PRIVATE
28	1	self.groups[1].req_rank_invite = 5
29		self.groups[1].save()
30	1
31	1	# Users
32		self.users = UserFactory.create_batch(3)
33
34		# Memberships
35		self.member1 = GroupMemberFactory(user=self.users[1], group=self.groups[1], perm_rank=1)
36		self.member2 = GroupMemberFactory(user=self.users[2], group=self.groups[1], perm_rank=Group.ADMINISTRATOR_RANK)
37		self.student1 = GroupMemberFactory(user=self.users[0], group=self.schools[0], perm_rank=1)
38		self.student2 = GroupMemberFactory(user=self.users[1], group=self.schools[0], perm_rank=Group.ADMINISTRATOR_RANK) # School admin
39	1	self.student3 = GroupMemberFactory(user=self.users[2], group=self.schools[0], perm_rank=1)
40
41	1	serializer = GroupSerializer(self.groups[0])
42	1	self.group_data = serializer.data
43	1	self.update_group_data = self.group_data.copy()
44	1	self.update_group_data['name'] = "Another name"
45		self.groups_url = "/group/"
46		self.group_url = self.groups_url + "%d/"
47	1
48		self.new_private_group_data = {"name": "New group", "type": Group.TYPE_BASIC, "visibility": Group.VIS_PRIVATE}
49	1	self.new_association_group_data = {"name": "New group", "type": Group.TYPE_ASSO, "visibility": Group.VIS_PUBLIC, "resp_school": self.schools[0].id}
50	1	self.invite_data = {"user": self.users[0].id}
51
52		#### List requests
53		def test_get_groups_list_unauthed(self):
54		# Client not authenticated
55		response = self.client.get(self.groups_url)
56	1	self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
57
58	1	def test_get_groups_list_limited(self):
		0 ignored issues – show Duplication introduced 2016-01-31 21:25 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
59	1	# Client authenticated and can see public groups
60	1	self.client.force_authenticate(user=self.users[0])
61	1	response = self.client.get(self.groups_url)
62		self.assertEqual(response.status_code, status.HTTP_200_OK)
63		self.assertIn(self.groups[0].id, [d['id'] for d in response.data]) # User can only see groups[0]
64		self.assertNotIn(self.groups[1].id, [d['id'] for d in response.data])
65
66		def test_get_groups_list_ok(self):
		0 ignored issues – show Duplication introduced 2016-01-31 21:25 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
67		# Client has permissions
68		self.client.force_authenticate(user=self.users[1])
69		response = self.client.get(self.groups_url)
70		self.assertEqual(response.status_code, status.HTTP_200_OK)
71		self.assertIn(self.groups[0].id, [d['id'] for d in response.data]) # groups[0] is public and user is member of groups[1]
72		self.assertIn(self.groups[1].id, [d['id'] for d in response.data])
73
74		#### Get requests
75		def test_get_group_unauthed(self):
76		# Client is not authenticated
77		response = self.client.get(self.group_url % self.groups[0].id)
78		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
79
80		def test_get_group_forbidden(self):
81		# Non-member wants to see a private group
82		self.client.force_authenticate(user=self.users[0])
83		response = self.client.get(self.group_url % self.groups[1].id)
84		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
85
86		def test_get_group_ok(self):
87		# Client wants to see a public group
88		self.client.force_authenticate(user=self.users[0])
89		response = self.client.get(self.group_url % self.groups[0].id)
90		self.assertEqual(response.status_code, status.HTTP_200_OK)
91		self.assertEqual(response.data, self.group_data)
92
93		#### Invitation requests
94		def test_invite_unauthed(self):
95		response = self.client.put((self.group_url + "invite/") % self.groups[1].id, self.invite_data)
96		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
97
98		def test_invite_forbidden(self):
99		# Client has not perms to invite
100		self.client.force_authenticate(user=self.users[1])
101		response = self.client.put((self.group_url + "invite/") % self.groups[1].id, self.invite_data)
102		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
103
104		def test_invite_ok(self):
105		# Client has perms to invite
106		self.client.force_authenticate(user=self.users[2])
107		response = self.client.put((self.group_url + "invite/") % self.groups[1].id, self.invite_data)
108		self.assertEqual(response.status_code, status.HTTP_200_OK)
109		self.assertIn(self.groups[1], reload(self.users[0]).invited_to_groups.all())
110
111		def test_invite_duplicate(self):
112		self.test_invite_ok()
113		response = self.client.put((self.group_url + "invite/") % self.groups[1].id, self.invite_data)
114		self.assertEqual(response.status_code, status.HTTP_200_OK)
115
116		#### Create requests
117		def test_create_unauthed(self):
118		# Client is not authenticated
119		response = self.client.post(self.groups_url, self.new_private_group_data)
120		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
121
122		def test_create_private_group(self):
123		# Everybody can create a private group
124		self.client.force_authenticate(user=self.users[0])
125		response = self.client.post(self.groups_url, self.new_private_group_data)
126		self.assertEqual(response.status_code, status.HTTP_201_CREATED)
127		self.assertEqual(response.data['name'], self.new_private_group_data['name'])
128		self.assertEqual(response.data['visibility'], Group.VIS_PRIVATE)
129		Group.objects.get(pk=response.data['id']).delete()
130
131		def test_create_association_group_forbidden(self):
132		# Only school andmins and Sigma admins can create association groups
133		self.client.force_authenticate(user=self.users[0])
134		response = self.client.post(self.groups_url, self.new_association_group_data)
135		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
136
137		def test_create_association_group_ok(self):
138		# Only school andmins and Sigma admins can create association groups
139		self.client.force_authenticate(user=self.users[1])
140		response = self.client.post(self.groups_url, self.new_association_group_data)
141		self.assertEqual(response.status_code, status.HTTP_201_CREATED)
142		self.assertEqual(response.data['type'], Group.TYPE_ASSO)
143		self.assertEqual(response.data['visibility'], Group.VIS_PUBLIC)
144		Group.objects.get(pk=response.data['id']).delete()
145
146		#### Modification requests
147		def test_update_unauthed(self):
148		response = self.client.put(self.group_url % self.groups[1].id, self.update_group_data)
149		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
150
151		def test_update_forbidden(self):
152		self.client.force_authenticate(user=self.users[1])
153		response = self.client.put(self.group_url % self.groups[1].id, self.update_group_data)
154		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
155
156		def test_update_ok(self):
157		self.client.force_authenticate(user=self.users[2])
158		response = self.client.put(self.group_url % self.groups[1].id, self.update_group_data)
159		self.assertEqual(response.status_code, status.HTTP_200_OK)
160		self.assertEqual(reload(self.groups[1]).name, self.update_group_data['name'])
161
162		#### Deletion requests
163

ProjetSigma / backend

Push — master ( d1397a...a78a43 )

GroupTests.test_invite_ok() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like