tests.test_user.UserTest.test_create_team() - Code Metrics - Inspection of ":recycle: Use iterators when browsing USI objects" - cnr-ibba/pyUSIrest - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — devel (#6)

by Paolo

created 2020-01-10 10:38 UTC

tests.test_user.UserTest.test_create_team() A

↳ Parent: tests.test_user

Complexity

Conditions

Size

Total Lines	13
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	10
nop	1
dl	0
loc	13
rs	9.9
c	0
b	0
f	0

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Jan 10 11:31:25 2020

@author: Paolo Cozzi <[email protected]>
"""

import os
import json
import types

from unittest.mock import patch, Mock
from unittest import TestCase

from pyUSIrest.auth import Auth
from pyUSIrest.usi import Team, User, Domain

from .common import DATA_PATH
from .test_auth import generate_token


class UserTest(TestCase):
    @classmethod
    def setup_class(cls):
        cls.mock_get_patcher = patch('requests.Session.get')
        cls.mock_get = cls.mock_get_patcher.start()

        cls.mock_post_patcher = patch('requests.Session.post')
        cls.mock_post = cls.mock_post_patcher.start()

        cls.mock_put_patcher = patch('requests.Session.put')
        cls.mock_put = cls.mock_put_patcher.start()

    @classmethod
    def teardown_class(cls):
        cls.mock_get_patcher.stop()
        cls.mock_post_patcher.stop()
        cls.mock_put_patcher.stop()

    def setUp(self):
        self.auth = Auth(token=generate_token())
        self.user = User(self.auth)

        self.data = {
            "userName": "foo",
            "email": "[email protected]",
            "userReference": "usr-f1801430-51e1-4718-8fca-778887087bad",
            "_links": {
                "self": {
                    "href": "https://explore.api.aai.ebi.ac.uk/users/usr-"
                             "f1801430-51e1-4718-8fca-778887087bad"
                }
            }
        }

    def test_get_user_by_id(self):
        self.mock_get.return_value = Mock()
        self.mock_get.return_value.json.return_value = self.data
        self.mock_get.return_value.status_code = 200

        user = self.user.get_user_by_id(
            "usr-f1801430-51e1-4718-8fca-778887087bad")

        self.assertIsInstance(user, User)

    def test_get_my_id(self):
        self.mock_get.return_value = Mock()
        self.mock_get.return_value.json.return_value = self.data
        self.mock_get.return_value.status_code = 200

        test = self.user.get_my_id()
        reference = "usr-f1801430-51e1-4718-8fca-778887087bad"

        self.assertEqual(reference, test)

    def test_create_user(self):
        reference = "usr-2a28ca65-2c2f-41e7-9aa5-e829830c6c71"
        self.mock_post.return_value = Mock()
        self.mock_post.return_value.text = reference
        self.mock_post.return_value.status_code = 200

        test = self.user.create_user(
            user="newuser",
            password="changeme",
            confirmPwd="changeme",
            email="[email protected]",
            full_name="New User",
            organisation="Test"
        )

        self.assertEqual(reference, test)

    def test_create_team(self):
        with open(os.path.join(DATA_PATH, "newTeam.json")) as handle:
            data = json.load(handle)

        self.mock_post.return_value = Mock()
        self.mock_post.return_value.json.return_value = data
        self.mock_post.return_value.status_code = 201

        team = self.user.create_team(
            description="test description",
            centreName="test Center")

        self.assertIsInstance(team, Team)

    def read_teams(self):
        with open(os.path.join(DATA_PATH, "userTeams.json")) as handle:
            data = json.load(handle)

        self.mock_get.return_value = Mock()
        self.mock_get.return_value.json.return_value = data
        self.mock_get.return_value.status_code = 200

    def test_get_teams(self):
        # initialize
        self.read_teams()

        # get user teams
        teams = self.user.get_teams()

        # teams is now a generator
        self.assertIsInstance(teams, types.GeneratorType)
        teams = list(teams)

        self.assertEqual(len(teams), 1)

        team = teams[0]
        self.assertIsInstance(team, Team)

    def test_get_team_by_name(self):
        # initialize
        self.read_teams()

        # get a specific team
        team = self.user.get_team_by_name("subs.dev-team-1")
        self.assertIsInstance(team, Team)

        # get a team I dont't belong to
        self.assertRaisesRegex(
            NameError,
            "team: .* not found",
            self.user.get_team_by_name,
            "subs.dev-team-2")

    def test_add_user2team(self):
        with open(os.path.join(DATA_PATH, "user2team.json")) as handle:
            data = json.load(handle)

        self.mock_put.return_value = Mock()
        self.mock_put.return_value.json.return_value = data
        self.mock_put.return_value.status_code = 200

        domain = self.user.add_user_to_team(
            user_id='dom-36ccaae5-1ce1-41f9-b65c-d349994e9c80',
            domain_id='usr-d8749acf-6a22-4438-accc-cc8d1877ba36')

        self.assertIsInstance(domain, Domain)

    def read_myDomain(self):
        with open(os.path.join(DATA_PATH, "myDomain.json")) as handle:
            data = json.load(handle)

        self.mock_get.return_value = Mock()
        self.mock_get.return_value.json.return_value = data
        self.mock_get.return_value.status_code = 200

    def test_get_domains(self):
        # initialize
        self.read_myDomain()

        # get user teams
        domains = self.user.get_domains()

        # domains is now a generator
        self.assertIsInstance(domains, types.GeneratorType)
        domains = list(domains)

        self.assertEqual(len(domains), 2)

        for domain in domains:
            self.assertIsInstance(domain, Domain)

    def test_get_domain_by_name(self):
        # initialize
        self.read_myDomain()

        # get a specific team
        domain = self.user.get_domain_by_name("subs.test-team-1")
        self.assertIsInstance(domain, Domain)

        # get a team I dont't belong to
        self.assertRaisesRegex(
            NameError,
            "domain: .* not found",
            self.user.get_domain_by_name,
            "subs.dev-team-2")


1			#!/usr/bin/env python3
2			# -- coding: utf-8 --
3			"""
4			Created on Fri Jan 10 11:31:25 2020
5
6			@author: Paolo Cozzi <[email protected]>
7			"""
8
9			import os
10			import json
11			import types
12
13			from unittest.mock import patch, Mock
14			from unittest import TestCase
15
16			from pyUSIrest.auth import Auth
17			from pyUSIrest.usi import Team, User, Domain
18
19			from .common import DATA_PATH
20			from .test_auth import generate_token
21
22
23			class UserTest(TestCase):
24			@classmethod
25			def setup_class(cls):
26			cls.mock_get_patcher = patch('requests.Session.get')
27			cls.mock_get = cls.mock_get_patcher.start()
28
29			cls.mock_post_patcher = patch('requests.Session.post')
30			cls.mock_post = cls.mock_post_patcher.start()
31
32			cls.mock_put_patcher = patch('requests.Session.put')
33			cls.mock_put = cls.mock_put_patcher.start()
34
35			@classmethod
36			def teardown_class(cls):
37			cls.mock_get_patcher.stop()
38			cls.mock_post_patcher.stop()
39			cls.mock_put_patcher.stop()
40
41			def setUp(self):
42			self.auth = Auth(token=generate_token())
43			self.user = User(self.auth)
44
45			self.data = {
46			"userName": "foo",
47			"email": "[email protected]",
48			"userReference": "usr-f1801430-51e1-4718-8fca-778887087bad",
49			"_links": {
50			"self": {
51			"href": "https://explore.api.aai.ebi.ac.uk/users/usr-"
52			"f1801430-51e1-4718-8fca-778887087bad"
53			}
54			}
55			}
56
57			def test_get_user_by_id(self):
58			self.mock_get.return_value = Mock()
59			self.mock_get.return_value.json.return_value = self.data
60			self.mock_get.return_value.status_code = 200
61
62			user = self.user.get_user_by_id(
63			"usr-f1801430-51e1-4718-8fca-778887087bad")
64
65			self.assertIsInstance(user, User)
66
67			def test_get_my_id(self):
68			self.mock_get.return_value = Mock()
69			self.mock_get.return_value.json.return_value = self.data
70			self.mock_get.return_value.status_code = 200
71
72			test = self.user.get_my_id()
73			reference = "usr-f1801430-51e1-4718-8fca-778887087bad"
74
75			self.assertEqual(reference, test)
76
77			def test_create_user(self):
78			reference = "usr-2a28ca65-2c2f-41e7-9aa5-e829830c6c71"
79			self.mock_post.return_value = Mock()
80			self.mock_post.return_value.text = reference
81			self.mock_post.return_value.status_code = 200
82
83			test = self.user.create_user(
84			user="newuser",
85			password="changeme",
86			confirmPwd="changeme",
87			email="[email protected]",
88			full_name="New User",
89			organisation="Test"
90			)
91
92			self.assertEqual(reference, test)
93
94			def test_create_team(self):
95			with open(os.path.join(DATA_PATH, "newTeam.json")) as handle:
96			data = json.load(handle)
97
98			self.mock_post.return_value = Mock()
99			self.mock_post.return_value.json.return_value = data
100			self.mock_post.return_value.status_code = 201
101
102			team = self.user.create_team(
103			description="test description",
104			centreName="test Center")
105
106			self.assertIsInstance(team, Team)
107
108			def read_teams(self):
109			with open(os.path.join(DATA_PATH, "userTeams.json")) as handle:
110			data = json.load(handle)
111
112			self.mock_get.return_value = Mock()
113			self.mock_get.return_value.json.return_value = data
114			self.mock_get.return_value.status_code = 200
115
116			def test_get_teams(self):
117			# initialize
118			self.read_teams()
119
120			# get user teams
121			teams = self.user.get_teams()
122
123			# teams is now a generator
124			self.assertIsInstance(teams, types.GeneratorType)
125			teams = list(teams)
126
127			self.assertEqual(len(teams), 1)
128
129			team = teams[0]
130			self.assertIsInstance(team, Team)
131
132			def test_get_team_by_name(self):
133			# initialize
134			self.read_teams()
135
136			# get a specific team
137			team = self.user.get_team_by_name("subs.dev-team-1")
138			self.assertIsInstance(team, Team)
139
140			# get a team I dont't belong to
141			self.assertRaisesRegex(
142			NameError,
143			"team: .* not found",
144			self.user.get_team_by_name,
145			"subs.dev-team-2")
146
147			def test_add_user2team(self):
148			with open(os.path.join(DATA_PATH, "user2team.json")) as handle:
149			data = json.load(handle)
150
151			self.mock_put.return_value = Mock()
152			self.mock_put.return_value.json.return_value = data
153			self.mock_put.return_value.status_code = 200
154
155			domain = self.user.add_user_to_team(
156			user_id='dom-36ccaae5-1ce1-41f9-b65c-d349994e9c80',
157			domain_id='usr-d8749acf-6a22-4438-accc-cc8d1877ba36')
158
159			self.assertIsInstance(domain, Domain)
160
161			def read_myDomain(self):
162			with open(os.path.join(DATA_PATH, "myDomain.json")) as handle:
163			data = json.load(handle)
164
165			self.mock_get.return_value = Mock()
166			self.mock_get.return_value.json.return_value = data
167			self.mock_get.return_value.status_code = 200
168
169			def test_get_domains(self):
170			# initialize
171			self.read_myDomain()
172
173			# get user teams
174			domains = self.user.get_domains()
175
176			# domains is now a generator
177			self.assertIsInstance(domains, types.GeneratorType)
178			domains = list(domains)
179
180			self.assertEqual(len(domains), 2)
181
182			for domain in domains:
183			self.assertIsInstance(domain, Domain)
184
185			def test_get_domain_by_name(self):
186			# initialize
187			self.read_myDomain()
188
189			# get a specific team
190			domain = self.user.get_domain_by_name("subs.test-team-1")
191			self.assertIsInstance(domain, Domain)
192
193			# get a team I dont't belong to
194			self.assertRaisesRegex(
195			NameError,
196			"domain: .* not found",
197			self.user.get_domain_by_name,
198			"subs.dev-team-2")
199

cnr-ibba / pyUSIrest

Pull Request — devel (#6)

tests.test_user.UserTest.test_create_team() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like