← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python-keystoneclient/trusty-proposed

« back to all changes in this revision

Viewing changes to tests/v2_0/test_roles.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Adam Gandelman, Chuck Short
  • Date: 2013-11-14 10:51:32 UTC
  • mfrom: (1.1.23)
  • Revision ID: package-import@ubuntu.com-20131114105132-p1o428l7fclasv9e
Tags: 1:0.4.1-0ubuntu1
[ Adam Gandelman ]
* debian/patches: Refreshed.
* debian/patches/use-mox-dependency.patch: Use mox instead of mox3
  dependency.

[ Chuck Short ]
* New upstream release.
* debian/control:
  - open icehouse release.
  - Dropped python-d2to1 and python-httplib2 dependency.
* debian/patches/skip-tests-ubuntu.patch: Dropped no longer needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/v2_0/test_roles.py
1
 
import copy
2
 
import json
3
 
import urlparse
4
 
 
5
 
import requests
6
 
 
7
 
from keystoneclient.v2_0 import roles
8
 
from tests import utils
9
 
 
10
 
 
11
 
class RoleTests(utils.TestCase):
12
 
    def setUp(self):
13
 
        super(RoleTests, self).setUp()
14
 
        self.TEST_REQUEST_HEADERS = {
15
 
            'X-Auth-Token': 'aToken',
16
 
            'User-Agent': 'python-keystoneclient',
17
 
        }
18
 
        self.TEST_POST_HEADERS = {
19
 
            'Content-Type': 'application/json',
20
 
            'X-Auth-Token': 'aToken',
21
 
            'User-Agent': 'python-keystoneclient',
22
 
        }
23
 
        self.TEST_ROLES = {
24
 
            "roles": {
25
 
                "values": [
26
 
                    {
27
 
                        "name": "admin",
28
 
                        "id": 1,
29
 
                    },
30
 
                    {
31
 
                        "name": "member",
32
 
                        "id": 2,
33
 
                    }
34
 
                ],
35
 
            },
36
 
        }
37
 
 
38
 
    def test_create(self):
39
 
        req_body = {
40
 
            "role": {
41
 
                "name": "sysadmin",
42
 
            }
43
 
        }
44
 
        resp_body = {
45
 
            "role": {
46
 
                "name": "sysadmin",
47
 
                "id": 3,
48
 
            }
49
 
        }
50
 
        resp = utils.TestResponse({
51
 
            "status_code": 200,
52
 
            "text": json.dumps(resp_body),
53
 
        })
54
 
 
55
 
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
56
 
        kwargs['headers'] = self.TEST_POST_HEADERS
57
 
        kwargs['data'] = json.dumps(req_body)
58
 
        requests.request('POST',
59
 
                         urlparse.urljoin(self.TEST_URL,
60
 
                         'v2.0/OS-KSADM/roles'),
61
 
                         **kwargs).AndReturn((resp))
62
 
        self.mox.ReplayAll()
63
 
 
64
 
        role = self.client.roles.create(req_body['role']['name'])
65
 
        self.assertTrue(isinstance(role, roles.Role))
66
 
        self.assertEqual(role.id, 3)
67
 
        self.assertEqual(role.name, req_body['role']['name'])
68
 
 
69
 
    def test_delete(self):
70
 
        resp = utils.TestResponse({
71
 
            "status_code": 204,
72
 
            "text": "",
73
 
        })
74
 
 
75
 
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
76
 
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
77
 
        requests.request('DELETE',
78
 
                         urlparse.urljoin(self.TEST_URL,
79
 
                         'v2.0/OS-KSADM/roles/1'),
80
 
                         **kwargs).AndReturn((resp))
81
 
        self.mox.ReplayAll()
82
 
 
83
 
        self.client.roles.delete(1)
84
 
 
85
 
    def test_get(self):
86
 
        resp = utils.TestResponse({
87
 
            "status_code": 200,
88
 
            "text": json.dumps({
89
 
                'role': self.TEST_ROLES['roles']['values'][0],
90
 
            }),
91
 
        })
92
 
 
93
 
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
94
 
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
95
 
        requests.request('GET',
96
 
                         urlparse.urljoin(self.TEST_URL,
97
 
                         'v2.0/OS-KSADM/roles/1'),
98
 
                         **kwargs).AndReturn((resp))
99
 
        self.mox.ReplayAll()
100
 
 
101
 
        role = self.client.roles.get(1)
102
 
        self.assertTrue(isinstance(role, roles.Role))
103
 
        self.assertEqual(role.id, 1)
104
 
        self.assertEqual(role.name, 'admin')
