← Back to branch summary

~ubuntu-branches/ubuntu/raring/horizon/raring

« back to all changes in this revision

Viewing changes to horizon/dashboards/syspanel/projects/tests.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Adam Gandelman, Chuck Short
  • Date: 2012-11-23 08:49:14 UTC
  • mfrom: (1.1.22)
  • Revision ID: package-import@ubuntu.com-20121123084914-95m0mzmiicdw64ti
Tags: 2013.1~g1-0ubuntu1
[ Adam Gandelman ]
* debian/patches/add_juju_settings_pannel.patch: Disable during
  Grizzly dev. cycle. 

[ Chuck Short ]
* New upstream relase.
* Refreshed patches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
horizon/dashboards/syspanel/projects/tests.py
1
 
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2
 
 
3
 
# Copyright 2012 Nebula, Inc.
4
 
#
5
 
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
6
 
#    not use this file except in compliance with the License. You may obtain
7
 
#    a copy of the License at
8
 
#
9
 
#         http://www.apache.org/licenses/LICENSE-2.0
10
 
#
11
 
#    Unless required by applicable law or agreed to in writing, software
12
 
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
13
 
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
14
 
#    License for the specific language governing permissions and limitations
15
 
#    under the License.
16
 
 
17
 
from django import http
18
 
from django.core.urlresolvers import reverse
19
 
from mox import IsA
20
 
 
21
 
from horizon import api
22
 
from horizon import test
23
 
 
24
 
from .workflows import CreateProject, UpdateProject
25
 
from .views import QUOTA_FIELDS
26
 
 
27
 
INDEX_URL = reverse('horizon:syspanel:projects:index')
28
 
 
29
 
 
30
 
class TenantsViewTests(test.BaseAdminViewTests):
31
 
    def test_index(self):
32
 
        self.mox.StubOutWithMock(api.keystone, 'tenant_list')
33
 
        api.keystone.tenant_list(IsA(http.HttpRequest), admin=True) \
34
 
                    .AndReturn(self.tenants.list())
35
 
        self.mox.ReplayAll()
36
 
 
37
 
        res = self.client.get(INDEX_URL)
38
 
        self.assertTemplateUsed(res, 'syspanel/projects/index.html')
39
 
        self.assertItemsEqual(res.context['table'].data, self.tenants.list())
40
 
 
41
 
 
42
 
class CreateProjectWorkflowTests(test.BaseAdminViewTests):
43
 
    def _get_project_info(self, project):
44
 
        project_info = {"tenant_name": project.name,
45
 
                        "description": project.description,
46
 
                        "enabled": project.enabled}
47
 
        return project_info
48
 
 
49
 
    def _get_workflow_fields(self, project):
50
 
        project_info = {"name": project.name,
51
 
                        "description": project.description,
52
 
                        "enabled": project.enabled}
53
 
        return project_info
54
 
 
55
 
    def _get_quota_info(self, quota):
56
 
        quota_data = {}
57
 
        for field in QUOTA_FIELDS:
58
 
            quota_data[field] = int(getattr(quota, field, None))
59
 
        return quota_data
60
 
 
61
 
    def _get_workflow_data(self, project, quota):
62
 
        project_info = self._get_workflow_fields(project)
63
 
        quota_data = self._get_quota_info(quota)
64
 
        project_info.update(quota_data)
65
 
        return project_info
66
 
 
67
 
    @test.create_stubs({api: ('tenant_quota_defaults',
68
 
                              'get_default_role',),
69
 
                       api.keystone: ('user_list',
70
 
                                      'role_list',)})
71
 
    def test_add_project_get(self):
72
 
        quota = self.quotas.first()
73
 
        default_role = self.roles.first()
74
 
        users = self.users.list()
75
 
        roles = self.roles.list()
76
 
 
77
 
        api.tenant_quota_defaults(IsA(http.HttpRequest), self.tenant.id) \
78
 
            .AndReturn(quota)
79
 
 
80
 
        # init
81
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
82
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
83
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
84
 
 
85
 
        self.mox.ReplayAll()
86
 
 
87
 
        url = reverse('horizon:syspanel:projects:create')
88
 
        res = self.client.get(url)
89
 
 
90
 
        self.assertTemplateUsed(res, 'syspanel/projects/create.html')
91
 
 
92
 
        workflow = res.context['workflow']
93
 
        self.assertEqual(res.context['workflow'].name, CreateProject.name)
