RequestGroupMemberCreationTests.test_create_success() - Code Metrics - Inspection of "Feature/group invites" - ProjetSigma/backend - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#20)

unknown

created 2016-02-01 19:24 UTC

test_create_success() A

↳ Parent: RequestGroupMemberCreationTests

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	6
rs	9.4285

import json

from django.core import mail

from rest_framework import status
from rest_framework.test import APITestCase

from sigma_core.models.user import User
from sigma_core.models.group import Group
from sigma_core.models.group_member import GroupMember
from sigma_core.serializers.user import DetailedUserSerializer as UserSerializer
from sigma_core.tests.factories import UserFactory, AdminUserFactory, GroupFactory, GroupMemberFactory


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

        # Routes
        self.members_url = "/group-member/"
        self.member_url = self.members_url + "%d/"

        # Group open to anyone
        self.group = GroupFactory()
        self.group.default_member_rank = 1
        self.group.save()

        # Users already in group
        self.users = [UserFactory()]
        # Associated GroupMember
        self.group_member1 = GroupMember(user=self.users[0], group=self.group, perm_rank=Group.ADMINISTRATOR_RANK)

        # Testing user
        self.user = UserFactory()

        # Misc
        self.new_membership_data = {"group": self.group.id, "user": self.user.id}

    def test_create_not_authed(self):
        self.client.force_authenticate(user=None)
        response = self.client.post(self.members_url, self.new_membership_data)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_create_not_for_self(self):
        # Attempt to add somebody else to a group
        self.client.force_authenticate(user=self.users[0])
        response = self.client.post(self.members_url, self.new_membership_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_create_success(self):
        # Succesful attempt to join an open group
        self.client.force_authenticate(user=self.user)
        response = self.client.post(self.members_url, self.new_membership_data)
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(response.data['perm_rank'], self.group.default_member_rank)


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

        # Routes
        self.members_url = "/group-member/"
        self.accept_join_requests_url = self.members_url + "%d/accept_join_request/"

        # Group with membership request
        self.group = GroupFactory(default_member_rank=0, req_rank_accept_join_requests=5)

        # Users already in group
        self.users = UserFactory.create_batch(3)
        # Associated GroupMember
        self.group_member1 = GroupMemberFactory(user=self.users[0], group=self.group, perm_rank=Group.ADMINISTRATOR_RANK) # can validate requests
        self.group_member2 = GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=1) # cannot validate requests
        self.group_member3 = GroupMemberFactory(user=self.users[2], group=self.group, perm_rank=0) # request to be validated

        # Testing user
        self.user = UserFactory()

        # Misc
        self.new_membership_data = {"group": self.group.id, "user": self.user.id}

    def test_create_not_authed(self):
        self.client.force_authenticate(user=None)
        response = self.client.post(self.members_url, self.new_membership_data)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_create_success(self):
        # Succesful attempt to request group membership
        self.client.force_authenticate(user=self.user)
        response = self.client.post(self.members_url, self.new_membership_data)
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(response.data['perm_rank'], self.group.default_member_rank)

    def test_validate_forbidden(self):
        # Attempt to validate a request but not enough permission
        self.client.force_authenticate(user=self.users[1])
        response = self.client.put(self.accept_join_requests_url % self.group_member3.id)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_validate_success(self):
        # Succesful attempt to validate a request
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.accept_join_requests_url % self.group_member3.id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['perm_rank'], 1)


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

        # Routes
        self.members_url = "/group-member/"

        # Group with invitation only
        self.group = GroupFactory(req_rank_invite=5, default_member_rank=-1, visibility=Group.VIS_PRIVATE)

        # Testing user
        self.users = UserFactory.create_batch(2)
        self.memberships = [
            None,
            GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=self.group.req_rank_invite)
        ]

        # Misc
        self.new_membership_data = {"group": self.group.id, "user": self.users[0].id}

    def test_create_not_authed(self):
        self.client.force_authenticate(user=None)
        response = self.client.post(self.members_url, self.new_membership_data)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_create_forbidden(self):
        # Can't join this Group
        self.client.force_authenticate(user=self.users[0])
        response = self.client.post(self.members_url, self.new_membership_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_create_already_group_member(self):
        self.client.force_authenticate(user=self.users[1])
        response = self.client.post(self.members_url, self.new_membership_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_create_self_forbidden(self):
        self.client.force_authenticate(user=self.users[1])
        response = self.client.post(self.members_url, self.new_membership_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)


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

        # Routes
        self.members_url = "/group-member/"
        self.group_invite_url = "/group/%d/invite/";
        self.group_invite_accept_url = "/group/%d/invite_accept/";

        # Group with invitation only
        self.group = GroupFactory(req_rank_invite=5, default_member_rank=-1)

        # Testing user
        self.users = UserFactory.create_batch(2)
        self.memberships = [
            None,
            GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=self.group.req_rank_invite)
        ]

    def test_invite_not_authed(self):
        self.client.force_authenticate(user=None)
        response = self.client.put(self.group_invite_url % (self.group.id), {"user": self.users[0].id} )
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_invite_forbidden(self):
        # Attempt to get group membership
        self.client.force_authenticate(user=self.users[0])
        response = self.client.put(self.group_invite_url % (self.group.id), {"user": self.users[0].id} )
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_invite_already_group_member(self):
        # Attempt to get group membership
        self.client.force_authenticate(user=self.users[1])
        response = self.client.put(self.group_invite_url % (self.group.id), {"user": self.users[1].id} )
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_invite_ok(self):
        # User0 invites User1 to group
        self.client.force_authenticate(user=self.users[1])
        response = self.client.put(self.group_invite_url % (self.group.id), {"user": self.users[0].id} )
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_invite_accept(self):
        self.test_invite_ok()
        self.client.force_authenticate(user=self.users[0])
        response = self.client.post(self.members_url, {"user": self.users[0].id, "group": self.group.id})
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)


