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

Completed

Push — master ( 14185c...203d73 )

by Camille

created 2016-02-01 09:53 UTC

GroupTests.test_create_association_group_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	8
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())

    #### 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		#### Create requests
112		def test_create_unauthed(self):
113		# Client is not authenticated
114		response = self.client.post(self.groups_url, self.new_private_group_data)
115		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
116
117		def test_create_private_group(self):
118		# Everybody can create a private group
119		self.client.force_authenticate(user=self.users[0])
120		response = self.client.post(self.groups_url, self.new_private_group_data)
121		self.assertEqual(response.status_code, status.HTTP_201_CREATED)
122		self.assertEqual(response.data['name'], self.new_private_group_data['name'])
123		self.assertEqual(response.data['visibility'], Group.VIS_PRIVATE)
124		Group.objects.get(pk=response.data['id']).delete()
125
126		def test_create_association_group_forbidden(self):
127		# Only school andmins and Sigma admins can create association groups
128		self.client.force_authenticate(user=self.users[0])
129		response = self.client.post(self.groups_url, self.new_association_group_data)
130		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
131
132		def test_create_association_group_ok(self):
133		# Only school andmins and Sigma admins can create association groups
134		self.client.force_authenticate(user=self.users[1])
135		response = self.client.post(self.groups_url, self.new_association_group_data)
136		self.assertEqual(response.status_code, status.HTTP_201_CREATED)
137		self.assertEqual(response.data['type'], Group.TYPE_ASSO)
138		self.assertEqual(response.data['visibility'], Group.VIS_PUBLIC)
139		Group.objects.get(pk=response.data['id']).delete()
140
141		#### Modification requests
142		def test_update_unauthed(self):
143		response = self.client.put(self.group_url % self.groups[1].id, self.update_group_data)
144		self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
145
146		def test_update_forbidden(self):
147		self.client.force_authenticate(user=self.users[1])
148		response = self.client.put(self.group_url % self.groups[1].id, self.update_group_data)
149		self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
150
151		def test_update_ok(self):
152		self.client.force_authenticate(user=self.users[2])
153		response = self.client.put(self.group_url % self.groups[1].id, self.update_group_data)
154		self.assertEqual(response.status_code, status.HTTP_200_OK)
155		self.assertEqual(reload(self.groups[1]).name, self.update_group_data['name'])
156
157		#### Deletion requests
158

ProjetSigma / backend

Push — master ( 14185c...203d73 )

GroupTests.test_create_association_group_ok() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like