94
 
 
95
 
        step = workflow.get_step("createprojectinfoaction")
96
 
        self.assertEqual(step.action.initial['ram'], quota.ram)
97
 
        self.assertEqual(step.action.initial['injected_files'],
98
 
                         quota.injected_files)
99
 
        self.assertQuerysetEqual(workflow.steps,
100
 
                            ['<CreateProjectInfo: createprojectinfoaction>',
101
 
                             '<UpdateProjectMembers: update_members>',
102
 
                             '<UpdateProjectQuota: update_quotas>'])
103
 
 
104
 
    @test.create_stubs({api: ('get_default_role',
105
 
                              'tenant_quota_defaults',
106
 
                              'add_tenant_user_role',),
107
 
                        api.keystone: ('tenant_create',
108
 
                                       'user_list',
109
 
                                       'role_list'),
110
 
                        api.nova: ('tenant_quota_update',)})
111
 
    def test_add_project_post(self):
112
 
        project = self.tenants.first()
113
 
        quota = self.quotas.first()
114
 
        default_role = self.roles.first()
115
 
        users = self.users.list()
116
 
        roles = self.roles.list()
117
 
 
118
 
        # init
119
 
        api.tenant_quota_defaults(IsA(http.HttpRequest), self.tenant.id) \
120
 
            .AndReturn(quota)
121
 
 
122
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
123
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
124
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
125
 
 
126
 
        # contribute
127
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
128
 
 
129
 
        # handle
130
 
        project_details = self._get_project_info(project)
131
 
        quota_data = self._get_quota_info(quota)
132
 
 
133
 
        api.keystone.tenant_create(IsA(http.HttpRequest), **project_details) \
134
 
                    .AndReturn(project)
135
 
 
136
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
137
 
 
138
 
        workflow_data = {}
139
 
        for role in roles:
140
 
            if "role_" + role.id in workflow_data:
141
 
                ulist = workflow_data["role_" + role.id]
142
 
                for user in ulist:
143
 
                    api.add_tenant_user_role(IsA(http.HttpRequest),
144
 
                                             tenant_id=self.tenant.id,
145
 
                                             user_id=user,
146
 
                                             role_id=role.id)
147
 
 
148
 
        api.nova.tenant_quota_update(IsA(http.HttpRequest),
149
 
                                     project.id,
150
 
                                     **quota_data)
151
 
 
152
 
        self.mox.ReplayAll()
153
 
 
154
 
        workflow_data.update(self._get_workflow_data(project, quota))
155
 
 
156
 
        url = reverse('horizon:syspanel:projects:create')
157
 
        res = self.client.post(url, workflow_data)
158
 
 
159
 
        self.assertNoFormErrors(res)
160
 
        self.assertRedirectsNoFollow(res, INDEX_URL)
161
 
 
162
 
    @test.create_stubs({api: ('tenant_quota_defaults',
163
 
                              'get_default_role',),
164
 
                        api.keystone: ('user_list',
165
 
                                       'role_list',)})
166
 
    def test_add_project_quota_defaults_error(self):
167
 
        default_role = self.roles.first()
168
 
        users = self.users.list()
169
 
        roles = self.roles.list()
170
 
 
171
 
        # init
172
 
        api.tenant_quota_defaults(IsA(http.HttpRequest), self.tenant.id) \
173
 
           .AndRaise(self.exceptions.nova)
174
 
 
175
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
176
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
177
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
178
 
 
179
 
        self.mox.ReplayAll()
180
 
 
181
 
        url = reverse('horizon:syspanel:projects:create')
182
 
        res = self.client.get(url)
183
 
 
184
 
        self.assertTemplateUsed(res, 'syspanel/projects/create.html')
185
 
        self.assertContains(res, "Unable to retrieve default quota values")
186
 
 
187
 
    @test.create_stubs({api: ('get_default_role',
188
 
                              'tenant_quota_defaults',),
189
 
                        api.keystone: ('tenant_create',
190
 
                                       'user_list',
191
 
                                       'role_list',)})
192
 
    def test_add_project_tenant_create_error(self):
193
 
        project = self.tenants.first()
194
 
        quota = self.quotas.first()
195
 
        default_role = self.roles.first()
196
 
        users = self.users.list()
197
 
        roles = self.roles.list()
198
 
 
199
 
        # init
200
 
        api.tenant_quota_defaults(IsA(http.HttpRequest), self.tenant.id) \
