1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2
# Copyright (c) 2010-2011 OpenStack, LLC.
4
# Licensed under the Apache License, Version 2.0 (the "License");
5
# you may not use this file except in compliance with the License.
6
# You may obtain a copy of the License at
8
# http://www.apache.org/licenses/LICENSE-2.0
10
# Unless required by applicable law or agreed to in writing, software
11
# distributed under the License is distributed on an "AS IS" BASIS,
12
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
14
# See the License for the specific language governing permissions and
15
# limitations under the License.
20
from lxml import etree
23
sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
24
'..', '..', '..', '..', '..', 'keystone')))
25
import unittest2 as unittest
27
import test_common as utils
28
from test_common import URL_V2
31
class UserTest(unittest.TestCase):
34
self.tenant = utils.get_tenant()
35
self.password = utils.get_password()
36
self.email = utils.get_email()
37
self.user = utils.get_user()
38
self.user1 = 'test_user1'
39
self.userdisabled = utils.get_userdisabled()
40
self.auth_token = utils.get_auth_token()
41
self.exp_auth_token = utils.get_exp_auth_token()
42
self.disabled_token = utils.get_disabled_token()
43
self.missing_token = utils.get_none_token()
44
self.invalid_token = utils.get_non_existing_token()
45
utils.create_tenant(self.tenant, str(self.auth_token))
46
utils.create_user(self.tenant, self.user, self.auth_token)
47
self.token = utils.get_token(self.user, 'secrete', self.tenant,
51
utils.delete_user(self.user, str(self.auth_token))
54
class CreateUserTest(UserTest):
56
def test_a_user_create_json(self):
58
_resp = utils.delete_user(self.user, str(self.auth_token))
60
resp, content = utils.create_user(self.tenant, self.user1,
62
self.user = self.user1
63
resp_val = int(resp['status'])
64
utils.handle_user_resp(self, content, resp_val,
65
utils.content_type(resp))
66
self.assertEqual(201, resp_val)
68
def test_a_user_witn_no_tenant(self):
69
_resp = utils.delete_user(self.user1, str(self.auth_token))
70
resp, content = utils.create_user(None, self.user1,
72
self.user = self.user1
73
resp_val = int(resp['status'])
74
utils.handle_user_resp(self, content, resp_val,
75
utils.content_type(resp))
76
self.assertEqual(201, resp_val)
78
def test_a_user_create_xml(self):
79
utils.delete_user_xml(self.user1, str(self.auth_token))
80
resp, content = utils.create_user_xml(self.tenant, self.user1,
82
resp_val = int(resp['status'])
83
utils.handle_user_resp(self, content, resp_val,
84
utils.content_type(resp))
85
self.assertEqual(201, resp_val)
86
self.assertEqual('application/xml', utils.content_type(resp))
88
def test_a_user_create_json_disabled_tenant(self):
89
resp, content = utils.create_user('0000', self.user,
91
resp_val = int(resp['status'])
92
utils.handle_user_resp(self, content, resp_val,
93
utils.content_type(resp))
94
self.assertEqual(403, resp_val)
96
def test_a_user_create_json_disabled_tenant_xml(self):
97
resp, content = utils.create_user_xml('0000', self.user,
99
resp_val = int(resp['status'])
100
utils.handle_user_resp(self, content, resp_val,
101
utils.content_type(resp))
102
self.assertEqual(403, resp_val)
103
self.assertEqual('application/xml', utils.content_type(resp))
105
def test_a_user_create_again_json(self):
106
resp, content = utils.create_user(self.tenant, self.user,
107
str(self.auth_token))
108
resp_val = int(resp['status'])
109
utils.handle_user_resp(self, content, resp_val,
110
utils.content_type(resp))
111
resp, content = utils.create_user(self.tenant, self.user,
112
str(self.auth_token))
113
self.assertEqual(409, int(resp['status']))
115
def test_a_user_create_again_xml(self):
116
utils.create_user_xml(self.tenant, self.user,
117
str(self.auth_token))
118
resp, content = utils.create_user_xml(self.tenant, self.user,
119
str(self.auth_token))
121
content = etree.fromstring(content)
122
resp_val = int(resp['status'])
123
utils.handle_user_resp(self, content, resp_val,
124
utils.content_type(resp))
125
self.assertEqual(409, int(resp['status']))
126
self.assertEqual('application/xml', utils.content_type(resp))
128
def test_a_user_create_email_conflict(self):
129
utils.create_user(self.tenant, self.user, str(self.auth_token),
131
resp, _content = utils.create_user(self.tenant, self.user,
132
str(self.auth_token),
134
self.assertEqual(409, int(resp['status']))
136
def test_a_user_create_email_conflict_xml(self):
137
utils.create_user_xml(self.tenant,
139
str(self.auth_token),
141
resp, content = utils.create_user_xml(self.tenant, self.user,
142
str(self.auth_token),
144
content = etree.fromstring(content)
145
resp_val = int(resp['status'])
146
utils.handle_user_resp(self, content, resp_val,
147
utils.content_type(resp))
148
self.assertEqual(409, int(resp['status']))
149
self.assertEqual('application/xml', utils.content_type(resp))
151
def test_a_user_create_empty_password(self):
153
resp, content = utils.create_user(self.tenant,
155
str(self.auth_token),
157
self.assertEqual(400, int(resp['status']))
160
resp, content = utils.create_user(self.tenant,
162
str(self.auth_token),
164
self.assertEqual(400, int(resp['status']))
166
def test_a_user_create_empty_username(self):
167
resp, content = utils.create_user_xml(self.tenant,
169
str(self.auth_token),
171
self.assertEqual(400, int(resp['status']))
173
resp, content = utils.create_user(self.tenant,
175
str(self.auth_token),
177
self.assertEqual(400, int(resp['status']))
179
def test_a_user_create_expired_token(self):
180
resp, content = utils.create_user(self.tenant, self.user,
181
str(self.exp_auth_token))
182
resp_val = int(resp['status'])
183
utils.handle_user_resp(self, content, resp_val,
184
utils.content_type(resp))
185
self.assertEqual(403, int(resp['status']))
187
def test_a_user_create_expired_token_xml(self):
188
resp, content = utils.create_user_xml(self.tenant, self.user,
189
str(self.exp_auth_token))
190
resp_val = int(resp['status'])
191
utils.handle_user_resp(self, content, resp_val,
192
utils.content_type(resp))
193
self.assertEqual(403, int(resp['status']))
194
self.assertEqual('application/xml', utils.content_type(resp))
196
def test_a_user_create_disabled_token(self):
197
resp, content = utils.create_user(self.tenant, self.user,
198
str(self.disabled_token))
199
resp_val = int(resp['status'])
200
utils.handle_user_resp(self, content, resp_val,
201
utils.content_type(resp))
202
self.assertEqual(403, int(resp['status']))
204
def test_a_user_create_disabled_token_xml(self):
205
resp, content = utils.create_user_xml(self.tenant, self.user,
206
str(self.disabled_token))
207
resp_val = int(resp['status'])
208
utils.handle_user_resp(self, content, resp_val,
209
utils.content_type(resp))
210
self.assertEqual(403, int(resp['status']))
211
self.assertEqual('application/xml', utils.content_type(resp))
213
def test_a_user_create_missing_token(self):
214
resp, content = utils.create_user(self.tenant, self.user,
215
str(self.missing_token))
216
resp_val = int(resp['status'])
217
utils.handle_user_resp(self, content, resp_val,
218
utils.content_type(resp))
219
self.assertEqual(401, int(resp['status']))
221
def test_a_user_create_missing_token_xml(self):
222
resp, content = utils.create_user_xml(self.tenant, self.user,
223
str(self.missing_token))
224
resp_val = int(resp['status'])
225
utils.handle_user_resp(self, content, resp_val,
226
utils.content_type(resp))
227
self.assertEqual(401, int(resp['status']))
228
self.assertEqual('application/xml', utils.content_type(resp))
230
def test_a_user_create_invalid_token(self):
231
resp, content = utils.create_user(self.tenant, self.user,
232
str(self.invalid_token))
233
resp_val = int(resp['status'])
234
utils.handle_user_resp(self, content, resp_val,
235
utils.content_type(resp))
236
self.assertEqual(404, int(resp['status']))
238
def test_a_user_create_invalid_token_xml(self):
239
resp, content = utils.create_user_xml(self.tenant, self.user,
240
str(self.invalid_token))
241
resp_val = int(resp['status'])
242
utils.handle_user_resp(self, content, resp_val,
243
utils.content_type(resp))
244
self.assertEqual(404, int(resp['status']))
245
self.assertEqual('application/xml', utils.content_type(resp))
248
class GetUserTest(UserTest):
250
def test_a_user_get(self):
251
utils.create_user(self.tenant, self.user, str(self.auth_token))
252
resp, content = utils.user_get_json(self.user,
253
str(self.auth_token))
254
resp_val = int(resp['status'])
255
utils.handle_user_resp(self, content, resp_val,
256
utils.content_type(resp))
257
self.assertEqual(200, resp_val)
259
def test_a_user_get_xml(self):
260
utils.create_user(self.tenant, self.user, str(self.auth_token))
261
resp, content = utils.user_get_xml(self.user,
262
str(self.auth_token))
263
resp_val = int(resp['status'])
264
utils.handle_user_resp(self, content, resp_val,
265
utils.content_type(resp))
266
self.assertEqual(200, resp_val)
267
self.assertEqual('application/xml', utils.content_type(resp))
269
def test_a_user_get_expired_token(self):
270
utils.create_user(self.tenant, self.user, str(self.auth_token))
271
resp, content = utils.user_get_json(self.user,
272
str(self.exp_auth_token))
273
resp_val = int(resp['status'])
274
utils.handle_user_resp(self, content, resp_val,
275
utils.content_type(resp))
276
self.assertEqual(403, resp_val)
278
def test_a_user_get_expired_token_xml(self):
279
utils.create_user(self.tenant, self.user, str(self.auth_token))
280
resp, content = utils.user_get_xml(self.user,
281
str(self.exp_auth_token))
282
resp_val = int(resp['status'])
283
utils.handle_user_resp(self, content, resp_val,
284
utils.content_type(resp))
285
self.assertEqual(403, resp_val)
286
self.assertEqual('application/xml', utils.content_type(resp))
288
def test_a_user_get_disabled_token(self):
289
utils.create_user(self.tenant, self.user, str(self.auth_token))
290
resp, content = utils.user_get_json(self.user,
291
str(self.disabled_token))
292
resp_val = int(resp['status'])
293
utils.handle_user_resp(self, content, resp_val,
294
utils.content_type(resp))
295
self.assertEqual(403, resp_val)
297
def test_a_user_get_disabled_token_xml(self):
298
utils.create_user(self.tenant, self.user, str(self.auth_token))
299
resp, content = utils.user_get_xml(self.user,
300
str(self.disabled_token))
301
resp_val = int(resp['status'])
302
utils.handle_user_resp(self, content, resp_val,
303
utils.content_type(resp))
304
self.assertEqual(403, resp_val)
305
self.assertEqual('application/xml', utils.content_type(resp))
307
def test_a_user_get_missing_token(self):
308
utils.create_user(self.tenant, self.user, str(self.auth_token))
309
resp, content = utils.user_get_json(self.user,
310
str(self.missing_token))
311
resp_val = int(resp['status'])
312
utils.handle_user_resp(self, content, resp_val,
313
utils.content_type(resp))
314
self.assertEqual(401, resp_val)
316
def test_a_user_get_missing_token_xml(self):
317
utils.create_user(self.tenant, self.user, str(self.auth_token))
318
resp, content = utils.user_get_xml(self.user,
319
str(self.missing_token))
320
resp_val = int(resp['status'])
321
utils.handle_user_resp(self, content, resp_val,
322
utils.content_type(resp))
323
self.assertEqual(401, resp_val)
324
self.assertEqual('application/xml', utils.content_type(resp))
326
def test_a_user_get_invalid_token(self):
327
utils.create_user(self.tenant, self.user, str(self.auth_token))
328
resp, content = utils.user_get_json(self.user,
329
str(self.invalid_token))
330
resp_val = int(resp['status'])
331
utils.handle_user_resp(self, content, resp_val,
332
utils.content_type(resp))
333
self.assertEqual(404, resp_val)
335
def test_a_user_get_invalid_token_xml(self):
336
utils.create_user(self.tenant, self.user, str(self.auth_token))
337
resp, content = utils.user_get_xml(self.user,
338
str(self.invalid_token))
339
resp_val = int(resp['status'])
340
utils.handle_user_resp(self, content, resp_val,
341
utils.content_type(resp))
342
self.assertEqual(404, resp_val)
343
self.assertEqual('application/xml', utils.content_type(resp))
345
def test_a_user_get_disabled_user(self):
346
utils.create_user(self.tenant, self.user, str(self.auth_token))
347
resp, content = utils.user_get_json(self.userdisabled,
348
str(self.auth_token))
349
resp_val = int(resp['status'])
350
utils.handle_user_resp(self, content, resp_val,
351
utils.content_type(resp))
352
self.assertEqual(200, resp_val)
354
def test_a_user_get_disabled_user_xml(self):
355
utils.create_user(self.tenant, self.user, str(self.auth_token))
356
resp, content = utils.user_get_xml(self.userdisabled,
357
str(self.auth_token))
358
resp_val = int(resp['status'])
359
utils.handle_user_resp(self, content, resp_val,
360
utils.content_type(resp))
361
self.assertEqual(200, resp_val)
362
self.assertEqual('application/xml', utils.content_type(resp))
364
# def test_a_user_get_disabled_tenant(self):
365
# utils.create_user('0000', self.user, str(self.auth_token))
366
# resp, content = utils.user_get_json(self.user,
367
# str(self.auth_token))
368
# resp_val = int(resp['status'])
369
# utils.handle_user_resp(self, content, resp_val,
370
# utils.content_type(resp))
371
# self.assertEqual(403, resp_val)
373
# def test_a_user_get_disabled_tenant_xml(self):
374
# utils.create_user('0000', self.user, str(self.auth_token))
375
# resp, content = utils.user_get_xml(self.user,
376
# str(self.auth_token))
377
# resp_val = int(resp['status'])
378
# utils.handle_user_resp(self, content, resp_val,
379
# utils.content_type(resp))
380
# self.assertEqual(403, resp_val)
381
# self.assertEqual('application/xml',
382
# utils.content_type(resp))
385
class DeleteUserTest(UserTest):
387
def test_a_user_delete(self):
388
utils.create_user(self.tenant, self.user,
389
str(self.auth_token))
390
resp = utils.delete_user(self.user,
391
str(self.auth_token))
392
resp_val = int(resp['status'])
394
self.fail('Identity Fault')
395
elif resp_val == 503:
396
self.fail('Service Not Available')
397
self.assertEqual(204, resp_val)
399
def test_a_user_delete_xml(self):
400
utils.create_user(self.tenant, self.user,
401
str(self.auth_token))
402
resp = utils.delete_user_xml(self.user, str(self.auth_token))
403
resp_val = int(resp['status'])
405
self.fail('Identity Fault')
406
elif resp_val == 503:
407
self.fail('Service Not Available')
408
self.assertEqual(204, resp_val)
410
def test_a_user_delete_expired_token(self):
411
utils.create_user(self.tenant, self.user,
412
str(self.auth_token))
413
resp = utils.delete_user(self.user,
414
str(self.exp_auth_token))
415
resp_val = int(resp['status'])
417
self.fail('Identity Fault')
418
elif resp_val == 503:
419
self.fail('Service Not Available')
420
self.assertEqual(403, resp_val)
422
def test_a_user_delete_expired_token_xml(self):
423
utils.create_user(self.tenant, self.user,
424
str(self.auth_token))
425
resp = utils.delete_user_xml(self.user, str(self.exp_auth_token))
426
resp_val = int(resp['status'])
428
self.fail('Identity Fault')
429
elif resp_val == 503:
430
self.fail('Service Not Available')
431
self.assertEqual(403, resp_val)
432
self.assertEqual('application/xml', utils.content_type(resp))
434
def test_a_user_delete_missing_token(self):
435
utils.create_user(self.tenant, self.user,
436
str(self.auth_token))
437
resp = utils.delete_user(self.user,
438
str(self.missing_token))
439
resp_val = int(resp['status'])
441
self.fail('Identity Fault')
442
elif resp_val == 503:
443
self.fail('Service Not Available')
444
self.assertEqual(401, resp_val)
446
def test_a_user_delete_missing_token_xml(self):
447
utils.create_user(self.tenant, self.user,
448
str(self.auth_token))
449
resp = utils.delete_user_xml(self.user, str(self.missing_token))
450
resp_val = int(resp['status'])
452
self.fail('Identity Fault')
453
elif resp_val == 503:
454
self.fail('Service Not Available')
455
self.assertEqual(401, resp_val)
456
self.assertEqual('application/xml', utils.content_type(resp))
458
def test_a_user_delete_invalid_token(self):
459
utils.create_user(self.tenant, self.user,
460
str(self.auth_token))
461
resp = utils.delete_user(self.user,
462
str(self.invalid_token))
463
resp_val = int(resp['status'])
465
self.fail('Identity Fault')
466
elif resp_val == 503:
467
self.fail('Service Not Available')
468
self.assertEqual(404, resp_val)
470
def test_a_user_delete_invalid_token_xml(self):
471
utils.create_user(self.tenant, self.user,
472
str(self.auth_token))
473
resp = utils.delete_user_xml(self.user, str(self.invalid_token))
474
resp_val = int(resp['status'])
476
self.fail('Identity Fault')
477
elif resp_val == 503:
478
self.fail('Service Not Available')
479
self.assertEqual(404, resp_val)
480
self.assertEqual('application/xml', utils.content_type(resp))
482
# def test_a_user_delete_disabled_tenant(self):
483
# utils.create_user(self.tenant, self.user,
484
# str(self.auth_token))
485
# resp = utils.delete_user(self.user,
486
# str(self.auth_token))
487
# resp_val = int(resp['status'])
488
# if resp_val == 500:
489
# self.fail('Identity Fault')
490
# elif resp_val == 503:
491
# self.fail('Service Not Available')
492
# self.assertEqual(403, resp_val)
494
# def test_a_user_delete_disabled_tenant_xml(self):
495
# utils.create_user(self.tenant, self.user,
496
# str(self.auth_token))
497
# resp = utils.delete_user_xml(self.user,
498
# str(self.auth_token))
499
# resp_val = int(resp['status'])
500
# if resp_val == 500:
501
# self.fail('Identity Fault')
502
# elif resp_val == 503:
503
# self.fail('Service Not Available')
504
# self.assertEqual(403, resp_val)
505
# self.assertEqual('application/xml', utils.content_type(resp))
508
class GetAllUsersTest(UserTest):
509
def test_users_get(self):
510
resp, _content = utils.users_get_all_json(self.auth_token)
511
resp_val = int(resp['status'])
513
self.fail('Identity Fault')
514
elif resp_val == 503:
515
self.fail('Service Not Available')
516
self.assertEqual(200, resp_val)
518
def test_users_get_xml(self):
519
resp, _content = utils.users_get_all_xml(self.auth_token)
520
resp_val = int(resp['status'])
522
self.fail('Identity Fault')
523
elif resp_val == 503:
524
self.fail('Service Not Available')
525
self.assertEqual(200, resp_val)
526
self.assertEqual('application/xml', utils.content_type(resp))
528
def test_users_get_expired_token(self):
529
resp, _content = utils.users_get_all_json(self.exp_auth_token)
530
resp_val = int(resp['status'])
532
self.fail('Identity Fault')
533
elif resp_val == 503:
534
self.fail('Service Not Available')
535
self.assertEqual(403, resp_val)
537
def test_users_get_expired_token_xml(self):
538
resp, _content = utils.users_get_all_xml(self.exp_auth_token)
539
resp_val = int(resp['status'])
541
self.fail('Identity Fault')
542
elif resp_val == 503:
543
self.fail('Service Not Available')
544
self.assertEqual(403, resp_val)
545
self.assertEqual('application/xml', utils.content_type(resp))
547
def test_users_get_disabled_token(self):
548
resp, _content = utils.users_get_all_json(self.disabled_token)
549
resp_val = int(resp['status'])
551
self.fail('Identity Fault')
552
elif resp_val == 503:
553
self.fail('Service Not Available')
554
self.assertEqual(403, resp_val)
556
def test_users_get_disabled_token_xml(self):
557
resp, _content = utils.users_get_all_xml(self.disabled_token)
558
resp_val = int(resp['status'])
560
self.fail('Identity Fault')
561
elif resp_val == 503:
562
self.fail('Service Not Available')
563
self.assertEqual(403, resp_val)
564
self.assertEqual('application/xml', utils.content_type(resp))
566
def test_users_get_missing_token(self):
567
resp, _content = utils.users_get_all_json(self.missing_token)
568
resp_val = int(resp['status'])
570
self.fail('Identity Fault')
571
elif resp_val == 503:
572
self.fail('Service Not Available')
573
self.assertEqual(401, resp_val)
575
def test_users_get_missing_token_xml(self):
576
resp, _content = utils.users_get_all_xml(self.missing_token)
577
resp_val = int(resp['status'])
579
self.fail('Identity Fault')
580
elif resp_val == 503:
581
self.fail('Service Not Available')
582
self.assertEqual(401, resp_val)
583
self.assertEqual('application/xml', utils.content_type(resp))
585
def test_users_get_invalid_token(self):
586
resp, _content = utils.users_get_all_json(self.invalid_token)
587
resp_val = int(resp['status'])
589
self.fail('Identity Fault')
590
elif resp_val == 503:
591
self.fail('Service Not Available')
592
self.assertEqual(404, resp_val)
594
def test_users_get_invalid_token_xml(self):
595
resp, _content = utils.users_get_all_xml(self.invalid_token)
596
resp_val = int(resp['status'])
598
self.fail('Identity Fault')
599
elif resp_val == 503:
600
self.fail('Service Not Available')
601
self.assertEqual(404, resp_val)
602
self.assertEqual('application/xml', utils.content_type(resp))
605
class GetUsersTest(UserTest):
607
def test_users_get(self):
608
resp, _content = utils.users_get_json(self.user, self.auth_token)
609
resp_val = int(resp['status'])
611
self.fail('Identity Fault')
612
elif resp_val == 503:
613
self.fail('Service Not Available')
614
self.assertEqual(200, resp_val)
616
def test_users_get_xml(self):
617
resp, _content = utils.users_get_xml(self.user, self.auth_token)
618
resp_val = int(resp['status'])
620
self.fail('Identity Fault')
621
elif resp_val == 503:
622
self.fail('Service Not Available')
623
self.assertEqual(200, resp_val)
624
self.assertEqual('application/xml', utils.content_type(resp))
626
def test_users_get_expired_token(self):
627
resp, _content = utils.users_get_json(self.user, self.exp_auth_token)
628
resp_val = int(resp['status'])
630
self.fail('Identity Fault')
631
elif resp_val == 503:
632
self.fail('Service Not Available')
633
self.assertEqual(403, resp_val)
635
def test_users_get_expired_token_xml(self):
636
resp, _content_content = utils.users_get_xml(self.user,
638
resp_val = int(resp['status'])
640
self.fail('Identity Fault')
641
elif resp_val == 503:
642
self.fail('Service Not Available')
643
self.assertEqual(403, resp_val)
644
self.assertEqual('application/xml', utils.content_type(resp))
646
def test_users_get_disabled_token(self):
647
resp, _content = utils.users_get_json(self.user, self.disabled_token)
648
resp_val = int(resp['status'])
650
self.fail('Identity Fault')
651
elif resp_val == 503:
652
self.fail('Service Not Available')
653
self.assertEqual(403, resp_val)
655
def test_users_get_disabled_token_xml(self):
656
resp, _content = utils.users_get_xml(self.user, self.disabled_token)
657
resp_val = int(resp['status'])
659
self.fail('Identity Fault')
660
elif resp_val == 503:
661
self.fail('Service Not Available')
662
self.assertEqual(403, resp_val)
663
self.assertEqual('application/xml', utils.content_type(resp))
665
def test_users_get_missing_token(self):
666
resp, _content = utils.users_get_json(self.user, self.missing_token)
667
resp_val = int(resp['status'])
669
self.fail('Identity Fault')
670
elif resp_val == 503:
671
self.fail('Service Not Available')
672
self.assertEqual(401, resp_val)
674
def test_users_get_missing_token_xml(self):
675
resp, _content = utils.users_get_xml(self.user, self.missing_token)
676
resp_val = int(resp['status'])
678
self.fail('Identity Fault')
679
elif resp_val == 503:
680
self.fail('Service Not Available')
681
self.assertEqual(401, resp_val)
682
self.assertEqual('application/xml', utils.content_type(resp))
684
def test_users_get_invalid_token(self):
685
resp, _content = utils.users_get_json(self.user, self.invalid_token)
686
resp_val = int(resp['status'])
688
self.fail('Identity Fault')
689
elif resp_val == 503:
690
self.fail('Service Not Available')
691
self.assertEqual(404, resp_val)
693
def test_users_get_invalid_token_xml(self):
694
resp, _content = utils.users_get_xml(self.user, self.invalid_token)
695
resp_val = int(resp['status'])
697
self.fail('Identity Fault')
698
elif resp_val == 503:
699
self.fail('Service Not Available')
700
self.assertEqual(404, resp_val)
701
self.assertEqual('application/xml', utils.content_type(resp))
703
# Right now the very first call to create a user fails.
704
# This prevents from executing test. Need to find a way.
705
# def test_users_get_disabled_tenant(self):
706
# utils.delete_user(self.user, self.auth_token);
707
# utils.create_user('0000', self.user, self.auth_token)
708
# resp, content = utils.users_get_json(self.user, self.auth_token)
709
# resp_val = int(resp['status'])
710
# if resp_val == 500:
711
# self.fail('Identity Fault')
712
# elif resp_val == 503:
713
# self.fail('Service Not Available')
714
# self.assertEqual(403, resp_val)
716
# def test_users_get_disabled_tenant_xml(self):
717
# utils.delete_user(self.user, self.auth_token);
718
# utils.create_user('0000', self.user, self.auth_token)
719
# resp, content = utils.users_get_xml(self.user, self.auth_token)
720
# resp_val = int(resp['status'])
721
# if resp_val == 500:
722
# self.fail('Identity Fault')
723
# elif resp_val == 503:
724
# self.fail('Service Not Available')
725
# self.assertEqual(403, resp_val)
726
# self.assertEqual('application/xml', utils.content_type(resp))
729
class UpdateUserTest(UserTest):
732
super(UpdateUserTest, self).setUp()
733
utils.create_user(self.tenant, self.user, str(self.auth_token))
736
super(UpdateUserTest, self).tearDown()
738
def test_user_update(self):
739
resp, content = utils.user_update_json(self.auth_token, self.user)
740
resp_val = int(resp['status'])
741
content = json.loads(content)
743
self.fail('Identity Fault')
744
elif resp_val == 503:
745
self.fail('Service Not Available')
746
self.assertEqual(200, resp_val)
747
self.assertEqual('updatedjoeuser@openstack.org',
748
content['user']['email'])
750
def test_user_update_xml(self):
751
resp, content = utils.user_update_xml(self.auth_token, self.user)
752
resp_val = int(resp['status'])
753
content = etree.fromstring(content)
755
self.fail('Identity Fault')
756
elif resp_val == 503:
757
self.fail('Service Not Available')
758
self.assertEqual(200, resp_val)
759
self.assertEqual('updatedjoeuser@openstack.org',
760
content.get("email"))
761
self.assertEqual('application/xml', utils.content_type(resp))
763
def test_user_update_user_disabled(self):
764
utils.user_set_enabled(self.auth_token, self.user, enabled=False)
765
resp, content = utils.user_update_json(self.auth_token,
767
resp_val = int(resp['status'])
768
content = json.loads(content)
770
self.fail('Identity Fault')
771
elif resp_val == 503:
772
self.fail('Service Not Available')
773
self.assertEqual(200, resp_val)
774
#Resetting to empty email to allow other tests to pass.
775
utils.user_update_json(self.auth_token,
776
self.userdisabled, '')
778
def test_user_update_user_disabled_xml(self):
779
utils.user_set_enabled(self.auth_token, self.user, enabled=False)
780
resp, content = utils.user_update_xml(self.auth_token,
782
resp_val = int(resp['status'])
783
content = etree.fromstring(content)
785
self.fail('Identity Fault')
786
elif resp_val == 503:
787
self.fail('Service Not Available')
788
self.assertEqual(200, resp_val)
789
self.assertEqual('application/xml', utils.content_type(resp))
790
#Resetting to empty email to allow other tests to pass.
791
utils.user_update_xml(self.auth_token,
792
self.userdisabled, '')
794
def test_user_update_email_conflict(self):
795
resp, content = utils.user_update_json(self.auth_token,
797
"test_user@openstack.org")
798
resp_val = int(resp['status'])
799
content = json.loads(content)
801
self.fail('Identity Fault')
802
elif resp_val == 503:
803
self.fail('Service Not Available')
804
self.assertEqual(409, resp_val)
806
def test_user_update_email_conflict_xml(self):
807
resp, content = utils.user_update_xml(self.auth_token,
809
"test_user@openstack.org")
810
resp_val = int(resp['status'])
811
content = etree.fromstring(content)
813
self.fail('Identity Fault')
814
elif resp_val == 503:
815
self.fail('Service Not Available')
816
self.assertEqual(409, resp_val)
817
self.assertEqual('application/xml', utils.content_type(resp))
819
def test_user_update_bad_request_json(self):
820
h = httplib2.Http(".cache")
821
_resp, _content = utils.create_user(self.tenant, self.user,
822
str(self.auth_token))
823
url = '%susers/%s' % (URL_V2, self.user)
824
data = '{"user_bad": { "bad": "updatedjoeuser@openstack.org"}}'
825
resp, content = h.request(url, "PUT", body=data,
826
headers={"Content-Type": "application/json",
827
"X-Auth-Token": self.auth_token})
828
resp_val = int(resp['status'])
829
content = json.loads(content)
831
self.fail('Identity Fault')
832
elif resp_val == 503:
833
self.fail('Service Not Available')
834
self.assertEqual(400, resp_val)
836
def test_user_update_bad_request_xml(self):
837
h = httplib2.Http(".cache")
838
_resp, _content = utils.create_user_xml(self.tenant, self.user,
839
str(self.auth_token))
840
url = '%susers/%s' % (URL_V2, self.user)
841
data = '<?xml version="1.0" encoding="UTF-8"?> \
842
user xmlns="http://docs.openstack.org/identity/api/v2.0" \
843
email="updatedjoeuser@openstack.org" />'
844
resp, content = h.request(url, "PUT", body=data,
845
headers={"Content-Type": "application/xml",
846
"X-Auth-Token": self.auth_token,
847
"ACCEPT": "application/xml"})
848
resp_val = int(resp['status'])
849
content = etree.fromstring(content)
851
self.fail('Identity Fault')
852
elif resp_val == 503:
853
self.fail('Service Not Available')
854
self.assertEqual(400, resp_val)
855
self.assertEqual('application/xml', utils.content_type(resp))
857
def test_user_update_expired_token(self):
858
resp, content = utils.user_update_json(self.exp_auth_token,
860
resp_val = int(resp['status'])
861
content = json.loads(content)
863
self.fail('Identity Fault')
864
elif resp_val == 503:
865
self.fail('Service Not Available')
866
self.assertEqual(403, resp_val)
868
def test_user_update_expired_token_xml(self):
869
resp, content = utils.user_update_xml(self.exp_auth_token,
871
resp_val = int(resp['status'])
872
content = etree.fromstring(content)
874
self.fail('Identity Fault')
875
elif resp_val == 503:
876
self.fail('Service Not Available')
877
self.assertEqual(403, resp_val)
878
self.assertEqual('application/xml', utils.content_type(resp))
880
def test_user_update_disabled_token(self):
881
resp, content = utils.user_update_json(self.disabled_token, self.user)
882
resp_val = int(resp['status'])
883
content = json.loads(content)
885
self.fail('Identity Fault')
886
elif resp_val == 503:
887
self.fail('Service Not Available')
888
self.assertEqual(403, resp_val)
890
def test_user_update_disabled_token_xml(self):
891
resp, content = utils.user_update_xml(self.disabled_token, self.user)
892
resp_val = int(resp['status'])
893
content = etree.fromstring(content)
895
self.fail('Identity Fault')
896
elif resp_val == 503:
897
self.fail('Service Not Available')
898
self.assertEqual(403, resp_val)
899
self.assertEqual('application/xml', utils.content_type(resp))
901
def test_user_update_invalid_token(self):
902
resp, content = utils.user_update_json(self.invalid_token,
904
resp_val = int(resp['status'])
905
content = json.loads(content)
907
self.fail('Identity Fault')
908
elif resp_val == 503:
909
self.fail('Service Not Available')
910
self.assertEqual(404, resp_val)
912
def test_user_update_invalid_token_xml(self):
913
resp, content = utils.user_update_xml(self.invalid_token, self.user)
914
resp_val = int(resp['status'])
915
content = etree.fromstring(content)
917
self.fail('Identity Fault')
918
elif resp_val == 503:
919
self.fail('Service Not Available')
920
self.assertEqual(404, resp_val)
921
self.assertEqual('application/xml', utils.content_type(resp))
923
def test_user_update_missing_token(self):
924
resp, content = utils.user_update_json(self.missing_token, self.user)
925
resp_val = int(resp['status'])
926
content = json.loads(content)
928
self.fail('Identity Fault')
929
elif resp_val == 503:
930
self.fail('Service Not Available')
931
self.assertEqual(401, resp_val)
933
def test_user_update_missing_token_xml(self):
934
resp, content = utils.user_update_xml(self.missing_token,
936
resp_val = int(resp['status'])
937
content = etree.fromstring(content)
939
self.fail('Identity Fault')
940
elif resp_val == 503:
941
self.fail('Service Not Available')
942
self.assertEqual(401, resp_val)
943
self.assertEqual('application/xml', utils.content_type(resp))
946
class SetPasswordTest(UserTest):
948
def test_user_password(self):
949
utils.create_user(self.tenant, self.user, str(self.auth_token))
950
resp, content = utils.user_password_json(self.user,
951
str(self.auth_token))
952
resp_val = int(resp['status'])
953
content = json.loads(content)
955
self.fail('Identity Fault')
956
elif resp_val == 503:
957
self.fail('Service Not Available')
958
utils.delete_user(self.user, str(self.auth_token))
959
self.assertEqual(200, resp_val)
960
self.assertEqual('p@ssword', content['user']['password'])
962
def test_user_password_xml(self):
963
utils.create_user(self.tenant, self.user, str(self.auth_token))
964
resp, content = utils.user_password_xml(self.user,
965
str(self.auth_token))
966
resp_val = int(resp['status'])
967
content = etree.fromstring(content)
969
self.fail('Identity Fault')
970
elif resp_val == 503:
971
self.fail('Service Not Available')
972
utils.delete_user(self.user, str(self.auth_token))
973
self.assertEqual(200, resp_val)
974
self.assertEqual('p@ssword', content.get("password"))
975
self.assertEqual('application/xml', utils.content_type(resp))
977
def test_user_password_user_disabled(self):
978
utils.create_user(self.tenant, self.user, str(self.auth_token))
979
resp, content = utils.user_password_json(self.userdisabled,
980
str(self.auth_token))
981
resp_val = int(resp['status'])
982
content = json.loads(content)
984
self.fail('Identity Fault')
985
elif resp_val == 503:
986
self.fail('Service Not Available')
987
self.assertEqual(200, resp_val)
989
def test_user_password_user_disabled_xml(self):
990
utils.create_user(self.tenant, self.user, str(self.auth_token))
991
resp, content = utils.user_password_xml(self.userdisabled,
992
str(self.auth_token))
993
resp_val = int(resp['status'])
994
content = etree.fromstring(content)
996
self.fail('Identity Fault')
997
elif resp_val == 503:
998
self.fail('Service Not Available')
999
self.assertEqual(200, resp_val)
1000
self.assertEqual('application/xml', utils.content_type(resp))
1002
def test_user_password_bad_request_json(self):
1003
h = httplib2.Http(".cache")
1004
utils.create_user(self.tenant, self.user,
1005
str(self.auth_token))
1006
url = '%susers/%s/password' % (URL_V2, self.user)
1007
data = '{"user_bad": { "password": "p@ssword"}}'
1008
resp, content = h.request(url, "PUT", body=data,
1009
headers={"Content-Type": "application/json",
1010
"X-Auth-Token": self.auth_token})
1011
resp_val = int(resp['status'])
1012
content = json.loads(content)
1014
self.fail('Identity Fault')
1015
elif resp_val == 503:
1016
self.fail('Service Not Available')
1017
utils.delete_user(self.user, str(self.auth_token))
1018
self.assertEqual(400, resp_val)
1020
def test_user_password_bad_request_xml(self):
1021
h = httplib2.Http(".cache")
1022
utils.create_user_xml(self.tenant, self.user, str(self.auth_token))
1023
url = '%susers/%s/password' % (URL_V2, self.user)
1024
data = '<?xml version="1.0" encoding="UTF-8"?> \
1025
user xmlns="http://docs.openstack.org/identity/api/v2.0" \
1026
password="p@ssword" />'
1027
resp, content = h.request(url, "PUT", body=data,
1028
headers={"Content-Type": "application/xml",
1029
"X-Auth-Token": self.auth_token,
1030
"ACCEPT": "application/xml"})
1031
resp_val = int(resp['status'])
1032
content = etree.fromstring(content)
1034
self.fail('Identity Fault')
1035
elif resp_val == 503:
1036
self.fail('Service Not Available')
1037
utils.delete_user(self.user, str(self.auth_token))
1038
self.assertEqual(400, resp_val)
1039
self.assertEqual('application/xml', utils.content_type(resp))
1041
def test_user_password_expired_token(self):
1042
utils.create_user(self.tenant, self.user, str(self.auth_token))
1043
resp, content = utils.user_password_json(self.user,
1044
str(self.exp_auth_token))
1045
resp_val = int(resp['status'])
1046
content = json.loads(content)
1048
self.fail('Identity Fault')
1049
elif resp_val == 503:
1050
self.fail('Service Not Available')
1051
self.assertEqual(403, resp_val)
1053
def test_user_password_expired_token_xml(self):
1054
utils.create_user(self.tenant, self.user, str(self.auth_token))
1055
resp, content = utils.user_password_xml(self.user,
1056
str(self.exp_auth_token))
1057
resp_val = int(resp['status'])
1058
content = etree.fromstring(content)
1060
self.fail('Identity Fault')
1061
elif resp_val == 503:
1062
self.fail('Service Not Available')
1063
self.assertEqual(403, resp_val)
1064
self.assertEqual('application/xml', utils.content_type(resp))
1066
def test_user_password_disabled_token(self):
1067
utils.create_user(self.tenant, self.user, str(self.auth_token))
1068
resp, content = utils.user_password_json(self.user,
1069
str(self.disabled_token))
1070
resp_val = int(resp['status'])
1071
content = json.loads(content)
1073
self.fail('Identity Fault')
1074
elif resp_val == 503:
1075
self.fail('Service Not Available')
1076
self.assertEqual(403, resp_val)
1078
def test_user_password_disabled_token_xml(self):
1079
utils.create_user(self.tenant, self.user, str(self.auth_token))
1080
resp, content = utils.user_password_xml(self.user,
1081
str(self.disabled_token))
1082
resp_val = int(resp['status'])
1083
content = etree.fromstring(content)
1085
self.fail('Identity Fault')
1086
elif resp_val == 503:
1087
self.fail('Service Not Available')
1088
self.assertEqual(403, resp_val)
1089
self.assertEqual('application/xml', utils.content_type(resp))
1091
def test_user_password_invalid_token(self):
1092
utils.create_user(self.tenant,
1094
str(self.auth_token))
1095
resp, content = utils.user_password_json(self.user,
1096
str(self.invalid_token))
1097
resp_val = int(resp['status'])
1098
content = json.loads(content)
1100
self.fail('Identity Fault')
1101
elif resp_val == 503:
1102
self.fail('Service Not Available')
1103
self.assertEqual(404, resp_val)
1105
def test_user_password_invalid_token_xml(self):
1106
utils.create_user(self.tenant, self.user, str(self.auth_token))
1107
resp, content = utils.user_password_xml(self.user,
1108
str(self.invalid_token))
1109
resp_val = int(resp['status'])
1110
content = etree.fromstring(content)
1112
self.fail('Identity Fault')
1113
elif resp_val == 503:
1114
self.fail('Service Not Available')
1115
self.assertEqual(404, resp_val)
1116
self.assertEqual('application/xml', utils.content_type(resp))
1118
def test_user_password_missing_token(self):
1119
utils.create_user(self.tenant, self.user, str(self.auth_token))
1120
resp, content = utils.user_password_json(self.user,
1121
str(self.missing_token))
1122
resp_val = int(resp['status'])
1123
content = json.loads(content)
1125
self.fail('Identity Fault')
1126
elif resp_val == 503:
1127
self.fail('Service Not Available')
1128
self.assertEqual(401, resp_val)
1130
def test_user_password_missing_token_xml(self):
1131
utils.create_user(self.tenant, self.user, str(self.auth_token))
1132
resp, content = utils.user_password_xml(self.user,
1133
str(self.missing_token))
1134
resp_val = int(resp['status'])
1135
content = etree.fromstring(content)
1137
self.fail('Identity Fault')
1138
elif resp_val == 503:
1139
self.fail('Service Not Available')
1140
self.assertEqual(401, resp_val)
1141
self.assertEqual('application/xml', utils.content_type(resp))
1144
class SetEnabledTest(UserTest):
1146
def test_user_enabled(self):
1147
utils.create_user(self.tenant, self.user, str(self.auth_token))
1148
resp, content = utils.user_enabled_json(self.user,
1149
str(self.auth_token))
1150
resp_val = int(resp['status'])
1151
content = json.loads(content)
1153
self.fail('Identity Fault')
1154
elif resp_val == 503:
1155
self.fail('Service Not Available')
1156
utils.delete_user(self.user, str(self.auth_token))
1157
self.assertEqual(200, resp_val)
1158
self.assertEqual(True, content['user']['enabled'])
1160
def test_user_enabled_xml(self):
1161
utils.create_user(self.tenant, self.user, str(self.auth_token))
1162
resp, content = utils.user_enabled_xml(self.user,
1163
str(self.auth_token))
1164
resp_val = int(resp['status'])
1165
content = etree.fromstring(content)
1167
self.fail('Identity Fault')
1168
elif resp_val == 503:
1169
self.fail('Service Not Available')
1170
utils.delete_user(self.user, str(self.auth_token))
1171
self.assertEqual(200, resp_val)
1172
self.assertEqual('true', content.get("enabled"))
1173
self.assertEqual('application/xml', utils.content_type(resp))
1175
def test_user_enabled_bad_request_json(self):
1176
h = httplib2.Http(".cache")
1177
utils.create_user(self.tenant, self.user,
1178
str(self.auth_token))
1179
url = '%susers/%s/enabled' % (URL_V2, self.user)
1180
data = '{"user_bad": { "enabled": true}}'
1181
resp, content = h.request(url, "PUT", body=data,
1182
headers={"Content-Type": "application/json",
1183
"X-Auth-Token": self.auth_token})
1184
resp_val = int(resp['status'])
1185
content = json.loads(content)
1187
self.fail('Identity Fault')
1188
elif resp_val == 503:
1189
self.fail('Service Not Available')
1190
utils.delete_user(self.user, str(self.auth_token))
1191
self.assertEqual(400, resp_val)
1193
def test_user_enabled_bad_request_xml(self):
1194
h = httplib2.Http(".cache")
1195
utils.create_user_xml(self.tenant, self.user,
1196
str(self.auth_token))
1197
url = '%susers/%s/enabled' % (URL_V2, self.user)
1198
data = '<?xml version="1.0" encoding="UTF-8"?> \
1199
user xmlns="http://docs.openstack.org/identity/api/v2.0" \
1201
resp, content = h.request(url, "PUT", body=data,
1202
headers={"Content-Type": "application/xml",
1203
"X-Auth-Token": self.auth_token,
1204
"ACCEPT": "application/xml"})
1205
resp_val = int(resp['status'])
1206
content = etree.fromstring(content)
1208
self.fail('Identity Fault')
1209
elif resp_val == 503:
1210
self.fail('Service Not Available')
1211
utils.delete_user(self.user, str(self.auth_token))
1212
self.assertEqual(400, resp_val)
1213
self.assertEqual('application/xml', utils.content_type(resp))
1215
def test_user_enabled_expired_token(self):
1216
utils.create_user(self.tenant, self.user, str(self.auth_token))
1217
resp, content = utils.user_enabled_json(self.user,
1218
str(self.exp_auth_token))
1219
resp_val = int(resp['status'])
1220
content = json.loads(content)
1222
self.fail('Identity Fault')
1223
elif resp_val == 503:
1224
self.fail('Service Not Available')
1225
self.assertEqual(403, resp_val)
1227
def test_user_enabled_expired_token_xml(self):
1228
utils.create_user(self.tenant, self.user, str(self.auth_token))
1229
resp, content = utils.user_enabled_xml(self.user,
1230
str(self.exp_auth_token))
1231
resp_val = int(resp['status'])
1232
content = etree.fromstring(content)
1234
self.fail('Identity Fault')
1235
elif resp_val == 503:
1236
self.fail('Service Not Available')
1237
self.assertEqual(403, resp_val)
1238
self.assertEqual('application/xml', utils.content_type(resp))
1240
def test_user_enabled_disabled_token(self):
1241
utils.create_user(self.tenant, self.user, str(self.auth_token))
1242
resp, content = utils.user_enabled_json(self.user,
1243
str(self.disabled_token))
1244
resp_val = int(resp['status'])
1245
content = json.loads(content)
1247
self.fail('Identity Fault')
1248
elif resp_val == 503:
1249
self.fail('Service Not Available')
1250
self.assertEqual(403, resp_val)
1252
def test_user_enabled_disabled_token_xml(self):
1253
utils.create_user(self.tenant, self.user, str(self.auth_token))
1254
resp, content = utils.user_enabled_xml(self.user,
1255
str(self.disabled_token))
1256
resp_val = int(resp['status'])
1257
content = etree.fromstring(content)
1259
self.fail('Identity Fault')
1260
elif resp_val == 503:
1261
self.fail('Service Not Available')
1262
self.assertEqual(403, resp_val)
1263
self.assertEqual('application/xml', utils.content_type(resp))
1265
def test_user_enabled_invalid_token(self):
1266
utils.create_user(self.tenant, self.user, str(self.auth_token))
1267
resp, content = utils.user_enabled_json(self.user,
1268
str(self.invalid_token))
1269
resp_val = int(resp['status'])
1270
content = json.loads(content)
1272
self.fail('Identity Fault')
1273
elif resp_val == 503:
1274
self.fail('Service Not Available')
1275
self.assertEqual(404, resp_val)
1277
def test_user_enabled_invalid_token_xml(self):
1278
utils.create_user(self.tenant, self.user, str(self.auth_token))
1279
resp, content = utils.user_enabled_xml(self.user,
1280
str(self.invalid_token))
1281
resp_val = int(resp['status'])
1282
content = etree.fromstring(content)
1284
self.fail('Identity Fault')
1285
elif resp_val == 503:
1286
self.fail('Service Not Available')
1287
self.assertEqual(404, resp_val)
1288
self.assertEqual('application/xml', utils.content_type(resp))
1290
def test_user_enabled_missing_token(self):
1291
utils.create_user(self.tenant, self.user, str(self.auth_token))
1292
resp, content = utils.user_enabled_json(self.user,
1293
str(self.missing_token))
1294
resp_val = int(resp['status'])
1295
content = json.loads(content)
1297
self.fail('Identity Fault')
1298
elif resp_val == 503:
1299
self.fail('Service Not Available')
1300
self.assertEqual(401, resp_val)
1302
def test_user_enabled_missing_token_xml(self):
1303
utils.create_user(self.tenant, self.user, str(self.auth_token))
1304
resp, content = utils.user_enabled_xml(self.user,
1305
str(self.missing_token))
1306
resp_val = int(resp['status'])
1307
content = etree.fromstring(content)
1309
self.fail('Identity Fault')
1310
elif resp_val == 503:
1311
self.fail('Service Not Available')
1312
self.assertEqual(401, resp_val)
1313
self.assertEqual('application/xml', utils.content_type(resp))
1316
class TenantUpdateTest(UserTest):
1318
def test_update_user_tenant(self):
1319
utils.create_user(self.tenant, self.user, str(self.auth_token))
1320
resp, content = utils.user_tenant_update_json(self.user,
1321
utils.get_another_tenant(), str(self.auth_token))
1322
resp_val = int(resp['status'])
1323
content = json.loads(content)
1325
self.fail('Identity Fault')
1326
elif resp_val == 503:
1327
self.fail('Service Not Available')
1328
utils.delete_user(self.user, str(self.auth_token))
1329
self.assertEqual(200, resp_val)
1330
self.assertEqual(utils.get_another_tenant(),
1331
content['user']['tenantId'])
1333
def test_update_user_tenant_xml(self):
1334
utils.create_user(self.tenant, self.user, str(self.auth_token))
1335
resp, content = utils.user_tenant_update_xml(
1336
self.user, utils.get_another_tenant(), str(self.auth_token))
1337
resp_val = int(resp['status'])
1338
content = etree.fromstring(content)
1340
self.fail('Identity Fault')
1341
elif resp_val == 503:
1342
self.fail('Service Not Available')
1343
utils.delete_user(self.user, str(self.auth_token))
1344
self.assertEqual(200, resp_val)
1345
self.assertEqual(utils.get_another_tenant(), content.get("tenantId"))
1346
self.assertEqual('application/xml', utils.content_type(resp))
1348
def test_update_user_tenant_using_invalid_tenant(self):
1349
utils.create_user(self.tenant, self.user, str(self.auth_token))
1350
resp, content = utils.user_tenant_update_json(self.user, "unknown",
1351
str(self.auth_token))
1352
resp_val = int(resp['status'])
1353
content = json.loads(content)
1355
self.fail('Identity Fault')
1356
elif resp_val == 503:
1357
self.fail('Service Not Available')
1358
self.assertEqual(404, resp_val)
1359
utils.delete_user(self.user, str(self.auth_token))
1361
def test_update_user_tenant_using_disabled_tenant(self):
1362
utils.create_user(self.tenant, self.user, str(self.auth_token))
1363
resp, content = utils.user_tenant_update_json(self.user, "disable",
1364
str(self.auth_token))
1365
resp_val = int(resp['status'])
1366
content = json.loads(content)
1368
self.fail('Identity Fault')
1369
elif resp_val == 503:
1370
self.fail('Service Not Available')
1371
self.assertEqual(404, resp_val)
1372
utils.delete_user(self.user, str(self.auth_token))
1374
def test_update_user_tenant_using_missing_token(self):
1375
utils.create_user(self.tenant, self.user, str(self.auth_token))
1376
resp, content = utils.user_tenant_update_json(
1377
self.user, utils.get_another_tenant(), str(self.missing_token))
1378
resp_val = int(resp['status'])
1379
content = json.loads(content)
1381
self.fail('Identity Fault')
1382
elif resp_val == 503:
1383
self.fail('Service Not Available')
1384
utils.delete_user(self.user, str(self.auth_token))
1385
self.assertEqual(401, resp_val)
1387
def test_update_user_tenant_using_invalid_token(self):
1388
utils.create_user(self.tenant, self.user, str(self.auth_token))
1389
resp, content = utils.user_tenant_update_json(
1390
self.user, utils.get_another_tenant(), str(self.invalid_token))
1391
resp_val = int(resp['status'])
1392
content = json.loads(content)
1394
self.fail('Identity Fault')
1395
elif resp_val == 503:
1396
self.fail('Service Not Available')
1397
utils.delete_user(self.user, str(self.auth_token))
1398
self.assertEqual(404, resp_val)
1400
def test_update_user_tenant_using_disabled_token(self):
1401
utils.create_user(self.tenant, self.user, str(self.auth_token))
1402
resp, content = utils.user_tenant_update_json(
1403
self.user, utils.get_another_tenant(), str(self.disabled_token))
1404
resp_val = int(resp['status'])
1405
content = json.loads(content)
1407
self.fail('Identity Fault')
1408
elif resp_val == 503:
1409
self.fail('Service Not Available')
1410
utils.delete_user(self.user, str(self.auth_token))
1411
self.assertEqual(403, resp_val)
1413
def test_update_user_tenant_using_exp_auth_token(self):
1414
utils.create_user(self.tenant, self.user, str(self.auth_token))
1415
resp, content = utils.user_tenant_update_json(
1416
self.user, utils.get_another_tenant(), str(self.exp_auth_token))
1417
resp_val = int(resp['status'])
1418
content = json.loads(content)
1420
self.fail('Identity Fault')
1421
elif resp_val == 503:
1422
self.fail('Service Not Available')
1423
utils.delete_user(self.user, str(self.auth_token))
1424
self.assertEqual(403, resp_val)
1426
def test_update_user_tenant_xml_using_missing_token(self):
1427
utils.create_user(self.tenant, self.user, str(self.auth_token))
1428
resp, content = utils.user_tenant_update_xml(
1429
self.user, utils.get_another_tenant(), str(self.missing_token))
1430
resp_val = int(resp['status'])
1431
content = etree.fromstring(content)
1433
self.fail('Identity Fault')
1434
elif resp_val == 503:
1435
self.fail('Service Not Available')
1436
utils.delete_user(self.user, str(self.auth_token))
1437
self.assertEqual(401, resp_val)
1439
def test_update_user_tenant_xml_using_invalid_token(self):
1440
utils.create_user(self.tenant, self.user, str(self.auth_token))
1441
resp, content = utils.user_tenant_update_xml(
1442
self.user, utils.get_another_tenant(), str(self.invalid_token))
1443
resp_val = int(resp['status'])
1444
content = etree.fromstring(content)
1446
self.fail('Identity Fault')
1447
elif resp_val == 503:
1448
self.fail('Service Not Available')
1449
utils.delete_user(self.user, str(self.auth_token))
1450
self.assertEqual(404, resp_val)
1452
def test_update_user_tenant_xml_using_disabled_token(self):
1453
utils.create_user(self.tenant, self.user, str(self.auth_token))
1454
resp, content = utils.user_tenant_update_xml(
1455
self.user, utils.get_another_tenant(), str(self.disabled_token))
1456
resp_val = int(resp['status'])
1457
content = etree.fromstring(content)
1459
self.fail('Identity Fault')
1460
elif resp_val == 503:
1461
self.fail('Service Not Available')
1462
utils.delete_user(self.user, str(self.auth_token))
1463
self.assertEqual(403, resp_val)
1465
def test_update_user_tenant_xml_using_exp_auth_token(self):
1466
utils.create_user(self.tenant, self.user, str(self.auth_token))
1467
resp, content = utils.user_tenant_update_xml(
1468
self.user, utils.get_another_tenant(), str(self.exp_auth_token))
1469
resp_val = int(resp['status'])
1470
content = etree.fromstring(content)
1472
self.fail('Identity Fault')
1473
elif resp_val == 503:
1474
self.fail('Service Not Available')
1475
utils.delete_user(self.user, str(self.auth_token))
1476
self.assertEqual(403, resp_val)
1479
class AddUserTest(UserTest):
1482
self.token = utils.get_token('joeuser1', 'secrete', '1234')
1483
self.tenant = utils.get_another_tenant()
1484
self.password = utils.get_password()
1485
self.email = utils.get_email()
1486
self.user = 'joeuser1'
1487
self.userdisabled = utils.get_userdisabled()
1488
self.auth_token = utils.get_auth_token()
1489
self.exp_auth_token = utils.get_exp_auth_token()
1490
self.disabled_token = utils.get_disabled_token()
1491
self.missing_token = utils.get_none_token()
1492
self.invalid_token = utils.get_non_existing_token()
1495
utils.delete_user(self.user, str(self.auth_token))
1496
utils.delete_tenant(str(self.auth_token), self.tenant)
1498
def test_add_user_tenant(self):
1499
utils.create_tenant(self.tenant, str(self.auth_token))
1500
resp, _content = utils.create_user(self.tenant,
1502
str(self.auth_token))
1503
resp_val = int(resp['status'])
1505
self.fail('Identity Fault')
1506
elif resp_val == 503:
1507
self.fail('Service Not Available')
1508
self.assertEqual(201, resp_val)
1510
def test_add_user_tenant_xml(self):
1511
utils.delete_user(self.user, str(self.auth_token))
1512
utils.create_tenant(self.tenant, str(self.auth_token))
1513
resp, _content = utils.create_user_xml(self.tenant,
1515
str(self.auth_token))
1516
resp_val = int(resp['status'])
1518
self.fail('Identity Fault')
1519
elif resp_val == 503:
1520
self.fail('Service Not Available')
1521
self.assertEqual(201, resp_val)
1523
def test_add_user_tenant_conflict(self):
1524
utils.create_tenant(self.tenant, str(self.auth_token))
1525
utils.create_user(self.tenant, self.user, str(self.auth_token))
1526
resp, _content = utils.create_user(self.tenant,
1528
str(self.auth_token))
1530
resp_val = int(resp['status'])
1532
self.fail('Identity Fault')
1533
elif resp_val == 503:
1534
self.fail('Service Not Available')
1535
self.assertEqual(409, resp_val)
1537
def test_add_user_tenant_conflict_xml(self):
1538
utils.create_tenant(self.tenant, str(self.auth_token))
1539
utils.create_user_xml(self.tenant, self.user, str(self.auth_token))
1540
resp, _content = utils.create_user_xml(self.tenant,
1542
str(self.auth_token))
1543
resp_val = int(resp['status'])
1545
self.fail('Identity Fault')
1546
elif resp_val == 503:
1547
self.fail('Service Not Available')
1548
self.assertEqual(409, resp_val)
1550
def test_add_user_tenant_expired_token(self):
1551
utils.create_tenant(self.tenant, str(self.auth_token))
1552
resp, _content = utils.create_user(self.tenant,
1554
str(self.exp_auth_token))
1555
resp_val = int(resp['status'])
1557
self.fail('Identity Fault')
1558
elif resp_val == 503:
1559
self.fail('Service Not Available')
1560
self.assertEqual(403, resp_val)
1562
def test_add_user_tenant_expired_token_xml(self):
1563
utils.create_tenant(self.tenant, str(self.auth_token))
1564
resp, _content = utils.create_user_xml(self.tenant,
1566
str(self.exp_auth_token))
1567
resp_val = int(resp['status'])
1569
self.fail('Identity Fault')
1570
elif resp_val == 503:
1571
self.fail('Service Not Available')
1572
self.assertEqual(403, resp_val)
1574
def test_add_user_tenant_disabled_token(self):
1575
utils.create_tenant(self.tenant, str(self.auth_token))
1576
resp, _content = utils.create_user(self.tenant,
1578
str(self.disabled_token))
1579
resp_val = int(resp['status'])
1581
self.fail('Identity Fault')
1582
elif resp_val == 503:
1583
self.fail('Service Not Available')
1584
self.assertEqual(403, resp_val)
1586
def test_add_user_tenant_disabled_token_xml(self):
1587
utils.create_tenant(self.tenant, str(self.auth_token))
1588
resp, _content = utils.create_user_xml(self.tenant,
1590
str(self.disabled_token))
1591
resp_val = int(resp['status'])
1593
self.fail('Identity Fault')
1594
elif resp_val == 503:
1595
self.fail('Service Not Available')
1596
self.assertEqual(403, resp_val)
1598
def test_add_user_tenant_invalid_token(self):
1599
utils.create_tenant(self.tenant, str(self.auth_token))
1600
resp, _content = utils.create_user(self.tenant,
1602
str(self.invalid_token))
1603
resp_val = int(resp['status'])
1605
self.fail('Identity Fault')
1606
elif resp_val == 503:
1607
self.fail('Service Not Available')
1608
self.assertEqual(404, resp_val)
1610
def test_add_user_tenant_invalid_token_xml(self):
1611
utils.create_tenant(self.tenant, str(self.auth_token))
1612
resp, _content = utils.create_user_xml(self.tenant,
1614
str(self.invalid_token))
1615
resp_val = int(resp['status'])
1617
self.fail('Identity Fault')
1618
elif resp_val == 503:
1619
self.fail('Service Not Available')
1620
self.assertEqual(404, resp_val)
1622
def test_add_user_tenant_missing_token(self):
1623
utils.create_tenant(self.tenant, str(self.auth_token))
1624
resp, _content = utils.create_user(self.tenant,
1626
str(self.missing_token))
1627
resp_val = int(resp['status'])
1629
self.fail('Identity Fault')
1630
elif resp_val == 503:
1631
self.fail('Service Not Available')
1632
self.assertEqual(401, resp_val)
1634
def test_add_user_tenant_missing_token_xml(self):
1635
utils.create_tenant(self.tenant, str(self.auth_token))
1636
resp, _content = utils.create_user_xml(self.tenant,
1638
str(self.missing_token))
1639
resp_val = int(resp['status'])
1641
self.fail('Identity Fault')
1642
elif resp_val == 503:
1643
self.fail('Service Not Available')
1644
self.assertEqual(401, resp_val)
1646
def test_add_user_tenant_disabled_tenant(self):
1647
utils.create_tenant(self.tenant, str(self.auth_token))
1648
resp, _content = utils.create_user('0000',
1650
str(self.auth_token))
1651
resp_val = int(resp['status'])
1653
self.fail('Identity Fault')
1654
elif resp_val == 503:
1655
self.fail('Service Not Available')
1656
self.assertEqual(403, resp_val)
1658
def test_add_user_tenant_disabled_tenant_xml(self):
1659
utils.create_tenant(self.tenant, str(self.auth_token))
1660
resp, _content = utils.create_user_xml('0000',
1662
str(self.auth_token))
1663
resp_val = int(resp['status'])
1665
self.fail('Identity Fault')
1666
elif resp_val == 503:
1667
self.fail('Service Not Available')
1668
self.assertEqual(403, resp_val)
1670
if __name__ == '__main__':
added
removed
keystone/test/unit/test_users.py
