← Back to branch summary

~ubuntu-branches/ubuntu/trusty/horizon/trusty-updates

« back to all changes in this revision

Viewing changes to openstack_dashboard/dashboards/admin/users/tests.py

  • Committer: Package Import Robot
  • Author(s): Adam Gandelman
  • Date: 2013-09-06 11:59:43 UTC
  • mfrom: (1.1.30)
  • Revision ID: package-import@ubuntu.com-20130906115943-h3td0l7tp16mb9oc
Tags: 1:2013.2~b3-0ubuntu1
* New upstream release.
* debian/control: Minimum python-openstack-auth version >= 1.1.1.
* debian/control: Add python-troveclient.
* debian/static: Refresh static assets for 2013.2~b3.
* debian/patches: ubuntu_local_settings.patch -> ubuntu_settings.patch, also
  patch location of secret key in openstack_dashboard/settings.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
openstack_dashboard/dashboards/admin/users/tests.py
18
18
#    License for the specific language governing permissions and limitations
19
19
#    under the License.
20
20
 
21
 
from socket import timeout as socket_timeout
 
21
from socket import timeout as socket_timeout  # noqa
22
22
 
23
 
from django.core.urlresolvers import reverse
 
23
from django.core.urlresolvers import reverse  # noqa
24
24
from django import http
25
25
 
26
 
from mox import IgnoreArg
27
 
from mox import IsA
 
26
from mox import IgnoreArg  # noqa
 
27
from mox import IsA  # noqa
28
28
 
29
29
from openstack_dashboard import api
30
30
from openstack_dashboard.test import helpers as test
36
36
 
37
37
 
38
38
class UsersViewTests(test.BaseAdminViewTests):
39
 
    def _get_domain_id(self):
40
 
        return self.request.session.get('domain_context', None)
 
39
    def _get_default_domain(self):
 
40
        domain = {"id": self.request.session.get('domain_context',
 
41
                                                 None),
 
42
                  "name": self.request.session.get('domain_context_name',
 
43
                                                   None)}
 
44
        return api.base.APIDictWrapper(domain)
41
45
 
42
46
    def _get_users(self, domain_id):
43
47
        if not domain_id:
49
53
 
50
54
    @test.create_stubs({api.keystone: ('user_list',)})
51
55
    def test_index(self):
52
 
        domain_id = self._get_domain_id()
 
56
        domain = self._get_default_domain()
 
57
        domain_id = domain.id
53
58
        users = self._get_users(domain_id)
54
59
        api.keystone.user_list(IgnoreArg(), domain=domain_id) \
55
60
                .AndReturn(users)
72
77
        self.test_index()
73
78
 
74
79
    @test.create_stubs({api.keystone: ('user_create',
 
80
                                       'get_default_domain',
75
81
                                       'tenant_list',
76
82
                                       'add_tenant_user_role',
77
83
                                       'get_default_role',
78
84
                                       'role_list')})
79
85
    def test_create(self):
80
86
        user = self.users.get(id="1")
81
 
        domain_id = self._get_domain_id()
 
87
        domain = self._get_default_domain()
 
88
        domain_id = domain.id
82
89
 
83
90
        role = self.roles.first()
84
91
 
85
 
        api.keystone.tenant_list(IgnoreArg(), user=None) \
 
92
        api.keystone.get_default_domain(IgnoreArg()) \
 
93
            .MultipleTimes().AndReturn(domain)
 
94
        api.keystone.tenant_list(IgnoreArg(), domain=domain_id, user=None) \
86
95
            .AndReturn([self.tenants.list(), False])