201
 
            .AndReturn(quota)
202
 
 
203
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
204
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
205
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
206
 
 
207
 
        # contribute
208
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
209
 
 
210
 
        # handle
211
 
        project_details = self._get_project_info(project)
212
 
 
213
 
        api.keystone.tenant_create(IsA(http.HttpRequest), **project_details) \
214
 
            .AndRaise(self.exceptions.keystone)
215
 
 
216
 
        self.mox.ReplayAll()
217
 
 
218
 
        workflow_data = self._get_workflow_data(project, quota)
219
 
 
220
 
        url = reverse('horizon:syspanel:projects:create')
221
 
        res = self.client.post(url, workflow_data)
222
 
 
223
 
        self.assertNoFormErrors(res)
224
 
        self.assertRedirectsNoFollow(res, INDEX_URL)
225
 
 
226
 
    @test.create_stubs({api: ('get_default_role',
227
 
                              'tenant_quota_defaults',
228
 
                              'add_tenant_user_role',),
229
 
                        api.keystone: ('tenant_create',
230
 
                                       'user_list',
231
 
                                       'role_list'),
232
 
                        api.nova: ('tenant_quota_update',)})
233
 
    def test_add_project_quota_update_error(self):
234
 
        project = self.tenants.first()
235
 
        quota = self.quotas.first()
236
 
        default_role = self.roles.first()
237
 
        users = self.users.list()
238
 
        roles = self.roles.list()
239
 
 
240
 
        # init
241
 
        api.tenant_quota_defaults(IsA(http.HttpRequest), self.tenant.id) \
242
 
            .AndReturn(quota)
243
 
 
244
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
245
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
246
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
247
 
 
248
 
        # contribute
249
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
250
 
 
251
 
        # handle
252
 
        project_details = self._get_project_info(project)
253
 
        quota_data = self._get_quota_info(quota)
254
 
 
255
 
        api.keystone.tenant_create(IsA(http.HttpRequest), **project_details) \
256
 
                    .AndReturn(project)
257
 
 
258
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
259
 
 
260
 
        workflow_data = {}
261
 
        for role in roles:
262
 
            if "role_" + role.id in workflow_data:
263
 
                ulist = workflow_data["role_" + role.id]
264
 
                for user in ulist:
265
 
                    api.add_tenant_user_role(IsA(http.HttpRequest),
266
 
                                             tenant_id=self.tenant.id,
267
 
                                             user_id=user,
268
 
                                             role_id=role.id)
269
 
 
270
 
        api.nova.tenant_quota_update(IsA(http.HttpRequest),
271
 
                                     project.id,
272
 
                                     **quota_data) \
273
 
           .AndRaise(self.exceptions.nova)
274
 
 
275
 
        self.mox.ReplayAll()
276
 
 
277
 
        workflow_data.update(self._get_workflow_data(project, quota))
278
 
 
279
 
        url = reverse('horizon:syspanel:projects:create')
280
 
        res = self.client.post(url, workflow_data)
281
 
 
282
 
        self.assertNoFormErrors(res)
283
 
        self.assertRedirectsNoFollow(res, INDEX_URL)
284
 
 
285
 
    @test.create_stubs({api: ('get_default_role',
286
 
                              'tenant_quota_defaults',
287
 
                              'add_tenant_user_role',),
288
 
                        api.keystone: ('tenant_create',
289
 
                                       'user_list',
290
 
                                       'role_list',),
291
 
                        api.nova: ('tenant_quota_update',)})
292
 
    def test_add_project_user_update_error(self):
293
 
        project = self.tenants.first()
294
 
        quota = self.quotas.first()
295
 
        default_role = self.roles.first()
296
 
        users = self.users.list()
297
 
        roles = self.roles.list()
298
 
 
299
 
        # init
300
 
        api.tenant_quota_defaults(IsA(http.HttpRequest), self.tenant.id) \
301
 
            .AndReturn(quota)
302
 
 
303
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
304
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
305
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
306
 
 
307
 
        # contribute
308
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
309
 
 
310
 
        # handle
311
 
        project_details = self._get_project_info(project)
312
 
        quota_data = self._get_quota_info(quota)
313
 
 
314
 
        api.keystone.tenant_create(IsA(http.HttpRequest), **project_details) \
315
 
                    .AndReturn(project)
316
 
 
317
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
318
 
 
319
 
        workflow_data = {}
320
 
        for role in roles:
321
 
            if "role_" + role.id in workflow_data:
322
 
                ulist = workflow_data["role_" + role.id]
323
 
                for user in ulist:
324
 
                    api.add_tenant_user_role(IsA(http.HttpRequest),
325
 
                                             tenant_id=self.tenant.id,
326
 
                                             user_id=user,
327
 
                                             role_id=role.id) \
328
 
                       .AndRaise(self.exceptions.keystone)
329
 
                    break
330
 
            break
331
 
 
332
 
        api.nova.tenant_quota_update(IsA(http.HttpRequest),
333
 
                                     project.id,
334
 
                                     **quota_data)
335
 
 
336
 
        self.mox.ReplayAll()
337
 
 
338
 
        workflow_data.update(self._get_workflow_data(project, quota))
339
 
 
340
 
        url = reverse('horizon:syspanel:projects:create')
341
 
        res = self.client.post(url, workflow_data)
342
 
 
343
 
        self.assertNoFormErrors(res)
344
 
        self.assertRedirectsNoFollow(res, INDEX_URL)
345
 
 
346
 
    @test.create_stubs({api: ('get_default_role',
347
 
                              'tenant_quota_defaults',),
348
 
                        api.keystone: ('user_list',
349
 
                                       'role_list',)})
350
 
    def test_add_project_missing_field_error(self):
351
 
        project = self.tenants.first()
352
 
        quota = self.quotas.first()
353
 
        default_role = self.roles.first()
354
 
        users = self.users.list()
355
 
        roles = self.roles.list()
356
 
 
357
 
        # init
358
 
        api.tenant_quota_defaults(IsA(http.HttpRequest), self.tenant.id) \
359
 
           .AndReturn(quota)
360
 
 
361
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
362
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
363
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
364
 
 
365
 
        # contribute
366
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
367
 
 
368
 
        self.mox.ReplayAll()
369
 
 
370
 
        workflow_data = self._get_workflow_data(project, quota)
371
 
        workflow_data["name"] = ""
372
 
 
373
 
        url = reverse('horizon:syspanel:projects:create')
374
 
        res = self.client.post(url, workflow_data)
375
 
 
376
 
        self.assertContains(res, "field is required")
377
 
 
378
 
 
379
 
class UpdateProjectWorkflowTests(test.BaseAdminViewTests):
380
 
    def _get_quota_info(self, quota):
381
 
        quota_data = {}
382
 
        for field in QUOTA_FIELDS:
383
 
            quota_data[field] = int(getattr(quota, field, None))
384
 
        return quota_data
385
 
 
386
 
    @test.create_stubs({api: ('get_default_role',
387
 
                              'roles_for_user',
388
 
                              'tenant_get',
389
 
                              'tenant_quota_get',),
390
 
                        api.keystone: ('user_list',
391
 
                                       'role_list',)})
392
 
    def test_update_project_get(self):
393
 
        project = self.tenants.first()
394
 
        quota = self.quotas.first()
395
 
        default_role = self.roles.first()
396
 
        users = self.users.list()
397
 
        roles = self.roles.list()
398
 
 
399
 
        api.tenant_get(IsA(http.HttpRequest), self.tenant.id, admin=True) \
400
 
            .AndReturn(project)
401
 
        api.tenant_quota_get(IsA(http.HttpRequest), self.tenant.id) \
402
 
            .AndReturn(quota)
403
 
 
404
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
405
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
406
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
407
 
 
408
 
        for user in users:
409
 
            api.roles_for_user(IsA(http.HttpRequest),
410
 
                               user.id,
411
 
                               self.tenant.id).AndReturn(roles)
412
 
 
413
 
        self.mox.ReplayAll()
414
 
 
415
 
        url = reverse('horizon:syspanel:projects:update',
416
 
                      args=[self.tenant.id])
417
 
        res = self.client.get(url)
418
 
 
419
 
        self.assertTemplateUsed(res, 'syspanel/projects/update.html')
420
 
 
421
 
        workflow = res.context['workflow']
422
 
        self.assertEqual(res.context['workflow'].name, UpdateProject.name)
423
 
 
424
 
        step = workflow.get_step("update_info")
425
 
        self.assertEqual(step.action.initial['ram'], quota.ram)
426
 
        self.assertEqual(step.action.initial['injected_files'],
427
 
                         quota.injected_files)
428
 
        self.assertEqual(step.action.initial['name'], project.name)