1			import json
2
3			from django.core import mail
4
5			from rest_framework import status
6			from rest_framework.test import APITestCase
7
8			from sigma_core.models.user import User
9			from sigma_core.models.group import Group
10			from sigma_core.models.group_member import GroupMember
11			from sigma_core.serializers.user import DetailedUserSerializer as UserSerializer
12			from sigma_core.tests.factories import UserFactory, AdminUserFactory, GroupFactory, GroupMemberFactory
13
14
15			class OpenGroupMemberCreationTests(APITestCase):
16			@classmethod
17			def setUpTestData(self):
18			super(APITestCase, self).setUpTestData()
19
20			# Routes
21			self.members_url = "/group-member/"
22			self.member_url = self.members_url + "%d/"
23
24			# Group open to anyone
25			self.group = GroupFactory()
26			self.group.default_member_rank = 1
27			self.group.save()
28
29			# Users already in group
30			self.users = [UserFactory()]
31			# Associated GroupMember
32			self.group_member1 = GroupMember(user=self.users[0], group=self.group, perm_rank=Group.ADMINISTRATOR_RANK)
33
34			# Testing user
35			self.user = UserFactory()
36
37			# Misc
38			self.new_membership_data = {"group": self.group.id, "user": self.user.id}
39
40			def test_create_not_authed(self):
41			self.client.force_authenticate(user=None)
42			response = self.client.post(self.members_url, self.new_membership_data)
43			self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
44
45			def test_create_not_for_self(self):
46			# Attempt to add somebody else to a group
47			self.client.force_authenticate(user=self.users[0])
48			response = self.client.post(self.members_url, self.new_membership_data)
49			self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
50
51			def test_create_success(self):
52			# Succesful attempt to join an open group
53			self.client.force_authenticate(user=self.user)
54			response = self.client.post(self.members_url, self.new_membership_data)
55			self.assertEqual(response.status_code, status.HTTP_201_CREATED)
56			self.assertEqual(response.data['perm_rank'], self.group.default_member_rank)
57
58
59			class RequestGroupMemberCreationTests(APITestCase):
60			@classmethod
61			def setUpTestData(self):
62			super(APITestCase, self).setUpTestData()
63
64			# Routes
65			self.members_url = "/group-member/"
66			self.accept_join_requests_url = self.members_url + "%d/accept_join_request/"
67
68			# Group with membership request
69			self.group = GroupFactory(default_member_rank=0, req_rank_accept_join_requests=5)
70
71			# Users already in group
72			self.users = UserFactory.create_batch(3)
73			# Associated GroupMember
74			self.group_member1 = GroupMemberFactory(user=self.users[0], group=self.group, perm_rank=Group.ADMINISTRATOR_RANK) # can validate requests
75			self.group_member2 = GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=1) # cannot validate requests
76			self.group_member3 = GroupMemberFactory(user=self.users[2], group=self.group, perm_rank=0) # request to be validated
77
78			# Testing user
79			self.user = UserFactory()
80
81			# Misc
82			self.new_membership_data = {"group": self.group.id, "user": self.user.id}
83
84			def test_create_not_authed(self):
85			self.client.force_authenticate(user=None)
86			response = self.client.post(self.members_url, self.new_membership_data)
87			self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
88
89			def test_create_success(self):
90			# Succesful attempt to request group membership
91			self.client.force_authenticate(user=self.user)
92			response = self.client.post(self.members_url, self.new_membership_data)
93			self.assertEqual(response.status_code, status.HTTP_201_CREATED)
94			self.assertEqual(response.data['perm_rank'], self.group.default_member_rank)
95
96			def test_validate_forbidden(self):
97			# Attempt to validate a request but not enough permission
98			self.client.force_authenticate(user=self.users[1])
99			response = self.client.put(self.accept_join_requests_url % self.group_member3.id)
100			self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
101
102			def test_validate_success(self):
103			# Succesful attempt to validate a request
104			self.client.force_authenticate(user=self.users[0])
105			response = self.client.put(self.accept_join_requests_url % self.group_member3.id)
106			self.assertEqual(response.status_code, status.HTTP_200_OK)
107			self.assertEqual(response.data['perm_rank'], 1)
108
109
110			class InvitationGroupMemberCreationTests(APITestCase):
111			@classmethod
112			def setUpTestData(self):
113			super(APITestCase, self).setUpTestData()
114
115			# Routes
116			self.members_url = "/group-member/"
117
118			# Group with invitation only
119			self.group = GroupFactory(req_rank_invite=5, default_member_rank=-1, visibility=Group.VIS_PRIVATE)
120
121			# Testing user
122			self.users = UserFactory.create_batch(2)
123			self.memberships = [
124			None,
125			GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=self.group.req_rank_invite)
126			]
127
128			# Misc
129			self.new_membership_data = {"group": self.group.id, "user": self.users[0].id}
130
131			def test_create_not_authed(self):
132			self.client.force_authenticate(user=None)
133			response = self.client.post(self.members_url, self.new_membership_data)
134			self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
135
136			def test_create_forbidden(self):
137			# Can't join this Group
138			self.client.force_authenticate(user=self.users[0])
139			response = self.client.post(self.members_url, self.new_membership_data)
140			self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
141
142			def test_create_already_group_member(self):
143			self.client.force_authenticate(user=self.users[1])
144			response = self.client.post(self.members_url, self.new_membership_data)
145			self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
146
147			def test_create_self_forbidden(self):
148			self.client.force_authenticate(user=self.users[1])
149			response = self.client.post(self.members_url, self.new_membership_data)
150			self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
151
152
153			class InvitationGroupMemberInvitationWorkflowTests(APITestCase):
154			@classmethod
155			def setUpTestData(self):
156			super(APITestCase, self).setUpTestData()
157
158			# Routes
159			self.members_url = "/group-member/"
160			self.group_invite_url = "/group/%d/invite/";
161			self.group_invite_accept_url = "/group/%d/invite_accept/";
162
163			# Group with invitation only
164			self.group = GroupFactory(req_rank_invite=5, default_member_rank=-1)
165
166			# Testing user
167			self.users = UserFactory.create_batch(2)
168			self.memberships = [
169			None,
170			GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=self.group.req_rank_invite)
171			]
172
173			def test_invite_not_authed(self):
174			self.client.force_authenticate(user=None)
175			response = self.client.put(self.group_invite_url % (self.group.id), {"user": self.users[0].id} )
176			self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
177
178			def test_invite_forbidden(self):
179			# Attempt to get group membership
180			self.client.force_authenticate(user=self.users[0])
181			response = self.client.put(self.group_invite_url % (self.group.id), {"user": self.users[0].id} )
182			self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
183
184			def test_invite_already_group_member(self):
185			# Attempt to get group membership
186			self.client.force_authenticate(user=self.users[1])
187			response = self.client.put(self.group_invite_url % (self.group.id), {"user": self.users[1].id} )
188			self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
189
190			def test_invite_ok(self):
191			# User0 invites User1 to group
192			self.client.force_authenticate(user=self.users[1])
193			response = self.client.put(self.group_invite_url % (self.group.id), {"user": self.users[0].id} )
194			self.assertEqual(response.status_code, status.HTTP_200_OK)
195
196			def test_invite_accept(self):
197			self.test_invite_ok()
198			self.client.force_authenticate(user=self.users[0])
199			response = self.client.post(self.members_url, {"user": self.users[0].id, "group": self.group.id})
200			self.assertEqual(response.status_code, status.HTTP_201_CREATED)
201

ProjetSigma / backend

Pull Request — master (#20)

test_create_success() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like