GroupFieldTests.setUpTestData() - 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 22:09 UTC

GroupFieldTests.setUpTestData() A

↳ Parent: GroupFieldTests

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	56
rs	9.7251

How to fix Long Method

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_member_value import GroupMemberValue
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, GroupMemberValueFactory


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

        # Routes
        self.group_field_url = "/group-member-value/"

        # Create the base Group
        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(), 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),
            GroupMemberFactory(user=self.users[4], group=self.group, perm_rank=0)
        ]
        # Let's add some custom fields to this Group
        self.validator_none = Validator.objects.all().get(html_name=Validator.VALIDATOR_NONE)
        self.validator_text = Validator.objects.all().get(html_name=Validator.VALIDATOR_TEXT)
        self.group_fields = [
            # First field does not require any validation
            GroupFieldFactory(group=self.group, validator=self.validator_none, validator_values={}),
            # Second field must be in the email format
            GroupFieldFactory(group=self.group,
                validator=self.validator_text,
                validator_values={"regex": "[^@]+@[^@]+\.[^@]+", "message": "Invalid email"}),
            GroupFieldFactory(group=self.group, validator=self.validator_none, validator_values={}),
        ]

        # And we need a second group
        self.group2 = GroupFactory()
        self.group2_user2 = GroupMemberFactory(user=self.users[4], group=self.group2, perm_rank=1)
        self.group2_fields = [
            # First field does not require any validation
            GroupFieldFactory(group=self.group2, validator=self.validator_none, validator_values={}),
            # Second field must be in the email format
            GroupFieldFactory(group=self.group2,
                validator=self.validator_text,
                validator_values={"regex": "[^@]+@[^@]+\.[^@]+", "message": "Invalid email"}),
            GroupFieldFactory(group=self.group2, validator=self.validator_none, validator_values={}),
        ]

        # Create some values
        GroupMemberValueFactory(field=self.group2_fields[0], membership=self.group2_user2, value="TextFieldValue1")
        GroupMemberValueFactory(field=self.group2_fields[1], membership=self.group2_user2, value="[email protected]")
        GroupMemberValueFactory(field=self.group_fields[2], membership=self.group_member[2], value="Field3Value__user2")
        GroupMemberValueFactory(field=self.group_fields[2], membership=self.group_member[3], value="Field3Value__user3")


    #################### TEST GROUP MEMBER VALUE CREATION ######################
    def try_create(self, userIdx, membershipIdx, fieldIdx, fieldValue, expectedHttpResponse):
        if userIdx >= 0:
            self.client.force_authenticate(user=self.users[userIdx])
        field_value = {
            "membership": membershipIdx,
            "field": fieldIdx,
            "value": fieldValue
        }
        resp = self.client.post(self.group_field_url, field_value)
        self.assertEqual(resp.status_code, expectedHttpResponse)

    # Basic permission checks
    def test_create_not_authed(self):
        self.try_create(-1, -1, self.group_fields[0].id, "ABC", status.HTTP_401_UNAUTHORIZED)

    def test_create_not_group_member(self):
        self.try_create(0, 0, self.group_fields[0].id, "ABC", status.HTTP_400_BAD_REQUEST)

    # Some possible hack attempts now
    def test_create_not_group_member2(self):
        self.try_create(0, self.group_member[2].id, self.group_fields[0].id, "ABC", status.HTTP_400_BAD_REQUEST)

    def test_create_other_user(self):
        self.try_create(1, self.group_member[2].id, self.group_fields[0].id, "ABC", status.HTTP_400_BAD_REQUEST)

    def test_create_group_field_mismatch(self):
        self.try_create(2, self.group2_user2.id, self.group_fields[0].id, "ABC", status.HTTP_400_BAD_REQUEST)

    def test_create_group_field_validation_fail(self):
        self.try_create(2, self.group_member[2].id, self.group_fields[1].id, "ABC", status.HTTP_400_BAD_REQUEST)

    # Create OK cases
    def test_create_group_member_not_accepted(self):
        self.try_create(1, self.group_member[1].id, self.group_fields[0].id, "ABC", status.HTTP_201_CREATED)

    def test_create_group_member(self):
        self.try_create(2, self.group_member[2].id, self.group_fields[0].id, "ABC", status.HTTP_201_CREATED)

    def test_create_group_admin(self):
        self.try_create(3, self.group_member[3].id, self.group_fields[0].id, "ABC", status.HTTP_201_CREATED)

    def test_create_group_field_validation_ok(self):
        self.try_create(2, self.group_member[2].id, self.group_fields[1].id, "[email protected]", status.HTTP_201_CREATED)

    #################### TEST GROUP MEMBER VALUE LISTING #######################
    def try_list(self, userIdx, expectedHttpResponse):
        if userIdx >= 0:
            self.client.force_authenticate(user=self.users[userIdx])
        resp = self.client.get(self.group_field_url)
        self.assertEqual(resp.status_code, expectedHttpResponse)
        return resp.data

    # Basic permission checks
    def test_list_not_authed(self):
        self.try_list(-1, status.HTTP_401_UNAUTHORIZED)

    def test_list_not_group_member(self):
        r = self.try_list(0, status.HTTP_200_OK)
        self.assertEqual(len(r), 0)

    def test_list_not_accepted(self):
        r = self.try_list(1, status.HTTP_200_OK)
        self.assertEqual(len(r), GroupMemberValue.objects.all().filter(membership=self.group_member[1]).count())

    def test_list_group_member(self):
        r = self.try_list(2, status.HTTP_200_OK)
        #import pdb; pdb.set_trace()
        self.assertEqual(len(r), GroupMemberValue.objects.all().filter(membership__group=self.group.id).count())

    def test_list_group_member2(self):
        # User4 is in a different group.
        r = self.try_list(4, status.HTTP_200_OK)
        self.assertEqual(len(r), GroupMemberValue.objects.all().filter(membership__group=self.group2.id).count())
        self.assertEqual(len(r), 2)


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_member_value import GroupMemberValue
12			from sigma_core.models.group_field import GroupField
13			from sigma_core.models.validator import Validator
14			from sigma_core.tests.factories import UserFactory, GroupFieldFactory, GroupFactory, GroupMemberFactory, GroupMemberValueFactory
15
16
17			class GroupFieldTests(APITestCase):
18			fixtures = ['fixtures_prod.json'] # Import Validators
19			@classmethod
20			def setUpTestData(self):
21			super(APITestCase, self).setUpTestData()
22
23			# Routes
24			self.group_field_url = "/group-member-value/"
25
26			# Create the base Group
27			self.group = GroupFactory()
28
29			# Users already in group
30			# User[0]: Not in Group
31			# User[1]: Requested join, not accepted
32			# User[2]: Group member
33			# User[3]: Group admin
34			self.users = [UserFactory(), UserFactory(), UserFactory(), UserFactory(), UserFactory()]
35
36			# Associated GroupMember
37			self.group_member = [
38			None,
39			GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=0),
40			GroupMemberFactory(user=self.users[2], group=self.group, perm_rank=1),
41			GroupMemberFactory(user=self.users[3], group=self.group, perm_rank=Group.ADMINISTRATOR_RANK),
42			GroupMemberFactory(user=self.users[4], group=self.group, perm_rank=0)
43			]
44			# Let's add some custom fields to this Group
45			self.validator_none = Validator.objects.all().get(html_name=Validator.VALIDATOR_NONE)
46			self.validator_text = Validator.objects.all().get(html_name=Validator.VALIDATOR_TEXT)
47			self.group_fields = [
48			# First field does not require any validation
49			GroupFieldFactory(group=self.group, validator=self.validator_none, validator_values={}),
50			# Second field must be in the email format
51			GroupFieldFactory(group=self.group,
52			validator=self.validator_text,
53			validator_values={"regex": "[^@]+@[^@]+\.[^@]+", "message": "Invalid email"}),
54			GroupFieldFactory(group=self.group, validator=self.validator_none, validator_values={}),
55			]
56
57			# And we need a second group
58			self.group2 = GroupFactory()
59			self.group2_user2 = GroupMemberFactory(user=self.users[4], group=self.group2, perm_rank=1)
60			self.group2_fields = [
61			# First field does not require any validation
62			GroupFieldFactory(group=self.group2, validator=self.validator_none, validator_values={}),
63			# Second field must be in the email format
64			GroupFieldFactory(group=self.group2,
65			validator=self.validator_text,
66			validator_values={"regex": "[^@]+@[^@]+\.[^@]+", "message": "Invalid email"}),
67			GroupFieldFactory(group=self.group2, validator=self.validator_none, validator_values={}),
68			]
69
70			# Create some values
71			GroupMemberValueFactory(field=self.group2_fields[0], membership=self.group2_user2, value="TextFieldValue1")
72			GroupMemberValueFactory(field=self.group2_fields[1], membership=self.group2_user2, value="[email protected]")
73			GroupMemberValueFactory(field=self.group_fields[2], membership=self.group_member[2], value="Field3Value__user2")
74			GroupMemberValueFactory(field=self.group_fields[2], membership=self.group_member[3], value="Field3Value__user3")
75
76
77			#################### TEST GROUP MEMBER VALUE CREATION ######################
78			def try_create(self, userIdx, membershipIdx, fieldIdx, fieldValue, expectedHttpResponse):
79			if userIdx >= 0:
80			self.client.force_authenticate(user=self.users[userIdx])
81			field_value = {
82			"membership": membershipIdx,
83			"field": fieldIdx,
84			"value": fieldValue
85			}
86			resp = self.client.post(self.group_field_url, field_value)
87			self.assertEqual(resp.status_code, expectedHttpResponse)
88
89			# Basic permission checks
90			def test_create_not_authed(self):
91			self.try_create(-1, -1, self.group_fields[0].id, "ABC", status.HTTP_401_UNAUTHORIZED)
92
93			def test_create_not_group_member(self):
94			self.try_create(0, 0, self.group_fields[0].id, "ABC", status.HTTP_400_BAD_REQUEST)
95
96			# Some possible hack attempts now
97			def test_create_not_group_member2(self):
98			self.try_create(0, self.group_member[2].id, self.group_fields[0].id, "ABC", status.HTTP_400_BAD_REQUEST)
99
100			def test_create_other_user(self):
101			self.try_create(1, self.group_member[2].id, self.group_fields[0].id, "ABC", status.HTTP_400_BAD_REQUEST)
102
103			def test_create_group_field_mismatch(self):
104			self.try_create(2, self.group2_user2.id, self.group_fields[0].id, "ABC", status.HTTP_400_BAD_REQUEST)
105
106			def test_create_group_field_validation_fail(self):
107			self.try_create(2, self.group_member[2].id, self.group_fields[1].id, "ABC", status.HTTP_400_BAD_REQUEST)
108
109			# Create OK cases
110			def test_create_group_member_not_accepted(self):
111			self.try_create(1, self.group_member[1].id, self.group_fields[0].id, "ABC", status.HTTP_201_CREATED)
112
113			def test_create_group_member(self):
114			self.try_create(2, self.group_member[2].id, self.group_fields[0].id, "ABC", status.HTTP_201_CREATED)
115
116			def test_create_group_admin(self):
117			self.try_create(3, self.group_member[3].id, self.group_fields[0].id, "ABC", status.HTTP_201_CREATED)
118
119			def test_create_group_field_validation_ok(self):
120			self.try_create(2, self.group_member[2].id, self.group_fields[1].id, "[email protected]", status.HTTP_201_CREATED)
121
122			#################### TEST GROUP MEMBER VALUE LISTING #######################
123			def try_list(self, userIdx, expectedHttpResponse):
124			if userIdx >= 0:
125			self.client.force_authenticate(user=self.users[userIdx])
126			resp = self.client.get(self.group_field_url)
127			self.assertEqual(resp.status_code, expectedHttpResponse)
128			return resp.data
129
130			# Basic permission checks
131			def test_list_not_authed(self):
132			self.try_list(-1, status.HTTP_401_UNAUTHORIZED)
133
134			def test_list_not_group_member(self):
135			r = self.try_list(0, status.HTTP_200_OK)
136			self.assertEqual(len(r), 0)
137
138			def test_list_not_accepted(self):
139			r = self.try_list(1, status.HTTP_200_OK)
140			self.assertEqual(len(r), GroupMemberValue.objects.all().filter(membership=self.group_member[1]).count())
141
142			def test_list_group_member(self):
143			r = self.try_list(2, status.HTTP_200_OK)
144			#import pdb; pdb.set_trace()
145			self.assertEqual(len(r), GroupMemberValue.objects.all().filter(membership__group=self.group.id).count())
146
147			def test_list_group_member2(self):
148			# User4 is in a different group.
149			r = self.try_list(4, status.HTTP_200_OK)
150			self.assertEqual(len(r), GroupMemberValue.objects.all().filter(membership__group=self.group2.id).count())
151			self.assertEqual(len(r), 2)
152

ProjetSigma / backend

Pull Request — master (#16)

GroupFieldTests.setUpTestData() A

Complexity

Size

Duplication

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like