429
 
        self.assertEqual(step.action.initial['description'],
430
 
                         project.description)
431
 
        self.assertQuerysetEqual(workflow.steps,
432
 
                            ['<UpdateProjectInfo: update_info>',
433
 
                             '<UpdateProjectMembers: update_members>',
434
 
                             '<UpdateProjectQuota: update_quotas>'])
435
 
 
436
 
    @test.create_stubs({api: ('tenant_get',
437
 
                              'tenant_quota_get',
438
 
                              'tenant_update',
439
 
                              'tenant_quota_update',
440
 
                              'get_default_role',
441
 
                              'roles_for_user',
442
 
                              'remove_tenant_user_role',
443
 
                              'add_tenant_user_role'),
444
 
                        api.keystone: ('user_list',
445
 
                                       'role_list',)})
446
 
    def test_update_project_post(self):
447
 
        project = self.tenants.first()
448
 
        quota = self.quotas.first()
449
 
        default_role = self.roles.first()
450
 
        users = self.users.list()
451
 
        roles = self.roles.list()
452
 
        current_roles = self.roles.list()
453
 
 
454
 
        # get/init
455
 
        api.tenant_get(IsA(http.HttpRequest), self.tenant.id, admin=True) \
456
 
            .AndReturn(project)
457
 
        api.tenant_quota_get(IsA(http.HttpRequest), self.tenant.id) \
458
 
            .AndReturn(quota)
459
 
 
460
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
461
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
462
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
463
 
 
464
 
        workflow_data = {}
465
 
        for user in users:
466
 
            api.roles_for_user(IsA(http.HttpRequest),
467
 
                               user.id,
468
 
                               self.tenant.id).AndReturn(roles)
469
 
            role_ids = [role.id for role in roles]
470
 
            if role_ids:
471
 
                workflow_data.setdefault("role_" + role_ids[0], []) \
472
 
                             .append(user.id)
473
 
 
474
 
        # update some fields
475
 
        project._info["name"] = "updated name"
476
 
        project._info["description"] = "updated description"
477
 
        quota.metadata_items = 444
478
 
        quota.volumes = 444
479
 
 
480
 
        updated_project = {"tenant_name": project._info["name"],
481
 
                           "tenant_id": project.id,
482
 
                           "description": project._info["description"],
483
 
                           "enabled": project.enabled}
484
 
        updated_quota = self._get_quota_info(quota)
485
 
 
486
 
        # contribute
487
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
488
 
 
489
 
        # handle
490
 
        api.tenant_update(IsA(http.HttpRequest), **updated_project) \
491
 
            .AndReturn(project)
492
 
 
493
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
494
 
        api.keystone.user_list(IsA(http.HttpRequest),
495
 
                               tenant_id=self.tenant.id).AndReturn(users)
496
 
 
497
 
        for user in users:
498
 
            api.roles_for_user(IsA(http.HttpRequest),
499
 
                                        user.id,
500
 
                                        self.tenant.id) \
501
 
                                .AndReturn(current_roles)
502
 
            for role in roles:
503
 
                if "role_" + role.id in workflow_data:
504
 
                    ulist = workflow_data["role_" + role.id]
505
 
                    if role not in current_roles:
506
 
                        api.add_tenant_user_role(IsA(http.HttpRequest),
507
 
                                             tenant_id=self.tenant.id,
508
 
                                             user_id=user,
509
 
                                             role_id=role.id)
510
 
                    else:
511
 
                        current_roles.pop(current_roles.index(role))
512
 
            for to_delete in current_roles:
513
 
                api.remove_tenant_user_role(IsA(http.HttpRequest),
514
 
                                            tenant_id=self.tenant.id,
515
 
                                            user_id=user.id,
516
 
                                            role_id=to_delete.id)
517
 
        for role in roles:
518
 
            if "role_" + role.id in workflow_data:
519
 
                ulist = workflow_data["role_" + role.id]
520
 
                for user in ulist:
521
 
                    if not filter(lambda x: user == x.id, users):
522
 
                        api.add_tenant_user_role(IsA(http.HttpRequest),
523
 
                                                 tenant_id=self.tenant.id,
524
 
                                                 user_id=user,
525
 
                                                 role_id=role.id)
526
 
 
527
 
        api.tenant_quota_update(IsA(http.HttpRequest),
528
 
                                project.id,
529
 
                                **updated_quota)
530
 
 
531
 
        self.mox.ReplayAll()