105
 
 
106
 
    def test_list(self):
107
 
        resp = utils.TestResponse({
108
 
            "status_code": 200,
109
 
            "text": json.dumps(self.TEST_ROLES),
110
 
        })
111
 
 
112
 
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
113
 
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
114
 
        requests.request('GET',
115
 
                         urlparse.urljoin(self.TEST_URL,
116
 
                         'v2.0/OS-KSADM/roles'),
117
 
                         **kwargs).AndReturn((resp))
118
 
        self.mox.ReplayAll()
119
 
 
120
 
        role_list = self.client.roles.list()
121
 
        [self.assertTrue(isinstance(r, roles.Role)) for r in role_list]
122
 
 
123
 
    def test_roles_for_user(self):
124
 
        resp = utils.TestResponse({
125
 
            "status_code": 200,
126
 
            "text": json.dumps(self.TEST_ROLES),
127
 
        })
128
 
 
129
 
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
130
 
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
131
 
        requests.request('GET',
132
 
                         urlparse.urljoin(self.TEST_URL,
133
 
                         'v2.0/users/foo/roles'),
134
 
                         **kwargs).AndReturn((resp))
135
 
        self.mox.ReplayAll()
136
 
 
137
 
        role_list = self.client.roles.roles_for_user('foo')
138
 
        [self.assertTrue(isinstance(r, roles.Role)) for r in role_list]
139
 
 
140
 
    def test_roles_for_user_tenant(self):
141
 
        resp = utils.TestResponse({
142
 
            "status_code": 200,
143
 
            "text": json.dumps(self.TEST_ROLES),
144
 
        })
145
 
 
146
 
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
147
 
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
148
 
        requests.request('GET',
149
 
                         urlparse.urljoin(self.TEST_URL,
150
 
                         'v2.0/tenants/barrr/users/foo/roles'),
151
 
                         **kwargs).AndReturn((resp))
152
 
        self.mox.ReplayAll()
153
 
 
154
 
        role_list = self.client.roles.roles_for_user('foo', 'barrr')
155
 
        [self.assertTrue(isinstance(r, roles.Role)) for r in role_list]
156
 
 
157
 
    def test_add_user_role(self):
158
 
        resp = utils.TestResponse({
159
 
            "status_code": 204,
160
 
            "text": '',
161
 
        })
162
 
 
163
 
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
164
 
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
165
 
        requests.request('PUT',
166
 
                         urlparse.urljoin(self.TEST_URL,
167
 
                         'v2.0/users/foo/roles/OS-KSADM/barrr'),
168
 
                         **kwargs).AndReturn((resp))
169
 
        self.mox.ReplayAll()
170
 
 
171
 
        self.client.roles.add_user_role('foo', 'barrr')
172
 
 
173
 
    def test_add_user_role_tenant(self):
174
 
        resp = utils.TestResponse({
175
 
            "status_code": 204,
176
 
            "text": '',
177
 
        })
178
 
 
179
 
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
180
 
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
181
 
        requests.request('PUT',
182
 
                         urlparse.urljoin(self.TEST_URL,
183
 
                         'v2.0/tenants/4/users/foo/roles/OS-KSADM/barrr'),
184
 
                         **kwargs).AndReturn((resp))
185
 
        self.mox.ReplayAll()
186
 
 
187
 
        self.client.roles.add_user_role('foo', 'barrr', '4')
188
 
 
189
 
    def test_remove_user_role(self):
190
 
        resp = utils.TestResponse({
191
 
            "status_code": 204,
192
 
            "text": '',
193
 
        })
194
 
 
195
 
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
196
 
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
197
 
        requests.request('DELETE',
198
 
                         urlparse.urljoin(self.TEST_URL,
199
 
                         'v2.0/users/foo/roles/OS-KSADM/barrr'),
200
 
                         **kwargs).AndReturn((resp))
201
 
        self.mox.ReplayAll()
202
 
 
203
 
        self.client.roles.remove_user_role('foo', 'barrr')
204
 
 
205
 
    def test_remove_user_role_tenant(self):
206
 
        resp = utils.TestResponse({
207
 
            "status_code": 204,
208
 
            "text": '',
209
 
        })
210
 
 
211
 
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
212
 
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
213
 
        requests.request('DELETE',
214
 
                         urlparse.urljoin(self.TEST_URL,
215
 
                         'v2.0/tenants/4/users/foo/roles/OS-KSADM/barrr'),
216
 
                         **kwargs).AndReturn((resp))
217
 
        self.mox.ReplayAll()
218
 
 
219
 
        self.client.roles.remove_user_role('foo', 'barrr', '4')