GroupFieldTests.test_create_not_group_admin() - Code Metrics - Inspection of "Custom fields / Validator" - ProjetSigma/backend - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#16)

unknown

created 2016-01-29 17:03 UTC

GroupFieldTests.test_create_not_group_admin() A

↳ Parent: GroupFieldTests

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	2
rs	10

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.models.group_field import GroupField
from sigma_core.models.validator import Validator
from sigma_core.tests.factories import UserFactory, GroupFieldFactory, GroupFactory, GroupMemberFactory


class GroupFieldTests(APITestCase):
    fixtures = ['fixtures_prod.json']
    @classmethod
    def setUpTestData(self):
        super(APITestCase, self).setUpTestData()

        # Routes
        self.group_field_url = "/group-field/"

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

        # Users already in group
        # User[0]: Not in Group
        # User[1]: Requested join, not accepted
        # User[2]: Group member
        # User[3]: Group admin
        self.users = [UserFactory(), UserFactory(), UserFactory(), UserFactory()]
        # Associated GroupMember
        self.group_member = [
                None,
                GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=0),
                GroupMemberFactory(user=self.users[2], group=self.group, perm_rank=1),
                GroupMemberFactory(user=self.users[3], group=self.group, perm_rank=Group.ADMINISTRATOR_RANK)
            ]
        self.validator_none = Validator.objects.all().get(html_name=Validator.VALIDATOR_NONE)
        self.group_field = GroupFieldFactory(group=self.group, validator=self.validator_none, validator_values={})

        # Misc
        self.new_field_data = {"group": self.group.id,
            "name": "Example Group Field",
            "validator": Validator.VALIDATOR_NONE,
            "validator_values": {}}

    def test_imported_validators(self):
        self.assertTrue(Validator.objects.all().filter(html_name=Validator.VALIDATOR_NONE).exists())

    #################### TEST GROUP FIELD CREATION ########################
    def try_create(self, user):
        self.client.force_authenticate(user=user)
        resp = self.client.post(self.group_field_url, self.new_field_data)
        return resp.status_code

    def test_create_not_authed(self):
        self.assertEqual(self.try_create(None), status.HTTP_401_UNAUTHORIZED)

    def test_create_not_group_member(self):
        self.assertEqual(self.try_create(self.users[0]), status.HTTP_403_FORBIDDEN)

    def test_create_not_group_accepted(self):
        self.assertEqual(self.try_create(self.users[1]), status.HTTP_403_FORBIDDEN)

    def test_create_not_group_admin(self):
        self.assertEqual(self.try_create(self.users[2]), status.HTTP_403_FORBIDDEN)

    def test_create_ok(self):
        self.assertEqual(self.try_create(self.users[3]), status.HTTP_201_CREATED)

    #################### TEST GROUP FIELD DELETION ########################
    def try_delete(self, user):
        self.client.force_authenticate(user=user)
        resp = self.client.delete(self.group_field_url + str(self.group_field.id) + "/")
        return resp.status_code

    def test_delete_not_authed(self):
        self.assertEqual(self.try_delete(None), status.HTTP_401_UNAUTHORIZED)
        self.assertTrue(GroupField.objects.all().filter(id=self.group_field.id).exists())

    def test_delete_not_group_member(self):
        self.assertEqual(self.try_delete(self.users[0]), status.HTTP_404_NOT_FOUND)
        self.assertTrue(GroupField.objects.all().filter(id=self.group_field.id).exists())

    def test_delete_not_group_accepted(self):
        self.assertEqual(self.try_delete(self.users[1]), status.HTTP_403_FORBIDDEN)
        self.assertTrue(GroupField.objects.all().filter(id=self.group_field.id).exists())

    def test_delete_not_group_admin(self):
        self.assertEqual(self.try_delete(self.users[2]), status.HTTP_403_FORBIDDEN)
        self.assertTrue(GroupField.objects.all().filter(id=self.group_field.id).exists())

    def test_delete_ok(self):
        self.assertEqual(self.try_delete(self.users[3]), status.HTTP_204_NO_CONTENT)
        self.assertFalse(GroupField.objects.all().filter(id=self.group_field.id).exists())

    #################### TEST GROUP FIELD LIST    ########################
    def test_list_not_authed(self):
        resp = self.client.get(self.group_field_url)
        self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_list_no_group(self):
        self.client.force_authenticate(user=self.users[0])
        resp = self.client.get(self.group_field_url)
        self.assertEqual(resp.status_code, status.HTTP_200_OK)
        self.assertFalse(any(resp.data))

    def test_list_in_group_not_accepted(self):
        from sigma_core.serializers.group_field import GroupFieldSerializer
        self.client.force_authenticate(user=self.users[1])
        resp = self.client.get(self.group_field_url)
        self.assertEqual(resp.status_code, status.HTTP_200_OK)
        self.assertEqual(len(resp.data), 1)
        self.assertEqual(resp.data[0], GroupFieldSerializer(self.group_field).data)

    def test_list_in_group(self):
        from sigma_core.serializers.group_field import GroupFieldSerializer
        self.client.force_authenticate(user=self.users[2])
        resp = self.client.get(self.group_field_url)
        self.assertEqual(resp.status_code, status.HTTP_200_OK)
        self.assertEqual(len(resp.data), 1)
        self.assertEqual(resp.data[0], GroupFieldSerializer(self.group_field).data)

    #################### TEST GROUP FIELD UPDATE ########################
    def try_update(self, user, allow):
        from sigma_core.serializers.group_field import GroupFieldSerializer
        group_field = GroupFieldFactory(group=self.group, validator=self.validator_none, validator_values={}, name="AAA")
        group_field_old = GroupFieldSerializer(group_field).data
        group_field_new = GroupFieldSerializer(group_field).data
        group_field_new["name"] = "BBB"

        self.client.force_authenticate(user=user)
        resp = self.client.put("%s%d/" % (self.group_field_url, group_field.id), group_field_new)
        group_field = GroupField.objects.all().get(id=group_field.id)
        if allow:
            self.assertEqual(GroupFieldSerializer(group_field).data, group_field_new)
        else:
            self.assertEqual(GroupFieldSerializer(group_field).data, group_field_old)
        return resp

    def test_update_not_authed(self):
        r = self.try_update(None, False)
        self.assertEqual(r.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_update_not_group_member(self):
        r = self.try_update(self.users[0], False)
        self.assertEqual(r.status_code, status.HTTP_404_NOT_FOUND)

    def test_update_not_accepted(self):
        r = self.try_update(self.users[1], False)
        self.assertEqual(r.status_code, status.HTTP_403_FORBIDDEN)

    def test_update_not_admin(self):
        r = self.try_update(self.users[2], False)
        self.assertEqual(r.status_code, status.HTTP_403_FORBIDDEN)

    def test_update_ok(self):
        r = self.try_update(self.users[3], True)
        self.assertEqual(r.status_code, status.HTTP_200_OK)


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.models.group_field import GroupField
12			from sigma_core.models.validator import Validator
13			from sigma_core.tests.factories import UserFactory, GroupFieldFactory, GroupFactory, GroupMemberFactory
14
15
16			class GroupFieldTests(APITestCase):
17			fixtures = ['fixtures_prod.json']
18			@classmethod
19			def setUpTestData(self):
20			super(APITestCase, self).setUpTestData()
21
22			# Routes
23			self.group_field_url = "/group-field/"
24
25			# Group open to anyone
26			self.group = GroupFactory()
27
28			# Users already in group
29			# User[0]: Not in Group
30			# User[1]: Requested join, not accepted
31			# User[2]: Group member
32			# User[3]: Group admin
33			self.users = [UserFactory(), UserFactory(), UserFactory(), UserFactory()]
34			# Associated GroupMember
35			self.group_member = [
36			None,
37			GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=0),
38			GroupMemberFactory(user=self.users[2], group=self.group, perm_rank=1),
39			GroupMemberFactory(user=self.users[3], group=self.group, perm_rank=Group.ADMINISTRATOR_RANK)
40			]
41			self.validator_none = Validator.objects.all().get(html_name=Validator.VALIDATOR_NONE)
42			self.group_field = GroupFieldFactory(group=self.group, validator=self.validator_none, validator_values={})
43
44			# Misc
45			self.new_field_data = {"group": self.group.id,
46			"name": "Example Group Field",
47			"validator": Validator.VALIDATOR_NONE,
48			"validator_values": {}}
49
50			def test_imported_validators(self):
51			self.assertTrue(Validator.objects.all().filter(html_name=Validator.VALIDATOR_NONE).exists())
52
53			#################### TEST GROUP FIELD CREATION ########################
54			def try_create(self, user):
55			self.client.force_authenticate(user=user)
56			resp = self.client.post(self.group_field_url, self.new_field_data)
57			return resp.status_code
58
59			def test_create_not_authed(self):
60			self.assertEqual(self.try_create(None), status.HTTP_401_UNAUTHORIZED)
61
62			def test_create_not_group_member(self):
63			self.assertEqual(self.try_create(self.users[0]), status.HTTP_403_FORBIDDEN)
64
65			def test_create_not_group_accepted(self):
66			self.assertEqual(self.try_create(self.users[1]), status.HTTP_403_FORBIDDEN)
67
68			def test_create_not_group_admin(self):
69			self.assertEqual(self.try_create(self.users[2]), status.HTTP_403_FORBIDDEN)
70
71			def test_create_ok(self):
72			self.assertEqual(self.try_create(self.users[3]), status.HTTP_201_CREATED)
73
74			#################### TEST GROUP FIELD DELETION ########################
75			def try_delete(self, user):
76			self.client.force_authenticate(user=user)
77			resp = self.client.delete(self.group_field_url + str(self.group_field.id) + "/")
78			return resp.status_code
79
80			def test_delete_not_authed(self):
81			self.assertEqual(self.try_delete(None), status.HTTP_401_UNAUTHORIZED)
82			self.assertTrue(GroupField.objects.all().filter(id=self.group_field.id).exists())
83
84			def test_delete_not_group_member(self):
85			self.assertEqual(self.try_delete(self.users[0]), status.HTTP_404_NOT_FOUND)
86			self.assertTrue(GroupField.objects.all().filter(id=self.group_field.id).exists())
87
88			def test_delete_not_group_accepted(self):
89			self.assertEqual(self.try_delete(self.users[1]), status.HTTP_403_FORBIDDEN)
90			self.assertTrue(GroupField.objects.all().filter(id=self.group_field.id).exists())
91
92			def test_delete_not_group_admin(self):
93			self.assertEqual(self.try_delete(self.users[2]), status.HTTP_403_FORBIDDEN)
94			self.assertTrue(GroupField.objects.all().filter(id=self.group_field.id).exists())
95
96			def test_delete_ok(self):
97			self.assertEqual(self.try_delete(self.users[3]), status.HTTP_204_NO_CONTENT)
98			self.assertFalse(GroupField.objects.all().filter(id=self.group_field.id).exists())
99
100			#################### TEST GROUP FIELD LIST ########################
101			def test_list_not_authed(self):
102			resp = self.client.get(self.group_field_url)
103			self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED)
104
105			def test_list_no_group(self):
106			self.client.force_authenticate(user=self.users[0])
107			resp = self.client.get(self.group_field_url)
108			self.assertEqual(resp.status_code, status.HTTP_200_OK)
109			self.assertFalse(any(resp.data))
110
111			def test_list_in_group_not_accepted(self):
112			from sigma_core.serializers.group_field import GroupFieldSerializer
113			self.client.force_authenticate(user=self.users[1])
114			resp = self.client.get(self.group_field_url)
115			self.assertEqual(resp.status_code, status.HTTP_200_OK)
116			self.assertEqual(len(resp.data), 1)
117			self.assertEqual(resp.data[0], GroupFieldSerializer(self.group_field).data)
118
119			def test_list_in_group(self):
120			from sigma_core.serializers.group_field import GroupFieldSerializer
121			self.client.force_authenticate(user=self.users[2])
122			resp = self.client.get(self.group_field_url)
123			self.assertEqual(resp.status_code, status.HTTP_200_OK)
124			self.assertEqual(len(resp.data), 1)
125			self.assertEqual(resp.data[0], GroupFieldSerializer(self.group_field).data)
126
127			#################### TEST GROUP FIELD UPDATE ########################
128			def try_update(self, user, allow):
129			from sigma_core.serializers.group_field import GroupFieldSerializer
130			group_field = GroupFieldFactory(group=self.group, validator=self.validator_none, validator_values={}, name="AAA")
131			group_field_old = GroupFieldSerializer(group_field).data
132			group_field_new = GroupFieldSerializer(group_field).data
133			group_field_new["name"] = "BBB"
134
135			self.client.force_authenticate(user=user)
136			resp = self.client.put("%s%d/" % (self.group_field_url, group_field.id), group_field_new)
137			group_field = GroupField.objects.all().get(id=group_field.id)
138			if allow:
139			self.assertEqual(GroupFieldSerializer(group_field).data, group_field_new)
140			else:
141			self.assertEqual(GroupFieldSerializer(group_field).data, group_field_old)
142			return resp
143
144			def test_update_not_authed(self):
145			r = self.try_update(None, False)
146			self.assertEqual(r.status_code, status.HTTP_401_UNAUTHORIZED)
147
148			def test_update_not_group_member(self):
149			r = self.try_update(self.users[0], False)
150			self.assertEqual(r.status_code, status.HTTP_404_NOT_FOUND)
151
152			def test_update_not_accepted(self):
153			r = self.try_update(self.users[1], False)
154			self.assertEqual(r.status_code, status.HTTP_403_FORBIDDEN)
155
156			def test_update_not_admin(self):
157			r = self.try_update(self.users[2], False)
158			self.assertEqual(r.status_code, status.HTTP_403_FORBIDDEN)
159
160			def test_update_ok(self):
161			r = self.try_update(self.users[3], True)
162			self.assertEqual(r.status_code, status.HTTP_200_OK)
163

ProjetSigma / backend

Pull Request — master (#16)

GroupFieldTests.test_create_not_group_admin() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like