1#   Licensed under the Apache License, Version 2.0 (the "License"); you may
2#   not use this file except in compliance with the License. You may obtain
3#   a copy of the License at
4#
5#        http://www.apache.org/licenses/LICENSE-2.0
6#
7#   Unless required by applicable law or agreed to in writing, software
8#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
9#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
10#   License for the specific language governing permissions and limitations
11#   under the License.
12#
13
14import copy
15from unittest import mock
16
17from openstackclient.identity.v3 import role_assignment
18from openstackclient.tests.unit import fakes
19from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes
20
21
22class TestRoleAssignment(identity_fakes.TestIdentityv3):
23
24    def setUp(self):
25        super(TestRoleAssignment, self).setUp()
26
27
28class TestRoleAssignmentList(TestRoleAssignment):
29
30    columns = (
31        'Role',
32        'User',
33        'Group',
34        'Project',
35        'Domain',
36        'System',
37        'Inherited',
38    )
39
40    def setUp(self):
41        super(TestRoleAssignment, self).setUp()
42
43        # Get a shortcut to the UserManager Mock
44        self.users_mock = self.app.client_manager.identity.users
45        self.users_mock.reset_mock()
46
47        # Get a shortcut to the GroupManager Mock
48        self.groups_mock = self.app.client_manager.identity.groups
49        self.groups_mock.reset_mock()
50
51        # Get a shortcut to the DomainManager Mock
52        self.domains_mock = self.app.client_manager.identity.domains
53        self.domains_mock.reset_mock()
54
55        # Get a shortcut to the ProjectManager Mock
56        self.projects_mock = self.app.client_manager.identity.projects
57        self.projects_mock.reset_mock()
58
59        # Get a shortcut to the RoleManager Mock
60        self.roles_mock = self.app.client_manager.identity.roles
61        self.roles_mock.reset_mock()
62
63        self.role_assignments_mock = self.app.client_manager.identity.\
64            role_assignments
65        self.role_assignments_mock.reset_mock()
66
67        # Get the command object to test
68        self.cmd = role_assignment.ListRoleAssignment(self.app, None)
69
70    def test_role_assignment_list_no_filters(self):
71
72        self.role_assignments_mock.list.return_value = [
73            fakes.FakeResource(
74                None,
75                copy.deepcopy(
76                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID),
77                loaded=True,
78            ),
79            fakes.FakeResource(
80                None,
81                copy.deepcopy(
82                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID),
83                loaded=True,
84            ),
85        ]
86
87        arglist = []
88        verifylist = []
89        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
90
91        # In base command class Lister in cliff, abstract method take_action()
92        # returns a tuple containing the column names and an iterable
93        # containing the data to be listed.
94        columns, data = self.cmd.take_action(parsed_args)
95
96        self.role_assignments_mock.list.assert_called_with(
97            domain=None,
98            system=None,
99            group=None,
100            effective=False,
101            role=None,
102            user=None,
103            project=None,
104            os_inherit_extension_inherited_to=None,
105            include_names=False)
106
107        self.assertEqual(self.columns, columns)
108        datalist = ((
109            identity_fakes.role_id,
110            identity_fakes.user_id,
111            '',
112            identity_fakes.project_id,
113            '',
114            '',
115            False
116        ), (identity_fakes.role_id,
117            '',
118            identity_fakes.group_id,
119            identity_fakes.project_id,
120            '',
121            '',
122            False
123            ),)
124        self.assertEqual(datalist, tuple(data))
125
126    def test_role_assignment_list_user(self):
127
128        self.role_assignments_mock.list.return_value = [
129            fakes.FakeResource(
130                None,
131                copy.deepcopy(
132                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID),
133                loaded=True,
134            ),
135            fakes.FakeResource(
136                None,
137                copy.deepcopy(
138                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID),
139                loaded=True,
140            ),
141        ]
142
143        arglist = [
144            '--user', identity_fakes.user_name
145        ]
146        verifylist = [
147            ('user', identity_fakes.user_name),
148            ('group', None),
149            ('system', None),
150            ('domain', None),
151            ('project', None),
152            ('role', None),
153            ('effective', False),
154            ('inherited', False),
155            ('names', False),
156        ]
157        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
158
159        # In base command class Lister in cliff, abstract method take_action()
160        # returns a tuple containing the column names and an iterable
161        # containing the data to be listed.
162        columns, data = self.cmd.take_action(parsed_args)
163
164        self.role_assignments_mock.list.assert_called_with(
165            domain=None,
166            system=None,
167            user=self.users_mock.get(),
168            group=None,
169            project=None,
170            role=None,
171            effective=False,
172            os_inherit_extension_inherited_to=None,
173            include_names=False)
174
175        self.assertEqual(self.columns, columns)
176        datalist = ((
177            identity_fakes.role_id,
178            identity_fakes.user_id,
179            '',
180            '',
181            identity_fakes.domain_id,
182            '',
183            False
184        ), (identity_fakes.role_id,
185            identity_fakes.user_id,
186            '',
187            identity_fakes.project_id,
188            '',
189            '',
190            False
191            ),)
192        self.assertEqual(datalist, tuple(data))
193
194    def test_role_assignment_list_group(self):
195
196        self.role_assignments_mock.list.return_value = [
197            fakes.FakeResource(
198                None,
199                copy.deepcopy(
200                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_GROUP_ID),
201                loaded=True,
202            ),
203            fakes.FakeResource(
204                None,
205                copy.deepcopy(
206                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID),
207                loaded=True,
208            ),
209        ]
210
211        arglist = [
212            '--group', identity_fakes.group_name
213        ]
214        verifylist = [
215            ('user', None),
216            ('group', identity_fakes.group_name),
217            ('system', None),
218            ('domain', None),
219            ('project', None),
220            ('role', None),
221            ('effective', False),
222            ('inherited', False),
223            ('names', False),
224        ]
225        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
226
227        # In base command class Lister in cliff, abstract method take_action()
228        # returns a tuple containing the column names and an iterable
229        # containing the data to be listed.
230        columns, data = self.cmd.take_action(parsed_args)
231
232        self.role_assignments_mock.list.assert_called_with(
233            domain=None,
234            system=None,
235            group=self.groups_mock.get(),
236            effective=False,
237            project=None,
238            role=None,
239            user=None,
240            os_inherit_extension_inherited_to=None,
241            include_names=False)
242
243        self.assertEqual(self.columns, columns)
244        datalist = ((
245            identity_fakes.role_id,
246            '',
247            identity_fakes.group_id,
248            '',
249            identity_fakes.domain_id,
250            '',
251            False
252        ), (identity_fakes.role_id,
253            '',
254            identity_fakes.group_id,
255            identity_fakes.project_id,
256            '',
257            '',
258            False
259            ),)
260        self.assertEqual(datalist, tuple(data))
261
262    def test_role_assignment_list_domain(self):
263
264        self.role_assignments_mock.list.return_value = [
265            fakes.FakeResource(
266                None,
267                copy.deepcopy(
268                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID),
269                loaded=True,
270            ),
271            fakes.FakeResource(
272                None,
273                copy.deepcopy(
274                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_GROUP_ID),
275                loaded=True,
276            ),
277        ]
278
279        arglist = [
280            '--domain', identity_fakes.domain_name
281        ]
282        verifylist = [
283            ('user', None),
284            ('group', None),
285            ('system', None),
286            ('domain', identity_fakes.domain_name),
287            ('project', None),
288            ('role', None),
289            ('effective', False),
290            ('inherited', False),
291            ('names', False),
292        ]
293        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
294
295        # In base command class Lister in cliff, abstract method take_action()
296        # returns a tuple containing the column names and an iterable
297        # containing the data to be listed.
298        columns, data = self.cmd.take_action(parsed_args)
299
300        self.role_assignments_mock.list.assert_called_with(
301            domain=self.domains_mock.get(),
302            system=None,
303            group=None,
304            effective=False,
305            project=None,
306            role=None,
307            user=None,
308            os_inherit_extension_inherited_to=None,
309            include_names=False)
310
311        self.assertEqual(self.columns, columns)
312        datalist = ((
313            identity_fakes.role_id,
314            identity_fakes.user_id,
315            '',
316            '',
317            identity_fakes.domain_id,
318            '',
319            False
320        ), (identity_fakes.role_id,
321            '',
322            identity_fakes.group_id,
323            '',
324            identity_fakes.domain_id,
325            '',
326            False
327            ),)
328        self.assertEqual(datalist, tuple(data))
329
330    def test_role_assignment_list_project(self):
331
332        self.role_assignments_mock.list.return_value = [
333            fakes.FakeResource(
334                None,
335                copy.deepcopy(
336                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID),
337                loaded=True,
338            ),
339            fakes.FakeResource(
340                None,
341                copy.deepcopy(
342                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID),
343                loaded=True,
344            ),
345        ]
346
347        arglist = [
348            '--project', identity_fakes.project_name
349        ]
350        verifylist = [
351            ('user', None),
352            ('group', None),
353            ('system', None),
354            ('domain', None),
355            ('project', identity_fakes.project_name),
356            ('role', None),
357            ('effective', False),
358            ('inherited', False),
359            ('names', False),
360        ]
361        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
362
363        # In base command class Lister in cliff, abstract method take_action()
364        # returns a tuple containing the column names and an iterable
365        # containing the data to be listed.
366        columns, data = self.cmd.take_action(parsed_args)
367
368        self.role_assignments_mock.list.assert_called_with(
369            domain=None,
370            system=None,
371            group=None,
372            effective=False,
373            project=self.projects_mock.get(),
374            role=None,
375            user=None,
376            os_inherit_extension_inherited_to=None,
377            include_names=False)
378
379        self.assertEqual(self.columns, columns)
380        datalist = ((
381            identity_fakes.role_id,
382            identity_fakes.user_id,
383            '',
384            identity_fakes.project_id,
385            '',
386            '',
387            False
388        ), (identity_fakes.role_id,
389            '',
390            identity_fakes.group_id,
391            identity_fakes.project_id,
392            '',
393            '',
394            False
395            ),)
396        self.assertEqual(datalist, tuple(data))
397
398    def test_role_assignment_list_def_creds(self):
399
400        auth_ref = self.app.client_manager.auth_ref = mock.Mock()
401        auth_ref.project_id.return_value = identity_fakes.project_id
402        auth_ref.user_id.return_value = identity_fakes.user_id
403
404        self.role_assignments_mock.list.return_value = [
405            fakes.FakeResource(
406                None,
407                copy.deepcopy(
408                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID),
409                loaded=True,
410            ),
411        ]
412
413        arglist = [
414            '--auth-user',
415            '--auth-project',
416        ]
417        verifylist = [
418            ('user', None),
419            ('group', None),
420            ('system', None),
421            ('domain', None),
422            ('project', None),
423            ('role', None),
424            ('effective', False),
425            ('inherited', False),
426            ('names', False),
427            ('authuser', True),
428            ('authproject', True),
429        ]
430        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
431
432        # In base command class Lister in cliff, abstract method take_action()
433        # returns a tuple containing the column names and an iterable
434        # containing the data to be listed.
435        columns, data = self.cmd.take_action(parsed_args)
436
437        self.role_assignments_mock.list.assert_called_with(
438            domain=None,
439            system=None,
440            user=self.users_mock.get(),
441            group=None,
442            project=self.projects_mock.get(),
443            role=None,
444            effective=False,
445            os_inherit_extension_inherited_to=None,
446            include_names=False)
447
448        self.assertEqual(self.columns, columns)
449        datalist = ((
450            identity_fakes.role_id,
451            identity_fakes.user_id,
452            '',
453            identity_fakes.project_id,
454            '',
455            '',
456            False
457        ),)
458        self.assertEqual(datalist, tuple(data))
459
460    def test_role_assignment_list_effective(self):
461
462        self.role_assignments_mock.list.return_value = [
463            fakes.FakeResource(
464                None,
465                copy.deepcopy(
466                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID),
467                loaded=True,
468            ),
469            fakes.FakeResource(
470                None,
471                copy.deepcopy(
472                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID),
473                loaded=True,
474            ),
475        ]
476
477        arglist = ['--effective']
478        verifylist = [
479            ('user', None),
480            ('group', None),
481            ('system', None),
482            ('domain', None),
483            ('project', None),
484            ('role', None),
485            ('effective', True),
486            ('inherited', False),
487            ('names', False),
488        ]
489        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
490
491        # In base command class Lister in cliff, abstract method take_action()
492        # returns a tuple containing the column names and an iterable
493        # containing the data to be listed.
494        columns, data = self.cmd.take_action(parsed_args)
495
496        self.role_assignments_mock.list.assert_called_with(
497            domain=None,
498            system=None,
499            group=None,
500            effective=True,
501            project=None,
502            role=None,
503            user=None,
504            os_inherit_extension_inherited_to=None,
505            include_names=False)
506
507        self.assertEqual(self.columns, columns)
508        datalist = ((
509            identity_fakes.role_id,
510            identity_fakes.user_id,
511            '',
512            identity_fakes.project_id,
513            '',
514            '',
515            False
516        ), (identity_fakes.role_id,
517            identity_fakes.user_id,
518            '',
519            '',
520            identity_fakes.domain_id,
521            '',
522            False
523            ),)
524        self.assertEqual(tuple(data), datalist)
525
526    def test_role_assignment_list_inherited(self):
527
528        self.role_assignments_mock.list.return_value = [
529            fakes.FakeResource(
530                None,
531                copy.deepcopy(
532                    (identity_fakes.
533                        ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INHERITED)),
534                loaded=True,
535            ),
536            fakes.FakeResource(
537                None,
538                copy.deepcopy(
539                    (identity_fakes.
540                        ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INHERITED)),
541                loaded=True,
542            ),
543        ]
544
545        arglist = ['--inherited']
546        verifylist = [
547            ('user', None),
548            ('group', None),
549            ('system', None),
550            ('domain', None),
551            ('project', None),
552            ('role', None),
553            ('effective', False),
554            ('inherited', True),
555            ('names', False),
556        ]
557        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
558
559        # In base command class Lister in cliff, abstract method take_action()
560        # returns a tuple containing the column names and an iterable
561        # containing the data to be listed.
562        columns, data = self.cmd.take_action(parsed_args)
563
564        self.role_assignments_mock.list.assert_called_with(
565            domain=None,
566            system=None,
567            group=None,
568            effective=False,
569            project=None,
570            role=None,
571            user=None,
572            os_inherit_extension_inherited_to='projects',
573            include_names=False)
574
575        self.assertEqual(self.columns, columns)
576        datalist = ((
577            identity_fakes.role_id,
578            identity_fakes.user_id,
579            '',
580            identity_fakes.project_id,
581            '',
582            '',
583            True
584        ), (identity_fakes.role_id,
585            identity_fakes.user_id,
586            '',
587            '',
588            identity_fakes.domain_id,
589            '',
590            True
591            ),)
592        self.assertEqual(datalist, tuple(data))
593
594    def test_role_assignment_list_include_names(self):
595
596        self.role_assignments_mock.list.return_value = [
597            fakes.FakeResource(
598                None,
599                copy.deepcopy(
600                    identity_fakes
601                    .ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INCLUDE_NAMES),
602                loaded=True,
603            ),
604            fakes.FakeResource(
605                None,
606                copy.deepcopy(
607                    identity_fakes
608                    .ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INCLUDE_NAMES),
609                loaded=True,
610            ),
611        ]
612
613        arglist = ['--names']
614        verifylist = [
615            ('user', None),
616            ('group', None),
617            ('system', None),
618            ('domain', None),
619            ('project', None),
620            ('role', None),
621            ('effective', False),
622            ('inherited', False),
623            ('names', True),
624        ]
625        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
626
627        # DisplayCommandBase.take_action() returns two tuples
628
629        # This test will not run correctly until the patch in the python
630        # client is merged. Once that is done 'data' should return the
631        # correct information
632        columns, data = self.cmd.take_action(parsed_args)
633
634        self.role_assignments_mock.list.assert_called_with(
635            domain=None,
636            system=None,
637            group=None,
638            effective=False,
639            project=None,
640            role=None,
641            user=None,
642            os_inherit_extension_inherited_to=None,
643            include_names=True)
644
645        collist = (
646            'Role', 'User', 'Group', 'Project', 'Domain', 'System', 'Inherited'
647        )
648        self.assertEqual(columns, collist)
649
650        datalist1 = ((
651            identity_fakes.role_name,
652            '@'.join([identity_fakes.user_name, identity_fakes.domain_name]),
653            '',
654            '@'.join([identity_fakes.project_name,
655                      identity_fakes.domain_name]),
656            '',
657            '',
658            False
659        ), (identity_fakes.role_name,
660            '@'.join([identity_fakes.user_name, identity_fakes.domain_name]),
661            '',
662            '',
663            identity_fakes.domain_name,
664            '',
665            False
666            ),)
667        self.assertEqual(tuple(data), datalist1)
668
669    def test_role_assignment_list_domain_role(self):
670
671        self.role_assignments_mock.list.return_value = [
672            fakes.FakeResource(
673                None,
674                copy.deepcopy(
675                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ROLE),
676                loaded=True,
677            ),
678        ]
679
680        arglist = [
681            '--role', identity_fakes.ROLE_2['name'],
682            '--role-domain', identity_fakes.domain_name
683        ]
684        verifylist = [
685            ('user', None),
686            ('group', None),
687            ('system', None),
688            ('domain', None),
689            ('project', None),
690            ('role', identity_fakes.ROLE_2['name']),
691            ('effective', False),
692            ('inherited', False),
693            ('names', False),
694        ]
695        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
696
697        # In base command class Lister in cliff, abstract method take_action()
698        # returns a tuple containing the column names and an iterable
699        # containing the data to be listed.
700        columns, data = self.cmd.take_action(parsed_args)
701
702        self.role_assignments_mock.list.assert_called_with(
703            domain=None,
704            system=None,
705            user=None,
706            group=None,
707            project=None,
708            role=self.roles_mock.get(),
709            effective=False,
710            os_inherit_extension_inherited_to=None,
711            include_names=False)
712
713        self.assertEqual(self.columns, columns)
714        datalist = ((
715            identity_fakes.ROLE_2['id'],
716            identity_fakes.user_id,
717            '',
718            '',
719            identity_fakes.domain_id,
720            '',
721            False
722        ),)
723        self.assertEqual(datalist, tuple(data))
724