Fix the role implies list command.

The code was calling an unexisting function which never existed.
The module refers now to the correct `InferenceRuleManager`. It
also allows the compatibility with the future python-keystoneclient
in which the compatibility method will be removed from the
RoleManager.

Change-Id: I08f785dc9e840da2e16915683eecfe49189c44b3

Author: Sami MAKKI

openstackclient/identity/v3/implied_role.py

@@ -71,7 +71,7 @@ def take_action(self, parsed_args):
         identity_client = self.app.client_manager.identity
         (prior_role_id, implied_role_id) = _get_role_ids(
             identity_client, parsed_args)
-        response = identity_client.roles.create_implied(
+        response = identity_client.inference_rules.create(
             prior_role_id, implied_role_id)
         response._info.pop('links', None)
         return zip(*sorted([(k, v['id'])
@@ -101,7 +101,7 @@ def take_action(self, parsed_args):
         identity_client = self.app.client_manager.identity
         (prior_role_id, implied_role_id) = _get_role_ids(
             identity_client, parsed_args)
-        identity_client.roles.delete_implied(
+        identity_client.inference_rules.delete(
             prior_role_id, implied_role_id)
 
 
@@ -125,5 +125,5 @@ def _list_implied(response):
                            implies['name'])
 
         identity_client = self.app.client_manager.identity
-        response = identity_client.roles.list_inference_roles()
+        response = identity_client.inference_rules.list_inference_roles()
         return (self._COLUMNS, _list_implied(response))

openstackclient/tests/functional/identity/v3/common.py

@@ -52,6 +52,8 @@ class IdentityTests(base.TestCase):
                                'id', 'relay_state_prefix', 'sp_url']
     SERVICE_PROVIDER_LIST_HEADERS = ['ID', 'Enabled', 'Description',
                                      'Auth URL']
+    IMPLIED_ROLE_LIST_HEADERS = ['Prior Role ID', 'Prior Role Name',
+                                 'Implied Role ID', 'Implied Role Name']
 
     @classmethod
     def setUpClass(cls):
@@ -149,6 +151,17 @@ def _create_dummy_role(self, add_clean_up=True):
         self.assertEqual(role_name, role['name'])
         return role_name
 
+    def _create_dummy_implied_role(self, add_clean_up=True):
+        role_name = self._create_dummy_role(add_clean_up)
+        implied_role_name = self._create_dummy_role(add_clean_up)
+        self.openstack(
+            'implied role create '
+            '--implied-role %(implied_role)s '
+            '%(role)s' % {'implied_role': implied_role_name,
+                          'role': role_name})
+
+        return implied_role_name, role_name
+
     def _create_dummy_group(self, add_clean_up=True):
         group_name = data_utils.rand_name('TestGroup')
         description = data_utils.rand_name('description')

openstackclient/tests/functional/identity/v3/test_role.py

@@ -143,3 +143,28 @@ def test_role_remove(self):
                           'role': role_name})
         self.assertEqual(0, len(add_raw_output))
         self.assertEqual(0, len(remove_raw_output))
+
+    def test_implied_role_list(self):
+        self._create_dummy_implied_role()
+        raw_output = self.openstack('implied role list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.IMPLIED_ROLE_LIST_HEADERS)
+        self.assertEqual(3, len(items))
+
+    def test_implied_role_create(self):
+        role_name = self._create_dummy_role()
+        implied_role_name = self._create_dummy_role()
+        self.openstack(
+            'implied role create '
+            '--implied-role %(implied_role)s '
+            '%(role)s' % {'implied_role': implied_role_name,
+                          'role': role_name})
+
+    def test_implied_role_delete(self):
+        implied_role_name, role_name = self._create_dummy_implied_role()
+        raw_output = self.openstack(
+            'implied role delete '
+            '--implied-role %(implied_role)s '
+            '%(role)s' % {'implied_role': implied_role_name,
+                          'role': role_name})
+        self.assertEqual(0, len(raw_output))

openstackclient/tests/unit/identity/v3/fakes.py

@@ -576,6 +576,8 @@ def __init__(self, **kwargs):
         self.application_credentials = mock.Mock()
         self.application_credentials.resource_class = fakes.FakeResource(None,
                                                                          {})
+        self.inference_rules = mock.Mock()
+        self.inference_rules.resource_class = fakes.FakeResource(None, {})
 
 
 class FakeFederationManager(object):

openstackclient/tests/unit/identity/v3/test_implied_role.py

@@ -25,26 +25,32 @@ class TestRole(identity_fakes.TestIdentityv3):
     def setUp(self):
         super(TestRole, self).setUp()
 
+        identity_client = self.app.client_manager.identity
+
         # Get a shortcut to the UserManager Mock
-        self.users_mock = self.app.client_manager.identity.users
+        self.users_mock = identity_client.users
         self.users_mock.reset_mock()
 
         # Get a shortcut to the UserManager Mock
-        self.groups_mock = self.app.client_manager.identity.groups
+        self.groups_mock = identity_client.groups
         self.groups_mock.reset_mock()
 
         # Get a shortcut to the DomainManager Mock
-        self.domains_mock = self.app.client_manager.identity.domains
+        self.domains_mock = identity_client.domains
         self.domains_mock.reset_mock()
 
         # Get a shortcut to the ProjectManager Mock
-        self.projects_mock = self.app.client_manager.identity.projects
+        self.projects_mock = identity_client.projects
         self.projects_mock.reset_mock()
 
         # Get a shortcut to the RoleManager Mock
-        self.roles_mock = self.app.client_manager.identity.roles
+        self.roles_mock = identity_client.roles
         self.roles_mock.reset_mock()
 
+        # Get a shortcut to the InferenceRuleManager Mock
+        self.inference_rules_mock = identity_client.inference_rules
+        self.inference_rules_mock.reset_mock()
+
     def _is_inheritance_testcase(self):
         return False
 
@@ -67,12 +73,13 @@ def setUp(self):
             ),
         ]
 