532
 
 
533
 
        # submit form data
534
 
        project_data = {"name": project._info["name"],
535
 
                         "id": project.id,
536
 
                         "description": project._info["description"],
537
 
                         "enabled": project.enabled}
538
 
        workflow_data.update(project_data)
539
 
        workflow_data.update(updated_quota)
540
 
        url = reverse('horizon:syspanel:projects:update',
541
 
                      args=[self.tenant.id])
542
 
        res = self.client.post(url, workflow_data)
543
 
 
544
 
        self.assertNoFormErrors(res)
545
 
        self.assertRedirectsNoFollow(res, INDEX_URL)
546
 
 
547
 
    @test.create_stubs({api: ('tenant_get',)})
548
 
    def test_update_project_get_error(self):
549
 
 
550
 
        api.tenant_get(IsA(http.HttpRequest), self.tenant.id, admin=True) \
551
 
            .AndRaise(self.exceptions.nova)
552
 
 
553
 
        self.mox.ReplayAll()
554
 
 
555
 
        url = reverse('horizon:syspanel:projects:update',
556
 
                      args=[self.tenant.id])
557
 
        res = self.client.get(url)
558
 
 
559
 
        self.assertRedirectsNoFollow(res, INDEX_URL)
560
 
 
561
 
    @test.create_stubs({api: ('tenant_get',
562
 
                              'tenant_quota_get',
563
 
                              'tenant_update',
564
 
                              'tenant_quota_update',
565
 
                              'get_default_role',
566
 
                              'roles_for_user',
567
 
                              'remove_tenant_user',
568
 
                              'add_tenant_user_role'),
569
 
                        api.keystone: ('user_list',
570
 
                                       'role_list',)})
571
 
    def test_update_project_tenant_update_error(self):
572
 
        project = self.tenants.first()
573
 
        quota = self.quotas.first()
574
 
        default_role = self.roles.first()
575
 
        users = self.users.list()
576
 
        roles = self.roles.list()
577
 
 
578
 
        # get/init
579
 
        api.tenant_get(IsA(http.HttpRequest), self.tenant.id, admin=True) \
580
 
            .AndReturn(project)
581
 
        api.tenant_quota_get(IsA(http.HttpRequest), self.tenant.id) \
582
 
            .AndReturn(quota)
583
 
 
584
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
585
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
586
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
587
 
 
588
 
        workflow_data = {}
589
 
        for user in users:
590
 
            api.roles_for_user(IsA(http.HttpRequest),
591
 
                               user.id,
592
 
                               self.tenant.id).AndReturn(roles)
593
 
            role_ids = [role.id for role in roles]
594
 
            if role_ids:
595
 
                workflow_data.setdefault("role_" + role_ids[0], []) \
596
 
                             .append(user.id)
597
 
 
598
 
        # update some fields
599
 
        project._info["name"] = "updated name"
600
 
        project._info["description"] = "updated description"
601
 
        quota.metadata_items = 444
602
 
        quota.volumes = 444
603
 
 
604
 
        updated_project = {"tenant_name": project._info["name"],
605
 
                           "tenant_id": project.id,
606
 
                           "description": project._info["description"],
607
 
                           "enabled": project.enabled}
608
 
        updated_quota = self._get_quota_info(quota)
609
 
 
610
 
        # contribute
611
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
612
 
 
613
 
        # handle
614
 
        api.tenant_update(IsA(http.HttpRequest), **updated_project) \
615
 
            .AndRaise(self.exceptions.keystone)
616
 
 
617
 
        self.mox.ReplayAll()
618
 
 
619
 
        # submit form data
620
 
        project_data = {"name": project._info["name"],
621
 
                         "id": project.id,
622
 
                         "description": project._info["description"],
623
 
                         "enabled": project.enabled}
624
 
        workflow_data.update(project_data)
625
 
        workflow_data.update(updated_quota)
626
 
        url = reverse('horizon:syspanel:projects:update',
627
 
                      args=[self.tenant.id])
628
 
        res = self.client.post(url, workflow_data)
629
 
 
630
 
        self.assertNoFormErrors(res)
631
 
        self.assertRedirectsNoFollow(res, INDEX_URL)