87
96
        api.keystone.user_create(IgnoreArg(),
88
97
                                 name=user.name,
99
108
        self.mox.ReplayAll()
100
109
 
101
110
        formData = {'method': 'CreateUserForm',
 
111
                    'domain_id': domain_id,
102
112
                    'name': user.name,
103
113
                    'email': user.email,
104
114
                    'password': user.password,
116
126
                              domain_context_name=domain.name)
117
127
        self.test_create()
118
128
 
119
 
    @test.create_stubs({api.keystone: ('tenant_list',
 
129
    @test.create_stubs({api.keystone: ('get_default_domain',
 
130
                                       'tenant_list',
120
131
                                       'role_list',
121
132
                                       'get_default_role')})
122
133
    def test_create_with_password_mismatch(self):
123
134
        user = self.users.get(id="1")
 
135
        domain = self._get_default_domain()
 
136
        domain_id = domain.id
124
137
 
125
 
        api.keystone.tenant_list(IgnoreArg(), user=None) \
 
138
        api.keystone.get_default_domain(IgnoreArg()) \
 
139
            .MultipleTimes().AndReturn(domain)
 
140
        api.keystone.tenant_list(IgnoreArg(), domain=domain_id, user=None) \
126
141
            .AndReturn([self.tenants.list(), False])
127
142
        api.keystone.role_list(IgnoreArg()).AndReturn(self.roles.list())
128
143
        api.keystone.get_default_role(IgnoreArg()) \
131
146
        self.mox.ReplayAll()
132
147
 
133
148
        formData = {'method': 'CreateUserForm',
 
149
                    'domain_id': domain_id,
134
150
                    'name': user.name,
135
151
                    'email': user.email,
136
152
                    'password': user.password,
142
158
 
143
159
        self.assertFormError(res, "form", None, ['Passwords do not match.'])
144
160
 
145
 
    @test.create_stubs({api.keystone: ('tenant_list',
 
161
    @test.create_stubs({api.keystone: ('get_default_domain',
 
162
                                       'tenant_list',
146
163
                                       'role_list',
147
164
                                       'get_default_role')})
148
165
    def test_create_validation_for_password_too_short(self):
149
166
        user = self.users.get(id="1")
 
167
        domain = self._get_default_domain()
 
168
        domain_id = domain.id
150
169
 
151
 
        api.keystone.tenant_list(IgnoreArg(), user=None) \
 
170
        api.keystone.get_default_domain(IgnoreArg()) \
 
171
            .MultipleTimes().AndReturn(domain)
 
172
        api.keystone.tenant_list(IgnoreArg(), domain=domain_id, user=None) \
152
173
            .AndReturn([self.tenants.list(), False])
153
174
        api.keystone.role_list(IgnoreArg()).AndReturn(self.roles.list())
154
175
        api.keystone.get_default_role(IgnoreArg()) \
158
179
 
159
180
        # check password min-len verification
160
181
        formData = {'method': 'CreateUserForm',
 
182
                    'domain_id': domain_id,
161
183
                    'name': user.name,
162
184
                    'email': user.email,
163
185
                    'password': 'four',
171
193
            res, "form", 'password',
172
194
            ['Password must be between 8 and 18 characters.'])
173
195
 
174
 
    @test.create_stubs({api.keystone: ('tenant_list',
 
196
    @test.create_stubs({api.keystone: ('get_default_domain',
 
197
                                       'tenant_list',
175
198
                                       'role_list',
176
199
                                       'get_default_role')})
177
200
    def test_create_validation_for_password_too_long(self):
178
201
        user = self.users.get(id="1")
 
202
        domain = self._get_default_domain()
 
203
        domain_id = domain.id
179
204
 
180
 
        api.keystone.tenant_list(IgnoreArg(), user=None) \
 
205
        api.keystone.get_default_domain(IgnoreArg()) \
 
206
            .MultipleTimes().AndReturn(domain)
 
207
        api.keystone.tenant_list(IgnoreArg(), domain=domain_id, user=None) \
181
208
            .AndReturn([self.tenants.list(), False])
182
209
        api.keystone.role_list(IgnoreArg()).AndReturn(self.roles.list())
183
210
        api.keystone.get_default_role(IgnoreArg()) \
187
214
 
188
215
        # check password min-len verification
189
216
        formData = {'method': 'CreateUserForm',
 
217
                    'domain_id': domain_id,
190
218
                    'name': user.name,
191
219
                    'email': user.email,
192
220
                    'password': 'MoreThanEighteenChars',
201
229
            ['Password must be between 8 and 18 characters.'])
202
230
 
203
231
    @test.create_stubs({api.keystone: ('user_get',
 
232
                                       'domain_get',
204
233
                                       'tenant_list',
205
234
                                       'user_update_tenant',
206
235
                                       'user_update_password',
208
237
                                       'roles_for_user', )})
209
238
    def test_update(self):
210
239
        user = self.users.get(id="1")
 
240
        domain_id = user.domain_id
 
241
        domain = self.domains.get(id=domain_id)
211
242
        test_password = 'normalpwd'
212
243
 
213
244
        api.keystone.user_get(IsA(http.HttpRequest), '1',
214
245
                              admin=True).AndReturn(user)
215
 
        api.keystone.tenant_list(IgnoreArg(), user=user.id) \
 
246
        api.keystone.domain_get(IsA(http.HttpRequest), domain_id) \
 
247
            .AndReturn(domain)
 
248
        api.keystone.tenant_list(IgnoreArg(), domain=domain_id, user=user.id) \
216
249
            .AndReturn([self.tenants.list(), False])
217
250
        api.keystone.user_update(IsA(http.HttpRequest),
218
251
                                 user.id,
236
269
        self.assertNoFormErrors(res)
237
270
 
238
271
    @test.create_stubs({api.keystone: ('user_get',
 
272
                                       'domain_get',
239
273
                                       'tenant_list',
240
274
                                       'user_update_tenant',
241
275
                                       'keystone_can_edit_user',
242
276
                                       'roles_for_user', )})
243
277
    def test_update_with_keystone_can_edit_user_false(self):
244
278
        user = self.users.get(id="1")
 
279
        domain_id = user.domain_id
 
280
        domain = self.domains.get(id=domain_id)
245
281
 
246
282
        api.keystone.user_get(IsA(http.HttpRequest),
247
283
                     '1',
248
284
                     admin=True).AndReturn(user)
249
 
        api.keystone.tenant_list(IgnoreArg(), user=user.id) \
 
285
        api.keystone.domain_get(IsA(http.HttpRequest), domain_id) \
 
286
            .AndReturn(domain)
 
287
        api.keystone.tenant_list(IgnoreArg(), domain=domain_id, user=user.id) \
250
288
            .AndReturn([self.tenants.list(), False])
251
289
        api.keystone.keystone_can_edit_user().AndReturn(False)
252
290
        api.keystone.keystone_can_edit_user().AndReturn(False)
263
301
        self.assertNoFormErrors(res)
264
302
        self.assertMessageCount(error=1)
265
303
 
266
 
    @test.create_stubs({api.keystone: ('user_get', 'tenant_list')})
 
304
    @test.create_stubs({api.keystone: ('domain_get',
 
305
                                       'user_get',
 
306
                                       'tenant_list')})
267
307
    def test_update_validation_for_password_too_short(self):
268
308
        user = self.users.get(id="1")
 
309
        domain_id = user.domain_id
 
310
        domain = self.domains.get(id=domain_id)
269
311
 
270
312
        api.keystone.user_get(IsA(http.HttpRequest), '1',
271
313
                              admin=True).AndReturn(user)
272
 
        api.keystone.tenant_list(IgnoreArg(), user=user.id) \
 
314
        api.keystone.domain_get(IsA(http.HttpRequest), domain_id) \
 
315
            .AndReturn(domain)
 
316
        api.keystone.tenant_list(IgnoreArg(), domain=domain_id, user=user.id) \
273
317
            .AndReturn([self.tenants.list(), False])
274
318
 
275
319
        self.mox.ReplayAll()
288
332
                res, "form", 'password',
289
333
                ['Password must be between 8 and 18 characters.'])
290
334
 
291
 
    @test.create_stubs({api.keystone: ('user_get', 'tenant_list')})
 
335
    @test.create_stubs({api.keystone: ('domain_get',
 
336
                                       'user_get',
 
337
                                       'tenant_list')})
292
338
    def test_update_validation_for_password_too_long(self):
293
339
        user = self.users.get(id="1")
 
340
        domain_id = user.domain_id
 
341
        domain = self.domains.get(id=domain_id)
294
342
 
295
343
        api.keystone.user_get(IsA(http.HttpRequest), '1',
296
344
                              admin=True).AndReturn(user)
297
 
        api.keystone.tenant_list(IgnoreArg(), user=user.id) \
 
345
        api.keystone.domain_get(IsA(http.HttpRequest), domain_id) \
 
346
            .AndReturn(domain)
 
347
        api.keystone.tenant_list(IgnoreArg(), domain=domain_id, user=user.id) \
298
348
            .AndReturn([self.tenants.list(), False])
299
349
 
300
350
        self.mox.ReplayAll()
315
365
 
316
366
    @test.create_stubs({api.keystone: ('user_update_enabled', 'user_list')})
317
367
    def test_enable_user(self):
 
368
        domain = self._get_default_domain()
 
369
        domain_id = domain.id
318
370
        user = self.users.get(id="2")
319
 
        domain_id = self._get_domain_id()
320
371
        users = self._get_users(domain_id)
321
372
        user.enabled = False
322
373
 
327
378
 
328
379
        self.mox.ReplayAll()
329
380
 
330
 
        formData = {'action': 'users__enable__%s' % user.id}
 
381
        formData = {'action': 'users__toggle__%s' % user.id}
331
382
        res = self.client.post(USERS_INDEX_URL, formData)
332
383
 
333
384
        self.assertRedirectsNoFollow(res, USERS_INDEX_URL)
334
385
 
335
386
    @test.create_stubs({api.keystone: ('user_update_enabled', 'user_list')})
336
387
    def test_disable_user(self):
 
388
        domain = self._get_default_domain()
 
389
        domain_id = domain.id
337
390
        user = self.users.get(id="2")
338
 
        domain_id = self._get_domain_id()
339
391
        users = self._get_users(domain_id)
340
392
 
341
393
        self.assertTrue(user.enabled)
348
400
 
349
401
        self.mox.ReplayAll()
350
402
 
351
 
        formData = {'action': 'users__enable__%s' % user.id}
 
403
        formData = {'action': 'users__toggle__%s' % user.id}
352
404
        res = self.client.post(USERS_INDEX_URL, formData)
353
405
 
354
406
        self.assertRedirectsNoFollow(res, USERS_INDEX_URL)
355
407
 
356
408
    @test.create_stubs({api.keystone: ('user_update_enabled', 'user_list')})
357
409
    def test_enable_disable_user_exception(self):
 
410
        domain = self._get_default_domain()
 
411
        domain_id = domain.id
358
412
        user = self.users.get(id="2")
359
 
        domain_id = self._get_domain_id()
360
413
        users = self._get_users(domain_id)
361
414
        user.enabled = False
362
415
 
366
419
                    .AndRaise(self.exceptions.keystone)
367
420
        self.mox.ReplayAll()
368
421
 
369
 
        formData = {'action': 'users__enable__%s' % user.id}
 
422
        formData = {'action': 'users__toggle__%s' % user.id}
370
423
        res = self.client.post(USERS_INDEX_URL, formData)
371
424
 
372
425
        self.assertRedirectsNoFollow(res, USERS_INDEX_URL)
373
426
 
374
427
    @test.create_stubs({api.keystone: ('user_list',)})
375
428
    def test_disabling_current_user(self):
376
 
        domain_id = self._get_domain_id()
 
429
        domain = self._get_default_domain()
 
430
        domain_id = domain.id
377
431
        users = self._get_users(domain_id)
378
432
        for i in range(0, 2):
379
433
            api.keystone.user_list(IgnoreArg(), domain=domain_id) \
381
435
 
382
436
        self.mox.ReplayAll()
383
437
 
384
 
        formData = {'action': 'users__enable__%s' % self.request.user.id}
 
438
        formData = {'action': 'users__toggle__%s' % self.request.user.id}
385
439
        res = self.client.post(USERS_INDEX_URL, formData, follow=True)
386
440
 
387
441
        self.assertEqual(list(res.context['messages'])[0].message,
390
444
 
391
445
    @test.create_stubs({api.keystone: ('user_list',)})
392
446
    def test_delete_user_with_improper_permissions(self):
393
 
        domain_id = self._get_domain_id()
 
447
        domain = self._get_default_domain()
 
448
        domain_id = domain.id
394
449
        users = self._get_users(domain_id)
395
450
        for i in range(0, 2):
396
451
            api.keystone.user_list(IgnoreArg(), domain=domain_id) \
407
462
 
408
463
 
409
464
class SeleniumTests(test.SeleniumAdminTestCase):
410
 
    @test.create_stubs({api.keystone: ('tenant_list',
 
465
    def _get_default_domain(self):
 
466
        domain = {"id": None, "name": None}
 
467
        return api.base.APIDictWrapper(domain)
 
468
 
 
469
    @test.create_stubs({api.keystone: ('get_default_domain',
 
470
                                       'tenant_list',
411
471
                                       'get_default_role',
412
472
                                       'role_list',
413
473
                                       'user_list')})
414
474
    def test_modal_create_user_with_passwords_not_matching(self):
415
 
        api.keystone.tenant_list(IgnoreArg(), user=None) \
 
475
        domain = self._get_default_domain()
 
476
 
 
477
        api.keystone.get_default_domain(IgnoreArg()) \
 
478
            .AndReturn(domain)
 
479
        api.keystone.tenant_list(IgnoreArg(), domain=None, user=None) \
416
480
            .AndReturn([self.tenants.list(), False])
417
481
        api.keystone.role_list(IgnoreArg()).AndReturn(self.roles.list())
418
482
        api.keystone.user_list(IgnoreArg(), domain=None) \
441
505
        self.assertTrue("Passwords do not match" in body.text,
442
506
                        "Error message not found in body")
443
507
 
444
 
    @test.create_stubs({api.keystone: ('tenant_list', 'user_get')})
 
508
    @test.create_stubs({api.keystone: ('tenant_list',
 
509
                                       'user_get',
 
510
                                       'domain_get')})
445
511
    def test_update_user_with_passwords_not_matching(self):
446
512
        api.keystone.user_get(IsA(http.HttpRequest), '1',
447
513
                              admin=True).AndReturn(self.user)
448
 
        api.keystone.tenant_list(IgnoreArg(), user=self.user.id) \
 
514
        api.keystone.domain_get(IsA(http.HttpRequest), '1') \
 
515
            .AndReturn(self.domain)
 
516
        api.keystone.tenant_list(IgnoreArg(),
 
517
                                 domain=self.user.domain_id,
 
518
                                 user=self.user.id) \
449
519
            .AndReturn([self.tenants.list(), False])
450
520
        self.mox.ReplayAll()
451
521