-        self.roles_mock.create_implied.return_value = fakes.FakeResource(
+        fake_resource = fakes.FakeResource(
             None,
             {'prior_role': copy.deepcopy(identity_fakes.ROLES[0]),
              'implied': copy.deepcopy(identity_fakes.ROLES[1]), },
             loaded=True,
         )
+        self.inference_rules_mock.create.return_value = fake_resource
 
         self.cmd = implied_role.CreateImpliedRole(self.app, None)
 
@@ -93,8 +100,8 @@ def test_implied_role_create(self):
         # data to be shown.
         columns, data = self.cmd.take_action(parsed_args)
 
-        # RoleManager.create_implied(prior, implied)
-        self.roles_mock.create_implied.assert_called_with(
+        # InferenceRuleManager.create(prior, implied)
+        self.inference_rules_mock.create.assert_called_with(
             identity_fakes.ROLES[0]['id'],
             identity_fakes.ROLES[1]['id']
         )
@@ -126,12 +133,13 @@ def setUp(self):
             ),
         ]
 
-        self.roles_mock.delete_implied.return_value = fakes.FakeResource(
+        fake_resource = fakes.FakeResource(
             None,
             {'prior-role': copy.deepcopy(identity_fakes.ROLES[0]),
              'implied': copy.deepcopy(identity_fakes.ROLES[1]), },
             loaded=True,
         )
+        self.inference_rules_mock.delete.return_value = fake_resource
 
         self.cmd = implied_role.DeleteImpliedRole(self.app, None)
 
@@ -147,7 +155,7 @@ def test_implied_role_delete(self):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         self.cmd.take_action(parsed_args)
 
-        self.roles_mock.delete_implied.assert_called_with(
+        self.inference_rules_mock.delete.assert_called_with(
             identity_fakes.ROLES[0]['id'],
             identity_fakes.ROLES[1]['id']
         )
@@ -158,7 +166,7 @@ class TestImpliedRoleList(TestRole):
     def setUp(self):
         super(TestImpliedRoleList, self).setUp()
 
-        self.roles_mock.list_inference_roles.return_value = (
+        self.inference_rules_mock.list_inference_roles.return_value = (
             identity_fakes.FakeImpliedRoleResponse.create_list())
 
         self.cmd = implied_role.ListImpliedRole(self.app, None)
@@ -168,7 +176,7 @@ def test_implied_role_list(self):
         verifylist = []
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         columns, data = self.cmd.take_action(parsed_args)
-        self.roles_mock.list_inference_roles.assert_called_with()
+        self.inference_rules_mock.list_inference_roles.assert_called_with()
 
         collist = ['Prior Role ID', 'Prior Role Name',
                    'Implied Role ID', 'Implied Role Name']