632
 
 
633
 
    @test.create_stubs({api: ('tenant_get',
634
 
                              'tenant_quota_get',
635
 
                              'tenant_update',
636
 
                              'tenant_quota_update',
637
 
                              'get_default_role',
638
 
                              'roles_for_user',
639
 
                              'remove_tenant_user_role',
640
 
                              'add_tenant_user_role'),
641
 
                        api.keystone: ('user_list',
642
 
                                       'role_list',)})
643
 
    def test_update_project_quota_update_error(self):
644
 
        project = self.tenants.first()
645
 
        quota = self.quotas.first()
646
 
        default_role = self.roles.first()
647
 
        users = self.users.list()
648
 
        roles = self.roles.list()
649
 
        current_roles = self.roles.list()
650
 
 
651
 
        # get/init
652
 
        api.tenant_get(IsA(http.HttpRequest), self.tenant.id, admin=True) \
653
 
            .AndReturn(project)
654
 
        api.tenant_quota_get(IsA(http.HttpRequest), self.tenant.id) \
655
 
            .AndReturn(quota)
656
 
 
657
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
658
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
659
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
660
 
 
661
 
        workflow_data = {}
662
 
        for user in users:
663
 
            api.roles_for_user(IsA(http.HttpRequest),
664
 
                               user.id,
665
 
                               self.tenant.id).AndReturn(roles)
666
 
            role_ids = [role.id for role in roles]
667
 
            if role_ids:
668
 
                workflow_data.setdefault("role_" + role_ids[0], []) \
669
 
                             .append(user.id)
670
 
 
671
 
        # update some fields
672
 
        project._info["name"] = "updated name"
673
 
        project._info["description"] = "updated description"
674
 
        quota.metadata_items = 444
675
 
        quota.volumes = 444
676
 
 
677
 
        updated_project = {"tenant_name": project._info["name"],
678
 
                           "tenant_id": project.id,
679
 
                           "description": project._info["description"],
680
 
                           "enabled": project.enabled}
681
 
        updated_quota = self._get_quota_info(quota)
682
 
 
683
 
        # contribute
684
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
685
 
 
686
 
        # handle
687
 
        # handle
688
 
        api.tenant_update(IsA(http.HttpRequest), **updated_project) \
689
 
            .AndReturn(project)
690
 
 
691
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
692
 
        api.keystone.user_list(IsA(http.HttpRequest),
693
 
                               tenant_id=self.tenant.id).AndReturn(users)
694
 
 
695
 
        for user in users:
696
 
            api.roles_for_user(IsA(http.HttpRequest),
697
 
                                        user.id,
698
 
                                        self.tenant.id) \
699
 
                              .AndReturn(current_roles)
700
 
            for role in roles:
701
 
                if "role_" + role.id in workflow_data:
702
 
                    ulist = workflow_data["role_" + role.id]
703
 
                    if role not in current_roles:
704
 
                        api.add_tenant_user_role(IsA(http.HttpRequest),
705
 
                                             tenant_id=self.tenant.id,
706
 
                                             user_id=user,
707
 
                                             role_id=role.id)
708
 
                    else:
709
 
                        current_roles.pop(current_roles.index(role))
710
 
            for to_delete in current_roles:
711
 
                api.remove_tenant_user_role(IsA(http.HttpRequest),
712
 
                                            tenant_id=self.tenant.id,
713
 
                                            user_id=user.id,
714
 
                                            role_id=to_delete.id)
715
 
        for role in roles:
716
 
            if "role_" + role.id in workflow_data:
717
 
                ulist = workflow_data["role_" + role.id]
718
 
                for user in ulist:
719
 
                    if not filter(lambda x: user == x.id, users):
720
 
                        api.add_tenant_user_role(IsA(http.HttpRequest),
721
 
                                                 tenant_id=self.tenant.id,
722
 
                                                 user_id=user,
723
 
                                                 role_id=role.id)
724
 
 
725
 
        api.tenant_quota_update(IsA(http.HttpRequest),
726
 
                                project.id,
727
 
                                **updated_quota).AndRaise(self.exceptions.nova)
728
 
 
729
 
        self.mox.ReplayAll()
730
 
 
731
 
        # submit form data
732
 
        project_data = {"name": project._info["name"],
733
 
                         "id": project.id,
734
 
                         "description": project._info["description"],
735
 
                         "enabled": project.enabled}
736
 
        workflow_data.update(project_data)
737
 
        workflow_data.update(updated_quota)
738
 
        url = reverse('horizon:syspanel:projects:update',
739
 
                      args=[self.tenant.id])
740
 
        res = self.client.post(url, workflow_data)
741
 
 
742
 
        self.assertNoFormErrors(res)
743
 
        self.assertRedirectsNoFollow(res, INDEX_URL)
744
 
 
745
 
    @test.create_stubs({api: ('tenant_get',
746
 
                              'tenant_quota_get',
747
 
                              'tenant_update',
748
 
                              'get_default_role',
749
 
                              'roles_for_user',
750
 
                              'remove_tenant_user_role',
751
 
                              'add_tenant_user_role'),
752
 
                        api.keystone: ('user_list',
753
 
                                       'role_list',)})
754
 
    def test_update_project_member_update_error(self):
755
 
        project = self.tenants.first()
756
 
        quota = self.quotas.first()
757
 
        default_role = self.roles.first()
758
 
        users = self.users.list()
759
 
        roles = self.roles.list()
760
 
        current_roles = self.roles.list()
761
 
 
762
 
        # get/init
763
 
        api.tenant_get(IsA(http.HttpRequest), self.tenant.id, admin=True) \
764
 
            .AndReturn(project)
765
 
        api.tenant_quota_get(IsA(http.HttpRequest), self.tenant.id) \
766
 
            .AndReturn(quota)
767
 
 
768
 
        api.get_default_role(IsA(http.HttpRequest)).AndReturn(default_role)
769
 
        api.keystone.user_list(IsA(http.HttpRequest)).AndReturn(users)
770
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
771
 
 
772
 
        workflow_data = {}
773
 
        for user in users:
774
 
            api.roles_for_user(IsA(http.HttpRequest),
775
 
                               user.id,
776
 
                               self.tenant.id).AndReturn(roles)
777
 
            role_ids = [role.id for role in roles]
778
 
            if role_ids:
779
 
                workflow_data.setdefault("role_" + role_ids[0], []) \
780
 
                             .append(user.id)
781
 
 
782
 
        # update some fields
783
 
        project._info["name"] = "updated name"
784
 
        project._info["description"] = "updated description"
785
 
        quota.metadata_items = 444
786
 
        quota.volumes = 444
787
 
 
788
 
        updated_project = {"tenant_name": project._info["name"],
789
 
                           "tenant_id": project.id,
790
 
                           "description": project._info["description"],
791
 
                           "enabled": project.enabled}
792
 
        updated_quota = self._get_quota_info(quota)
793
 
 
794
 
        # contribute
795
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
796
 
 
797
 
        # handle
798
 
        api.tenant_update(IsA(http.HttpRequest), **updated_project) \
799
 
            .AndReturn(project)
800
 
 
801
 
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
802
 
        api.keystone.user_list(IsA(http.HttpRequest),
803
 
                               tenant_id=self.tenant.id).AndReturn(users)
804
 
 
805
 
        for user in users:
806
 
            api.roles_for_user(IsA(http.HttpRequest),
807
 
                                        user.id,
808
 
                                        self.tenant.id) \
809
 
                              .AndReturn(current_roles)
810
 
            for role in roles:
811
 
                if "role_" + role.id in workflow_data:
812
 
                    if role not in current_roles:
813
 
                        api.add_tenant_user_role(IsA(http.HttpRequest),
814
 
                                             tenant_id=self.tenant.id,
815
 
                                             user_id=user,
816
 
                                             role_id=role.id)
817
 
                    else:
818
 
                        current_roles.pop(current_roles.index(role))
819
 
            for to_delete in current_roles:
820
 
                api.remove_tenant_user_role(IsA(http.HttpRequest),
821
 
                                            tenant_id=self.tenant.id,
822
 
                                            user_id=user.id,
823
 
                                            role_id=to_delete.id) \
824
 
                                            .AndRaise(self.exceptions.nova)
825
 
                break
826
 
            break
827
 
 
828
 
        self.mox.ReplayAll()
829
 
 
830
 
        # submit form data
831
 
        project_data = {"name": project._info["name"],
832
 
                         "id": project.id,
833
 
                         "description": project._info["description"],
834
 
                         "enabled": project.enabled}
835
 
        workflow_data.update(project_data)
836
 
        workflow_data.update(updated_quota)
837
 
        url = reverse('horizon:syspanel:projects:update',
838
 
                      args=[self.tenant.id])
839
 
        res = self.client.post(url, workflow_data)
840
 
 
841
 
        self.assertNoFormErrors(res)
842
 
        self.assertRedirectsNoFollow(res, INDEX_URL)