move unit tests to new "unit" test module

this will better isolate the unit tests from the functional tests.
unfortunately, the "integration" tests had to be lumped into the
"unit" tests since we need the separation in testr.conf

Change-Id: Ifd12198c1f90e4e3c951c73bfa1884ab300d8ded

33 files changed, 0 insertions, 13686 deletions

diff --git a/openstackclient/tests/identity/__init__.py b/openstackclient/tests/identity/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/openstackclient/tests/identity/__init__.py
+++ /dev/null
diff --git a/openstackclient/tests/identity/v2_0/__init__.py b/openstackclient/tests/identity/v2_0/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/openstackclient/tests/identity/v2_0/__init__.py
+++ /dev/null
diff --git a/openstackclient/tests/identity/v2_0/fakes.py b/openstackclient/tests/identity/v2_0/fakes.py
deleted file mode 100644
index 3e0b9993..00000000
--- a/openstackclient/tests/identity/v2_0/fakes.py
+++ /dev/null
@@ -1,515 +0,0 @@
-#   Copyright 2013 Nebula Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import copy
-import mock
-import uuid
-
-from keystoneauth1 import access
-from keystoneauth1 import fixture
-
-from openstackclient.tests import fakes
-from openstackclient.tests import utils
-
-
-project_id = '8-9-64'
-project_name = 'beatles'
-project_description = 'Fab Four'
-
-PROJECT = {
-    'id': project_id,
-    'name': project_name,
-    'description': project_description,
-    'enabled': True,
-}
-
-PROJECT_2 = {
-    'id': project_id + '-2222',
-    'name': project_name + ' reprise',
-    'description': project_description + 'plus four more',
-    'enabled': True,
-}
-
-role_id = '1'
-role_name = 'boss'
-
-ROLE = {
-    'id': role_id,
-    'name': role_name,
-}
-
-ROLE_2 = {
-    'id': '2',
-    'name': 'bigboss',
-}
-
-service_id = '1925-10-11'
-service_name = 'elmore'
-service_description = 'Leonard, Elmore, rip'
-service_type = 'author'
-
-SERVICE = {
-    'id': service_id,
-    'name': service_name,
-    'description': service_description,
-    'type': service_type,
-}
-
-user_id = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'
-user_name = 'paul'
-user_description = 'Sir Paul'
-user_email = 'paul@applecorps.com'
-
-USER = {
-    'id': user_id,
-    'name': user_name,
-    'tenantId': project_id,
-    'email': user_email,
-    'enabled': True,
-}
-
-token_expires = '2016-09-05T18:04:52+0000'
-token_id = 'token-id-' + uuid.uuid4().hex
-
-TOKEN = {
-    'expires': token_expires,
-    'id': token_id,
-    'tenant_id': 'project-id',
-    'user_id': 'user-id',
-}
-
-UNSCOPED_TOKEN = {
-    'expires': token_expires,
-    'id': token_id,
-    'user_id': 'user-id',
-}
-
-endpoint_name = service_name
-endpoint_adminurl = 'https://admin.example.com/v2/UUID'
-endpoint_region = 'RegionOne'
-endpoint_internalurl = 'https://internal.example.com/v2/UUID'
-endpoint_type = service_type
-endpoint_id = '11b41ee1b00841128b7333d4bf1a6140'
-endpoint_publicurl = 'https://public.example.com/v2/UUID'
-endpoint_service_id = service_id
-
-ENDPOINT = {
-    'service_name': endpoint_name,
-    'adminurl': endpoint_adminurl,
-    'region': endpoint_region,
-    'internalurl': endpoint_internalurl,
-    'service_type': endpoint_type,
-    'id': endpoint_id,
-    'publicurl': endpoint_publicurl,
-    'service_id': endpoint_service_id,
-}
-
-
-def fake_auth_ref(fake_token, fake_service=None):
-    """Create an auth_ref using keystoneauth's fixtures"""
-    token_copy = copy.deepcopy(fake_token)
-    token_copy['token_id'] = token_copy.pop('id')
-    token = fixture.V2Token(**token_copy)
-    # An auth_ref is actually an access info object
-    auth_ref = access.create(body=token)
-
-    # Create a service catalog
-    if fake_service:
-        service = token.add_service(
-            fake_service.type,
-            fake_service.name,
-        )
-        # TODO(dtroyer): Add an 'id' element to KSA's _Service fixure
-        service['id'] = fake_service.id
-        for e in fake_service.endpoints:
-            # KSA's _Service fixture copies publicURL to internalURL and
-            # adminURL if they do not exist.  Soooo helpful...
-            internal = e.get('internalURL', None)
-            admin = e.get('adminURL', None)
-            region = e.get('region_id') or e.get('region', '<none>')
-            endpoint = service.add_endpoint(
-                public=e['publicURL'],
-                internal=internal,
-                admin=admin,
-                region=region,
-            )
-            # ...so undo that helpfulness
-            if not internal:
-                endpoint['internalURL'] = None
-            if not admin:
-                endpoint['adminURL'] = None
-
-    return auth_ref
-
-
-class FakeIdentityv2Client(object):
-
-    def __init__(self, **kwargs):
-        self.roles = mock.Mock()
-        self.roles.resource_class = fakes.FakeResource(None, {})
-        self.services = mock.Mock()
-        self.services.resource_class = fakes.FakeResource(None, {})
-        self.tenants = mock.Mock()
-        self.tenants.resource_class = fakes.FakeResource(None, {})
-        self.tokens = mock.Mock()
-        self.tokens.resource_class = fakes.FakeResource(None, {})
-        self.users = mock.Mock()
-        self.users.resource_class = fakes.FakeResource(None, {})
-        self.ec2 = mock.Mock()
-        self.ec2.resource_class = fakes.FakeResource(None, {})
-        self.endpoints = mock.Mock()
-        self.endpoints.resource_class = fakes.FakeResource(None, {})
-        self.extensions = mock.Mock()
-        self.extensions.resource_class = fakes.FakeResource(None, {})
-        self.auth_token = kwargs['token']
-        self.management_url = kwargs['endpoint']
-
-    def __getattr__(self, name):
-        # Map v3 'projects' back to v2 'tenants'
-        if name == "projects":
-            return self.tenants
-        else:
-            raise AttributeError(name)
-
-
-class TestIdentityv2(utils.TestCommand):
-
-    def setUp(self):
-        super(TestIdentityv2, self).setUp()
-
-        self.app.client_manager.identity = FakeIdentityv2Client(
-            endpoint=fakes.AUTH_URL,
-            token=fakes.AUTH_TOKEN,
-        )
-
-
-class FakeExtension(object):
-    """Fake one or more extension."""
-
-    @staticmethod
-    def create_one_extension(attrs=None):
-        """Create a fake extension.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object with name, namespace, etc.
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        extension_info = {
-            'name': 'name-' + uuid.uuid4().hex,
-            'namespace': ('http://docs.openstack.org/identity/'
-                          'api/ext/OS-KSCRUD/v1.0'),
-            'description': 'description-' + uuid.uuid4().hex,
-            'updated': '2013-07-07T12:00:0-00:00',
-            'alias': 'OS-KSCRUD',
-            'links': ('[{"href":'
-                      '"https://github.com/openstack/identity-api", "type":'
-                      ' "text/html", "rel": "describedby"}]')
-        }
-
-        # Overwrite default attributes.
-        extension_info.update(attrs)
-
-        extension = fakes.FakeResource(
-            info=copy.deepcopy(extension_info),
-            loaded=True)
-        return extension
-
-
-class FakeCatalog(object):
-    """Fake one or more catalog."""
-
-    @staticmethod
-    def create_catalog(attrs=None):
-        """Create a fake catalog.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object with id, name, type and so on.
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        catalog_info = {
-            'id': 'service-id-' + uuid.uuid4().hex,
-            'type': 'compute',
-            'name': 'supernova',
-            'endpoints': [
-                {
-                    'region': 'one',
-                    'publicURL': 'https://public.one.example.com',
-                    'internalURL': 'https://internal.one.example.com',
-                    'adminURL': 'https://admin.one.example.com',
-                },
-                {
-                    'region': 'two',
-                    'publicURL': 'https://public.two.example.com',
-                    'internalURL': 'https://internal.two.example.com',
-                    'adminURL': 'https://admin.two.example.com',
-                },
-                {
-                    'region': None,
-                    'publicURL': 'https://public.none.example.com',
-                    'internalURL': 'https://internal.none.example.com',
-                    'adminURL': 'https://admin.none.example.com',
-                },
-            ],
-        }
-        # Overwrite default attributes.
-        catalog_info.update(attrs)
-
-        catalog = fakes.FakeResource(
-            info=copy.deepcopy(catalog_info),
-            loaded=True)
-
-        return catalog
-
-
-class FakeProject(object):
-    """Fake one or more project."""
-
-    @staticmethod
-    def create_one_project(attrs=None):
-        """Create a fake project.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        project_info = {
-            'id': 'project-id-' + uuid.uuid4().hex,
-            'name': 'project-name-' + uuid.uuid4().hex,
-            'description': 'project_description',
-            'enabled': True,
-        }
-        project_info.update(attrs)
-
-        project = fakes.FakeResource(info=copy.deepcopy(project_info),
-                                     loaded=True)
-        return project
-
-    @staticmethod
-    def create_projects(attrs=None, count=2):
-        """Create multiple fake projects.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of projects to fake
-        :return:
-            A list of FakeResource objects faking the projects
-        """
-        projects = []
-        for i in range(0, count):
-            projects.append(FakeProject.create_one_project(attrs))
-
-        return projects
-
-
-class FakeEndpoint(object):
-    """Fake one or more endpoint."""
-
-    @staticmethod
-    def create_one_endpoint(attrs=None):
-        """Create a fake agent.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, region, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        endpoint_info = {
-            'service_name': 'service-name-' + uuid.uuid4().hex,
-            'adminurl': 'http://endpoint_adminurl',
-            'region': 'endpoint_region',
-            'internalurl': 'http://endpoint_internalurl',
-            'service_type': 'service_type',
-            'id': 'endpoint-id-' + uuid.uuid4().hex,
-            'publicurl': 'http://endpoint_publicurl',
-            'service_id': 'service-name-' + uuid.uuid4().hex,
-
-        }
-        endpoint_info.update(attrs)
-
-        endpoint = fakes.FakeResource(info=copy.deepcopy(endpoint_info),
-                                      loaded=True)
-        return endpoint
-
-    @staticmethod
-    def create_endpoints(attrs=None, count=2):
-        """Create multiple fake endpoints.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of endpoints to fake
-        :return:
-            A list of FakeResource objects faking the endpoints
-        """
-        endpoints = []
-        for i in range(0, count):
-            endpoints.append(FakeEndpoint.create_one_endpoint(attrs))
-
-        return endpoints
-
-
-class FakeService(object):
-    """Fake one or more service."""
-
-    @staticmethod
-    def create_one_service(attrs=None):
-        """Create a fake service.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, type, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        service_info = {
-            'id': 'service-id-' + uuid.uuid4().hex,
-            'name': 'service-name-' + uuid.uuid4().hex,
-            'description': 'service_description',
-            'type': 'service_type',
-
-        }
-        service_info.update(attrs)
-
-        service = fakes.FakeResource(info=copy.deepcopy(service_info),
-                                     loaded=True)
-        return service
-
-    @staticmethod
-    def create_services(attrs=None, count=2):
-        """Create multiple fake services.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of services to fake
-        :return:
-            A list of FakeResource objects faking the services
-        """
-        services = []
-        for i in range(0, count):
-            services.append(FakeService.create_one_service(attrs))
-
-        return services
-
-
-class FakeRole(object):
-    """Fake one or more role."""
-
-    @staticmethod
-    def create_one_role(attrs=None):
-        """Create a fake role.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        role_info = {
-            'id': 'role-id' + uuid.uuid4().hex,
-            'name': 'role-name' + uuid.uuid4().hex,
-        }
-        role_info.update(attrs)
-
-        role = fakes.FakeResource(info=copy.deepcopy(role_info),
-                                  loaded=True)
-        return role
-
-    @staticmethod
-    def create_roles(attrs=None, count=2):
-        """Create multiple fake roles.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of roles to fake
-        :return:
-            A list of FakeResource objects faking the roles
-        """
-        roles = []
-        for i in range(0, count):
-            roles.append(FakeRole.create_one_role(attrs))
-
-        return roles
-
-
-class FakeUser(object):
-    """Fake one or more user."""
-
-    @staticmethod
-    def create_one_user(attrs=None):
-        """Create a fake user.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, and so on
-        """
-        attrs = attrs or {}
-
-        # set default attributes.
-        user_info = {
-            'id': 'user-id-' + uuid.uuid4().hex,
-            'name': 'user-name-' + uuid.uuid4().hex,
-            'tenantId': 'project-id-' + uuid.uuid4().hex,
-            'email': 'admin@openstack.org',
-            'enabled': True,
-        }
-        user_info.update(attrs)
-
-        user = fakes.FakeResource(info=copy.deepcopy(user_info),
-                                  loaded=True)
-        return user
-
-    @staticmethod
-    def create_users(attrs=None, count=2):
-        """Create multiple fake users.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of users to fake
-        :return:
-            A list of FakeResource objects faking the users
-        """
-        users = []
-        for i in range(0, count):
-            users.append(FakeUser.create_one_user(attrs))
-
-        return users
diff --git a/openstackclient/tests/identity/v2_0/test_catalog.py b/openstackclient/tests/identity/v2_0/test_catalog.py
deleted file mode 100644
index 487d8f31..00000000
--- a/openstackclient/tests/identity/v2_0/test_catalog.py
+++ /dev/null
@@ -1,176 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import mock
-
-from openstackclient.identity.v2_0 import catalog
-from openstackclient.tests.identity.v2_0 import fakes as identity_fakes
-from openstackclient.tests import utils
-
-
-class TestCatalog(utils.TestCommand):
-
-    service_catalog = identity_fakes.FakeCatalog.create_catalog()
-
-    def setUp(self):
-        super(TestCatalog, self).setUp()
-
-        self.sc_mock = mock.MagicMock()
-        self.sc_mock.service_catalog.catalog.return_value = [
-            self.service_catalog,
-        ]
-
-        self.auth_mock = mock.MagicMock()
-        self.app.client_manager.session = self.auth_mock
-
-        self.auth_mock.auth.get_auth_ref.return_value = self.sc_mock
-
-
-class TestCatalogList(TestCatalog):
-
-    columns = (
-        'Name',
-        'Type',
-        'Endpoints',
-    )
-
-    def setUp(self):
-        super(TestCatalogList, self).setUp()
-
-        # Get the command object to test
-        self.cmd = catalog.ListCatalog(self.app, None)
-
-    def test_catalog_list(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.TOKEN,
-            fake_service=self.service_catalog,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            'supernova',
-            'compute',
-            'one\n  publicURL: https://public.one.example.com\n  '
-            'internalURL: https://internal.one.example.com\n  '
-            'adminURL: https://admin.one.example.com\n'
-            'two\n  publicURL: https://public.two.example.com\n  '
-            'internalURL: https://internal.two.example.com\n  '
-            'adminURL: https://admin.two.example.com\n'
-            '<none>\n  publicURL: https://public.none.example.com\n  '
-            'internalURL: https://internal.none.example.com\n  '
-            'adminURL: https://admin.none.example.com\n',
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_catalog_list_with_endpoint_url(self):
-        attr = {
-            'id': 'qwertyuiop',
-            'type': 'compute',
-            'name': 'supernova',
-            'endpoints': [
-                {
-                    'region': 'one',
-                    'publicURL': 'https://public.one.example.com',
-                },
-                {
-                    'region': 'two',
-                    'publicURL': 'https://public.two.example.com',
-                    'internalURL': 'https://internal.two.example.com',
-                },
-            ],
-        }
-        service_catalog = identity_fakes.FakeCatalog.create_catalog(attr)
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.TOKEN,
-            fake_service=service_catalog,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            'supernova',
-            'compute',
-            'one\n  publicURL: https://public.one.example.com\n'
-            'two\n  publicURL: https://public.two.example.com\n  '
-            'internalURL: https://internal.two.example.com\n'
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestCatalogShow(TestCatalog):
-
-    def setUp(self):
-        super(TestCatalogShow, self).setUp()
-
-        # Get the command object to test
-        self.cmd = catalog.ShowCatalog(self.app, None)
-
-    def test_catalog_show(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.UNSCOPED_TOKEN,
-            fake_service=self.service_catalog,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = [
-            'compute',
-        ]
-        verifylist = [
-            ('service', 'compute'),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        collist = ('endpoints', 'id', 'name', 'type')
-        self.assertEqual(collist, columns)
-        datalist = (
-            'one\n  publicURL: https://public.one.example.com\n  '
-            'internalURL: https://internal.one.example.com\n  '
-            'adminURL: https://admin.one.example.com\n'
-            'two\n  publicURL: https://public.two.example.com\n  '
-            'internalURL: https://internal.two.example.com\n  '
-            'adminURL: https://admin.two.example.com\n'
-            '<none>\n  publicURL: https://public.none.example.com\n  '
-            'internalURL: https://internal.none.example.com\n  '
-            'adminURL: https://admin.none.example.com\n',
-            self.service_catalog.id,
-            'supernova',
-            'compute',
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v2_0/test_endpoint.py b/openstackclient/tests/identity/v2_0/test_endpoint.py
deleted file mode 100644
index 26ec654d..00000000
--- a/openstackclient/tests/identity/v2_0/test_endpoint.py
+++ /dev/null
@@ -1,239 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-from openstackclient.identity.v2_0 import endpoint
-from openstackclient.tests.identity.v2_0 import fakes as identity_fakes
-
-
-class TestEndpoint(identity_fakes.TestIdentityv2):
-
-    fake_service = identity_fakes.FakeService.create_one_service()
-    attr = {
-        'service_name': fake_service.name,
-        'service_id': fake_service.id,
-    }
-    fake_endpoint = identity_fakes.FakeEndpoint.create_one_endpoint(attr)
-
-    def setUp(self):
-        super(TestEndpoint, self).setUp()
-
-        # Get a shortcut to the EndpointManager Mock
-        self.endpoints_mock = self.app.client_manager.identity.endpoints
-        self.endpoints_mock.reset_mock()
-
-        # Get a shortcut to the ServiceManager Mock
-        self.services_mock = self.app.client_manager.identity.services
-        self.services_mock.reset_mock()
-
-
-class TestEndpointCreate(TestEndpoint):
-
-    def setUp(self):
-        super(TestEndpointCreate, self).setUp()
-
-        self.endpoints_mock.create.return_value = self.fake_endpoint
-
-        self.services_mock.get.return_value = self.fake_service
-
-        # Get the command object to test
-        self.cmd = endpoint.CreateEndpoint(self.app, None)
-
-    def test_endpoint_create(self):
-        arglist = [
-            '--publicurl', self.fake_endpoint.publicurl,
-            '--internalurl', self.fake_endpoint.internalurl,
-            '--adminurl', self.fake_endpoint.adminurl,
-            '--region', self.fake_endpoint.region,
-            self.fake_service.id,
-        ]
-        verifylist = [
-            ('adminurl', self.fake_endpoint.adminurl),
-            ('internalurl', self.fake_endpoint.internalurl),
-            ('publicurl', self.fake_endpoint.publicurl),
-            ('region', self.fake_endpoint.region),
-            ('service', self.fake_service.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # EndpointManager.create(region, service_id, publicurl, adminurl,
-        #  internalurl)
-        self.endpoints_mock.create.assert_called_with(
-            self.fake_endpoint.region,
-            self.fake_service.id,
-            self.fake_endpoint.publicurl,
-            self.fake_endpoint.adminurl,
-            self.fake_endpoint.internalurl,
-        )
-
-        collist = ('adminurl', 'id', 'internalurl', 'publicurl',
-                   'region', 'service_id', 'service_name', 'service_type')
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.fake_endpoint.adminurl,
-            self.fake_endpoint.id,
-            self.fake_endpoint.internalurl,
-            self.fake_endpoint.publicurl,
-            self.fake_endpoint.region,
-            self.fake_endpoint.service_id,
-            self.fake_endpoint.service_name,
-            self.fake_endpoint.service_type,
-        )
-
-        self.assertEqual(datalist, data)
-
-
-class TestEndpointDelete(TestEndpoint):
-
-    def setUp(self):
-        super(TestEndpointDelete, self).setUp()
-
-        self.endpoints_mock.get.return_value = self.fake_endpoint
-        self.endpoints_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = endpoint.DeleteEndpoint(self.app, None)
-
-    def test_endpoint_delete_no_options(self):
-        arglist = [
-            self.fake_endpoint.id,
-        ]
-        verifylist = [
-            ('endpoints', [self.fake_endpoint.id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.endpoints_mock.delete.assert_called_with(
-            self.fake_endpoint.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestEndpointList(TestEndpoint):
-
-    def setUp(self):
-        super(TestEndpointList, self).setUp()
-
-        self.endpoints_mock.list.return_value = [self.fake_endpoint]
-
-        self.services_mock.get.return_value = self.fake_service
-
-        # Get the command object to test
-        self.cmd = endpoint.ListEndpoint(self.app, None)
-
-    def test_endpoint_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.endpoints_mock.list.assert_called_with()
-
-        collist = ('ID', 'Region', 'Service Name', 'Service Type')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.fake_endpoint.id,
-            self.fake_endpoint.region,
-            self.fake_endpoint.service_name,
-            self.fake_endpoint.service_type,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_endpoint_list_long(self):
-        arglist = [
-            '--long',
-        ]
-        verifylist = [
-            ('long', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.endpoints_mock.list.assert_called_with()
-
-        collist = ('ID', 'Region', 'Service Name', 'Service Type',
-                   'PublicURL', 'AdminURL', 'InternalURL')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.fake_endpoint.id,
-            self.fake_endpoint.region,
-            self.fake_endpoint.service_name,
-            self.fake_endpoint.service_type,
-            self.fake_endpoint.publicurl,
-            self.fake_endpoint.adminurl,
-            self.fake_endpoint.internalurl,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestEndpointShow(TestEndpoint):
-
-    def setUp(self):
-        super(TestEndpointShow, self).setUp()
-
-        self.endpoints_mock.list.return_value = [self.fake_endpoint]
-
-        self.services_mock.get.return_value = self.fake_service
-
-        # Get the command object to test
-        self.cmd = endpoint.ShowEndpoint(self.app, None)
-
-    def test_endpoint_show(self):
-        arglist = [
-            self.fake_endpoint.id,
-        ]
-        verifylist = [
-            ('endpoint_or_service', self.fake_endpoint.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # EndpointManager.list()
-        self.endpoints_mock.list.assert_called_with()
-        # ServiceManager.get(name)
-        self.services_mock.get.assert_called_with(
-            self.fake_endpoint.service_id,
-        )
-
-        collist = ('adminurl', 'id', 'internalurl', 'publicurl',
-                   'region', 'service_id', 'service_name', 'service_type')
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.fake_endpoint.adminurl,
-            self.fake_endpoint.id,
-            self.fake_endpoint.internalurl,
-            self.fake_endpoint.publicurl,
-            self.fake_endpoint.region,
-            self.fake_endpoint.service_id,
-            self.fake_endpoint.service_name,
-            self.fake_endpoint.service_type,
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v2_0/test_project.py b/openstackclient/tests/identity/v2_0/test_project.py
deleted file mode 100644
index 96731c0c..00000000
--- a/openstackclient/tests/identity/v2_0/test_project.py
+++ /dev/null
@@ -1,635 +0,0 @@
-#   Copyright 2013 Nebula Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-from keystoneauth1 import exceptions as ks_exc
-from osc_lib import exceptions
-
-from openstackclient.identity.v2_0 import project
-from openstackclient.tests.identity.v2_0 import fakes as identity_fakes
-
-
-class TestProject(identity_fakes.TestIdentityv2):
-
-    fake_project = identity_fakes.FakeProject.create_one_project()
-
-    columns = (
-        'description',
-        'enabled',
-        'id',
-        'name',
-    )
-    datalist = (
-        fake_project.description,
-        True,
-        fake_project.id,
-        fake_project.name,
-    )
-
-    def setUp(self):
-        super(TestProject, self).setUp()
-
-        # Get a shortcut to the TenantManager Mock
-        self.projects_mock = self.app.client_manager.identity.tenants
-        self.projects_mock.reset_mock()
-
-
-class TestProjectCreate(TestProject):
-
-    def setUp(self):
-        super(TestProjectCreate, self).setUp()
-
-        self.projects_mock.create.return_value = self.fake_project
-
-        # Get the command object to test
-        self.cmd = project.CreateProject(self.app, None)
-
-    def test_project_create_no_options(self):
-        arglist = [
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('enable', False),
-            ('disable', False),
-            ('name', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': None,
-            'enabled': True,
-        }
-        self.projects_mock.create.assert_called_with(
-            self.fake_project.name,
-            **kwargs
-        )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_description(self):
-        arglist = [
-            '--description', 'new desc',
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('description', 'new desc'),
-            ('name', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': 'new desc',
-            'enabled': True,
-        }
-        self.projects_mock.create.assert_called_with(
-            self.fake_project.name,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_enable(self):
-        arglist = [
-            '--enable',
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('enable', True),
-            ('disable', False),
-            ('name', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': None,
-            'enabled': True,
-        }
-        self.projects_mock.create.assert_called_with(
-            self.fake_project.name,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_disable(self):
-        arglist = [
-            '--disable',
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('enable', False),
-            ('disable', True),
-            ('name', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': None,
-            'enabled': False,
-        }
-        self.projects_mock.create.assert_called_with(
-            self.fake_project.name,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_property(self):
-        arglist = [
-            '--property', 'fee=fi',
-            '--property', 'fo=fum',
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('property', {'fee': 'fi', 'fo': 'fum'}),
-            ('name', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': None,
-            'enabled': True,
-            'fee': 'fi',
-            'fo': 'fum',
-        }
-        self.projects_mock.create.assert_called_with(
-            self.fake_project.name,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_or_show_exists(self):
-        def _raise_conflict(*args, **kwargs):
-            raise ks_exc.Conflict(None)
-
-        # need to make this throw an exception...
-        self.projects_mock.create.side_effect = _raise_conflict
-
-        self.projects_mock.get.return_value = self.fake_project
-
-        arglist = [
-            '--or-show',
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('or_show', True),
-            ('name', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ProjectManager.create(name, description, enabled)
-        self.projects_mock.get.assert_called_with(self.fake_project.name)
-
-        # Set expected values
-        kwargs = {
-            'description': None,
-            'enabled': True,
-        }
-        self.projects_mock.create.assert_called_with(
-            self.fake_project.name,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_or_show_not_exists(self):
-        arglist = [
-            '--or-show',
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('or_show', True),
-            ('name', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': None,
-            'enabled': True,
-        }
-        self.projects_mock.create.assert_called_with(
-            self.fake_project.name,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-
-class TestProjectDelete(TestProject):
-
-    def setUp(self):
-        super(TestProjectDelete, self).setUp()
-
-        # This is the return value for utils.find_resource()
-        self.projects_mock.get.return_value = self.fake_project
-        self.projects_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = project.DeleteProject(self.app, None)
-
-    def test_project_delete_no_options(self):
-        arglist = [
-            self.fake_project.id,
-        ]
-        verifylist = [
-            ('projects', [self.fake_project.id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.projects_mock.delete.assert_called_with(
-            self.fake_project.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestProjectList(TestProject):
-
-    def setUp(self):
-        super(TestProjectList, self).setUp()
-
-        self.projects_mock.list.return_value = [self.fake_project]
-
-        # Get the command object to test
-        self.cmd = project.ListProject(self.app, None)
-
-    def test_project_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.projects_mock.list.assert_called_with()
-
-        collist = ('ID', 'Name')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.fake_project.id,
-            self.fake_project.name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_project_list_long(self):
-        arglist = [
-            '--long',
-        ]
-        verifylist = [
-            ('long', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.projects_mock.list.assert_called_with()
-
-        collist = ('ID', 'Name', 'Description', 'Enabled')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.fake_project.id,
-            self.fake_project.name,
-            self.fake_project.description,
-            True,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestProjectSet(TestProject):
-
-    def setUp(self):
-        super(TestProjectSet, self).setUp()
-
-        self.projects_mock.get.return_value = self.fake_project
-        self.projects_mock.update.return_value = self.fake_project
-
-        # Get the command object to test
-        self.cmd = project.SetProject(self.app, None)
-
-    def test_project_set_no_options(self):
-        arglist = [
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('project', self.fake_project.name),
-            ('enable', False),
-            ('disable', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.assertIsNone(result)
-
-    def test_project_set_unexist_project(self):
-        arglist = [
-            "unexist-project",
-        ]
-        verifylist = [
-            ('project', "unexist-project"),
-            ('name', None),
-            ('description', None),
-            ('enable', False),
-            ('disable', False),
-            ('property', None),
-        ]
-        self.projects_mock.get.side_effect = exceptions.NotFound(None)
-        self.projects_mock.find.side_effect = exceptions.NotFound(None)
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.assertRaises(
-            exceptions.CommandError, self.cmd.take_action, parsed_args)
-
-    def test_project_set_name(self):
-        arglist = [
-            '--name', self.fake_project.name,
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('name', self.fake_project.name),
-            ('enable', False),
-            ('disable', False),
-            ('project', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': self.fake_project.description,
-            'enabled': True,
-            'tenant_name': self.fake_project.name,
-        }
-        self.projects_mock.update.assert_called_with(
-            self.fake_project.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_project_set_description(self):
-        arglist = [
-            '--description', self.fake_project.description,
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('description', self.fake_project.description),
-            ('enable', False),
-            ('disable', False),
-            ('project', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': self.fake_project.description,
-            'enabled': True,
-            'tenant_name': self.fake_project.name,
-        }
-        self.projects_mock.update.assert_called_with(
-            self.fake_project.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_project_set_enable(self):
-        arglist = [
-            '--enable',
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('enable', True),
-            ('disable', False),
-            ('project', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': self.fake_project.description,
-            'enabled': True,
-            'tenant_name': self.fake_project.name,
-        }
-        self.projects_mock.update.assert_called_with(
-            self.fake_project.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_project_set_disable(self):
-        arglist = [
-            '--disable',
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('enable', False),
-            ('disable', True),
-            ('project', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': self.fake_project.description,
-            'enabled': False,
-            'tenant_name': self.fake_project.name,
-        }
-        self.projects_mock.update.assert_called_with(
-            self.fake_project.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_project_set_property(self):
-        arglist = [
-            '--property', 'fee=fi',
-            '--property', 'fo=fum',
-            self.fake_project.name,
-        ]
-        verifylist = [
-            ('property', {'fee': 'fi', 'fo': 'fum'}),
-            ('project', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': self.fake_project.description,
-            'enabled': True,
-            'tenant_name': self.fake_project.name,
-            'fee': 'fi',
-            'fo': 'fum',
-        }
-        self.projects_mock.update.assert_called_with(
-            self.fake_project.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestProjectShow(TestProject):
-
-    fake_proj_show = identity_fakes.FakeProject.create_one_project()
-
-    def setUp(self):
-        super(TestProjectShow, self).setUp()
-
-        self.projects_mock.get.return_value = self.fake_proj_show
-
-        # Get the command object to test
-        self.cmd = project.ShowProject(self.app, None)
-
-    def test_project_show(self):
-        arglist = [
-            self.fake_proj_show.id,
-        ]
-        verifylist = [
-            ('project', self.fake_proj_show.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.projects_mock.get.assert_called_with(
-            self.fake_proj_show.id,
-        )
-
-        collist = ('description', 'enabled', 'id', 'name', 'properties')
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.fake_proj_show.description,
-            True,
-            self.fake_proj_show.id,
-            self.fake_proj_show.name,
-            '',
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestProjectUnset(TestProject):
-
-    attr = {'fee': 'fi', 'fo': 'fum'}
-    fake_proj = identity_fakes.FakeProject.create_one_project(attr)
-
-    def setUp(self):
-        super(TestProjectUnset, self).setUp()
-
-        self.projects_mock.get.return_value = self.fake_proj
-
-        # Get the command object to test
-        self.cmd = project.UnsetProject(self.app, None)
-
-    def test_project_unset_no_options(self):
-        arglist = [
-            self.fake_proj.name,
-        ]
-        verifylist = [
-            ('project', self.fake_proj.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.assertIsNone(result)
-
-    def test_project_unset_key(self):
-        arglist = [
-            '--property', 'fee',
-            '--property', 'fo',
-            self.fake_proj.name,
-        ]
-        verifylist = [
-            ('property', ['fee', 'fo']),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-        # Set expected values
-        kwargs = {
-            'description': self.fake_proj.description,
-            'enabled': True,
-            'fee': None,
-            'fo': None,
-            'id': self.fake_proj.id,
-            'name': self.fake_proj.name,
-        }
-
-        self.projects_mock.update.assert_called_with(
-            self.fake_proj.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
diff --git a/openstackclient/tests/identity/v2_0/test_role.py b/openstackclient/tests/identity/v2_0/test_role.py
deleted file mode 100644
index 3d379356..00000000
--- a/openstackclient/tests/identity/v2_0/test_role.py
+++ /dev/null
@@ -1,480 +0,0 @@
-#   Copyright 2013 Nebula Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import mock
-
-from keystoneauth1 import exceptions as ks_exc
-from osc_lib import exceptions
-
-from openstackclient.identity.v2_0 import role
-from openstackclient.tests.identity.v2_0 import fakes as identity_fakes
-
-
-class TestRole(identity_fakes.TestIdentityv2):
-
-    attr = {}
-    attr['endpoints'] = [
-        {
-            'publicURL': identity_fakes.ENDPOINT['publicurl'],
-        },
-    ]
-    fake_service = identity_fakes.FakeService.create_one_service(attr)
-    fake_role = identity_fakes.FakeRole.create_one_role()
-    fake_project = identity_fakes.FakeProject.create_one_project()
-    attr = {}
-    attr = {
-        'tenantId': fake_project.id,
-    }
-    fake_user = identity_fakes.FakeUser.create_one_user(attr)
-
-    def setUp(self):
-        super(TestRole, self).setUp()
-
-        # Get a shortcut to the TenantManager Mock
-        self.projects_mock = self.app.client_manager.identity.tenants
-        self.projects_mock.reset_mock()
-
-        # Get a shortcut to the UserManager Mock
-        self.users_mock = self.app.client_manager.identity.users
-        self.users_mock.reset_mock()
-
-        # Get a shortcut to the RoleManager Mock
-        self.roles_mock = self.app.client_manager.identity.roles
-        self.roles_mock.reset_mock()
-
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.TOKEN,
-            fake_service=self.fake_service,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-
-class TestRoleAdd(TestRole):
-
-    def setUp(self):
-        super(TestRoleAdd, self).setUp()
-
-        self.projects_mock.get.return_value = self.fake_project
-
-        self.users_mock.get.return_value = self.fake_user
-
-        self.roles_mock.get.return_value = self.fake_role
-        self.roles_mock.add_user_role.return_value = self.fake_role
-
-        # Get the command object to test
-        self.cmd = role.AddRole(self.app, None)
-
-    def test_role_add(self):
-        arglist = [
-            '--project', self.fake_project.name,
-            '--user', self.fake_user.name,
-            self.fake_role.name,
-        ]
-        verifylist = [
-            ('project', self.fake_project.name),
-            ('user', self.fake_user.name),
-            ('role', self.fake_role.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # RoleManager.add_user_role(user, role, tenant=None)
-        self.roles_mock.add_user_role.assert_called_with(
-            self.fake_user.id,
-            self.fake_role.id,
-            self.fake_project.id,
-        )
-
-        collist = ('id', 'name')
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.fake_role.id,
-            self.fake_role.name,
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestRoleCreate(TestRole):
-
-    fake_role_c = identity_fakes.FakeRole.create_one_role()
-    columns = (
-        'id',
-        'name'
-    )
-    datalist = (
-        fake_role_c.id,
-        fake_role_c.name,
-    )
-
-    def setUp(self):
-        super(TestRoleCreate, self).setUp()
-
-        self.roles_mock.create.return_value = self.fake_role_c
-
-        # Get the command object to test
-        self.cmd = role.CreateRole(self.app, None)
-
-    def test_role_create_no_options(self):
-        arglist = [
-            self.fake_role_c.name,
-        ]
-        verifylist = [
-            ('role_name', self.fake_role_c.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # RoleManager.create(name)
-        self.roles_mock.create.assert_called_with(
-            self.fake_role_c.name,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_role_create_or_show_exists(self):
-        def _raise_conflict(*args, **kwargs):
-            raise ks_exc.Conflict(None)
-
-        # need to make this throw an exception...
-        self.roles_mock.create.side_effect = _raise_conflict
-
-        self.roles_mock.get.return_value = self.fake_role_c
-
-        arglist = [
-            '--or-show',
-            self.fake_role_c.name,
-        ]
-        verifylist = [
-            ('role_name', self.fake_role_c.name),
-            ('or_show', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # RoleManager.get(name, description, enabled)
-        self.roles_mock.get.assert_called_with(self.fake_role_c.name)
-
-        # RoleManager.create(name)
-        self.roles_mock.create.assert_called_with(
-            self.fake_role_c.name,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_role_create_or_show_not_exists(self):
-        arglist = [
-            '--or-show',
-            self.fake_role_c.name,
-        ]
-        verifylist = [
-            ('role_name', self.fake_role_c.name),
-            ('or_show', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # RoleManager.create(name)
-        self.roles_mock.create.assert_called_with(
-            self.fake_role_c.name,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-
-class TestRoleDelete(TestRole):
-
-    def setUp(self):
-        super(TestRoleDelete, self).setUp()
-
-        self.roles_mock.get.return_value = self.fake_role
-        self.roles_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = role.DeleteRole(self.app, None)
-
-    def test_role_delete_no_options(self):
-        arglist = [
-            self.fake_role.name,
-        ]
-        verifylist = [
-            ('roles', [self.fake_role.name]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.delete.assert_called_with(
-            self.fake_role.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestRoleList(TestRole):
-
-    def setUp(self):
-        super(TestRoleList, self).setUp()
-
-        self.roles_mock.list.return_value = [self.fake_role]
-
-        # Get the command object to test
-        self.cmd = role.ListRole(self.app, None)
-
-    def test_role_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.list.assert_called_with()
-
-        collist = ('ID', 'Name')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.fake_role.id,
-            self.fake_role.name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestUserRoleList(TestRole):
-
-    columns = (
-        'ID',
-        'Name',
-        'Project',
-        'User'
-    )
-
-    def setUp(self):
-        super(TestUserRoleList, self).setUp()
-
-        self.projects_mock.get.return_value = self.fake_project
-
-        self.users_mock.get.return_value = self.fake_user
-
-        self.roles_mock.roles_for_user.return_value = [self.fake_role]
-
-        # Get the command object to test
-        self.cmd = role.ListUserRole(self.app, None)
-
-    def test_user_role_list_no_options_unscoped_token(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.UNSCOPED_TOKEN,
-            fake_service=self.fake_service,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # This argument combination should raise a CommandError
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args,
-        )
-
-    def test_user_role_list_no_options_scoped_token(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.roles_for_user.assert_called_with(
-            self.fake_user.id,
-            self.fake_project.id,
-        )
-
-        collist = ('ID', 'Name', 'Project', 'User')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.fake_role.id,
-            self.fake_role.name,
-            self.fake_project.name,
-            self.fake_user.name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_user_role_list_project_unscoped_token(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.UNSCOPED_TOKEN,
-            fake_service=self.fake_service,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        self.projects_mock.get.return_value = self.fake_project
-        arglist = [
-            '--project', self.fake_project.name,
-        ]
-        verifylist = [
-            ('project', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.roles_for_user.assert_called_with(
-            self.fake_user.id,
-            self.fake_project.id,
-        )
-
-        self.assertEqual(columns, columns)
-        datalist = ((
-            self.fake_role.id,
-            self.fake_role.name,
-            self.fake_project.name,
-            self.fake_user.name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_user_role_list_project_scoped_token(self):
-        self.projects_mock.get.return_value = self.fake_project
-        arglist = [
-            '--project', self.fake_project.name,
-        ]
-        verifylist = [
-            ('project', self.fake_project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.roles_for_user.assert_called_with(
-            self.fake_user.id,
-            self.fake_project.id,
-        )
-
-        self.assertEqual(columns, columns)
-        datalist = ((
-            self.fake_role.id,
-            self.fake_role.name,
-            self.fake_project.name,
-            self.fake_user.name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestRoleRemove(TestRole):
-
-    def setUp(self):
-        super(TestRoleRemove, self).setUp()
-
-        self.projects_mock.get.return_value = self.fake_project
-
-        self.users_mock.get.return_value = self.fake_user
-
-        self.roles_mock.get.return_value = self.fake_role
-        self.roles_mock.remove_user_role.return_value = None
-
-        # Get the command object to test
-        self.cmd = role.RemoveRole(self.app, None)
-
-    def test_role_remove(self):
-        arglist = [
-            '--project', self.fake_project.name,
-            '--user', self.fake_user.name,
-            self.fake_role.name,
-        ]
-        verifylist = [
-            ('role', self.fake_role.name),
-            ('project', self.fake_project.name),
-            ('user', self.fake_user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # RoleManager.remove_user_role(user, role, tenant=None)
-        self.roles_mock.remove_user_role.assert_called_with(
-            self.fake_user.id,
-            self.fake_role.id,
-            self.fake_project.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestRoleShow(TestRole):
-
-    def setUp(self):
-        super(TestRoleShow, self).setUp()
-
-        self.roles_mock.get.return_value = self.fake_role
-
-        # Get the command object to test
-        self.cmd = role.ShowRole(self.app, None)
-
-    def test_service_show(self):
-        arglist = [
-            self.fake_role.name,
-        ]
-        verifylist = [
-            ('role', self.fake_role.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # RoleManager.get(role)
-        self.roles_mock.get.assert_called_with(
-            self.fake_role.name,
-        )
-
-        collist = ('id', 'name')
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.fake_role.id,
-            self.fake_role.name,
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v2_0/test_role_assignment.py b/openstackclient/tests/identity/v2_0/test_role_assignment.py
deleted file mode 100644
index a356ae0a..00000000
--- a/openstackclient/tests/identity/v2_0/test_role_assignment.py
+++ /dev/null
@@ -1,271 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import copy
-import mock
-
-from osc_lib import exceptions
-
-from openstackclient.identity.v2_0 import role_assignment
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v2_0 import fakes as identity_fakes
-
-
-class TestRoleAssignment(identity_fakes.TestIdentityv2):
-
-    def setUp(self):
-        super(TestRoleAssignment, self).setUp()
-
-
-class TestRoleAssignmentList(TestRoleAssignment):
-
-    columns = (
-        'Role',
-        'User',
-        'Project',
-    )
-
-    def setUp(self):
-        super(TestRoleAssignment, self).setUp()
-
-        # Get a shortcut to the UserManager Mock
-        self.users_mock = self.app.client_manager.identity.users
-        self.users_mock.reset_mock()
-
-        # Get a shortcut to the ProjectManager Mock
-        self.projects_mock = self.app.client_manager.identity.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.reset_mock()
-
-        self.projects_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.PROJECT),
-            loaded=True,
-        )
-
-        self.users_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.USER),
-            loaded=True,
-        )
-
-        self.roles_mock.roles_for_user.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.ROLE),
-                loaded=True,
-            ),
-        ]
-
-        # Get the command object to test
-        self.cmd = role_assignment.ListRoleAssignment(self.app, None)
-
-    def test_role_assignment_list_no_filters(self):
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # This argument combination should raise a CommandError
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args,
-        )
-
-    def test_role_assignment_list_only_project_filter(self):
-
-        arglist = [
-            '--project', identity_fakes.project_name,
-        ]
-        verifylist = [
-            ('project', identity_fakes.project_name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # This argument combination should raise a CommandError
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args,
-        )
-
-    def test_role_assignment_list_only_user_filter(self):
-
-        arglist = [
-            '--user', identity_fakes.user_name,
-        ]
-        verifylist = [
-            ('user', identity_fakes.user_name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # This argument combination should raise a CommandError
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args,
-        )
-
-    def test_role_assignment_list_project_and_user(self):
-
-        self.roles_mock.roles_for_user.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ROLE),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ROLE_2),
-                loaded=True,
-            ),
-        ]
-
-        arglist = [
-            '--project', identity_fakes.project_name,
-            '--user', identity_fakes.user_name,
-        ]
-        verifylist = [
-            ('user', identity_fakes.user_name),
-            ('project', identity_fakes.project_name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.roles_for_user.assert_called_with(
-            identity_fakes.user_id,
-            identity_fakes.project_id,
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.user_id,
-            identity_fakes.project_id,
-        ), (identity_fakes.ROLE_2['id'],
-            identity_fakes.user_id,
-            identity_fakes.project_id,
-            ),)
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_assignment_list_def_creds(self):
-
-        auth_ref = self.app.client_manager.auth_ref = mock.MagicMock()
-        auth_ref.project_id.return_value = identity_fakes.project_id
-        auth_ref.user_id.return_value = identity_fakes.user_id
-
-        self.roles_mock.roles_for_user.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ROLE),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ROLE_2),
-                loaded=True,
-            ),
-        ]
-
-        arglist = [
-            '--auth-user',
-            '--auth-project',
-        ]
-        verifylist = [
-            ('authuser', True),
-            ('authproject', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.roles_for_user.assert_called_with(
-            identity_fakes.user_id,
-            identity_fakes.project_id,
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.user_id,
-            identity_fakes.project_id,
-        ), (identity_fakes.ROLE_2['id'],
-            identity_fakes.user_id,
-            identity_fakes.project_id,
-            ),)
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_assignment_list_by_name_project_and_user(self):
-
-        self.roles_mock.roles_for_user.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ROLE),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ROLE_2),
-                loaded=True,
-            ),
-        ]
-
-        arglist = [
-            '--project', identity_fakes.project_name,
-            '--user', identity_fakes.user_name,
-            '--names'
-        ]
-        verifylist = [
-            ('user', identity_fakes.user_name),
-            ('project', identity_fakes.project_name),
-            ('names', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.roles_for_user.assert_called_with(
-            identity_fakes.user_id,
-            identity_fakes.project_id,
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_name,
-            identity_fakes.user_name,
-            identity_fakes.project_name,
-        ), (identity_fakes.ROLE_2['name'],
-            identity_fakes.user_name,
-            identity_fakes.project_name,
-            ),)
-        self.assertEqual(datalist, tuple(data))
diff --git a/openstackclient/tests/identity/v2_0/test_service.py b/openstackclient/tests/identity/v2_0/test_service.py
deleted file mode 100644
index 7efd2a60..00000000
--- a/openstackclient/tests/identity/v2_0/test_service.py
+++ /dev/null
@@ -1,316 +0,0 @@
-#   Copyright 2013 Nebula Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-from keystoneclient import exceptions as identity_exc
-from osc_lib import exceptions
-
-from openstackclient.identity.v2_0 import service
-from openstackclient.tests.identity.v2_0 import fakes as identity_fakes
-
-
-class TestService(identity_fakes.TestIdentityv2):
-    fake_service = identity_fakes.FakeService.create_one_service()
-
-    def setUp(self):
-        super(TestService, self).setUp()
-
-        # Get a shortcut to the ServiceManager Mock
-        self.services_mock = self.app.client_manager.identity.services
-        self.services_mock.reset_mock()
-
-
-class TestServiceCreate(TestService):
-
-    fake_service_c = identity_fakes.FakeService.create_one_service()
-    columns = (
-        'description',
-        'id',
-        'name',
-        'type',
-    )
-    datalist = (
-        fake_service_c.description,
-        fake_service_c.id,
-        fake_service_c.name,
-        fake_service_c.type,
-    )
-
-    def setUp(self):
-        super(TestServiceCreate, self).setUp()
-
-        self.services_mock.create.return_value = self.fake_service_c
-
-        # Get the command object to test
-        self.cmd = service.CreateService(self.app, None)
-
-    def test_service_create_with_type_positional(self):
-        arglist = [
-            self.fake_service_c.type,
-        ]
-        verifylist = [
-            ('type_or_name', self.fake_service_c.type),
-            ('type', None),
-            ('description', None),
-            ('name', None),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ServiceManager.create(name, service_type, description)
-        self.services_mock.create.assert_called_with(
-            None,
-            self.fake_service_c.type,
-            None,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_service_create_with_type_option(self):
-        arglist = [
-            '--type', self.fake_service_c.type,
-            self.fake_service_c.name,
-        ]
-        verifylist = [
-            ('type_or_name', self.fake_service_c.name),
-            ('type', self.fake_service_c.type),
-            ('description', None),
-            ('name', None),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ServiceManager.create(name, service_type, description)
-        self.services_mock.create.assert_called_with(
-            self.fake_service_c.name,
-            self.fake_service_c.type,
-            None,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_service_create_with_name_option(self):
-        arglist = [
-            '--name', self.fake_service_c.name,
-            self.fake_service_c.type,
-        ]
-        verifylist = [
-            ('type_or_name', self.fake_service_c.type),
-            ('type', None),
-            ('description', None),
-            ('name', self.fake_service_c.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ServiceManager.create(name, service_type, description)
-        self.services_mock.create.assert_called_with(
-            self.fake_service_c.name,
-            self.fake_service_c.type,
-            None,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_service_create_description(self):
-        arglist = [
-            '--name', self.fake_service_c.name,
-            '--description', self.fake_service_c.description,
-            self.fake_service_c.type,
-        ]
-        verifylist = [
-            ('type_or_name', self.fake_service_c.type),
-            ('type', None),
-            ('description', self.fake_service_c.description),
-            ('name', self.fake_service_c.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ServiceManager.create(name, service_type, description)
-        self.services_mock.create.assert_called_with(
-            self.fake_service_c.name,
-            self.fake_service_c.type,
-            self.fake_service_c.description,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-
-class TestServiceDelete(TestService):
-
-    def setUp(self):
-        super(TestServiceDelete, self).setUp()
-
-        self.services_mock.get.side_effect = identity_exc.NotFound(None)
-        self.services_mock.find.return_value = self.fake_service
-        self.services_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = service.DeleteService(self.app, None)
-
-    def test_service_delete_no_options(self):
-        arglist = [
-            self.fake_service.name,
-        ]
-        verifylist = [
-            ('services', [self.fake_service.name]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.services_mock.delete.assert_called_with(
-            self.fake_service.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestServiceList(TestService):
-
-    def setUp(self):
-        super(TestServiceList, self).setUp()
-
-        self.services_mock.list.return_value = [self.fake_service]
-
-        # Get the command object to test
-        self.cmd = service.ListService(self.app, None)
-
-    def test_service_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.services_mock.list.assert_called_with()
-
-        collist = ('ID', 'Name', 'Type')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.fake_service.id,
-            self.fake_service.name,
-            self.fake_service.type,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_service_list_long(self):
-        arglist = [
-            '--long',
-        ]
-        verifylist = [
-            ('long', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.services_mock.list.assert_called_with()
-
-        collist = ('ID', 'Name', 'Type', 'Description')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.fake_service.id,
-            self.fake_service.name,
-            self.fake_service.type,
-            self.fake_service.description,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestServiceShow(TestService):
-
-    fake_service_s = identity_fakes.FakeService.create_one_service()
-
-    def setUp(self):
-        super(TestServiceShow, self).setUp()
-
-        self.services_mock.get.side_effect = identity_exc.NotFound(None)
-        self.services_mock.find.return_value = self.fake_service_s
-
-        # Get the command object to test
-        self.cmd = service.ShowService(self.app, None)
-
-    def test_service_show(self):
-        arglist = [
-            self.fake_service_s.name,
-        ]
-        verifylist = [
-            ('service', self.fake_service_s.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ServiceManager.find(id)
-        self.services_mock.find.assert_called_with(
-            name=self.fake_service_s.name,
-        )
-
-        collist = ('description', 'id', 'name', 'type')
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.fake_service_s.description,
-            self.fake_service_s.id,
-            self.fake_service_s.name,
-            self.fake_service_s.type,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_service_show_nounique(self):
-        self.services_mock.find.side_effect = identity_exc.NoUniqueMatch(None)
-        arglist = [
-            'nounique_service',
-        ]
-        verifylist = [
-            ('service', 'nounique_service'),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        try:
-            self.cmd.take_action(parsed_args)
-            self.fail('CommandError should be raised.')
-        except exceptions.CommandError as e:
-            self.assertEqual(
-                "Multiple service matches found for 'nounique_service',"
-                " use an ID to be more specific.", str(e))
diff --git a/openstackclient/tests/identity/v2_0/test_token.py b/openstackclient/tests/identity/v2_0/test_token.py
deleted file mode 100644
index 17115e6b..00000000
--- a/openstackclient/tests/identity/v2_0/test_token.py
+++ /dev/null
@@ -1,115 +0,0 @@
-#   Copyright 2014 eBay Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import mock
-
-from openstackclient.identity.v2_0 import token
-from openstackclient.tests.identity.v2_0 import fakes as identity_fakes
-
-
-class TestToken(identity_fakes.TestIdentityv2):
-
-    fake_user = identity_fakes.FakeUser.create_one_user()
-    fake_project = identity_fakes.FakeProject.create_one_project()
-
-    def setUp(self):
-        super(TestToken, self).setUp()
-
-        # Get a shortcut to the Auth Ref Mock
-        self.ar_mock = mock.PropertyMock()
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-
-class TestTokenIssue(TestToken):
-
-    def setUp(self):
-        super(TestTokenIssue, self).setUp()
-
-        self.cmd = token.IssueToken(self.app, None)
-
-    def test_token_issue(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.TOKEN,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        collist = ('expires', 'id', 'project_id', 'user_id')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.token_expires,
-            identity_fakes.token_id,
-            'project-id',
-            'user-id',
-        )
-        self.assertEqual(datalist, data)
-
-    def test_token_issue_with_unscoped_token(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.UNSCOPED_TOKEN,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # DisplayCommandBase.take_action() returns two tuples
-        columns, data = self.cmd.take_action(parsed_args)
-
-        collist = (
-            'expires',
-            'id',
-            'user_id',
-        )
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.token_expires,
-            identity_fakes.token_id,
-            'user-id',
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestTokenRevoke(TestToken):
-
-    TOKEN = 'fob'
-
-    def setUp(self):
-        super(TestTokenRevoke, self).setUp()
-        self.tokens_mock = self.app.client_manager.identity.tokens
-        self.tokens_mock.reset_mock()
-        self.tokens_mock.delete.return_value = True
-        self.cmd = token.RevokeToken(self.app, None)
-
-    def test_token_revoke(self):
-        arglist = [self.TOKEN]
-        verifylist = [('token', self.TOKEN)]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.tokens_mock.delete.assert_called_with(self.TOKEN)
-        self.assertIsNone(result)
diff --git a/openstackclient/tests/identity/v2_0/test_user.py b/openstackclient/tests/identity/v2_0/test_user.py
deleted file mode 100644
index ba871247..00000000
--- a/openstackclient/tests/identity/v2_0/test_user.py
+++ /dev/null
@@ -1,793 +0,0 @@
-#   Copyright 2013 Nebula Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import mock
-
-from keystoneauth1 import exceptions as ks_exc
-from osc_lib import exceptions
-
-from openstackclient.identity.v2_0 import user
-from openstackclient.tests.identity.v2_0 import fakes as identity_fakes
-
-
-class TestUser(identity_fakes.TestIdentityv2):
-
-    fake_project = identity_fakes.FakeProject.create_one_project()
-    attr = {
-        'tenantId': fake_project.id,
-    }
-    fake_user = identity_fakes.FakeUser.create_one_user(attr)
-
-    def setUp(self):
-        super(TestUser, self).setUp()
-
-        # Get a shortcut to the TenantManager Mock
-        self.projects_mock = self.app.client_manager.identity.tenants
-        self.projects_mock.reset_mock()
-
-        # Get a shortcut to the UserManager Mock
-        self.users_mock = self.app.client_manager.identity.users
-        self.users_mock.reset_mock()
-
-
-class TestUserCreate(TestUser):
-
-    fake_project_c = identity_fakes.FakeProject.create_one_project()
-    attr = {
-        'tenantId': fake_project_c.id,
-    }
-    fake_user_c = identity_fakes.FakeUser.create_one_user(attr)
-
-    columns = (
-        'email',
-        'enabled',
-        'id',
-        'name',
-        'project_id',
-    )
-    datalist = (
-        fake_user_c.email,
-        True,
-        fake_user_c.id,
-        fake_user_c.name,
-        fake_project_c.id,
-    )
-
-    def setUp(self):
-        super(TestUserCreate, self).setUp()
-
-        self.projects_mock.get.return_value = self.fake_project_c
-
-        self.users_mock.create.return_value = self.fake_user_c
-
-        # Get the command object to test
-        self.cmd = user.CreateUser(self.app, None)
-
-    def test_user_create_no_options(self):
-        arglist = [
-            self.fake_user_c.name,
-        ]
-        verifylist = [
-            ('enable', False),
-            ('disable', False),
-            ('name', self.fake_user_c.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'tenant_id': None,
-        }
-        # UserManager.create(name, password, email, tenant_id=, enabled=)
-        self.users_mock.create.assert_called_with(
-            self.fake_user_c.name,
-            None,
-            None,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_password(self):
-        arglist = [
-            '--password', 'secret',
-            self.fake_user_c.name,
-        ]
-        verifylist = [
-            ('name', self.fake_user_c.name),
-            ('password_prompt', False),
-            ('password', 'secret')
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'tenant_id': None,
-        }
-        # UserManager.create(name, password, email, tenant_id=, enabled=)
-        self.users_mock.create.assert_called_with(
-            self.fake_user_c.name,
-            'secret',
-            None,
-            **kwargs
-        )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_password_prompt(self):
-        arglist = [
-            '--password-prompt',
-            self.fake_user_c.name,
-        ]
-        verifylist = [
-            ('name', self.fake_user_c.name),
-            ('password_prompt', True)
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        mocker = mock.Mock()
-        mocker.return_value = 'abc123'
-        with mock.patch("osc_lib.utils.get_password", mocker):
-            columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'tenant_id': None,
-        }
-        # UserManager.create(name, password, email, tenant_id=, enabled=)
-        self.users_mock.create.assert_called_with(
-            self.fake_user_c.name,
-            'abc123',
-            None,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_email(self):
-        arglist = [
-            '--email', 'barney@example.com',
-            self.fake_user_c.name,
-        ]
-        verifylist = [
-            ('name', self.fake_user_c.name),
-            ('email', 'barney@example.com'),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'tenant_id': None,
-        }
-        # UserManager.create(name, password, email, tenant_id=, enabled=)
-        self.users_mock.create.assert_called_with(
-            self.fake_user_c.name,
-            None,
-            'barney@example.com',
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_project(self):
-        # Return the new project
-        self.projects_mock.get.return_value = self.fake_project_c
-
-        # Set up to return an updated user
-        attr = {
-            'tenantId': self.fake_project_c.id,
-        }
-        user_2 = identity_fakes.FakeUser.create_one_user(attr)
-        self.users_mock.create.return_value = user_2
-
-        arglist = [
-            '--project', self.fake_project_c.name,
-            user_2.name,
-        ]
-        verifylist = [
-            ('name', user_2.name),
-            ('project', self.fake_project_c.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'tenant_id': self.fake_project_c.id,
-        }
-        # UserManager.create(name, password, email, tenant_id=, enabled=)
-        self.users_mock.create.assert_called_with(
-            user_2.name,
-            None,
-            None,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            user_2.email,
-            True,
-            user_2.id,
-            user_2.name,
-            self.fake_project_c.id,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_user_create_enable(self):
-        arglist = [
-            '--enable',
-            self.fake_user_c.name,
-        ]
-        verifylist = [
-            ('name', self.fake_user_c.name),
-            ('enable', True),
-            ('disable', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'tenant_id': None,
-        }
-        # UserManager.create(name, password, email, tenant_id=, enabled=)
-        self.users_mock.create.assert_called_with(
-            self.fake_user_c.name,
-            None,
-            None,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_disable(self):
-        arglist = [
-            '--disable',
-            self.fake_user_c.name,
-        ]
-        verifylist = [
-            ('name', self.fake_user_c.name),
-            ('enable', False),
-            ('disable', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': False,
-            'tenant_id': None,
-        }
-        # UserManager.create(name, password, email, tenant_id=, enabled=)
-        self.users_mock.create.assert_called_with(
-            self.fake_user_c.name,
-            None,
-            None,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_or_show_exists(self):
-        def _raise_conflict(*args, **kwargs):
-            raise ks_exc.Conflict(None)
-
-        # need to make this throw an exception...
-        self.users_mock.create.side_effect = _raise_conflict
-
-        self.users_mock.get.return_value = self.fake_user_c
-
-        arglist = [
-            '--or-show',
-            self.fake_user_c.name,
-        ]
-        verifylist = [
-            ('name', self.fake_user_c.name),
-            ('or_show', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # UserManager.create(name, password, email, tenant_id=, enabled=)
-        self.users_mock.get.assert_called_with(self.fake_user_c.name)
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_or_show_not_exists(self):
-        arglist = [
-            '--or-show',
-            self.fake_user_c.name,
-        ]
-        verifylist = [
-            ('name', self.fake_user_c.name),
-            ('or_show', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'tenant_id': None,
-        }
-        # UserManager.create(name, password, email, tenant_id=, enabled=)
-        self.users_mock.create.assert_called_with(
-            self.fake_user_c.name,
-            None,
-            None,
-            **kwargs
-        )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-
-class TestUserDelete(TestUser):
-
-    def setUp(self):
-        super(TestUserDelete, self).setUp()
-
-        # This is the return value for utils.find_resource()
-        self.users_mock.get.return_value = self.fake_user
-        self.users_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = user.DeleteUser(self.app, None)
-
-    def test_user_delete_no_options(self):
-        arglist = [
-            self.fake_user.id,
-        ]
-        verifylist = [
-            ('users', [self.fake_user.id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.users_mock.delete.assert_called_with(
-            self.fake_user.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestUserList(TestUser):
-
-    fake_project_l = identity_fakes.FakeProject.create_one_project()
-    attr = {
-        'tenantId': fake_project_l.id,
-    }
-    fake_user_l = identity_fakes.FakeUser.create_one_user(attr)
-
-    columns = (
-        'ID',
-        'Name',
-    )
-    datalist = (
-        (
-            fake_user_l.id,
-            fake_user_l.name,
-        ),
-    )
-
-    def setUp(self):
-        super(TestUserList, self).setUp()
-
-        self.projects_mock.get.return_value = self.fake_project_l
-        self.projects_mock.list.return_value = [self.fake_project_l]
-
-        self.users_mock.list.return_value = [self.fake_user_l]
-
-        # Get the command object to test
-        self.cmd = user.ListUser(self.app, None)
-
-    def test_user_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.users_mock.list.assert_called_with(tenant_id=None)
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_user_list_project(self):
-        arglist = [
-            '--project', self.fake_project_l.id,
-        ]
-        verifylist = [
-            ('project', self.fake_project_l.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        project_id = self.fake_project_l.id
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.users_mock.list.assert_called_with(tenant_id=project_id)
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_user_list_long(self):
-        arglist = [
-            '--long',
-        ]
-        verifylist = [
-            ('long', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.users_mock.list.assert_called_with(tenant_id=None)
-
-        collist = ('ID', 'Name', 'Project', 'Email', 'Enabled')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.fake_user_l.id,
-            self.fake_user_l.name,
-            self.fake_project_l.name,
-            self.fake_user_l.email,
-            True,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestUserSet(TestUser):
-
-    def setUp(self):
-        super(TestUserSet, self).setUp()
-
-        self.projects_mock.get.return_value = self.fake_project
-        self.users_mock.get.return_value = self.fake_user
-
-        # Get the command object to test
-        self.cmd = user.SetUser(self.app, None)
-
-    def test_user_set_no_options(self):
-        arglist = [
-            self.fake_user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.fake_user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.assertIsNone(result)
-
-    def test_user_set_unexist_user(self):
-        arglist = [
-            "unexist-user",
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', "unexist-user"),
-        ]
-        self.users_mock.get.side_effect = exceptions.NotFound(None)
-        self.users_mock.find.side_effect = exceptions.NotFound(None)
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.assertRaises(
-            exceptions.CommandError, self.cmd.take_action, parsed_args)
-
-    def test_user_set_name(self):
-        arglist = [
-            '--name', 'qwerty',
-            self.fake_user.name,
-        ]
-        verifylist = [
-            ('name', 'qwerty'),
-            ('password', None),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.fake_user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'name': 'qwerty',
-        }
-        # UserManager.update(user, **kwargs)
-        self.users_mock.update.assert_called_with(
-            self.fake_user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_password(self):
-        arglist = [
-            '--password', 'secret',
-            self.fake_user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', 'secret'),
-            ('password_prompt', False),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.fake_user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # UserManager.update_password(user, password)
-        self.users_mock.update_password.assert_called_with(
-            self.fake_user.id,
-            'secret',
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_password_prompt(self):
-        arglist = [
-            '--password-prompt',
-            self.fake_user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('password_prompt', True),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.fake_user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        mocker = mock.Mock()
-        mocker.return_value = 'abc123'
-        with mock.patch("osc_lib.utils.get_password", mocker):
-            result = self.cmd.take_action(parsed_args)
-
-        # UserManager.update_password(user, password)
-        self.users_mock.update_password.assert_called_with(
-            self.fake_user.id,
-            'abc123',
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_email(self):
-        arglist = [
-            '--email', 'barney@example.com',
-            self.fake_user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', 'barney@example.com'),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.fake_user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'email': 'barney@example.com',
-            'enabled': True,
-        }
-        # UserManager.update(user, **kwargs)
-        self.users_mock.update.assert_called_with(
-            self.fake_user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_project(self):
-        arglist = [
-            '--project', self.fake_project.id,
-            self.fake_user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', None),
-            ('project', self.fake_project.id),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.fake_user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # UserManager.update_tenant(user, tenant)
-        self.users_mock.update_tenant.assert_called_with(
-            self.fake_user.id,
-            self.fake_project.id,
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_enable(self):
-        arglist = [
-            '--enable',
-            self.fake_user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', None),
-            ('project', None),
-            ('enable', True),
-            ('disable', False),
-            ('user', self.fake_user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-        }
-        # UserManager.update(user, **kwargs)
-        self.users_mock.update.assert_called_with(
-            self.fake_user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_disable(self):
-        arglist = [
-            '--disable',
-            self.fake_user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', True),
-            ('user', self.fake_user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': False,
-        }
-        # UserManager.update(user, **kwargs)
-        self.users_mock.update.assert_called_with(
-            self.fake_user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestUserShow(TestUser):
-
-    def setUp(self):
-        super(TestUserShow, self).setUp()
-
-        self.users_mock.get.return_value = self.fake_user
-
-        # Get the command object to test
-        self.cmd = user.ShowUser(self.app, None)
-
-    def test_user_show(self):
-        arglist = [
-            self.fake_user.id,
-        ]
-        verifylist = [
-            ('user', self.fake_user.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.users_mock.get.assert_called_with(self.fake_user.id)
-
-        collist = ('email', 'enabled', 'id', 'name', 'project_id')
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.fake_user.email,
-            True,
-            self.fake_user.id,
-            self.fake_user.name,
-            self.fake_project.id,
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/__init__.py b/openstackclient/tests/identity/v3/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/openstackclient/tests/identity/v3/__init__.py
+++ /dev/null
diff --git a/openstackclient/tests/identity/v3/fakes.py b/openstackclient/tests/identity/v3/fakes.py
deleted file mode 100644
index 38f6724e..00000000
--- a/openstackclient/tests/identity/v3/fakes.py
+++ /dev/null
@@ -1,914 +0,0 @@
-#   Copyright 2013 Nebula Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import copy
-import mock
-import uuid
-
-from keystoneauth1 import access
-from keystoneauth1 import fixture
-
-from openstackclient.tests import fakes
-from openstackclient.tests import utils
-
-base_url = 'http://identity:5000/v3/'
-
-domain_id = 'd1'
-domain_name = 'oftheking'
-domain_description = 'domain description'
-
-DOMAIN = {
-    'id': domain_id,
-    'name': domain_name,
-    'description': domain_description,
-    'enabled': True,
-    'links': base_url + 'domains/' + domain_id,
-}
-
-group_id = 'gr-010'
-group_name = 'spencer davis'
-
-GROUP = {
-    'id': group_id,
-    'name': group_name,
-    'links': base_url + 'groups/' + group_id,
-}
-
-mapping_id = 'test_mapping'
-mapping_rules_file_path = '/tmp/path/to/file'
-# Copied from
-# (https://github.com/openstack/keystone/blob\
-# master/keystone/tests/mapping_fixtures.py
-EMPLOYEE_GROUP_ID = "0cd5e9"
-DEVELOPER_GROUP_ID = "xyz"
-MAPPING_RULES = [
-    {
-        "local": [
-            {
-                "group": {
-                    "id": EMPLOYEE_GROUP_ID
-                }
-            }
-        ],
-        "remote": [
-            {
-                "type": "orgPersonType",
-                "not_any_of": [
-                    "Contractor",
-                    "Guest"
-                ]
-            }
-        ]
-    }
-]
-
-MAPPING_RULES_2 = [
-    {
-        "local": [
-            {
-                "group": {
-                    "id": DEVELOPER_GROUP_ID
-                }
-            }
-        ],
-        "remote": [
-            {
-                "type": "orgPersonType",
-                "any_one_of": [
-                    "Contractor"
-                ]
-            }
-        ]
-    }
-]
-
-
-MAPPING_RESPONSE = {
-    "id": mapping_id,
-    "rules": MAPPING_RULES
-}
-
-MAPPING_RESPONSE_2 = {
-    "id": mapping_id,
-    "rules": MAPPING_RULES_2
-}
-
-project_id = '8-9-64'
-project_name = 'beatles'
-project_description = 'Fab Four'
-
-PROJECT = {
-    'id': project_id,
-    'name': project_name,
-    'description': project_description,
-    'enabled': True,
-    'domain_id': domain_id,
-    'links': base_url + 'projects/' + project_id,
-}
-
-PROJECT_2 = {
-    'id': project_id + '-2222',
-    'name': project_name + ' reprise',
-    'description': project_description + 'plus four more',
-    'enabled': True,
-    'domain_id': domain_id,
-    'links': base_url + 'projects/' + project_id,
-}
-
-region_id = 'region_one'
-region_parent_region_id = 'region_two'
-region_description = 'region one'
-
-REGION = {
-    'id': region_id,
-    'description': region_description,
-    'parent_region_id': region_parent_region_id,
-    'links': base_url + 'regions/' + region_id,
-}
-
-PROJECT_WITH_PARENT = {
-    'id': project_id + '-with-parent',
-    'name': project_name + ' and their parents',
-    'description': project_description + ' plus another four',
-    'enabled': True,
-    'domain_id': domain_id,
-    'parent_id': project_id,
-    'links': base_url + 'projects/' + (project_id + '-with-parent'),
-}
-
-PROJECT_WITH_GRANDPARENT = {
-    'id': project_id + '-with-grandparent',
-    'name': project_name + ', granny and grandpa',
-    'description': project_description + ' plus another eight?',
-    'enabled': True,
-    'domain_id': domain_id,
-    'parent_id': PROJECT_WITH_PARENT['id'],
-    'links': base_url + 'projects/' + (project_id + '-with-grandparent'),
-}
-
-parents = [{'project': PROJECT}]
-grandparents = [{'project': PROJECT}, {'project': PROJECT_WITH_PARENT}]
-ids_for_parents = [PROJECT['id']]
-ids_for_parents_and_grandparents = [PROJECT['id'], PROJECT_WITH_PARENT['id']]
-
-children = [{'project': PROJECT_WITH_GRANDPARENT}]
-ids_for_children = [PROJECT_WITH_GRANDPARENT['id']]
-
-
-role_id = 'r1'
-role_name = 'roller'
-
-ROLE = {
-    'id': role_id,
-    'name': role_name,
-    'domain': None,
-    'links': base_url + 'roles/' + role_id,
-}
-
-ROLE_2 = {
-    'id': 'r2',
-    'name': 'Rolls Royce',
-    'domain': domain_id,
-    'links': base_url + 'roles/' + 'r2',
-}
-
-service_id = 's-123'
-service_name = 'Texaco'
-service_type = 'gas'
-service_description = 'oil brand'
-
-SERVICE = {
-    'id': service_id,
-    'name': service_name,
-    'type': service_type,
-    'description': service_description,
-    'enabled': True,
-    'links': base_url + 'services/' + service_id,
-}
-
-SERVICE_WITHOUT_NAME = {
-    'id': service_id,
-    'type': service_type,
-    'description': service_description,
-    'enabled': True,
-    'links': base_url + 'services/' + service_id,
-}
-
-endpoint_id = 'e-123'
-endpoint_url = 'http://127.0.0.1:35357'
-endpoint_region = 'RegionOne'
-endpoint_interface = 'admin'
-
-ENDPOINT = {
-    'id': endpoint_id,
-    'url': endpoint_url,
-    'region': endpoint_region,
-    'interface': endpoint_interface,
-    'service_id': service_id,
-    'enabled': True,
-    'links': base_url + 'endpoints/' + endpoint_id,
-}
-
-user_id = 'bbbbbbb-aaaa-aaaa-aaaa-bbbbbbbaaaa'
-user_name = 'paul'
-user_description = 'Sir Paul'
-user_email = 'paul@applecorps.com'
-
-USER = {
-    'id': user_id,
-    'name': user_name,
-    'default_project_id': project_id,
-    'email': user_email,
-    'enabled': True,
-    'domain_id': domain_id,
-    'links': base_url + 'users/' + user_id,
-}
-
-trust_id = 't-456'
-trust_expires = None
-trust_impersonation = False
-trust_roles = {"id": role_id, "name": role_name},
-
-TRUST = {
-    'expires_at': trust_expires,
-    'id': trust_id,
-    'impersonation': trust_impersonation,
-    'links': base_url + 'trusts/' + trust_id,
-    'project_id': project_id,
-    'roles': trust_roles,
-    'trustee_user_id': user_id,
-    'trustor_user_id': user_id,
-}
-
-token_expires = '2016-09-05T18:04:52+0000'
-token_id = 'tttttttt-tttt-tttt-tttt-tttttttttttt'
-
-UNSCOPED_TOKEN = {
-    'expires': token_expires,
-    'id': token_id,
-    'user_id': user_id,
-}
-
-TOKEN_WITH_PROJECT_ID = {
-    'expires': token_expires,
-    'id': token_id,
-    'project_id': project_id,
-    'user_id': user_id,
-}
-
-TOKEN_WITH_DOMAIN_ID = {
-    'expires': token_expires,
-    'id': token_id,
-    'domain_id': domain_id,
-    'user_id': user_id,
-}
-
-idp_id = 'test_idp'
-idp_description = 'super exciting IdP description'
-idp_remote_ids = ['entity1', 'entity2']
-formatted_idp_remote_ids = 'entity1, entity2'
-
-IDENTITY_PROVIDER = {
-    'id': idp_id,
-    'remote_ids': idp_remote_ids,
-    'enabled': True,
-    'description': idp_description
-}
-
-protocol_id = 'protocol'
-
-mapping_id = 'test_mapping'
-mapping_id_updated = 'prod_mapping'
-
-sp_id = 'BETA'
-sp_description = 'Service Provider to burst into'
-service_provider_url = 'https://beta.example.com/Shibboleth.sso/POST/SAML'
-sp_auth_url = ('https://beta.example.com/v3/OS-FEDERATION/identity_providers/'
-               'idp/protocol/saml2/auth')
-
-SERVICE_PROVIDER = {
-    'id': sp_id,
-    'enabled': True,
-    'description': sp_description,
-    'sp_url': service_provider_url,
-    'auth_url': sp_auth_url
-}
-
-PROTOCOL_ID_MAPPING = {
-    'id': protocol_id,
-    'mapping': mapping_id
-}
-
-PROTOCOL_OUTPUT = {
-    'id': protocol_id,
-    'mapping_id': mapping_id,
-    'identity_provider': idp_id
-}
-
-PROTOCOL_OUTPUT_UPDATED = {
-    'id': protocol_id,
-    'mapping_id': mapping_id_updated,
-    'identity_provider': idp_id
-}
-
-# Assignments
-
-ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID = {
-    'scope': {'project': {'id': project_id}},
-    'user': {'id': user_id},
-    'role': {'id': role_id},
-}
-
-ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INCLUDE_NAMES = {
-    'scope': {
-        'project': {
-            'domain': {'id': domain_id,
-                       'name': domain_name},
-            'id': project_id,
-            'name': project_name}},
-    'user': {
-        'domain': {'id': domain_id,
-                   'name': domain_name},
-        'id': user_id,
-        'name': user_name},
-    'role': {'id': role_id,
-             'name': role_name},
-}
-
-ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INHERITED = {
-    'scope': {'project': {'id': project_id},
-              'OS-INHERIT:inherited_to': 'projects'},
-    'user': {'id': user_id},
-    'role': {'id': role_id},
-}
-
-ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID = {
-    'scope': {'project': {'id': project_id}},
-    'group': {'id': group_id},
-    'role': {'id': role_id},
-}
-
-ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID = {
-    'scope': {'domain': {'id': domain_id}},
-    'user': {'id': user_id},
-    'role': {'id': role_id},
-}
-
-ASSIGNMENT_WITH_DOMAIN_ROLE = {
-    'scope': {'domain': {'id': domain_id}},
-    'user': {'id': user_id},
-    'role': {'id': ROLE_2['id']},
-}
-
-ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INCLUDE_NAMES = {
-    'scope': {
-        'domain': {'id': domain_id,
-                   'name': domain_name}},
-    'user': {
-        'domain': {'id': domain_id,
-                   'name': domain_name},
-        'id': user_id,
-        'name': user_name},
-    'role': {'id': role_id,
-             'name': role_name},
-}
-
-ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INHERITED = {
-    'scope': {'domain': {'id': domain_id},
-              'OS-INHERIT:inherited_to': 'projects'},
-    'user': {'id': user_id},
-    'role': {'id': role_id},
-}
-
-ASSIGNMENT_WITH_DOMAIN_ID_AND_GROUP_ID = {
-    'scope': {'domain': {'id': domain_id}},
-    'group': {'id': group_id},
-    'role': {'id': role_id},
-}
-
-consumer_id = 'test consumer id'
-consumer_description = 'someone we trust'
-consumer_secret = 'test consumer secret'
-
-OAUTH_CONSUMER = {
-    'id': consumer_id,
-    'secret': consumer_secret,
-    'description': consumer_description
-}
-
-access_token_id = 'test access token id'
-access_token_secret = 'test access token secret'
-access_token_expires = '2014-05-18T03:13:18.152071Z'
-
-OAUTH_ACCESS_TOKEN = {
-    'id': access_token_id,
-    'expires': access_token_expires,
-    'key': access_token_id,
-    'secret': access_token_secret
-}
-
-request_token_id = 'test request token id'
-request_token_secret = 'test request token secret'
-request_token_expires = '2014-05-17T11:10:51.511336Z'
-
-OAUTH_REQUEST_TOKEN = {
-    'id': request_token_id,
-    'expires': request_token_expires,
-    'key': request_token_id,
-    'secret': request_token_secret
-}
-
-oauth_verifier_pin = '6d74XaDS'
-OAUTH_VERIFIER = {
-    'oauth_verifier': oauth_verifier_pin
-}
-
-
-def fake_auth_ref(fake_token, fake_service=None):
-    """Create an auth_ref using keystoneauth's fixtures"""
-    token_copy = copy.deepcopy(fake_token)
-    token_id = token_copy.pop('id')
-    token = fixture.V3Token(**token_copy)
-    # An auth_ref is actually an access info object
-    auth_ref = access.create(
-        body=token,
-        auth_token=token_id,
-    )
-
-    # Create a service catalog
-    if fake_service:
-        service = token.add_service(
-            fake_service['type'],
-            fake_service['name'],
-        )
-        # TODO(dtroyer): Add an 'id' element to KSA's _Service fixure
-        service['id'] = fake_service['id']
-        for e in fake_service['endpoints']:
-            region = e.get('region_id') or e.get('region', '<none>')
-            service.add_endpoint(
-                e['interface'],
-                e['url'],
-                region=region,
-            )
-
-    return auth_ref
-
-
-class FakeAuth(object):
-
-    def __init__(self, auth_method_class=None):
-        self._auth_method_class = auth_method_class
-
-    def get_token(self, *args, **kwargs):
-        return token_id
-
-
-class FakeSession(object):
-
-    def __init__(self, **kwargs):
-        self.auth = FakeAuth()
-
-
-class FakeIdentityv3Client(object):
-
-    def __init__(self, **kwargs):
-        self.domains = mock.Mock()
-        self.domains.resource_class = fakes.FakeResource(None, {})
-        self.credentials = mock.Mock()
-        self.credentials.resource_class = fakes.FakeResource(None, {})
-        self.endpoints = mock.Mock()
-        self.endpoints.resource_class = fakes.FakeResource(None, {})
-        self.groups = mock.Mock()
-        self.groups.resource_class = fakes.FakeResource(None, {})
-        self.oauth1 = mock.Mock()
-        self.oauth1.resource_class = fakes.FakeResource(None, {})
-        self.projects = mock.Mock()
-        self.projects.resource_class = fakes.FakeResource(None, {})
-        self.regions = mock.Mock()
-        self.regions.resource_class = fakes.FakeResource(None, {})
-        self.roles = mock.Mock()
-        self.roles.resource_class = fakes.FakeResource(None, {})
-        self.services = mock.Mock()
-        self.services.resource_class = fakes.FakeResource(None, {})
-        self.session = mock.Mock()
-        self.session.auth.auth_ref.service_catalog.resource_class = \
-            fakes.FakeResource(None, {})
-        self.tokens = mock.Mock()
-        self.tokens.resource_class = fakes.FakeResource(None, {})
-        self.trusts = mock.Mock()
-        self.trusts.resource_class = fakes.FakeResource(None, {})
-        self.users = mock.Mock()
-        self.users.resource_class = fakes.FakeResource(None, {})
-        self.role_assignments = mock.Mock()
-        self.role_assignments.resource_class = fakes.FakeResource(None, {})
-        self.auth_token = kwargs['token']
-        self.management_url = kwargs['endpoint']
-        self.auth = FakeAuth()
-        self.auth.client = mock.Mock()
-        self.auth.client.resource_class = fakes.FakeResource(None, {})
-
-
-class FakeFederationManager(object):
-
-    def __init__(self, **kwargs):
-        self.identity_providers = mock.Mock()
-        self.identity_providers.resource_class = fakes.FakeResource(None, {})
-        self.mappings = mock.Mock()
-        self.mappings.resource_class = fakes.FakeResource(None, {})
-        self.protocols = mock.Mock()
-        self.protocols.resource_class = fakes.FakeResource(None, {})
-        self.projects = mock.Mock()
-        self.projects.resource_class = fakes.FakeResource(None, {})
-        self.domains = mock.Mock()
-        self.domains.resource_class = fakes.FakeResource(None, {})
-        self.service_providers = mock.Mock()
-        self.service_providers.resource_class = fakes.FakeResource(None, {})
-
-
-class FakeFederatedClient(FakeIdentityv3Client):
-
-    def __init__(self, **kwargs):
-        super(FakeFederatedClient, self).__init__(**kwargs)
-        self.federation = FakeFederationManager()
-
-
-class FakeOAuth1Client(FakeIdentityv3Client):
-
-    def __init__(self, **kwargs):
-        super(FakeOAuth1Client, self).__init__(**kwargs)
-
-        self.access_tokens = mock.Mock()
-        self.access_tokens.resource_class = fakes.FakeResource(None, {})
-        self.consumers = mock.Mock()
-        self.consumers.resource_class = fakes.FakeResource(None, {})
-        self.request_tokens = mock.Mock()
-        self.request_tokens.resource_class = fakes.FakeResource(None, {})
-
-
-class TestIdentityv3(utils.TestCommand):
-
-    def setUp(self):
-        super(TestIdentityv3, self).setUp()
-
-        self.app.client_manager.identity = FakeIdentityv3Client(
-            endpoint=fakes.AUTH_URL,
-            token=fakes.AUTH_TOKEN,
-        )
-
-
-class TestFederatedIdentity(utils.TestCommand):
-
-    def setUp(self):
-        super(TestFederatedIdentity, self).setUp()
-
-        self.app.client_manager.identity = FakeFederatedClient(
-            endpoint=fakes.AUTH_URL,
-            token=fakes.AUTH_TOKEN
-        )
-
-
-class TestOAuth1(utils.TestCommand):
-
-    def setUp(self):
-        super(TestOAuth1, self).setUp()
-
-        self.app.client_manager.identity = FakeOAuth1Client(
-            endpoint=fakes.AUTH_URL,
-            token=fakes.AUTH_TOKEN
-        )
-
-
-class FakeProject(object):
-    """Fake one or more project."""
-
-    @staticmethod
-    def create_one_project(attrs=None):
-        """Create a fake project.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        project_info = {
-            'id': 'project-id-' + uuid.uuid4().hex,
-            'name': 'project-name-' + uuid.uuid4().hex,
-            'description': 'project-description-' + uuid.uuid4().hex,
-            'enabled': True,
-            'is_domain': False,
-            'domain_id': 'domain-id-' + uuid.uuid4().hex,
-            'parent_id': 'parent-id-' + uuid.uuid4().hex,
-            'links': 'links-' + uuid.uuid4().hex,
-        }
-        project_info.update(attrs)
-
-        project = fakes.FakeResource(info=copy.deepcopy(project_info),
-                                     loaded=True)
-        return project
-
-
-class FakeDomain(object):
-    """Fake one or more domain."""
-
-    @staticmethod
-    def create_one_domain(attrs=None):
-        """Create a fake domain.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        domain_info = {
-            'id': 'domain-id-' + uuid.uuid4().hex,
-            'name': 'domain-name-' + uuid.uuid4().hex,
-            'description': 'domain-description-' + uuid.uuid4().hex,
-            'enabled': True,
-            'links': 'links-' + uuid.uuid4().hex,
-        }
-        domain_info.update(attrs)
-
-        domain = fakes.FakeResource(info=copy.deepcopy(domain_info),
-                                    loaded=True)
-        return domain
-
-
-class FakeCredential(object):
-    """Fake one or more credential."""
-
-    @staticmethod
-    def create_one_credential(attrs=None):
-        """Create a fake credential.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, type, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        credential_info = {
-            'id': 'credential-id-' + uuid.uuid4().hex,
-            'type': 'cert',
-            'user_id': 'user-id-' + uuid.uuid4().hex,
-            'blob': 'credential-data-' + uuid.uuid4().hex,
-            'project_id': 'project-id-' + uuid.uuid4().hex,
-            'links': 'links-' + uuid.uuid4().hex,
-        }
-        credential_info.update(attrs)
-
-        credential = fakes.FakeResource(
-            info=copy.deepcopy(credential_info), loaded=True)
-        return credential
-
-    @staticmethod
-    def create_credentials(attrs=None, count=2):
-        """Create multiple fake credentials.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of credentials to fake
-        :return:
-            A list of FakeResource objects faking the credentials
-        """
-        credentials = []
-        for i in range(0, count):
-            credential = FakeCredential.create_one_credential(attrs)
-            credentials.append(credential)
-
-        return credentials
-
-    @staticmethod
-    def get_credentials(credentials=None, count=2):
-        """Get an iterable MagicMock object with a list of faked credentials.
-
-        If credentials list is provided, then initialize the Mock object with
-        the list. Otherwise create one.
-
-        :param List credentials:
-            A list of FakeResource objects faking credentials
-        :param Integer count:
-            The number of credentials to be faked
-        :return
-            An iterable Mock object with side_effect set to a list of faked
-            credentials
-        """
-        if credentials is None:
-            credentials = FakeCredential.create_credentials(count)
-
-        return mock.MagicMock(side_effect=credentials)
-
-
-class FakeUser(object):
-    """Fake one or more user."""
-
-    @staticmethod
-    def create_one_user(attrs=None):
-        """Create a fake user.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        user_info = {
-            'id': 'user-id-' + uuid.uuid4().hex,
-            'name': 'user-name-' + uuid.uuid4().hex,
-            'default_project_id': 'project-' + uuid.uuid4().hex,
-            'email': 'user-email-' + uuid.uuid4().hex,
-            'enabled': True,
-            'domain_id': 'domain-id-' + uuid.uuid4().hex,
-            'links': 'links-' + uuid.uuid4().hex,
-        }
-        user_info.update(attrs)
-
-        user = fakes.FakeResource(info=copy.deepcopy(user_info),
-                                  loaded=True)
-        return user
-
-
-class FakeGroup(object):
-    """Fake one or more group."""
-
-    @staticmethod
-    def create_one_group(attrs=None):
-        """Create a fake group.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        group_info = {
-            'id': 'group-id-' + uuid.uuid4().hex,
-            'name': 'group-name-' + uuid.uuid4().hex,
-            'links': 'links-' + uuid.uuid4().hex,
-            'domain_id': 'domain-id-' + uuid.uuid4().hex,
-            'description': 'group-description-' + uuid.uuid4().hex,
-        }
-        group_info.update(attrs)
-
-        group = fakes.FakeResource(info=copy.deepcopy(group_info),
-                                   loaded=True)
-        return group
-
-    @staticmethod
-    def create_groups(attrs=None, count=2):
-        """Create multiple fake groups.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of groups to fake
-        :return:
-            A list of FakeResource objects faking the groups
-        """
-        groups = []
-        for i in range(0, count):
-            group = FakeGroup.create_one_group(attrs)
-            groups.append(group)
-
-        return groups
-
-    @staticmethod
-    def get_groups(groups=None, count=2):
-        """Get an iterable MagicMock object with a list of faked groups.
-
-        If groups list is provided, then initialize the Mock object with
-        the list. Otherwise create one.
-
-        :param List groups:
-            A list of FakeResource objects faking groups
-        :param Integer count:
-            The number of groups to be faked
-        :return
-            An iterable Mock object with side_effect set to a list of faked
-            groups
-        """
-        if groups is None:
-            groups = FakeGroup.create_groups(count)
-
-        return mock.MagicMock(side_effect=groups)
-
-
-class FakeEndpoint(object):
-    """Fake one or more endpoint."""
-
-    @staticmethod
-    def create_one_endpoint(attrs=None):
-        """Create a fake endpoint.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, url, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        endpoint_info = {
-            'id': 'endpoint-id-' + uuid.uuid4().hex,
-            'url': 'url-' + uuid.uuid4().hex,
-            'region': 'endpoint-region-' + uuid.uuid4().hex,
-            'interface': 'admin',
-            'service_id': 'service-id-' + uuid.uuid4().hex,
-            'enabled': True,
-            'links': 'links-' + uuid.uuid4().hex,
-        }
-        endpoint_info.update(attrs)
-
-        endpoint = fakes.FakeResource(info=copy.deepcopy(endpoint_info),
-                                      loaded=True)
-        return endpoint
-
-
-class FakeService(object):
-    """Fake one or more service."""
-
-    @staticmethod
-    def create_one_service(attrs=None):
-        """Create a fake service.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        service_info = {
-            'id': 'service-id-' + uuid.uuid4().hex,
-            'name': 'service-name-' + uuid.uuid4().hex,
-            'type': 'service-type-' + uuid.uuid4().hex,
-            'description': 'service-description-' + uuid.uuid4().hex,
-            'enabled': True,
-            'links': 'links-' + uuid.uuid4().hex,
-        }
-        service_info.update(attrs)
-
-        service = fakes.FakeResource(info=copy.deepcopy(service_info),
-                                     loaded=True)
-        return service
-
-
-class FakeRoleAssignment(object):
-    """Fake one or more role assignment."""
-
-    @staticmethod
-    def create_one_role_assignment(attrs=None):
-        """Create a fake role assignment.
-
-        :param Dictionary attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with scope, user, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        role_assignment_info = {
-            'scope': {'project': {'id': 'project-id-' + uuid.uuid4().hex}},
-            'user': {'id': 'user-id-' + uuid.uuid4().hex},
-            'role': {'id': 'role-id-' + uuid.uuid4().hex},
-        }
-        role_assignment_info.update(attrs)
-
-        role_assignment = fakes.FakeResource(
-            info=copy.deepcopy(role_assignment_info), loaded=True)
-
-        return role_assignment
diff --git a/openstackclient/tests/identity/v3/test_catalog.py b/openstackclient/tests/identity/v3/test_catalog.py
deleted file mode 100644
index e3c5ed3d..00000000
--- a/openstackclient/tests/identity/v3/test_catalog.py
+++ /dev/null
@@ -1,142 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import mock
-
-from openstackclient.identity.v3 import catalog
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-from openstackclient.tests import utils
-
-
-class TestCatalog(utils.TestCommand):
-
-    fake_service = {
-        'id': 'qwertyuiop',
-        'type': 'compute',
-        'name': 'supernova',
-        'endpoints': [
-            {
-                'region': 'onlyone',
-                'url': 'https://public.example.com',
-                'interface': 'public',
-            },
-            {
-                'region_id': 'onlyone',
-                'url': 'https://admin.example.com',
-                'interface': 'admin',
-            },
-            {
-                'url': 'https://internal.example.com',
-                'interface': 'internal',
-            },
-            {
-                'region': None,
-                'url': 'https://none.example.com',
-                'interface': 'none',
-            },
-        ],
-    }
-
-    def setUp(self):
-        super(TestCatalog, self).setUp()
-
-        self.sc_mock = mock.MagicMock()
-        self.sc_mock.service_catalog.catalog.return_value = [
-            self.fake_service,
-        ]
-
-        self.auth_mock = mock.MagicMock()
-        self.app.client_manager.session = self.auth_mock
-
-        self.auth_mock.auth.get_auth_ref.return_value = self.sc_mock
-
-
-class TestCatalogList(TestCatalog):
-
-    def setUp(self):
-        super(TestCatalogList, self).setUp()
-
-        # Get the command object to test
-        self.cmd = catalog.ListCatalog(self.app, None)
-
-    def test_catalog_list(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.TOKEN_WITH_PROJECT_ID,
-            fake_service=self.fake_service,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        collist = ('Name', 'Type', 'Endpoints')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            'supernova',
-            'compute',
-            'onlyone\n  public: https://public.example.com\n'
-            'onlyone\n  admin: https://admin.example.com\n'
-            '<none>\n  internal: https://internal.example.com\n'
-            '<none>\n  none: https://none.example.com\n',
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestCatalogShow(TestCatalog):
-
-    def setUp(self):
-        super(TestCatalogShow, self).setUp()
-
-        # Get the command object to test
-        self.cmd = catalog.ShowCatalog(self.app, None)
-
-    def test_catalog_show(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.TOKEN_WITH_PROJECT_ID,
-            fake_service=self.fake_service,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = [
-            'compute',
-        ]
-        verifylist = [
-            ('service', 'compute'),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        collist = ('endpoints', 'id', 'name', 'type')
-        self.assertEqual(collist, columns)
-        datalist = (
-            'onlyone\n  public: https://public.example.com\nonlyone\n'
-            '  admin: https://admin.example.com\n'
-            '<none>\n  internal: https://internal.example.com\n'
-            '<none>\n  none: https://none.example.com\n',
-            'qwertyuiop',
-            'supernova',
-            'compute',
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/test_consumer.py b/openstackclient/tests/identity/v3/test_consumer.py
deleted file mode 100644
index d90c7347..00000000
--- a/openstackclient/tests/identity/v3/test_consumer.py
+++ /dev/null
@@ -1,219 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-
-import copy
-
-from openstackclient.identity.v3 import consumer
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestOAuth1(identity_fakes.TestOAuth1):
-
-    def setUp(self):
-        super(TestOAuth1, self).setUp()
-        identity_client = self.app.client_manager.identity
-        self.consumers_mock = identity_client.oauth1.consumers
-        self.consumers_mock.reset_mock()
-
-
-class TestConsumerCreate(TestOAuth1):
-
-    def setUp(self):
-        super(TestConsumerCreate, self).setUp()
-
-        self.consumers_mock.create.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.OAUTH_CONSUMER),
-            loaded=True,
-        )
-
-        self.cmd = consumer.CreateConsumer(self.app, None)
-
-    def test_create_consumer(self):
-        arglist = [
-            '--description', identity_fakes.consumer_description,
-        ]
-        verifylist = [
-            ('description', identity_fakes.consumer_description),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.consumers_mock.create.assert_called_with(
-            identity_fakes.consumer_description,
-        )
-
-        collist = ('description', 'id', 'secret')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.consumer_description,
-            identity_fakes.consumer_id,
-            identity_fakes.consumer_secret,
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestConsumerDelete(TestOAuth1):
-
-    def setUp(self):
-        super(TestConsumerDelete, self).setUp()
-
-        # This is the return value for utils.find_resource()
-        self.consumers_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.OAUTH_CONSUMER),
-            loaded=True,
-        )
-
-        self.consumers_mock.delete.return_value = None
-        self.cmd = consumer.DeleteConsumer(self.app, None)
-
-    def test_delete_consumer(self):
-        arglist = [
-            identity_fakes.consumer_id,
-        ]
-        verifylist = [
-            ('consumer', [identity_fakes.consumer_id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.consumers_mock.delete.assert_called_with(
-            identity_fakes.consumer_id,
-        )
-        self.assertIsNone(result)
-
-
-class TestConsumerList(TestOAuth1):
-
-    def setUp(self):
-        super(TestConsumerList, self).setUp()
-
-        self.consumers_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.OAUTH_CONSUMER),
-            loaded=True,
-        )
-        self.consumers_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.OAUTH_CONSUMER),
-                loaded=True,
-            ),
-        ]
-
-        # Get the command object to test
-        self.cmd = consumer.ListConsumer(self.app, None)
-
-    def test_consumer_list(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.consumers_mock.list.assert_called_with()
-
-        collist = ('ID', 'Description')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            identity_fakes.consumer_id,
-            identity_fakes.consumer_description,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestConsumerSet(TestOAuth1):
-
-    def setUp(self):
-        super(TestConsumerSet, self).setUp()
-
-        self.consumers_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.OAUTH_CONSUMER),
-            loaded=True,
-        )
-
-        consumer_updated = copy.deepcopy(identity_fakes.OAUTH_CONSUMER)
-        consumer_updated['description'] = "consumer new description"
-        self.consumers_mock.update.return_value = fakes.FakeResource(
-            None,
-            consumer_updated,
-            loaded=True,
-        )
-
-        self.cmd = consumer.SetConsumer(self.app, None)
-
-    def test_consumer_update(self):
-        new_description = "consumer new description"
-
-        arglist = [
-            '--description', new_description,
-            identity_fakes.consumer_id,
-        ]
-        verifylist = [
-            ('description', new_description),
-            ('consumer', identity_fakes.consumer_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        kwargs = {'description': new_description}
-        self.consumers_mock.update.assert_called_with(
-            identity_fakes.consumer_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestConsumerShow(TestOAuth1):
-
-    def setUp(self):
-        super(TestConsumerShow, self).setUp()
-
-        consumer_no_secret = copy.deepcopy(identity_fakes.OAUTH_CONSUMER)
-        del consumer_no_secret['secret']
-        self.consumers_mock.get.return_value = fakes.FakeResource(
-            None,
-            consumer_no_secret,
-            loaded=True,
-        )
-
-        # Get the command object to test
-        self.cmd = consumer.ShowConsumer(self.app, None)
-
-    def test_consumer_show(self):
-        arglist = [
-            identity_fakes.consumer_id,
-        ]
-        verifylist = [
-            ('consumer', identity_fakes.consumer_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.consumers_mock.get.assert_called_with(
-            identity_fakes.consumer_id,
-        )
-
-        collist = ('description', 'id')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.consumer_description,
-            identity_fakes.consumer_id,
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/test_credential.py b/openstackclient/tests/identity/v3/test_credential.py
deleted file mode 100644
index b272087d..00000000
--- a/openstackclient/tests/identity/v3/test_credential.py
+++ /dev/null
@@ -1,357 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-
-import mock
-from mock import call
-
-from osc_lib import exceptions
-
-from openstackclient.identity.v3 import credential
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-from openstackclient.tests import utils
-
-
-class TestCredential(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestCredential, self).setUp()
-
-        # Get a shortcut to the CredentialManager Mock
-        self.credentials_mock = self.app.client_manager.identity.credentials
-        self.credentials_mock.reset_mock()
-
-        # Get a shortcut to the UserManager Mock
-        self.users_mock = self.app.client_manager.identity.users
-        self.users_mock.reset_mock()
-
-        # Get a shortcut to the ProjectManager Mock
-        self.projects_mock = self.app.client_manager.identity.projects
-        self.projects_mock.reset_mock()
-
-
-class TestCredentialCreate(TestCredential):
-
-    user = identity_fakes.FakeUser.create_one_user()
-    project = identity_fakes.FakeProject.create_one_project()
-    columns = (
-        'blob',
-        'id',
-        'project_id',
-        'type',
-        'user_id',
-    )
-
-    def setUp(self):
-        super(TestCredentialCreate, self).setUp()
-
-        self.credential = identity_fakes.FakeCredential.create_one_credential(
-            attrs={'user_id': self.user.id, 'project_id': self.project.id})
-        self.credentials_mock.create.return_value = self.credential
-        self.users_mock.get.return_value = self.user
-        self.projects_mock.get.return_value = self.project
-        self.data = (
-            self.credential.blob,
-            self.credential.id,
-            self.credential.project_id,
-            self.credential.type,
-            self.credential.user_id,
-        )
-
-        self.cmd = credential.CreateCredential(self.app, None)
-
-    def test_credential_create_no_options(self):
-        arglist = [
-            self.credential.user_id,
-            self.credential.blob,
-        ]
-        verifylist = [
-            ('user', self.credential.user_id),
-            ('data', self.credential.blob),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-
-        kwargs = {
-            'user': self.credential.user_id,
-            'type': self.credential.type,
-            'blob': self.credential.blob,
-            'project': None,
-        }
-        self.credentials_mock.create.assert_called_once_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
-
-    def test_credential_create_with_options(self):
-        arglist = [
-            self.credential.user_id,
-            self.credential.blob,
-            '--type', self.credential.type,
-            '--project', self.credential.project_id,
-        ]
-        verifylist = [
-            ('user', self.credential.user_id),
-            ('data', self.credential.blob),
-            ('type', self.credential.type),
-            ('project', self.credential.project_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-
-        kwargs = {
-            'user': self.credential.user_id,
-            'type': self.credential.type,
-            'blob': self.credential.blob,
-            'project': self.credential.project_id,
-        }
-        self.credentials_mock.create.assert_called_once_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
-
-    def test_credential_create_with_invalid_type(self):
-        arglist = [
-            self.credential.user_id,
-            self.credential.blob,
-            '--type', 'invalid_type',
-        ]
-        verifylist = [
-            ('user', self.credential.user_id),
-            ('data', self.credential.blob),
-            ('type', 'invalid_type'),
-        ]
-        self.assertRaises(utils.ParserException, self.check_parser,
-                          self.cmd, arglist, verifylist)
-
-
-class TestCredentialDelete(TestCredential):
-
-    credentials = identity_fakes.FakeCredential.create_credentials(count=2)
-
-    def setUp(self):
-        super(TestCredentialDelete, self).setUp()
-
-        self.credentials_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = credential.DeleteCredential(self.app, None)
-
-    def test_credential_delete(self):
-        arglist = [
-            self.credentials[0].id,
-        ]
-        verifylist = [
-            ('credential', [self.credentials[0].id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.credentials_mock.delete.assert_called_with(
-            self.credentials[0].id,
-        )
-        self.assertIsNone(result)
-
-    def test_credential_multi_delete(self):
-        arglist = []
-        for c in self.credentials:
-            arglist.append(c.id)
-        verifylist = [
-            ('credential', arglist),
-        ]
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        result = self.cmd.take_action(parsed_args)
-
-        calls = []
-        for c in self.credentials:
-            calls.append(call(c.id))
-        self.credentials_mock.delete.assert_has_calls(calls)
-        self.assertIsNone(result)
-
-    def test_credential_multi_delete_with_exception(self):
-        arglist = [
-            self.credentials[0].id,
-            'unexist_credential',
-        ]
-        verifylist = [
-            ('credential', [self.credentials[0].id, 'unexist_credential'])
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        delete_mock_result = [None, exceptions.CommandError]
-        self.credentials_mock.delete = (
-            mock.MagicMock(side_effect=delete_mock_result)
-        )
-
-        try:
-            self.cmd.take_action(parsed_args)
-            self.fail('CommandError should be raised.')
-        except exceptions.CommandError as e:
-            self.assertEqual('1 of 2 credential failed to delete.', str(e))
-
-        self.credentials_mock.delete.assert_any_call(self.credentials[0].id)
-        self.credentials_mock.delete.assert_any_call('unexist_credential')
-
-
-class TestCredentialList(TestCredential):
-
-    credential = identity_fakes.FakeCredential.create_one_credential()
-
-    columns = ('ID', 'Type', 'User ID', 'Data', 'Project ID')
-    data = ((
-        credential.id,
-        credential.type,
-        credential.user_id,
-        credential.blob,
-        credential.project_id,
-    ), )
-
-    def setUp(self):
-        super(TestCredentialList, self).setUp()
-
-        self.credentials_mock.list.return_value = [self.credential]
-
-        # Get the command object to test
-        self.cmd = credential.ListCredential(self.app, None)
-
-    def test_domain_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.credentials_mock.list.assert_called_with()
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, tuple(data))
-
-
-class TestCredentialSet(TestCredential):
-
-    credential = identity_fakes.FakeCredential.create_one_credential()
-
-    def setUp(self):
-        super(TestCredentialSet, self).setUp()
-        self.cmd = credential.SetCredential(self.app, None)
-
-    def test_credential_set_no_options(self):
-        arglist = [
-            self.credential.id,
-        ]
-
-        self.assertRaises(utils.ParserException,
-                          self.check_parser, self.cmd, arglist, [])
-
-    def test_credential_set_missing_user(self):
-        arglist = [
-            '--type', 'ec2',
-            '--data', self.credential.blob,
-            self.credential.id,
-        ]
-
-        self.assertRaises(utils.ParserException,
-                          self.check_parser, self.cmd, arglist, [])
-
-    def test_credential_set_missing_type(self):
-        arglist = [
-            '--user', self.credential.user_id,
-            '--data', self.credential.blob,
-            self.credential.id,
-        ]
-
-        self.assertRaises(utils.ParserException,
-                          self.check_parser, self.cmd, arglist, [])
-
-    def test_credential_set_missing_data(self):
-        arglist = [
-            '--user', self.credential.user_id,
-            '--type', 'ec2',
-            self.credential.id,
-        ]
-
-        self.assertRaises(utils.ParserException,
-                          self.check_parser, self.cmd, arglist, [])
-
-    def test_credential_set_valid(self):
-        arglist = [
-            '--user', self.credential.user_id,
-            '--type', 'ec2',
-            '--data', self.credential.blob,
-            self.credential.id,
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, [])
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.assertIsNone(result)
-
-    def test_credential_set_valid_with_project(self):
-        arglist = [
-            '--user', self.credential.user_id,
-            '--type', 'ec2',
-            '--data', self.credential.blob,
-            '--project', self.credential.project_id,
-            self.credential.id,
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, [])
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.assertIsNone(result)
-
-
-class TestCredentialShow(TestCredential):
-
-    columns = (
-        'blob',
-        'id',
-        'project_id',
-        'type',
-        'user_id',
-    )
-
-    def setUp(self):
-        super(TestCredentialShow, self).setUp()
-
-        self.credential = identity_fakes.FakeCredential.create_one_credential()
-        self.credentials_mock.get.return_value = self.credential
-        self.data = (
-            self.credential.blob,
-            self.credential.id,
-            self.credential.project_id,
-            self.credential.type,
-            self.credential.user_id,
-        )
-
-        self.cmd = credential.ShowCredential(self.app, None)
-
-    def test_credential_show(self):
-        arglist = [
-            self.credential.id,
-        ]
-        verifylist = [
-            ('credential', self.credential.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.credentials_mock.get.assert_called_once_with(self.credential.id)
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
diff --git a/openstackclient/tests/identity/v3/test_domain.py b/openstackclient/tests/identity/v3/test_domain.py
deleted file mode 100644
index 5e094021..00000000
--- a/openstackclient/tests/identity/v3/test_domain.py
+++ /dev/null
@@ -1,401 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-
-from openstackclient.identity.v3 import domain
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestDomain(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestDomain, self).setUp()
-
-        # Get a shortcut to the DomainManager Mock
-        self.domains_mock = self.app.client_manager.identity.domains
-        self.domains_mock.reset_mock()
-
-
-class TestDomainCreate(TestDomain):
-
-    columns = (
-        'description',
-        'enabled',
-        'id',
-        'name',
-    )
-
-    def setUp(self):
-        super(TestDomainCreate, self).setUp()
-
-        self.domain = identity_fakes.FakeDomain.create_one_domain()
-        self.domains_mock.create.return_value = self.domain
-        self.datalist = (
-            self.domain.description,
-            True,
-            self.domain.id,
-            self.domain.name,
-        )
-
-        # Get the command object to test
-        self.cmd = domain.CreateDomain(self.app, None)
-
-    def test_domain_create_no_options(self):
-        arglist = [
-            self.domain.name,
-        ]
-        verifylist = [
-            ('name', self.domain.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.domain.name,
-            'description': None,
-            'enabled': True,
-        }
-        self.domains_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_domain_create_description(self):
-        arglist = [
-            '--description', 'new desc',
-            self.domain.name,
-        ]
-        verifylist = [
-            ('description', 'new desc'),
-            ('name', self.domain.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.domain.name,
-            'description': 'new desc',
-            'enabled': True,
-        }
-        self.domains_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_domain_create_enable(self):
-        arglist = [
-            '--enable',
-            self.domain.name,
-        ]
-        verifylist = [
-            ('enable', True),
-            ('name', self.domain.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.domain.name,
-            'description': None,
-            'enabled': True,
-        }
-        self.domains_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_domain_create_disable(self):
-        arglist = [
-            '--disable',
-            self.domain.name,
-        ]
-        verifylist = [
-            ('disable', True),
-            ('name', self.domain.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.domain.name,
-            'description': None,
-            'enabled': False,
-        }
-        self.domains_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-
-class TestDomainDelete(TestDomain):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-
-    def setUp(self):
-        super(TestDomainDelete, self).setUp()
-
-        # This is the return value for utils.find_resource()
-        self.domains_mock.get.return_value = self.domain
-        self.domains_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = domain.DeleteDomain(self.app, None)
-
-    def test_domain_delete(self):
-        arglist = [
-            self.domain.id,
-        ]
-        verifylist = [
-            ('domain', [self.domain.id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.domains_mock.delete.assert_called_with(
-            self.domain.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestDomainList(TestDomain):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-
-    def setUp(self):
-        super(TestDomainList, self).setUp()
-
-        self.domains_mock.list.return_value = [self.domain]
-
-        # Get the command object to test
-        self.cmd = domain.ListDomain(self.app, None)
-
-    def test_domain_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.domains_mock.list.assert_called_with()
-
-        collist = ('ID', 'Name', 'Enabled', 'Description')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.domain.id,
-            self.domain.name,
-            True,
-            self.domain.description,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestDomainSet(TestDomain):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-
-    def setUp(self):
-        super(TestDomainSet, self).setUp()
-
-        self.domains_mock.get.return_value = self.domain
-
-        self.domains_mock.update.return_value = self.domain
-
-        # Get the command object to test
-        self.cmd = domain.SetDomain(self.app, None)
-
-    def test_domain_set_no_options(self):
-        arglist = [
-            self.domain.name,
-        ]
-        verifylist = [
-            ('domain', self.domain.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        kwargs = {}
-        self.domains_mock.update.assert_called_with(
-            self.domain.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_domain_set_name(self):
-        arglist = [
-            '--name', 'qwerty',
-            self.domain.id,
-        ]
-        verifylist = [
-            ('name', 'qwerty'),
-            ('domain', self.domain.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': 'qwerty',
-        }
-        self.domains_mock.update.assert_called_with(
-            self.domain.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_domain_set_description(self):
-        arglist = [
-            '--description', 'new desc',
-            self.domain.id,
-        ]
-        verifylist = [
-            ('description', 'new desc'),
-            ('domain', self.domain.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': 'new desc',
-        }
-        self.domains_mock.update.assert_called_with(
-            self.domain.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_domain_set_enable(self):
-        arglist = [
-            '--enable',
-            self.domain.id,
-        ]
-        verifylist = [
-            ('enable', True),
-            ('domain', self.domain.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-        }
-        self.domains_mock.update.assert_called_with(
-            self.domain.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_domain_set_disable(self):
-        arglist = [
-            '--disable',
-            self.domain.id,
-        ]
-        verifylist = [
-            ('disable', True),
-            ('domain', self.domain.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': False,
-        }
-        self.domains_mock.update.assert_called_with(
-            self.domain.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestDomainShow(TestDomain):
-
-    def setUp(self):
-        super(TestDomainShow, self).setUp()
-
-        self.domain = identity_fakes.FakeDomain.create_one_domain()
-        self.domains_mock.get.return_value = self.domain
-        # Get the command object to test
-        self.cmd = domain.ShowDomain(self.app, None)
-
-    def test_domain_show(self):
-        arglist = [
-            self.domain.id,
-        ]
-        verifylist = [
-            ('domain', self.domain.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        self.app.client_manager.identity.tokens.get_token_data.return_value = \
-            {'token':
-             {'project':
-              {'domain':
-               {'id': 'd1',
-                'name': 'd1'
-                }
-               }
-              }
-             }
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.domains_mock.get.assert_called_with(
-            self.domain.id,
-        )
-
-        collist = ('description', 'enabled', 'id', 'name')
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.domain.description,
-            True,
-            self.domain.id,
-            self.domain.name,
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/test_endpoint.py b/openstackclient/tests/identity/v3/test_endpoint.py
deleted file mode 100644
index b2463a0d..00000000
--- a/openstackclient/tests/identity/v3/test_endpoint.py
+++ /dev/null
@@ -1,750 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-
-from openstackclient.identity.v3 import endpoint
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestEndpoint(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestEndpoint, self).setUp()
-
-        # Get a shortcut to the EndpointManager Mock
-        self.endpoints_mock = self.app.client_manager.identity.endpoints
-        self.endpoints_mock.reset_mock()
-
-        # Get a shortcut to the ServiceManager Mock
-        self.services_mock = self.app.client_manager.identity.services
-        self.services_mock.reset_mock()
-
-
-class TestEndpointCreate(TestEndpoint):
-
-    service = identity_fakes.FakeService.create_one_service()
-
-    columns = (
-        'enabled',
-        'id',
-        'interface',
-        'region',
-        'service_id',
-        'service_name',
-        'service_type',
-        'url',
-    )
-
-    def setUp(self):
-        super(TestEndpointCreate, self).setUp()
-
-        self.endpoint = identity_fakes.FakeEndpoint.create_one_endpoint(
-            attrs={'service_id': self.service.id})
-        self.endpoints_mock.create.return_value = self.endpoint
-
-        # This is the return value for common.find_resource(service)
-        self.services_mock.get.return_value = self.service
-
-        # Get the command object to test
-        self.cmd = endpoint.CreateEndpoint(self.app, None)
-
-    def test_endpoint_create_no_options(self):
-        arglist = [
-            self.service.id,
-            self.endpoint.interface,
-            self.endpoint.url,
-        ]
-        verifylist = [
-            ('enabled', True),
-            ('service', self.service.id),
-            ('interface', self.endpoint.interface),
-            ('url', self.endpoint.url),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'service': self.service.id,
-            'url': self.endpoint.url,
-            'interface': self.endpoint.interface,
-            'enabled': True,
-            'region': None,
-        }
-
-        self.endpoints_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            True,
-            self.endpoint.id,
-            self.endpoint.interface,
-            self.endpoint.region,
-            self.service.id,
-            self.service.name,
-            self.service.type,
-            self.endpoint.url,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_endpoint_create_region(self):
-        arglist = [
-            self.service.id,
-            self.endpoint.interface,
-            self.endpoint.url,
-            '--region', self.endpoint.region,
-        ]
-        verifylist = [
-            ('enabled', True),
-            ('service', self.service.id),
-            ('interface', self.endpoint.interface),
-            ('url', self.endpoint.url),
-            ('region', self.endpoint.region),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'service': self.service.id,
-            'url': self.endpoint.url,
-            'interface': self.endpoint.interface,
-            'enabled': True,
-            'region': self.endpoint.region,
-        }
-
-        self.endpoints_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            True,
-            self.endpoint.id,
-            self.endpoint.interface,
-            self.endpoint.region,
-            self.service.id,
-            self.service.name,
-            self.service.type,
-            self.endpoint.url,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_endpoint_create_enable(self):
-        arglist = [
-            self.service.id,
-            self.endpoint.interface,
-            self.endpoint.url,
-            '--enable'
-        ]
-        verifylist = [
-            ('enabled', True),
-            ('service', self.service.id),
-            ('interface', self.endpoint.interface),
-            ('url', self.endpoint.url),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'service': self.service.id,
-            'url': self.endpoint.url,
-            'interface': self.endpoint.interface,
-            'enabled': True,
-            'region': None,
-        }
-
-        self.endpoints_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            True,
-            self.endpoint.id,
-            self.endpoint.interface,
-            self.endpoint.region,
-            self.service.id,
-            self.service.name,
-            self.service.type,
-            self.endpoint.url,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_endpoint_create_disable(self):
-        arglist = [
-            self.service.id,
-            self.endpoint.interface,
-            self.endpoint.url,
-            '--disable',
-        ]
-        verifylist = [
-            ('enabled', False),
-            ('service', self.service.id),
-            ('interface', self.endpoint.interface),
-            ('url', self.endpoint.url),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'service': self.service.id,
-            'url': self.endpoint.url,
-            'interface': self.endpoint.interface,
-            'enabled': False,
-            'region': None,
-        }
-
-        self.endpoints_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            True,
-            self.endpoint.id,
-            self.endpoint.interface,
-            self.endpoint.region,
-            self.service.id,
-            self.service.name,
-            self.service.type,
-            self.endpoint.url,
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestEndpointDelete(TestEndpoint):
-
-    endpoint = identity_fakes.FakeEndpoint.create_one_endpoint()
-
-    def setUp(self):
-        super(TestEndpointDelete, self).setUp()
-
-        # This is the return value for utils.find_resource(endpoint)
-        self.endpoints_mock.get.return_value = self.endpoint
-        self.endpoints_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = endpoint.DeleteEndpoint(self.app, None)
-
-    def test_endpoint_delete(self):
-        arglist = [
-            self.endpoint.id,
-        ]
-        verifylist = [
-            ('endpoint', [self.endpoint.id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.endpoints_mock.delete.assert_called_with(
-            self.endpoint.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestEndpointList(TestEndpoint):
-
-    service = identity_fakes.FakeService.create_one_service()
-    endpoint = identity_fakes.FakeEndpoint.create_one_endpoint(
-        attrs={'service_id': service.id})
-
-    columns = (
-        'ID',
-        'Region',
-        'Service Name',
-        'Service Type',
-        'Enabled',
-        'Interface',
-        'URL',
-    )
-
-    def setUp(self):
-        super(TestEndpointList, self).setUp()
-
-        self.endpoints_mock.list.return_value = [self.endpoint]
-
-        # This is the return value for common.find_resource(service)
-        self.services_mock.get.return_value = self.service
-
-        # Get the command object to test
-        self.cmd = endpoint.ListEndpoint(self.app, None)
-
-    def test_endpoint_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.endpoints_mock.list.assert_called_with()
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            (
-                self.endpoint.id,
-                self.endpoint.region,
-                self.service.name,
-                self.service.type,
-                True,
-                self.endpoint.interface,
-                self.endpoint.url,
-            ),
-        )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_endpoint_list_service(self):
-        arglist = [
-            '--service', self.service.id,
-        ]
-        verifylist = [
-            ('service', self.service.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'service': self.service.id,
-        }
-        self.endpoints_mock.list.assert_called_with(**kwargs)
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            (
-                self.endpoint.id,
-                self.endpoint.region,
-                self.service.name,
-                self.service.type,
-                True,
-                self.endpoint.interface,
-                self.endpoint.url,
-            ),
-        )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_endpoint_list_interface(self):
-        arglist = [
-            '--interface', self.endpoint.interface,
-        ]
-        verifylist = [
-            ('interface', self.endpoint.interface),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'interface': self.endpoint.interface,
-        }
-        self.endpoints_mock.list.assert_called_with(**kwargs)
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            (
-                self.endpoint.id,
-                self.endpoint.region,
-                self.service.name,
-                self.service.type,
-                True,
-                self.endpoint.interface,
-                self.endpoint.url,
-            ),
-        )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_endpoint_list_region(self):
-        arglist = [
-            '--region', self.endpoint.region,
-        ]
-        verifylist = [
-            ('region', self.endpoint.region),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'region': self.endpoint.region,
-        }
-        self.endpoints_mock.list.assert_called_with(**kwargs)
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            (
-                self.endpoint.id,
-                self.endpoint.region,
-                self.service.name,
-                self.service.type,
-                True,
-                self.endpoint.interface,
-                self.endpoint.url,
-            ),
-        )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestEndpointSet(TestEndpoint):
-
-    service = identity_fakes.FakeService.create_one_service()
-    endpoint = identity_fakes.FakeEndpoint.create_one_endpoint(
-        attrs={'service_id': service.id})
-
-    def setUp(self):
-        super(TestEndpointSet, self).setUp()
-
-        # This is the return value for utils.find_resource(endpoint)
-        self.endpoints_mock.get.return_value = self.endpoint
-
-        self.endpoints_mock.update.return_value = self.endpoint
-
-        # This is the return value for common.find_resource(service)
-        self.services_mock.get.return_value = self.service
-
-        # Get the command object to test
-        self.cmd = endpoint.SetEndpoint(self.app, None)
-
-    def test_endpoint_set_no_options(self):
-        arglist = [
-            self.endpoint.id,
-        ]
-        verifylist = [
-            ('endpoint', self.endpoint.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        kwargs = {
-            'enabled': None,
-            'interface': None,
-            'region': None,
-            'service': None,
-            'url': None,
-        }
-        self.endpoints_mock.update.assert_called_with(
-            self.endpoint.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_endpoint_set_interface(self):
-        arglist = [
-            '--interface', 'public',
-            self.endpoint.id
-        ]
-        verifylist = [
-            ('interface', 'public'),
-            ('endpoint', self.endpoint.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': None,
-            'interface': 'public',
-            'url': None,
-            'region': None,
-            'service': None,
-        }
-        self.endpoints_mock.update.assert_called_with(
-            self.endpoint.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_endpoint_set_url(self):
-        arglist = [
-            '--url', 'http://localhost:5000',
-            self.endpoint.id
-        ]
-        verifylist = [
-            ('url', 'http://localhost:5000'),
-            ('endpoint', self.endpoint.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': None,
-            'interface': None,
-            'url': 'http://localhost:5000',
-            'region': None,
-            'service': None,
-        }
-        self.endpoints_mock.update.assert_called_with(
-            self.endpoint.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_endpoint_set_service(self):
-        arglist = [
-            '--service', self.service.id,
-            self.endpoint.id
-        ]
-        verifylist = [
-            ('service', self.service.id),
-            ('endpoint', self.endpoint.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': None,
-            'interface': None,
-            'url': None,
-            'region': None,
-            'service': self.service.id,
-        }
-        self.endpoints_mock.update.assert_called_with(
-            self.endpoint.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_endpoint_set_region(self):
-        arglist = [
-            '--region', 'e-rzzz',
-            self.endpoint.id
-        ]
-        verifylist = [
-            ('region', 'e-rzzz'),
-            ('endpoint', self.endpoint.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': None,
-            'interface': None,
-            'url': None,
-            'region': 'e-rzzz',
-            'service': None,
-        }
-        self.endpoints_mock.update.assert_called_with(
-            self.endpoint.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_endpoint_set_enable(self):
-        arglist = [
-            '--enable',
-            self.endpoint.id
-        ]
-        verifylist = [
-            ('enabled', True),
-            ('endpoint', self.endpoint.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'interface': None,
-            'url': None,
-            'region': None,
-            'service': None,
-        }
-        self.endpoints_mock.update.assert_called_with(
-            self.endpoint.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_endpoint_set_disable(self):
-        arglist = [
-            '--disable',
-            self.endpoint.id
-        ]
-        verifylist = [
-            ('disabled', True),
-            ('endpoint', self.endpoint.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': False,
-            'interface': None,
-            'url': None,
-            'region': None,
-            'service': None,
-        }
-        self.endpoints_mock.update.assert_called_with(
-            self.endpoint.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestEndpointShow(TestEndpoint):
-
-    service = identity_fakes.FakeService.create_one_service()
-    endpoint = identity_fakes.FakeEndpoint.create_one_endpoint(
-        attrs={'service_id': service.id})
-
-    def setUp(self):
-        super(TestEndpointShow, self).setUp()
-
-        self.endpoints_mock.get.return_value = self.endpoint
-
-        # This is the return value for common.find_resource(service)
-        self.services_mock.get.return_value = self.service
-
-        # Get the command object to test
-        self.cmd = endpoint.ShowEndpoint(self.app, None)
-
-    def test_endpoint_show(self):
-        arglist = [
-            self.endpoint.id,
-        ]
-        verifylist = [
-            ('endpoint', self.endpoint.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.endpoints_mock.get.assert_called_with(
-            self.endpoint.id,
-        )
-
-        collist = (
-            'enabled',
-            'id',
-            'interface',
-            'region',
-            'service_id',
-            'service_name',
-            'service_type',
-            'url',
-        )
-        self.assertEqual(collist, columns)
-        datalist = (
-            True,
-            self.endpoint.id,
-            self.endpoint.interface,
-            self.endpoint.region,
-            self.service.id,
-            self.service.name,
-            self.service.type,
-            self.endpoint.url,
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestEndpointCreateServiceWithoutName(TestEndpointCreate):
-
-    service = identity_fakes.FakeService.create_one_service(
-        attrs={'service_name': ''})
-
-    def setUp(self):
-        super(TestEndpointCreate, self).setUp()
-
-        self.endpoint = identity_fakes.FakeEndpoint.create_one_endpoint(
-            attrs={'service_id': self.service.id})
-
-        self.endpoints_mock.create.return_value = self.endpoint
-
-        # This is the return value for common.find_resource(service)
-        self.services_mock.get.return_value = self.service
-
-        # Get the command object to test
-        self.cmd = endpoint.CreateEndpoint(self.app, None)
-
-
-class TestEndpointListServiceWithoutName(TestEndpointList):
-
-    service = identity_fakes.FakeService.create_one_service(
-        attrs={'service_name': ''})
-    endpoint = identity_fakes.FakeEndpoint.create_one_endpoint(
-        attrs={'service_id': service.id})
-
-    def setUp(self):
-        super(TestEndpointList, self).setUp()
-
-        self.endpoints_mock.list.return_value = [self.endpoint]
-
-        # This is the return value for common.find_resource(service)
-        self.services_mock.get.return_value = self.service
-
-        # Get the command object to test
-        self.cmd = endpoint.ListEndpoint(self.app, None)
-
-
-class TestEndpointShowServiceWithoutName(TestEndpointShow):
-
-    service = identity_fakes.FakeService.create_one_service(
-        attrs={'service_name': ''})
-    endpoint = identity_fakes.FakeEndpoint.create_one_endpoint(
-        attrs={'service_id': service.id})
-
-    def setUp(self):
-        super(TestEndpointShow, self).setUp()
-
-        self.endpoints_mock.get.return_value = self.endpoint
-
-        # This is the return value for common.find_resource(service)
-        self.services_mock.get.return_value = self.service
-
-        # Get the command object to test
-        self.cmd = endpoint.ShowEndpoint(self.app, None)
diff --git a/openstackclient/tests/identity/v3/test_group.py b/openstackclient/tests/identity/v3/test_group.py
deleted file mode 100644
index a678dee9..00000000
--- a/openstackclient/tests/identity/v3/test_group.py
+++ /dev/null
@@ -1,569 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import mock
-from mock import call
-
-from keystoneauth1 import exceptions as ks_exc
-from osc_lib import exceptions
-
-from openstackclient.identity.v3 import group
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestGroup(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestGroup, self).setUp()
-
-        # Get a shortcut to the DomainManager Mock
-        self.domains_mock = self.app.client_manager.identity.domains
-        self.domains_mock.reset_mock()
-
-        # Get a shortcut to the GroupManager Mock
-        self.groups_mock = self.app.client_manager.identity.groups
-        self.groups_mock.reset_mock()
-
-        # Get a shortcut to the UserManager Mock
-        self.users_mock = self.app.client_manager.identity.users
-        self.users_mock.reset_mock()
-
-
-class TestGroupAddUser(TestGroup):
-
-    group = identity_fakes.FakeGroup.create_one_group()
-    user = identity_fakes.FakeUser.create_one_user()
-
-    def setUp(self):
-        super(TestGroupAddUser, self).setUp()
-
-        self.groups_mock.get.return_value = self.group
-        self.users_mock.get.return_value = self.user
-        self.users_mock.add_to_group.return_value = None
-
-        self.cmd = group.AddUserToGroup(self.app, None)
-
-    def test_group_add_user(self):
-        arglist = [
-            self.group.name,
-            self.user.name,
-        ]
-        verifylist = [
-            ('group', self.group.name),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-        self.users_mock.add_to_group.assert_called_once_with(
-            self.user.id, self.group.id)
-        self.assertIsNone(result)
-
-
-class TestGroupCheckUser(TestGroup):
-
-    group = identity_fakes.FakeGroup.create_one_group()
-    user = identity_fakes.FakeUser.create_one_user()
-
-    def setUp(self):
-        super(TestGroupCheckUser, self).setUp()
-
-        self.groups_mock.get.return_value = self.group
-        self.users_mock.get.return_value = self.user
-        self.users_mock.check_in_group.return_value = None
-
-        self.cmd = group.CheckUserInGroup(self.app, None)
-
-    def test_group_check_user(self):
-        arglist = [
-            self.group.name,
-            self.user.name,
-        ]
-        verifylist = [
-            ('group', self.group.name),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-        self.users_mock.check_in_group.assert_called_once_with(
-            self.user.id, self.group.id)
-        self.assertIsNone(result)
-
-
-class TestGroupCreate(TestGroup):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-
-    columns = (
-        'description',
-        'domain_id',
-        'id',
-        'name',
-    )
-
-    def setUp(self):
-        super(TestGroupCreate, self).setUp()
-        self.group = identity_fakes.FakeGroup.create_one_group(
-            attrs={'domain_id': self.domain.id})
-        self.data = (
-            self.group.description,
-            self.group.domain_id,
-            self.group.id,
-            self.group.name,
-        )
-
-        self.groups_mock.create.return_value = self.group
-        self.groups_mock.get.return_value = self.group
-        self.domains_mock.get.return_value = self.domain
-
-        self.cmd = group.CreateGroup(self.app, None)
-
-    def test_group_create(self):
-        arglist = [
-            self.group.name,
-        ]
-        verifylist = [
-            ('name', self.group.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-        self.groups_mock.create.assert_called_once_with(
-            name=self.group.name,
-            domain=None,
-            description=None,
-        )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
-
-    def test_group_create_with_options(self):
-        arglist = [
-            '--domain', self.domain.name,
-            '--description', self.group.description,
-            self.group.name,
-        ]
-        verifylist = [
-            ('domain', self.domain.name),
-            ('description', self.group.description),
-            ('name', self.group.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-        self.groups_mock.create.assert_called_once_with(
-            name=self.group.name,
-            domain=self.domain.id,
-            description=self.group.description,
-        )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
-
-    def test_group_create_or_show(self):
-        self.groups_mock.create.side_effect = ks_exc.Conflict()
-        arglist = [
-            '--or-show',
-            self.group.name,
-        ]
-        verifylist = [
-            ('or_show', True),
-            ('name', self.group.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-        self.groups_mock.get.assert_called_once_with(self.group.name)
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
-
-
-class TestGroupDelete(TestGroup):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-    groups = identity_fakes.FakeGroup.create_groups(
-        attrs={'domain_id': domain.id}, count=2)
-
-    def setUp(self):
-        super(TestGroupDelete, self).setUp()
-
-        self.groups_mock.get = (
-            identity_fakes.FakeGroup.get_groups(self.groups))
-        self.groups_mock.delete.return_value = None
-        self.domains_mock.get.return_value = self.domain
-
-        self.cmd = group.DeleteGroup(self.app, None)
-
-    def test_group_delete(self):
-        arglist = [
-            self.groups[0].id,
-        ]
-        verifylist = [
-            ('groups', [self.groups[0].id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-        self.groups_mock.get.assert_called_once_with(self.groups[0].id)
-        self.groups_mock.delete.assert_called_once_with(self.groups[0].id)
-        self.assertIsNone(result)
-
-    def test_group_multi_delete(self):
-        arglist = []
-        verifylist = []
-
-        for g in self.groups:
-            arglist.append(g.id)
-        verifylist = [
-            ('groups', arglist),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        calls = []
-        for g in self.groups:
-            calls.append(call(g.id))
-        self.groups_mock.delete.assert_has_calls(calls)
-        self.assertIsNone(result)
-
-    def test_group_delete_with_domain(self):
-        get_mock_result = [exceptions.CommandError, self.groups[0]]
-        self.groups_mock.get = (
-            mock.MagicMock(side_effect=get_mock_result))
-
-        arglist = [
-            '--domain', self.domain.id,
-            self.groups[0].id,
-        ]
-        verifylist = [
-            ('domain', self.groups[0].domain_id),
-            ('groups', [self.groups[0].id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-        self.groups_mock.get.assert_any_call(
-            self.groups[0].id, domain_id=self.domain.id)
-        self.groups_mock.delete.assert_called_once_with(self.groups[0].id)
-        self.assertIsNone(result)
-
-
-class TestGroupList(TestGroup):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-    group = identity_fakes.FakeGroup.create_one_group()
-    user = identity_fakes.FakeUser.create_one_user()
-
-    columns = (
-        'ID',
-        'Name',
-    )
-    datalist = (
-        (
-            group.id,
-            group.name,
-        ),
-    )
-
-    def setUp(self):
-        super(TestGroupList, self).setUp()
-
-        self.groups_mock.get.return_value = self.group
-        self.groups_mock.list.return_value = [self.group]
-
-        self.domains_mock.get.return_value = self.domain
-
-        self.users_mock.get.return_value = self.user
-
-        # Get the command object to test
-        self.cmd = group.ListGroup(self.app, None)
-
-    def test_group_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': None,
-            'user': None,
-        }
-
-        self.groups_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_group_list_domain(self):
-        arglist = [
-            '--domain', self.domain.id,
-        ]
-        verifylist = [
-            ('domain', self.domain.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': self.domain.id,
-            'user': None,
-        }
-
-        self.groups_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_group_list_user(self):
-        arglist = [
-            '--user', self.user.name,
-        ]
-        verifylist = [
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': None,
-            'user': self.user.id,
-        }
-
-        self.groups_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_group_list_long(self):
-        arglist = [
-            '--long',
-        ]
-        verifylist = [
-            ('long', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': None,
-            'user': None,
-        }
-
-        self.groups_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        columns = self.columns + (
-            'Domain ID',
-            'Description',
-        )
-        datalist = ((
-            self.group.id,
-            self.group.name,
-            self.group.domain_id,
-            self.group.description,
-        ), )
-        self.assertEqual(columns, columns)
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestGroupRemoveUser(TestGroup):
-
-    group = identity_fakes.FakeGroup.create_one_group()
-    user = identity_fakes.FakeUser.create_one_user()
-
-    def setUp(self):
-        super(TestGroupRemoveUser, self).setUp()
-
-        self.groups_mock.get.return_value = self.group
-        self.users_mock.get.return_value = self.user
-        self.users_mock.remove_from_group.return_value = None
-
-        self.cmd = group.RemoveUserFromGroup(self.app, None)
-
-    def test_group_remove_user(self):
-        arglist = [
-            self.group.id,
-            self.user.id,
-        ]
-        verifylist = [
-            ('group', self.group.id),
-            ('user', self.user.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-        self.users_mock.remove_from_group.assert_called_once_with(
-            self.user.id, self.group.id)
-        self.assertIsNone(result)
-
-
-class TestGroupSet(TestGroup):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-    group = identity_fakes.FakeGroup.create_one_group(
-        attrs={'domain_id': domain.id})
-
-    def setUp(self):
-        super(TestGroupSet, self).setUp()
-
-        self.groups_mock.get.return_value = self.group
-        self.domains_mock.get.return_value = self.domain
-        self.groups_mock.update.return_value = None
-
-        self.cmd = group.SetGroup(self.app, None)
-
-    def test_group_set_nothing(self):
-        arglist = [
-            self.group.id,
-        ]
-        verifylist = [
-            ('group', self.group.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-        self.groups_mock.update.assert_called_once_with(self.group.id)
-        self.assertIsNone(result)
-
-    def test_group_set_name_and_description(self):
-        arglist = [
-            '--name', 'new_name',
-            '--description', 'new_description',
-            self.group.id,
-        ]
-        verifylist = [
-            ('name', 'new_name'),
-            ('description', 'new_description'),
-            ('group', self.group.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-        kwargs = {
-            'name': 'new_name',
-            'description': 'new_description',
-        }
-        self.groups_mock.update.assert_called_once_with(
-            self.group.id, **kwargs)
-        self.assertIsNone(result)
-
-    def test_group_set_with_domain(self):
-        get_mock_result = [exceptions.CommandError, self.group]
-        self.groups_mock.get = (
-            mock.MagicMock(side_effect=get_mock_result))
-
-        arglist = [
-            '--domain', self.domain.id,
-            self.group.id,
-        ]
-        verifylist = [
-            ('domain', self.domain.id),
-            ('group', self.group.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-        self.groups_mock.get.assert_any_call(
-            self.group.id, domain_id=self.domain.id)
-        self.groups_mock.update.assert_called_once_with(self.group.id)
-        self.assertIsNone(result)
-
-
-class TestGroupShow(TestGroup):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-
-    columns = (
-        'description',
-        'domain_id',
-        'id',
-        'name',
-    )
-
-    def setUp(self):
-        super(TestGroupShow, self).setUp()
-        self.group = identity_fakes.FakeGroup.create_one_group(
-            attrs={'domain_id': self.domain.id})
-        self.data = (
-            self.group.description,
-            self.group.domain_id,
-            self.group.id,
-            self.group.name,
-        )
-
-        self.groups_mock.get.return_value = self.group
-        self.domains_mock.get.return_value = self.domain
-
-        self.cmd = group.ShowGroup(self.app, None)
-
-    def test_group_show(self):
-        arglist = [
-            self.group.id,
-        ]
-        verifylist = [
-            ('group', self.group.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-        self.groups_mock.get.assert_called_once_with(self.group.id)
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
-
-    def test_group_show_with_domain(self):
-        get_mock_result = [exceptions.CommandError, self.group]
-        self.groups_mock.get = (
-            mock.MagicMock(side_effect=get_mock_result))
-
-        arglist = [
-            '--domain', self.domain.id,
-            self.group.id,
-        ]
-        verifylist = [
-            ('domain', self.domain.id),
-            ('group', self.group.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-        self.groups_mock.get.assert_any_call(
-            self.group.id, domain_id=self.domain.id)
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
diff --git a/openstackclient/tests/identity/v3/test_identity_provider.py b/openstackclient/tests/identity/v3/test_identity_provider.py
deleted file mode 100644
index d86ac11e..00000000
--- a/openstackclient/tests/identity/v3/test_identity_provider.py
+++ /dev/null
@@ -1,593 +0,0 @@
-#   Copyright 2014 CERN.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-
-import copy
-import mock
-
-from openstackclient.identity.v3 import identity_provider
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestIdentityProvider(identity_fakes.TestFederatedIdentity):
-
-    def setUp(self):
-        super(TestIdentityProvider, self).setUp()
-
-        federation_lib = self.app.client_manager.identity.federation
-        self.identity_providers_mock = federation_lib.identity_providers
-        self.identity_providers_mock.reset_mock()
-
-
-class TestIdentityProviderCreate(TestIdentityProvider):
-
-    columns = (
-        'description',
-        'enabled',
-        'id',
-        'remote_ids',
-    )
-    datalist = (
-        identity_fakes.idp_description,
-        True,
-        identity_fakes.idp_id,
-        identity_fakes.formatted_idp_remote_ids,
-    )
-
-    def setUp(self):
-        super(TestIdentityProviderCreate, self).setUp()
-
-        copied_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER)
-        resource = fakes.FakeResource(None, copied_idp, loaded=True)
-        self.identity_providers_mock.create.return_value = resource
-        self.cmd = identity_provider.CreateIdentityProvider(self.app, None)
-
-    def test_create_identity_provider_no_options(self):
-        arglist = [
-            identity_fakes.idp_id,
-        ]
-        verifylist = [
-            ('identity_provider_id', identity_fakes.idp_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'remote_ids': None,
-            'enabled': True,
-            'description': None,
-        }
-
-        self.identity_providers_mock.create.assert_called_with(
-            id=identity_fakes.idp_id,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_create_identity_provider_description(self):
-        arglist = [
-            '--description', identity_fakes.idp_description,
-            identity_fakes.idp_id,
-        ]
-        verifylist = [
-            ('identity_provider_id', identity_fakes.idp_id),
-            ('description', identity_fakes.idp_description),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'remote_ids': None,
-            'description': identity_fakes.idp_description,
-            'enabled': True,
-        }
-
-        self.identity_providers_mock.create.assert_called_with(
-            id=identity_fakes.idp_id,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_create_identity_provider_remote_id(self):
-        arglist = [
-            identity_fakes.idp_id,
-            '--remote-id', identity_fakes.idp_remote_ids[0]
-        ]
-        verifylist = [
-            ('identity_provider_id', identity_fakes.idp_id),
-            ('remote_id', identity_fakes.idp_remote_ids[:1]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'remote_ids': identity_fakes.idp_remote_ids[:1],
-            'description': None,
-            'enabled': True,
-        }
-
-        self.identity_providers_mock.create.assert_called_with(
-            id=identity_fakes.idp_id,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_create_identity_provider_remote_ids_multiple(self):
-        arglist = [
-            '--remote-id', identity_fakes.idp_remote_ids[0],
-            '--remote-id', identity_fakes.idp_remote_ids[1],
-            identity_fakes.idp_id
-        ]
-        verifylist = [
-            ('identity_provider_id', identity_fakes.idp_id),
-            ('remote_id', identity_fakes.idp_remote_ids),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'remote_ids': identity_fakes.idp_remote_ids,
-            'description': None,
-            'enabled': True,
-        }
-
-        self.identity_providers_mock.create.assert_called_with(
-            id=identity_fakes.idp_id,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_create_identity_provider_remote_ids_file(self):
-        arglist = [
-            '--remote-id-file', '/tmp/file_name',
-            identity_fakes.idp_id,
-        ]
-        verifylist = [
-            ('identity_provider_id', identity_fakes.idp_id),
-            ('remote_id_file', '/tmp/file_name'),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        mocker = mock.Mock()
-        mocker.return_value = "\n".join(identity_fakes.idp_remote_ids)
-        with mock.patch("openstackclient.identity.v3.identity_provider."
-                        "utils.read_blob_file_contents", mocker):
-            columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'remote_ids': identity_fakes.idp_remote_ids,
-            'description': None,
-            'enabled': True,
-        }
-
-        self.identity_providers_mock.create.assert_called_with(
-            id=identity_fakes.idp_id,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_create_identity_provider_disabled(self):
-
-        # Prepare FakeResource object
-        IDENTITY_PROVIDER = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER)
-        IDENTITY_PROVIDER['enabled'] = False
-        IDENTITY_PROVIDER['description'] = None
-
-        resource = fakes.FakeResource(None, IDENTITY_PROVIDER, loaded=True)
-        self.identity_providers_mock.create.return_value = resource
-
-        arglist = [
-            '--disable',
-            identity_fakes.idp_id,
-        ]
-        verifylist = [
-            ('identity_provider_id', identity_fakes.idp_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'remote_ids': None,
-            'enabled': False,
-            'description': None,
-        }
-
-        self.identity_providers_mock.create.assert_called_with(
-            id=identity_fakes.idp_id,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            None,
-            False,
-            identity_fakes.idp_id,
-            identity_fakes.formatted_idp_remote_ids
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestIdentityProviderDelete(TestIdentityProvider):
-
-    def setUp(self):
-        super(TestIdentityProviderDelete, self).setUp()
-
-        # This is the return value for utils.find_resource()
-        self.identity_providers_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.IDENTITY_PROVIDER),
-            loaded=True,
-        )
-
-        self.identity_providers_mock.delete.return_value = None
-        self.cmd = identity_provider.DeleteIdentityProvider(self.app, None)
-
-    def test_delete_identity_provider(self):
-        arglist = [
-            identity_fakes.idp_id,
-        ]
-        verifylist = [
-            ('identity_provider', [identity_fakes.idp_id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.identity_providers_mock.delete.assert_called_with(
-            identity_fakes.idp_id,
-        )
-        self.assertIsNone(result)
-
-
-class TestIdentityProviderList(TestIdentityProvider):
-
-    def setUp(self):
-        super(TestIdentityProviderList, self).setUp()
-
-        self.identity_providers_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.IDENTITY_PROVIDER),
-            loaded=True,
-        )
-        self.identity_providers_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.IDENTITY_PROVIDER),
-                loaded=True,
-            ),
-        ]
-
-        # Get the command object to test
-        self.cmd = identity_provider.ListIdentityProvider(self.app, None)
-
-    def test_identity_provider_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.identity_providers_mock.list.assert_called_with()
-
-        collist = ('ID', 'Enabled', 'Description')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            identity_fakes.idp_id,
-            True,
-            identity_fakes.idp_description,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestIdentityProviderSet(TestIdentityProvider):
-
-    columns = (
-        'description',
-        'enabled',
-        'id',
-        'remote_ids',
-    )
-    datalist = (
-        identity_fakes.idp_description,
-        True,
-        identity_fakes.idp_id,
-        identity_fakes.idp_remote_ids,
-    )
-
-    def setUp(self):
-        super(TestIdentityProviderSet, self).setUp()
-        self.cmd = identity_provider.SetIdentityProvider(self.app, None)
-
-    def test_identity_provider_set_description(self):
-        """Set Identity Provider's description. """
-
-        def prepare(self):
-            """Prepare fake return objects before the test is executed"""
-            updated_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER)
-            updated_idp['enabled'] = False
-            resources = fakes.FakeResource(
-                None,
-                updated_idp,
-                loaded=True
-            )
-            self.identity_providers_mock.update.return_value = resources
-
-        prepare(self)
-        new_description = 'new desc'
-        arglist = [
-            '--description', new_description,
-            identity_fakes.idp_id
-        ]
-        verifylist = [
-            ('identity_provider', identity_fakes.idp_id),
-            ('description', new_description),
-            ('enable', False),
-            ('disable', False),
-            ('remote_id', None)
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        self.cmd.take_action(parsed_args)
-        self.identity_providers_mock.update.assert_called_with(
-            identity_fakes.idp_id,
-            description=new_description,
-        )
-
-    def test_identity_provider_disable(self):
-        """Disable Identity Provider
-
-        Set Identity Provider's ``enabled`` attribute to False.
-        """
-
-        def prepare(self):
-            """Prepare fake return objects before the test is executed"""
-            updated_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER)
-            updated_idp['enabled'] = False
-            resources = fakes.FakeResource(
-                None,
-                updated_idp,
-                loaded=True
-            )
-            self.identity_providers_mock.update.return_value = resources
-
-        prepare(self)
-        arglist = [
-            '--disable', identity_fakes.idp_id,
-            '--remote-id', identity_fakes.idp_remote_ids[0],
-            '--remote-id', identity_fakes.idp_remote_ids[1]
-        ]
-        verifylist = [
-            ('identity_provider', identity_fakes.idp_id),
-            ('description', None),
-            ('enable', False),
-            ('disable', True),
-            ('remote_id', identity_fakes.idp_remote_ids)
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.cmd.take_action(parsed_args)
-        self.identity_providers_mock.update.assert_called_with(
-            identity_fakes.idp_id,
-            enabled=False,
-            remote_ids=identity_fakes.idp_remote_ids
-        )
-
-    def test_identity_provider_enable(self):
-        """Enable Identity Provider.
-
-        Set Identity Provider's ``enabled`` attribute to True.
-        """
-
-        def prepare(self):
-            """Prepare fake return objects before the test is executed"""
-            resources = fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.IDENTITY_PROVIDER),
-                loaded=True
-            )
-            self.identity_providers_mock.update.return_value = resources
-
-        prepare(self)
-        arglist = [
-            '--enable', identity_fakes.idp_id,
-            '--remote-id', identity_fakes.idp_remote_ids[0],
-            '--remote-id', identity_fakes.idp_remote_ids[1]
-        ]
-        verifylist = [
-            ('identity_provider', identity_fakes.idp_id),
-            ('description', None),
-            ('enable', True),
-            ('disable', False),
-            ('remote_id', identity_fakes.idp_remote_ids)
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.cmd.take_action(parsed_args)
-        self.identity_providers_mock.update.assert_called_with(
-            identity_fakes.idp_id, enabled=True,
-            remote_ids=identity_fakes.idp_remote_ids)
-
-    def test_identity_provider_replace_remote_ids(self):
-        """Enable Identity Provider.
-
-        Set Identity Provider's ``enabled`` attribute to True.
-        """
-
-        def prepare(self):
-            """Prepare fake return objects before the test is executed"""
-            self.new_remote_id = 'new_entity'
-
-            updated_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER)
-            updated_idp['remote_ids'] = [self.new_remote_id]
-            resources = fakes.FakeResource(
-                None,
-                updated_idp,
-                loaded=True
-            )
-            self.identity_providers_mock.update.return_value = resources
-
-        prepare(self)
-        arglist = [
-            '--enable', identity_fakes.idp_id,
-            '--remote-id', self.new_remote_id
-        ]
-        verifylist = [
-            ('identity_provider', identity_fakes.idp_id),
-            ('description', None),
-            ('enable', True),
-            ('disable', False),
-            ('remote_id', [self.new_remote_id])
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.cmd.take_action(parsed_args)
-        self.identity_providers_mock.update.assert_called_with(
-            identity_fakes.idp_id, enabled=True,
-            remote_ids=[self.new_remote_id])
-
-    def test_identity_provider_replace_remote_ids_file(self):
-        """Enable Identity Provider.
-
-        Set Identity Provider's ``enabled`` attribute to True.
-        """
-
-        def prepare(self):
-            """Prepare fake return objects before the test is executed"""
-            self.new_remote_id = 'new_entity'
-
-            updated_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER)
-            updated_idp['remote_ids'] = [self.new_remote_id]
-            resources = fakes.FakeResource(
-                None,
-                updated_idp,
-                loaded=True
-            )
-            self.identity_providers_mock.update.return_value = resources
-
-        prepare(self)
-        arglist = [
-            '--enable', identity_fakes.idp_id,
-            '--remote-id-file', self.new_remote_id,
-        ]
-        verifylist = [
-            ('identity_provider', identity_fakes.idp_id),
-            ('description', None),
-            ('enable', True),
-            ('disable', False),
-            ('remote_id_file', self.new_remote_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        mocker = mock.Mock()
-        mocker.return_value = self.new_remote_id
-        with mock.patch("openstackclient.identity.v3.identity_provider."
-                        "utils.read_blob_file_contents", mocker):
-            self.cmd.take_action(parsed_args)
-        self.identity_providers_mock.update.assert_called_with(
-            identity_fakes.idp_id, enabled=True,
-            remote_ids=[self.new_remote_id])
-
-    def test_identity_provider_no_options(self):
-        def prepare(self):
-            """Prepare fake return objects before the test is executed"""
-            resources = fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.IDENTITY_PROVIDER),
-                loaded=True
-            )
-            self.identity_providers_mock.get.return_value = resources
-
-            resources = fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.IDENTITY_PROVIDER),
-                loaded=True,
-            )
-            self.identity_providers_mock.update.return_value = resources
-
-        prepare(self)
-        arglist = [
-            identity_fakes.idp_id,
-        ]
-        verifylist = [
-            ('identity_provider', identity_fakes.idp_id),
-            ('enable', False),
-            ('disable', False),
-            ('remote_id', None)
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.cmd.take_action(parsed_args)
-
-
-class TestIdentityProviderShow(TestIdentityProvider):
-
-    def setUp(self):
-        super(TestIdentityProviderShow, self).setUp()
-
-        ret = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.IDENTITY_PROVIDER),
-            loaded=True,
-        )
-
-        self.identity_providers_mock.get.side_effect = [Exception("Not found"),
-                                                        ret]
-        self.identity_providers_mock.get.return_value = ret
-
-        # Get the command object to test
-        self.cmd = identity_provider.ShowIdentityProvider(self.app, None)
-
-    def test_identity_provider_show(self):
-        arglist = [
-            identity_fakes.idp_id,
-        ]
-        verifylist = [
-            ('identity_provider', identity_fakes.idp_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.identity_providers_mock.get.assert_called_with(
-            identity_fakes.idp_id,
-            id='test_idp'
-        )
-
-        collist = ('description', 'enabled', 'id', 'remote_ids')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.idp_description,
-            True,
-            identity_fakes.idp_id,
-            identity_fakes.formatted_idp_remote_ids
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/test_mappings.py b/openstackclient/tests/identity/v3/test_mappings.py
deleted file mode 100644
index 09a383eb..00000000
--- a/openstackclient/tests/identity/v3/test_mappings.py
+++ /dev/null
@@ -1,244 +0,0 @@
-#   Copyright 2014 CERN.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-
-import copy
-import mock
-
-from osc_lib import exceptions
-
-from openstackclient.identity.v3 import mapping
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestMapping(identity_fakes.TestFederatedIdentity):
-
-    def setUp(self):
-        super(TestMapping, self).setUp()
-
-        federation_lib = self.app.client_manager.identity.federation
-        self.mapping_mock = federation_lib.mappings
-        self.mapping_mock.reset_mock()
-
-
-class TestMappingCreate(TestMapping):
-
-    def setUp(self):
-        super(TestMappingCreate, self).setUp()
-        self.mapping_mock.create.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.MAPPING_RESPONSE),
-            loaded=True
-        )
-        self.cmd = mapping.CreateMapping(self.app, None)
-
-    def test_create_mapping(self):
-        arglist = [
-            '--rules', identity_fakes.mapping_rules_file_path,
-            identity_fakes.mapping_id
-        ]
-        verifylist = [
-            ('mapping', identity_fakes.mapping_id),
-            ('rules', identity_fakes.mapping_rules_file_path)
-        ]
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        mocker = mock.Mock()
-        mocker.return_value = identity_fakes.MAPPING_RULES
-        with mock.patch("openstackclient.identity.v3.mapping."
-                        "CreateMapping._read_rules", mocker):
-            columns, data = self.cmd.take_action(parsed_args)
-
-        self.mapping_mock.create.assert_called_with(
-            mapping_id=identity_fakes.mapping_id,
-            rules=identity_fakes.MAPPING_RULES)
-
-        collist = ('id', 'rules')
-        self.assertEqual(collist, columns)
-
-        datalist = (identity_fakes.mapping_id,
-                    identity_fakes.MAPPING_RULES)
-        self.assertEqual(datalist, data)
-
-
-class TestMappingDelete(TestMapping):
-
-    def setUp(self):
-        super(TestMappingDelete, self).setUp()
-        self.mapping_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.MAPPING_RESPONSE),
-            loaded=True)
-
-        self.mapping_mock.delete.return_value = None
-        self.cmd = mapping.DeleteMapping(self.app, None)
-
-    def test_delete_mapping(self):
-        arglist = [
-            identity_fakes.mapping_id
-        ]
-        verifylist = [
-            ('mapping', [identity_fakes.mapping_id])
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.mapping_mock.delete.assert_called_with(
-            identity_fakes.mapping_id)
-        self.assertIsNone(result)
-
-
-class TestMappingList(TestMapping):
-
-    def setUp(self):
-        super(TestMappingList, self).setUp()
-        self.mapping_mock.get.return_value = fakes.FakeResource(
-            None,
-            {'id': identity_fakes.mapping_id},
-            loaded=True)
-        # Pretend list command returns list of two mappings.
-        # NOTE(marek-denis): We are returning FakeResources with mapping id
-        # only as ShowMapping class is implemented in a way where rules will
-        # not be displayed, only mapping ids.
-        self.mapping_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                {'id': identity_fakes.mapping_id},
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                {'id': 'extra_mapping'},
-                loaded=True,
-            ),
-        ]
-
-        # Get the command object to test
-        self.cmd = mapping.ListMapping(self.app, None)
-
-    def test_mapping_list(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.mapping_mock.list.assert_called_with()
-
-        collist = ('ID',)
-        self.assertEqual(collist, columns)
-
-        datalist = [(identity_fakes.mapping_id,), ('extra_mapping',)]
-        self.assertEqual(datalist, data)
-
-
-class TestMappingSet(TestMapping):
-
-    def setUp(self):
-        super(TestMappingSet, self).setUp()
-
-        self.mapping_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.MAPPING_RESPONSE),
-            loaded=True
-        )
-
-        self.mapping_mock.update.return_value = fakes.FakeResource(
-            None,
-            identity_fakes.MAPPING_RESPONSE_2,
-            loaded=True
-        )
-
-        # Get the command object to test
-        self.cmd = mapping.SetMapping(self.app, None)
-
-    def test_set_new_rules(self):
-        arglist = [
-            '--rules', identity_fakes.mapping_rules_file_path,
-            identity_fakes.mapping_id
-        ]
-        verifylist = [
-            ('mapping', identity_fakes.mapping_id),
-            ('rules', identity_fakes.mapping_rules_file_path)
-        ]
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        mocker = mock.Mock()
-        mocker.return_value = identity_fakes.MAPPING_RULES_2
-        with mock.patch("openstackclient.identity.v3.mapping."
-                        "SetMapping._read_rules", mocker):
-            columns, data = self.cmd.take_action(parsed_args)
-        self.mapping_mock.update.assert_called_with(
-            mapping=identity_fakes.mapping_id,
-            rules=identity_fakes.MAPPING_RULES_2)
-
-        collist = ('id', 'rules')
-        self.assertEqual(collist, columns)
-        datalist = (identity_fakes.mapping_id,
-                    identity_fakes.MAPPING_RULES_2)
-        self.assertEqual(datalist, data)
-
-    def test_set_rules_wrong_file_path(self):
-        arglist = [
-            '--rules', identity_fakes.mapping_rules_file_path,
-            identity_fakes.mapping_id
-        ]
-        verifylist = [
-            ('mapping', identity_fakes.mapping_id),
-            ('rules', identity_fakes.mapping_rules_file_path)
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args)
-
-
-class TestMappingShow(TestMapping):
-
-    def setUp(self):
-        super(TestMappingShow, self).setUp()
-
-        self.mapping_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.MAPPING_RESPONSE),
-            loaded=True
-        )
-
-        self.cmd = mapping.ShowMapping(self.app, None)
-
-    def test_mapping_show(self):
-        arglist = [
-            identity_fakes.mapping_id
-        ]
-        verifylist = [
-            ('mapping', identity_fakes.mapping_id)
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.mapping_mock.get.assert_called_with(
-            identity_fakes.mapping_id)
-
-        collist = ('id', 'rules')
-        self.assertEqual(collist, columns)
-
-        datalist = (identity_fakes.mapping_id,
-                    identity_fakes.MAPPING_RULES)
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/test_oauth.py b/openstackclient/tests/identity/v3/test_oauth.py
deleted file mode 100644
index d3cf3655..00000000
--- a/openstackclient/tests/identity/v3/test_oauth.py
+++ /dev/null
@@ -1,173 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-
-import copy
-
-from openstackclient.identity.v3 import token
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestOAuth1(identity_fakes.TestOAuth1):
-
-    def setUp(self):
-        super(TestOAuth1, self).setUp()
-        identity_client = self.app.client_manager.identity
-        self.access_tokens_mock = identity_client.oauth1.access_tokens
-        self.access_tokens_mock.reset_mock()
-        self.request_tokens_mock = identity_client.oauth1.request_tokens
-        self.request_tokens_mock.reset_mock()
-        self.projects_mock = identity_client.projects
-        self.projects_mock.reset_mock()
-        self.roles_mock = identity_client.roles
-        self.roles_mock.reset_mock()
-
-
-class TestAccessTokenCreate(TestOAuth1):
-
-    def setUp(self):
-        super(TestAccessTokenCreate, self).setUp()
-
-        self.access_tokens_mock.create.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.OAUTH_ACCESS_TOKEN),
-            loaded=True,
-        )
-
-        self.cmd = token.CreateAccessToken(self.app, None)
-
-    def test_create_access_tokens(self):
-        arglist = [
-            '--consumer-key', identity_fakes.consumer_id,
-            '--consumer-secret', identity_fakes.consumer_secret,
-            '--request-key', identity_fakes.request_token_id,
-            '--request-secret', identity_fakes.request_token_secret,
-            '--verifier', identity_fakes.oauth_verifier_pin,
-        ]
-        verifylist = [
-            ('consumer_key', identity_fakes.consumer_id),
-            ('consumer_secret', identity_fakes.consumer_secret),
-            ('request_key', identity_fakes.request_token_id),
-            ('request_secret', identity_fakes.request_token_secret),
-            ('verifier', identity_fakes.oauth_verifier_pin),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.access_tokens_mock.create.assert_called_with(
-            identity_fakes.consumer_id,
-            identity_fakes.consumer_secret,
-            identity_fakes.request_token_id,
-            identity_fakes.request_token_secret,
-            identity_fakes.oauth_verifier_pin,
-        )
-
-        collist = ('expires', 'id', 'key', 'secret')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.access_token_expires,
-            identity_fakes.access_token_id,
-            identity_fakes.access_token_id,
-            identity_fakes.access_token_secret,
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestRequestTokenAuthorize(TestOAuth1):
-
-    def setUp(self):
-        super(TestRequestTokenAuthorize, self).setUp()
-
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE),
-            loaded=True,
-        )
-
-        copied_verifier = copy.deepcopy(identity_fakes.OAUTH_VERIFIER)
-        resource = fakes.FakeResource(None, copied_verifier, loaded=True)
-        self.request_tokens_mock.authorize.return_value = resource
-        self.cmd = token.AuthorizeRequestToken(self.app, None)
-
-    def test_authorize_request_tokens(self):
-        arglist = [
-            '--request-key', identity_fakes.request_token_id,
-            '--role', identity_fakes.role_name,
-        ]
-        verifylist = [
-            ('request_key', identity_fakes.request_token_id),
-            ('role', [identity_fakes.role_name]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.request_tokens_mock.authorize.assert_called_with(
-            identity_fakes.request_token_id,
-            [identity_fakes.role_id],
-        )
-
-        collist = ('oauth_verifier',)
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.oauth_verifier_pin,
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestRequestTokenCreate(TestOAuth1):
-
-    def setUp(self):
-        super(TestRequestTokenCreate, self).setUp()
-
-        self.request_tokens_mock.create.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.OAUTH_REQUEST_TOKEN),
-            loaded=True,
-        )
-
-        self.projects_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.PROJECT),
-            loaded=True,
-        )
-
-        self.cmd = token.CreateRequestToken(self.app, None)
-
-    def test_create_request_tokens(self):
-        arglist = [
-            '--consumer-key', identity_fakes.consumer_id,
-            '--consumer-secret', identity_fakes.consumer_secret,
-            '--project', identity_fakes.project_id,
-        ]
-        verifylist = [
-            ('consumer_key', identity_fakes.consumer_id),
-            ('consumer_secret', identity_fakes.consumer_secret),
-            ('project', identity_fakes.project_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.request_tokens_mock.create.assert_called_with(
-            identity_fakes.consumer_id,
-            identity_fakes.consumer_secret,
-            identity_fakes.project_id,
-        )
-
-        collist = ('expires', 'id', 'key', 'secret')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.request_token_expires,
-            identity_fakes.request_token_id,
-            identity_fakes.request_token_id,
-            identity_fakes.request_token_secret,
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/test_project.py b/openstackclient/tests/identity/v3/test_project.py
deleted file mode 100644
index 65874baa..00000000
--- a/openstackclient/tests/identity/v3/test_project.py
+++ /dev/null
@@ -1,978 +0,0 @@
-#   Copyright 2013 Nebula Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import mock
-
-from osc_lib import exceptions
-
-from openstackclient.identity.v3 import project
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestProject(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestProject, self).setUp()
-
-        # Get a shortcut to the DomainManager Mock
-        self.domains_mock = self.app.client_manager.identity.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.reset_mock()
-
-
-class TestProjectCreate(TestProject):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-
-    columns = (
-        'description',
-        'domain_id',
-        'enabled',
-        'id',
-        'is_domain',
-        'name',
-        'parent_id',
-    )
-
-    def setUp(self):
-        super(TestProjectCreate, self).setUp()
-
-        self.project = identity_fakes.FakeProject.create_one_project(
-            attrs={'domain_id': self.domain.id})
-        self.domains_mock.get.return_value = self.domain
-        self.projects_mock.create.return_value = self.project
-        self.datalist = (
-            self.project.description,
-            self.project.domain_id,
-            True,
-            self.project.id,
-            False,
-            self.project.name,
-            self.project.parent_id,
-        )
-        # Get the command object to test
-        self.cmd = project.CreateProject(self.app, None)
-
-    def test_project_create_no_options(self):
-        arglist = [
-            self.project.name,
-        ]
-        verifylist = [
-            ('parent', None),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.project.name,
-            'domain': None,
-            'description': None,
-            'enabled': True,
-            'parent': None,
-        }
-        # ProjectManager.create(name=, domain=, description=,
-        #                       enabled=, **kwargs)
-        self.projects_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        collist = (
-            'description',
-            'domain_id',
-            'enabled',
-            'id',
-            'is_domain',
-            'name',
-            'parent_id',
-        )
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.project.description,
-            self.project.domain_id,
-            True,
-            self.project.id,
-            False,
-            self.project.name,
-            self.project.parent_id,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_project_create_description(self):
-        arglist = [
-            '--description', 'new desc',
-            self.project.name,
-        ]
-        verifylist = [
-            ('description', 'new desc'),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.project.name),
-            ('parent', None),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.project.name,
-            'domain': None,
-            'description': 'new desc',
-            'enabled': True,
-            'parent': None,
-        }
-        # ProjectManager.create(name=, domain=, description=,
-        #                       enabled=, **kwargs)
-        self.projects_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_domain(self):
-        arglist = [
-            '--domain', self.project.domain_id,
-            self.project.name,
-        ]
-        verifylist = [
-            ('domain', self.project.domain_id),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.project.name),
-            ('parent', None),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.project.name,
-            'domain': self.project.domain_id,
-            'description': None,
-            'enabled': True,
-            'parent': None,
-        }
-        # ProjectManager.create(name=, domain=, description=,
-        #                       enabled=, **kwargs)
-        self.projects_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_domain_no_perms(self):
-        arglist = [
-            '--domain', self.project.domain_id,
-            self.project.name,
-        ]
-        verifylist = [
-            ('domain', self.project.domain_id),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.project.name),
-            ('parent', None),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        mocker = mock.Mock()
-        mocker.return_value = None
-
-        with mock.patch("osc_lib.utils.find_resource", mocker):
-            columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.project.name,
-            'domain': self.project.domain_id,
-            'description': None,
-            'enabled': True,
-            'parent': None,
-        }
-        self.projects_mock.create.assert_called_with(
-            **kwargs
-        )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_enable(self):
-        arglist = [
-            '--enable',
-            self.project.name,
-        ]
-        verifylist = [
-            ('enable', True),
-            ('disable', False),
-            ('name', self.project.name),
-            ('parent', None),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.project.name,
-            'domain': None,
-            'description': None,
-            'enabled': True,
-            'parent': None,
-        }
-        # ProjectManager.create(name=, domain=, description=,
-        #                       enabled=, **kwargs)
-        self.projects_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_disable(self):
-        arglist = [
-            '--disable',
-            self.project.name,
-        ]
-        verifylist = [
-            ('enable', False),
-            ('disable', True),
-            ('name', self.project.name),
-            ('parent', None),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.project.name,
-            'domain': None,
-            'description': None,
-            'enabled': False,
-            'parent': None,
-        }
-        # ProjectManager.create(name=, domain=,
-        #                       description=, enabled=, **kwargs)
-        self.projects_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_property(self):
-        arglist = [
-            '--property', 'fee=fi',
-            '--property', 'fo=fum',
-            self.project.name,
-        ]
-        verifylist = [
-            ('property', {'fee': 'fi', 'fo': 'fum'}),
-            ('name', self.project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.project.name,
-            'domain': None,
-            'description': None,
-            'enabled': True,
-            'parent': None,
-            'fee': 'fi',
-            'fo': 'fum',
-        }
-        # ProjectManager.create(name=, domain=, description=,
-        #                       enabled=, **kwargs)
-        self.projects_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_project_create_parent(self):
-        self.parent = identity_fakes.FakeProject.create_one_project()
-        self.project = identity_fakes.FakeProject.create_one_project(
-            attrs={'domain_id': self.domain.id, 'parent_id': self.parent.id})
-        self.projects_mock.get.return_value = self.parent
-        self.projects_mock.create.return_value = self.project
-
-        arglist = [
-            '--domain', self.project.domain_id,
-            '--parent', self.parent.name,
-            self.project.name,
-        ]
-        verifylist = [
-            ('domain', self.project.domain_id),
-            ('parent', self.parent.name),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-
-        kwargs = {
-            'name': self.project.name,
-            'domain': self.project.domain_id,
-            'parent': self.parent.id,
-            'description': None,
-            'enabled': True,
-        }
-
-        self.projects_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        collist = (
-            'description',
-            'domain_id',
-            'enabled',
-            'id',
-            'is_domain',
-            'name',
-            'parent_id',
-        )
-        self.assertEqual(columns, collist)
-        datalist = (
-            self.project.description,
-            self.project.domain_id,
-            self.project.enabled,
-            self.project.id,
-            self.project.is_domain,
-            self.project.name,
-            self.parent.id,
-        )
-        self.assertEqual(data, datalist)
-
-    def test_project_create_invalid_parent(self):
-        self.projects_mock.resource_class.__name__ = 'Project'
-        self.projects_mock.get.side_effect = exceptions.NotFound(
-            'Invalid parent')
-        self.projects_mock.find.side_effect = exceptions.NotFound(
-            'Invalid parent')
-
-        arglist = [
-            '--domain', self.project.domain_id,
-            '--parent', 'invalid',
-            self.project.name,
-        ]
-        verifylist = [
-            ('domain', self.project.domain_id),
-            ('parent', 'invalid'),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args,
-        )
-
-
-class TestProjectDelete(TestProject):
-
-    project = identity_fakes.FakeProject.create_one_project()
-
-    def setUp(self):
-        super(TestProjectDelete, self).setUp()
-
-        # This is the return value for utils.find_resource()
-        self.projects_mock.get.return_value = self.project
-        self.projects_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = project.DeleteProject(self.app, None)
-
-    def test_project_delete_no_options(self):
-        arglist = [
-            self.project.id,
-        ]
-        verifylist = [
-            ('projects', [self.project.id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.projects_mock.delete.assert_called_with(
-            self.project.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestProjectList(TestProject):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-    project = identity_fakes.FakeProject.create_one_project(
-        attrs={'domain_id': domain.id})
-
-    columns = (
-        'ID',
-        'Name',
-    )
-    datalist = (
-        (
-            project.id,
-            project.name,
-        ),
-    )
-
-    def setUp(self):
-        super(TestProjectList, self).setUp()
-
-        self.projects_mock.list.return_value = [self.project]
-
-        # Get the command object to test
-        self.cmd = project.ListProject(self.app, None)
-
-    def test_project_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.projects_mock.list.assert_called_with()
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_project_list_long(self):
-        arglist = [
-            '--long',
-        ]
-        verifylist = [
-            ('long', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.projects_mock.list.assert_called_with()
-
-        collist = ('ID', 'Name', 'Domain ID', 'Description', 'Enabled')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.project.id,
-            self.project.name,
-            self.project.domain_id,
-            self.project.description,
-            True,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_project_list_domain(self):
-        arglist = [
-            '--domain', self.project.domain_id,
-        ]
-        verifylist = [
-            ('domain', self.project.domain_id),
-        ]
-
-        self.domains_mock.get.return_value = self.domain
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.projects_mock.list.assert_called_with(
-            domain=self.project.domain_id)
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_project_list_domain_no_perms(self):
-        arglist = [
-            '--domain', self.project.domain_id,
-        ]
-        verifylist = [
-            ('domain', self.project.domain_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        mocker = mock.Mock()
-        mocker.return_value = None
-
-        with mock.patch("osc_lib.utils.find_resource", mocker):
-            columns, data = self.cmd.take_action(parsed_args)
-
-        self.projects_mock.list.assert_called_with(
-            domain=self.project.domain_id)
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-
-class TestProjectSet(TestProject):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-    project = identity_fakes.FakeProject.create_one_project(
-        attrs={'domain_id': domain.id})
-
-    def setUp(self):
-        super(TestProjectSet, self).setUp()
-
-        self.domains_mock.get.return_value = self.domain
-
-        self.projects_mock.get.return_value = self.project
-        self.projects_mock.update.return_value = self.project
-
-        # Get the command object to test
-        self.cmd = project.SetProject(self.app, None)
-
-    def test_project_set_no_options(self):
-        arglist = [
-            self.project.name,
-        ]
-        verifylist = [
-            ('project', self.project.name),
-            ('enable', False),
-            ('disable', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.assertIsNone(result)
-
-    def test_project_set_name(self):
-        arglist = [
-            '--name', 'qwerty',
-            '--domain', self.project.domain_id,
-            self.project.name,
-        ]
-        verifylist = [
-            ('name', 'qwerty'),
-            ('domain', self.project.domain_id),
-            ('enable', False),
-            ('disable', False),
-            ('project', self.project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': 'qwerty',
-        }
-        # ProjectManager.update(project, name=, domain=, description=,
-        #                       enabled=, **kwargs)
-        self.projects_mock.update.assert_called_with(
-            self.project.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_project_set_description(self):
-        arglist = [
-            '--domain', self.project.domain_id,
-            '--description', 'new desc',
-            self.project.name,
-        ]
-        verifylist = [
-            ('domain', self.project.domain_id),
-            ('description', 'new desc'),
-            ('enable', False),
-            ('disable', False),
-            ('project', self.project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': 'new desc',
-        }
-        self.projects_mock.update.assert_called_with(
-            self.project.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_project_set_enable(self):
-        arglist = [
-            '--domain', self.project.domain_id,
-            '--enable',
-            self.project.name,
-        ]
-        verifylist = [
-            ('domain', self.project.domain_id),
-            ('enable', True),
-            ('disable', False),
-            ('project', self.project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-        }
-        self.projects_mock.update.assert_called_with(
-            self.project.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_project_set_disable(self):
-        arglist = [
-            '--domain', self.project.domain_id,
-            '--disable',
-            self.project.name,
-        ]
-        verifylist = [
-            ('domain', self.project.domain_id),
-            ('enable', False),
-            ('disable', True),
-            ('project', self.project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': False,
-        }
-        self.projects_mock.update.assert_called_with(
-            self.project.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_project_set_property(self):
-        arglist = [
-            '--domain', self.project.domain_id,
-            '--property', 'fee=fi',
-            '--property', 'fo=fum',
-            self.project.name,
-        ]
-        verifylist = [
-            ('domain', self.project.domain_id),
-            ('property', {'fee': 'fi', 'fo': 'fum'}),
-            ('project', self.project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'fee': 'fi',
-            'fo': 'fum',
-        }
-        self.projects_mock.update.assert_called_with(
-            self.project.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestProjectShow(TestProject):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-
-    def setUp(self):
-        super(TestProjectShow, self).setUp()
-
-        self.project = identity_fakes.FakeProject.create_one_project(
-            attrs={'domain_id': self.domain.id})
-
-        # Get the command object to test
-        self.cmd = project.ShowProject(self.app, None)
-
-    def test_project_show(self):
-
-        self.projects_mock.get.side_effect = [Exception("Not found"),
-                                              self.project]
-        self.projects_mock.get.return_value = self.project
-
-        arglist = [
-            self.project.id,
-        ]
-        verifylist = [
-            ('project', self.project.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.app.client_manager.identity.tokens.get_token_data.return_value = \
-            {'token':
-             {'project':
-              {'domain': {},
-               'name': parsed_args.project,
-               'id': parsed_args.project
-               }
-              }
-             }
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.projects_mock.get.assert_called_with(
-            self.project.id,
-            parents_as_list=False,
-            subtree_as_list=False,
-        )
-
-        collist = (
-            'description',
-            'domain_id',
-            'enabled',
-            'id',
-            'is_domain',
-            'name',
-            'parent_id',
-        )
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.project.description,
-            self.project.domain_id,
-            True,
-            self.project.id,
-            False,
-            self.project.name,
-            self.project.parent_id,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_project_show_parents(self):
-        self.project = identity_fakes.FakeProject.create_one_project(
-            attrs={
-                'parent_id': self.project.parent_id,
-                'parents': [{'project': {'id': self.project.parent_id}}]
-            }
-        )
-        self.projects_mock.get.side_effect = [Exception("Not found"),
-                                              self.project]
-        self.projects_mock.get.return_value = self.project
-
-        arglist = [
-            self.project.id,
-            '--parents',
-        ]
-        verifylist = [
-            ('project', self.project.id),
-            ('parents', True),
-            ('children', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        self.app.client_manager.identity.tokens.get_token_data.return_value = \
-            {'token':
-             {'project':
-              {'domain': {},
-               'name': parsed_args.project,
-               'id': parsed_args.project
-               }
-              }
-             }
-
-        columns, data = self.cmd.take_action(parsed_args)
-        self.projects_mock.get.assert_called_with(
-            self.project.id,
-            parents_as_list=True,
-            subtree_as_list=False,
-        )
-
-        collist = (
-            'description',
-            'domain_id',
-            'enabled',
-            'id',
-            'is_domain',
-            'name',
-            'parent_id',
-            'parents',
-        )
-        self.assertEqual(columns, collist)
-        datalist = (
-            self.project.description,
-            self.project.domain_id,
-            self.project.enabled,
-            self.project.id,
-            self.project.is_domain,
-            self.project.name,
-            self.project.parent_id,
-            [self.project.parent_id],
-        )
-        self.assertEqual(data, datalist)
-
-    def test_project_show_subtree(self):
-        self.project = identity_fakes.FakeProject.create_one_project(
-            attrs={
-                'parent_id': self.project.parent_id,
-                'subtree': [{'project': {'id': 'children-id'}}]
-            }
-        )
-        self.projects_mock.get.side_effect = [Exception("Not found"),
-                                              self.project]
-        self.projects_mock.get.return_value = self.project
-
-        arglist = [
-            self.project.id,
-            '--children',
-        ]
-        verifylist = [
-            ('project', self.project.id),
-            ('parents', False),
-            ('children', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        self.app.client_manager.identity.tokens.get_token_data.return_value = \
-            {'token':
-             {'project':
-              {'domain': {},
-               'name': parsed_args.project,
-               'id': parsed_args.project
-               }
-              }
-             }
-
-        columns, data = self.cmd.take_action(parsed_args)
-        self.projects_mock.get.assert_called_with(
-            self.project.id,
-            parents_as_list=False,
-            subtree_as_list=True,
-        )
-
-        collist = (
-            'description',
-            'domain_id',
-            'enabled',
-            'id',
-            'is_domain',
-            'name',
-            'parent_id',
-            'subtree',
-        )
-        self.assertEqual(columns, collist)
-        datalist = (
-            self.project.description,
-            self.project.domain_id,
-            self.project.enabled,
-            self.project.id,
-            self.project.is_domain,
-            self.project.name,
-            self.project.parent_id,
-            ['children-id'],
-        )
-        self.assertEqual(data, datalist)
-
-    def test_project_show_parents_and_children(self):
-        self.project = identity_fakes.FakeProject.create_one_project(
-            attrs={
-                'parent_id': self.project.parent_id,
-                'parents': [{'project': {'id': self.project.parent_id}}],
-                'subtree': [{'project': {'id': 'children-id'}}]
-            }
-        )
-        self.projects_mock.get.side_effect = [Exception("Not found"),
-                                              self.project]
-        self.projects_mock.get.return_value = self.project
-
-        arglist = [
-            self.project.id,
-            '--parents',
-            '--children',
-        ]
-        verifylist = [
-            ('project', self.project.id),
-            ('parents', True),
-            ('children', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        self.app.client_manager.identity.tokens.get_token_data.return_value = \
-            {'token':
-             {'project':
-              {'domain': {},
-               'name': parsed_args.project,
-               'id': parsed_args.project
-               }
-              }
-             }
-
-        columns, data = self.cmd.take_action(parsed_args)
-        self.projects_mock.get.assert_called_with(
-            self.project.id,
-            parents_as_list=True,
-            subtree_as_list=True,
-        )
-
-        collist = (
-            'description',
-            'domain_id',
-            'enabled',
-            'id',
-            'is_domain',
-            'name',
-            'parent_id',
-            'parents',
-            'subtree',
-        )
-        self.assertEqual(columns, collist)
-        datalist = (
-            self.project.description,
-            self.project.domain_id,
-            self.project.enabled,
-            self.project.id,
-            self.project.is_domain,
-            self.project.name,
-            self.project.parent_id,
-            [self.project.parent_id],
-            ['children-id'],
-        )
-        self.assertEqual(data, datalist)
diff --git a/openstackclient/tests/identity/v3/test_protocol.py b/openstackclient/tests/identity/v3/test_protocol.py
deleted file mode 100644
index f718b27b..00000000
--- a/openstackclient/tests/identity/v3/test_protocol.py
+++ /dev/null
@@ -1,188 +0,0 @@
-#   Copyright 2014 CERN.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-
-import copy
-
-from openstackclient.identity.v3 import federation_protocol
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestProtocol(identity_fakes.TestFederatedIdentity):
-
-    def setUp(self):
-        super(TestProtocol, self).setUp()
-
-        federation_lib = self.app.client_manager.identity.federation
-        self.protocols_mock = federation_lib.protocols
-        self.protocols_mock.reset_mock()
-
-
-class TestProtocolCreate(TestProtocol):
-
-    def setUp(self):
-        super(TestProtocolCreate, self).setUp()
-
-        proto = copy.deepcopy(identity_fakes.PROTOCOL_OUTPUT)
-        resource = fakes.FakeResource(None, proto, loaded=True)
-        self.protocols_mock.create.return_value = resource
-        self.cmd = federation_protocol.CreateProtocol(self.app, None)
-
-    def test_create_protocol(self):
-        argslist = [
-            identity_fakes.protocol_id,
-            '--identity-provider', identity_fakes.idp_id,
-            '--mapping', identity_fakes.mapping_id
-        ]
-
-        verifylist = [
-            ('federation_protocol', identity_fakes.protocol_id),
-            ('identity_provider', identity_fakes.idp_id),
-            ('mapping', identity_fakes.mapping_id)
-        ]
-        parsed_args = self.check_parser(self.cmd, argslist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-        self.protocols_mock.create.assert_called_with(
-            protocol_id=identity_fakes.protocol_id,
-            identity_provider=identity_fakes.idp_id,
-            mapping=identity_fakes.mapping_id)
-
-        collist = ('id', 'identity_provider', 'mapping')
-        self.assertEqual(collist, columns)
-
-        datalist = (identity_fakes.protocol_id,
-                    identity_fakes.idp_id,
-                    identity_fakes.mapping_id)
-        self.assertEqual(datalist, data)
-
-
-class TestProtocolDelete(TestProtocol):
-
-    def setUp(self):
-        super(TestProtocolDelete, self).setUp()
-
-        # This is the return value for utils.find_resource()
-        self.protocols_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.PROTOCOL_OUTPUT),
-            loaded=True,
-        )
-
-        self.protocols_mock.delete.return_value = None
-        self.cmd = federation_protocol.DeleteProtocol(self.app, None)
-
-    def test_delete_identity_provider(self):
-        arglist = [
-            '--identity-provider', identity_fakes.idp_id,
-            identity_fakes.protocol_id
-        ]
-        verifylist = [
-            ('federation_protocol', [identity_fakes.protocol_id]),
-            ('identity_provider', identity_fakes.idp_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.protocols_mock.delete.assert_called_with(
-            identity_fakes.idp_id, identity_fakes.protocol_id)
-        self.assertIsNone(result)
-
-
-class TestProtocolList(TestProtocol):
-
-    def setUp(self):
-        super(TestProtocolList, self).setUp()
-
-        self.protocols_mock.get.return_value = fakes.FakeResource(
-            None, identity_fakes.PROTOCOL_ID_MAPPING, loaded=True)
-
-        self.protocols_mock.list.return_value = [fakes.FakeResource(
-            None, identity_fakes.PROTOCOL_ID_MAPPING, loaded=True)]
-
-        self.cmd = federation_protocol.ListProtocols(self.app, None)
-
-    def test_list_protocols(self):
-        arglist = ['--identity-provider', identity_fakes.idp_id]
-        verifylist = [('identity_provider', identity_fakes.idp_id)]
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.protocols_mock.list.assert_called_with(identity_fakes.idp_id)
-
-
-class TestProtocolSet(TestProtocol):
-
-    def setUp(self):
-        super(TestProtocolSet, self).setUp()
-        self.protocols_mock.get.return_value = fakes.FakeResource(
-            None, identity_fakes.PROTOCOL_OUTPUT, loaded=True)
-        self.protocols_mock.update.return_value = fakes.FakeResource(
-            None, identity_fakes.PROTOCOL_OUTPUT_UPDATED, loaded=True)
-
-        self.cmd = federation_protocol.SetProtocol(self.app, None)
-
-    def test_set_new_mapping(self):
-        arglist = [
-            identity_fakes.protocol_id,
-            '--identity-provider', identity_fakes.idp_id,
-            '--mapping', identity_fakes.mapping_id
-        ]
-        verifylist = [('identity_provider', identity_fakes.idp_id),
-                      ('federation_protocol', identity_fakes.protocol_id),
-                      ('mapping', identity_fakes.mapping_id)]
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.protocols_mock.update.assert_called_with(
-            identity_fakes.idp_id, identity_fakes.protocol_id,
-            identity_fakes.mapping_id)
-
-        collist = ('id', 'identity_provider', 'mapping')
-        self.assertEqual(collist, columns)
-
-        datalist = (identity_fakes.protocol_id, identity_fakes.idp_id,
-                    identity_fakes.mapping_id_updated)
-        self.assertEqual(datalist, data)
-
-
-class TestProtocolShow(TestProtocol):
-
-    def setUp(self):
-        super(TestProtocolShow, self).setUp()
-        self.protocols_mock.get.return_value = fakes.FakeResource(
-            None, identity_fakes.PROTOCOL_OUTPUT, loaded=False)
-
-        self.cmd = federation_protocol.ShowProtocol(self.app, None)
-
-    def test_show_protocol(self):
-        arglist = [identity_fakes.protocol_id, '--identity-provider',
-                   identity_fakes.idp_id]
-        verifylist = [('federation_protocol', identity_fakes.protocol_id),
-                      ('identity_provider', identity_fakes.idp_id)]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-        self.protocols_mock.get.assert_called_with(identity_fakes.idp_id,
-                                                   identity_fakes.protocol_id)
-
-        collist = ('id', 'identity_provider', 'mapping')
-        self.assertEqual(collist, columns)
-
-        datalist = (identity_fakes.protocol_id,
-                    identity_fakes.idp_id,
-                    identity_fakes.mapping_id)
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/test_region.py b/openstackclient/tests/identity/v3/test_region.py
deleted file mode 100644
index 41ee5ce9..00000000
--- a/openstackclient/tests/identity/v3/test_region.py
+++ /dev/null
@@ -1,348 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import copy
-
-from openstackclient.identity.v3 import region
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestRegion(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestRegion, self).setUp()
-
-        # Get a shortcut to the RegionManager Mock
-        self.regions_mock = self.app.client_manager.identity.regions
-        self.regions_mock.reset_mock()
-
-
-class TestRegionCreate(TestRegion):
-
-    columns = (
-        'description',
-        'parent_region',
-        'region',
-    )
-    datalist = (
-        identity_fakes.region_description,
-        identity_fakes.region_parent_region_id,
-        identity_fakes.region_id,
-    )
-
-    def setUp(self):
-        super(TestRegionCreate, self).setUp()
-
-        self.regions_mock.create.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.REGION),
-            loaded=True,
-        )
-
-        # Get the command object to test
-        self.cmd = region.CreateRegion(self.app, None)
-
-    def test_region_create_description(self):
-        arglist = [
-            identity_fakes.region_id,
-            '--description', identity_fakes.region_description,
-        ]
-        verifylist = [
-            ('region', identity_fakes.region_id),
-            ('description', identity_fakes.region_description)
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': identity_fakes.region_description,
-            'id': identity_fakes.region_id,
-            'parent_region': None,
-        }
-        self.regions_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_region_create_no_options(self):
-        arglist = [
-            identity_fakes.region_id,
-        ]
-        verifylist = [
-            ('region', identity_fakes.region_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': None,
-            'id': identity_fakes.region_id,
-            'parent_region': None,
-        }
-        self.regions_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_region_create_parent_region_id(self):
-        arglist = [
-            identity_fakes.region_id,
-            '--parent-region', identity_fakes.region_parent_region_id,
-        ]
-        verifylist = [
-            ('region', identity_fakes.region_id),
-            ('parent_region', identity_fakes.region_parent_region_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': None,
-            'id': identity_fakes.region_id,
-            'parent_region': identity_fakes.region_parent_region_id,
-        }
-        self.regions_mock.create.assert_called_with(
-            **kwargs
-        )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-
-class TestRegionDelete(TestRegion):
-
-    def setUp(self):
-        super(TestRegionDelete, self).setUp()
-
-        self.regions_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = region.DeleteRegion(self.app, None)
-
-    def test_region_delete_no_options(self):
-        arglist = [
-            identity_fakes.region_id,
-        ]
-        verifylist = [
-            ('region', [identity_fakes.region_id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.regions_mock.delete.assert_called_with(
-            identity_fakes.region_id,
-        )
-        self.assertIsNone(result)
-
-
-class TestRegionList(TestRegion):
-
-    columns = (
-        'Region',
-        'Parent Region',
-        'Description',
-    )
-    datalist = (
-        (
-            identity_fakes.region_id,
-            identity_fakes.region_parent_region_id,
-            identity_fakes.region_description,
-        ),
-    )
-
-    def setUp(self):
-        super(TestRegionList, self).setUp()
-
-        self.regions_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.REGION),
-                loaded=True,
-            ),
-        ]
-
-        # Get the command object to test
-        self.cmd = region.ListRegion(self.app, None)
-
-    def test_region_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.regions_mock.list.assert_called_with()
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_region_list_parent_region_id(self):
-        arglist = [
-            '--parent-region', identity_fakes.region_parent_region_id,
-        ]
-        verifylist = [
-            ('parent_region', identity_fakes.region_parent_region_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.regions_mock.list.assert_called_with(
-            parent_region_id=identity_fakes.region_parent_region_id)
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-
-class TestRegionSet(TestRegion):
-
-    def setUp(self):
-        super(TestRegionSet, self).setUp()
-
-        self.regions_mock.update.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.REGION),
-            loaded=True,
-        )
-
-        # Get the command object to test
-        self.cmd = region.SetRegion(self.app, None)
-
-    def test_region_set_no_options(self):
-        arglist = [
-            identity_fakes.region_id,
-        ]
-        verifylist = [
-            ('region', identity_fakes.region_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        kwargs = {}
-        self.regions_mock.update.assert_called_with(
-            identity_fakes.region_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_region_set_description(self):
-        arglist = [
-            '--description', 'qwerty',
-            identity_fakes.region_id,
-        ]
-        verifylist = [
-            ('description', 'qwerty'),
-            ('region', identity_fakes.region_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': 'qwerty',
-        }
-        self.regions_mock.update.assert_called_with(
-            identity_fakes.region_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_region_set_parent_region_id(self):
-        arglist = [
-            '--parent-region', 'new_parent',
-            identity_fakes.region_id,
-        ]
-        verifylist = [
-            ('parent_region', 'new_parent'),
-            ('region', identity_fakes.region_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'parent_region': 'new_parent',
-        }
-        self.regions_mock.update.assert_called_with(
-            identity_fakes.region_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestRegionShow(TestRegion):
-
-    def setUp(self):
-        super(TestRegionShow, self).setUp()
-
-        self.regions_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.REGION),
-            loaded=True,
-        )
-
-        # Get the command object to test
-        self.cmd = region.ShowRegion(self.app, None)
-
-    def test_region_show(self):
-        arglist = [
-            identity_fakes.region_id,
-        ]
-        verifylist = [
-            ('region', identity_fakes.region_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-        self.regions_mock.get.assert_called_with(
-            identity_fakes.region_id,
-        )
-
-        collist = ('description', 'parent_region', 'region')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.region_description,
-            identity_fakes.region_parent_region_id,
-            identity_fakes.region_id,
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/test_role.py b/openstackclient/tests/identity/v3/test_role.py
deleted file mode 100644
index b4e76d96..00000000
--- a/openstackclient/tests/identity/v3/test_role.py
+++ /dev/null
@@ -1,1105 +0,0 @@
-#   Copyright 2013 Nebula Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import copy
-
-from openstackclient.identity.v3 import role
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestRole(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestRole, self).setUp()
-
-        # Get a shortcut to the UserManager Mock
-        self.users_mock = self.app.client_manager.identity.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.reset_mock()
-
-        # Get a shortcut to the DomainManager Mock
-        self.domains_mock = self.app.client_manager.identity.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.reset_mock()
-
-        # Get a shortcut to the RoleManager Mock
-        self.roles_mock = self.app.client_manager.identity.roles
-        self.roles_mock.reset_mock()
-
-    def _is_inheritance_testcase(self):
-        return False
-
-
-class TestRoleInherited(TestRole):
-
-    def _is_inheritance_testcase(self):
-        return True
-
-
-class TestRoleAdd(TestRole):
-
-    def setUp(self):
-        super(TestRoleAdd, self).setUp()
-
-        self.users_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.USER),
-            loaded=True,
-        )
-
-        self.groups_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.GROUP),
-            loaded=True,
-        )
-
-        self.domains_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.DOMAIN),
-            loaded=True,
-        )
-
-        self.projects_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.PROJECT),
-            loaded=True,
-        )
-
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE),
-            loaded=True,
-        )
-        self.roles_mock.grant.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE),
-            loaded=True,
-        )
-
-        # Get the command object to test
-        self.cmd = role.AddRole(self.app, None)
-
-    def test_role_add_user_domain(self):
-        arglist = [
-            '--user', identity_fakes.user_name,
-            '--domain', identity_fakes.domain_name,
-            identity_fakes.role_name,
-        ]
-        if self._is_inheritance_testcase():
-            arglist.append('--inherited')
-        verifylist = [
-            ('user', identity_fakes.user_name),
-            ('group', None),
-            ('domain', identity_fakes.domain_name),
-            ('project', None),
-            ('role', identity_fakes.role_name),
-            ('inherited', self._is_inheritance_testcase()),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'user': identity_fakes.user_id,
-            'domain': identity_fakes.domain_id,
-            'os_inherit_extension_inherited': self._is_inheritance_testcase(),
-        }
-        # RoleManager.grant(role, user=, group=, domain=, project=)
-        self.roles_mock.grant.assert_called_with(
-            identity_fakes.role_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_role_add_user_project(self):
-        arglist = [
-            '--user', identity_fakes.user_name,
-            '--project', identity_fakes.project_name,
-            identity_fakes.role_name,
-        ]
-        if self._is_inheritance_testcase():
-            arglist.append('--inherited')
-        verifylist = [
-            ('user', identity_fakes.user_name),
-            ('group', None),
-            ('domain', None),
-            ('project', identity_fakes.project_name),
-            ('role', identity_fakes.role_name),
-            ('inherited', self._is_inheritance_testcase()),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'user': identity_fakes.user_id,
-            'project': identity_fakes.project_id,
-            'os_inherit_extension_inherited': self._is_inheritance_testcase(),
-        }
-        # RoleManager.grant(role, user=, group=, domain=, project=)
-        self.roles_mock.grant.assert_called_with(
-            identity_fakes.role_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_role_add_group_domain(self):
-        arglist = [
-            '--group', identity_fakes.group_name,
-            '--domain', identity_fakes.domain_name,
-            identity_fakes.role_name,
-        ]
-        if self._is_inheritance_testcase():
-            arglist.append('--inherited')
-        verifylist = [
-            ('user', None),
-            ('group', identity_fakes.group_name),
-            ('domain', identity_fakes.domain_name),
-            ('project', None),
-            ('role', identity_fakes.role_name),
-            ('inherited', self._is_inheritance_testcase()),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'group': identity_fakes.group_id,
-            'domain': identity_fakes.domain_id,
-            'os_inherit_extension_inherited': self._is_inheritance_testcase(),
-        }
-        # RoleManager.grant(role, user=, group=, domain=, project=)
-        self.roles_mock.grant.assert_called_with(
-            identity_fakes.role_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_role_add_group_project(self):
-        arglist = [
-            '--group', identity_fakes.group_name,
-            '--project', identity_fakes.project_name,
-            identity_fakes.role_name,
-        ]
-        if self._is_inheritance_testcase():
-            arglist.append('--inherited')
-        verifylist = [
-            ('user', None),
-            ('group', identity_fakes.group_name),
-            ('domain', None),
-            ('project', identity_fakes.project_name),
-            ('role', identity_fakes.role_name),
-            ('inherited', self._is_inheritance_testcase()),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'group': identity_fakes.group_id,
-            'project': identity_fakes.project_id,
-            'os_inherit_extension_inherited': self._is_inheritance_testcase(),
-        }
-        # RoleManager.grant(role, user=, group=, domain=, project=)
-        self.roles_mock.grant.assert_called_with(
-            identity_fakes.role_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_role_add_domain_role_on_user_project(self):
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE_2),
-            loaded=True,
-        )
-        arglist = [
-            '--user', identity_fakes.user_name,
-            '--project', identity_fakes.project_name,
-            '--role-domain', identity_fakes.domain_name,
-            identity_fakes.ROLE_2['name'],
-        ]
-        if self._is_inheritance_testcase():
-            arglist.append('--inherited')
-        verifylist = [
-            ('user', identity_fakes.user_name),
-            ('group', None),
-            ('domain', None),
-            ('project', identity_fakes.project_name),
-            ('role', identity_fakes.ROLE_2['name']),
-            ('inherited', self._is_inheritance_testcase()),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'user': identity_fakes.user_id,
-            'project': identity_fakes.project_id,
-            'os_inherit_extension_inherited': self._is_inheritance_testcase(),
-        }
-        # RoleManager.grant(role, user=, group=, domain=, project=)
-        self.roles_mock.grant.assert_called_with(
-            identity_fakes.ROLE_2['id'],
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestRoleAddInherited(TestRoleAdd, TestRoleInherited):
-    pass
-
-
-class TestRoleCreate(TestRole):
-
-    def setUp(self):
-        super(TestRoleCreate, self).setUp()
-
-        self.domains_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.DOMAIN),
-            loaded=True,
-        )
-
-        self.roles_mock.create.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE),
-            loaded=True,
-        )
-
-        # Get the command object to test
-        self.cmd = role.CreateRole(self.app, None)
-
-    def test_role_create_no_options(self):
-        arglist = [
-            identity_fakes.role_name,
-        ]
-        verifylist = [
-            ('name', identity_fakes.role_name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': None,
-            'name': identity_fakes.role_name,
-        }
-
-        # RoleManager.create(name=, domain=)
-        self.roles_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        collist = ('domain', 'id', 'name')
-        self.assertEqual(collist, columns)
-        datalist = (
-            None,
-            identity_fakes.role_id,
-            identity_fakes.role_name,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_role_create_with_domain(self):
-
-        self.roles_mock.create.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE_2),
-            loaded=True,
-        )
-
-        arglist = [
-            '--domain', identity_fakes.domain_name,
-            identity_fakes.ROLE_2['name'],
-        ]
-        verifylist = [
-            ('domain', identity_fakes.domain_name),
-            ('name', identity_fakes.ROLE_2['name']),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': identity_fakes.domain_id,
-            'name': identity_fakes.ROLE_2['name'],
-        }
-
-        # RoleManager.create(name=, domain=)
-        self.roles_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        collist = ('domain', 'id', 'name')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.domain_id,
-            identity_fakes.ROLE_2['id'],
-            identity_fakes.ROLE_2['name'],
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestRoleDelete(TestRole):
-
-    def setUp(self):
-        super(TestRoleDelete, self).setUp()
-
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE),
-            loaded=True,
-        )
-        self.roles_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = role.DeleteRole(self.app, None)
-
-    def test_role_delete_no_options(self):
-        arglist = [
-            identity_fakes.role_name,
-        ]
-        verifylist = [
-            ('roles', [identity_fakes.role_name]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.delete.assert_called_with(
-            identity_fakes.role_id,
-        )
-        self.assertIsNone(result)
-
-    def test_role_delete_with_domain(self):
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE_2),
-            loaded=True,
-        )
-        self.roles_mock.delete.return_value = None
-
-        arglist = [
-            '--domain', identity_fakes.domain_name,
-            identity_fakes.ROLE_2['name'],
-        ]
-        verifylist = [
-            ('roles', [identity_fakes.ROLE_2['name']]),
-            ('domain', identity_fakes.domain_name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.delete.assert_called_with(
-            identity_fakes.ROLE_2['id'],
-        )
-        self.assertIsNone(result)
-
-
-class TestRoleList(TestRole):
-
-    columns = (
-        'ID',
-        'Name',
-    )
-    datalist = (
-        (
-            identity_fakes.role_id,
-            identity_fakes.role_name,
-        ),
-    )
-
-    def setUp(self):
-        super(TestRoleList, self).setUp()
-
-        self.roles_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.ROLE),
-                loaded=True,
-            ),
-        ]
-
-        self.domains_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.DOMAIN),
-            loaded=True,
-        )
-        self.projects_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.PROJECT),
-            loaded=True,
-        )
-        self.users_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.USER),
-            loaded=True,
-        )
-        self.groups_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.GROUP),
-            loaded=True,
-        )
-
-        # Get the command object to test
-        self.cmd = role.ListRole(self.app, None)
-
-    def test_role_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.roles_mock.list.assert_called_with()
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_user_list_inherited(self):
-        arglist = [
-            '--user', identity_fakes.user_id,
-            '--inherited',
-        ]
-        verifylist = [
-            ('user', identity_fakes.user_id),
-            ('inherited', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': 'default',
-            'user': self.users_mock.get(),
-            'os_inherit_extension_inherited': True,
-        }
-        # RoleManager.list(user=, group=, domain=, project=, **kwargs)
-        self.roles_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_user_list_user(self):
-        arglist = [
-            '--user', identity_fakes.user_id,
-        ]
-        verifylist = [
-            ('user', identity_fakes.user_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': 'default',
-            'user': self.users_mock.get(),
-            'os_inherit_extension_inherited': False
-        }
-        # RoleManager.list(user=, group=, domain=, project=, **kwargs)
-        self.roles_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_role_list_domain_user(self):
-        arglist = [
-            '--domain', identity_fakes.domain_name,
-            '--user', identity_fakes.user_id,
-        ]
-        verifylist = [
-            ('domain', identity_fakes.domain_name),
-            ('user', identity_fakes.user_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': self.domains_mock.get(),
-            'user': self.users_mock.get(),
-            'os_inherit_extension_inherited': False
-        }
-        # RoleManager.list(user=, group=, domain=, project=, **kwargs)
-        self.roles_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        collist = ('ID', 'Name', 'Domain', 'User')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.role_name,
-            identity_fakes.domain_name,
-            identity_fakes.user_name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_list_domain_group(self):
-        arglist = [
-            '--domain', identity_fakes.domain_name,
-            '--group', identity_fakes.group_id,
-        ]
-        verifylist = [
-            ('domain', identity_fakes.domain_name),
-            ('group', identity_fakes.group_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': self.domains_mock.get(),
-            'group': self.groups_mock.get(),
-            'os_inherit_extension_inherited': False
-        }
-        # RoleManager.list(user=, group=, domain=, project=, **kwargs)
-        self.roles_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        collist = ('ID', 'Name', 'Domain', 'Group')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.role_name,
-            identity_fakes.domain_name,
-            identity_fakes.group_name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_list_project_user(self):
-        arglist = [
-            '--project', identity_fakes.project_name,
-            '--user', identity_fakes.user_id,
-        ]
-        verifylist = [
-            ('project', identity_fakes.project_name),
-            ('user', identity_fakes.user_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'project': self.projects_mock.get(),
-            'user': self.users_mock.get(),
-            'os_inherit_extension_inherited': False
-        }
-        # RoleManager.list(user=, group=, domain=, project=, **kwargs)
-        self.roles_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        collist = ('ID', 'Name', 'Project', 'User')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.role_name,
-            identity_fakes.project_name,
-            identity_fakes.user_name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_list_project_group(self):
-        arglist = [
-            '--project', identity_fakes.project_name,
-            '--group', identity_fakes.group_id,
-        ]
-        verifylist = [
-            ('project', identity_fakes.project_name),
-            ('group', identity_fakes.group_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'project': self.projects_mock.get(),
-            'group': self.groups_mock.get(),
-            'os_inherit_extension_inherited': False
-        }
-        # RoleManager.list(user=, group=, domain=, project=, **kwargs)
-        self.roles_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        collist = ('ID', 'Name', 'Project', 'Group')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.role_name,
-            identity_fakes.project_name,
-            identity_fakes.group_name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_list_domain_role(self):
-        self.roles_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.ROLE_2),
-                loaded=True,
-            ),
-        ]
-        arglist = [
-            '--domain', identity_fakes.domain_name,
-        ]
-        verifylist = [
-            ('domain', identity_fakes.domain_name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain_id': identity_fakes.domain_id
-        }
-        # RoleManager.list(user=, group=, domain=, project=, **kwargs)
-        self.roles_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        collist = ('ID', 'Name', 'Domain')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            identity_fakes.ROLE_2['id'],
-            identity_fakes.ROLE_2['name'],
-            identity_fakes.domain_name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestRoleRemove(TestRole):
-
-    def setUp(self):
-        super(TestRoleRemove, self).setUp()
-
-        self.users_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.USER),
-            loaded=True,
-        )
-
-        self.groups_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.GROUP),
-            loaded=True,
-        )
-
-        self.domains_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.DOMAIN),
-            loaded=True,
-        )
-
-        self.projects_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.PROJECT),
-            loaded=True,
-        )
-
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE),
-            loaded=True,
-        )
-        self.roles_mock.revoke.return_value = None
-
-        # Get the command object to test
-        self.cmd = role.RemoveRole(self.app, None)
-
-    def test_role_remove_user_domain(self):
-        arglist = [
-            '--user', identity_fakes.user_name,
-            '--domain', identity_fakes.domain_name,
-            identity_fakes.role_name,
-        ]
-        if self._is_inheritance_testcase():
-            arglist.append('--inherited')
-        verifylist = [
-            ('user', identity_fakes.user_name),
-            ('group', None),
-            ('domain', identity_fakes.domain_name),
-            ('project', None),
-            ('role', identity_fakes.role_name),
-            ('inherited', self._is_inheritance_testcase()),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'user': identity_fakes.user_id,
-            'domain': identity_fakes.domain_id,
-            'os_inherit_extension_inherited': self._is_inheritance_testcase(),
-        }
-        # RoleManager.revoke(role, user=, group=, domain=, project=)
-        self.roles_mock.revoke.assert_called_with(
-            identity_fakes.role_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_role_remove_user_project(self):
-        arglist = [
-            '--user', identity_fakes.user_name,
-            '--project', identity_fakes.project_name,
-            identity_fakes.role_name,
-        ]
-        if self._is_inheritance_testcase():
-            arglist.append('--inherited')
-        verifylist = [
-            ('user', identity_fakes.user_name),
-            ('group', None),
-            ('domain', None),
-            ('project', identity_fakes.project_name),
-            ('role', identity_fakes.role_name),
-            ('inherited', self._is_inheritance_testcase()),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'user': identity_fakes.user_id,
-            'project': identity_fakes.project_id,
-            'os_inherit_extension_inherited': self._is_inheritance_testcase(),
-        }
-        # RoleManager.revoke(role, user=, group=, domain=, project=)
-        self.roles_mock.revoke.assert_called_with(
-            identity_fakes.role_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_role_remove_group_domain(self):
-        arglist = [
-            '--group', identity_fakes.group_name,
-            '--domain', identity_fakes.domain_name,
-            identity_fakes.role_name,
-        ]
-        if self._is_inheritance_testcase():
-            arglist.append('--inherited')
-        verifylist = [
-            ('user', None),
-            ('group', identity_fakes.group_name),
-            ('domain', identity_fakes.domain_name),
-            ('project', None),
-            ('role', identity_fakes.role_name),
-            ('role', identity_fakes.role_name),
-            ('inherited', self._is_inheritance_testcase()),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'group': identity_fakes.group_id,
-            'domain': identity_fakes.domain_id,
-            'os_inherit_extension_inherited': self._is_inheritance_testcase(),
-        }
-        # RoleManager.revoke(role, user=, group=, domain=, project=)
-        self.roles_mock.revoke.assert_called_with(
-            identity_fakes.role_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_role_remove_group_project(self):
-        arglist = [
-            '--group', identity_fakes.group_name,
-            '--project', identity_fakes.project_name,
-            identity_fakes.role_name,
-        ]
-        if self._is_inheritance_testcase():
-            arglist.append('--inherited')
-        verifylist = [
-            ('user', None),
-            ('group', identity_fakes.group_name),
-            ('domain', None),
-            ('project', identity_fakes.project_name),
-            ('role', identity_fakes.role_name),
-            ('inherited', self._is_inheritance_testcase()),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'group': identity_fakes.group_id,
-            'project': identity_fakes.project_id,
-            'os_inherit_extension_inherited': self._is_inheritance_testcase(),
-        }
-        # RoleManager.revoke(role, user=, group=, domain=, project=)
-        self.roles_mock.revoke.assert_called_with(
-            identity_fakes.role_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_role_remove_domain_role_on_group_domain(self):
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE_2),
-            loaded=True,
-        )
-        arglist = [
-            '--group', identity_fakes.group_name,
-            '--domain', identity_fakes.domain_name,
-            identity_fakes.ROLE_2['name'],
-        ]
-        if self._is_inheritance_testcase():
-            arglist.append('--inherited')
-        verifylist = [
-            ('user', None),
-            ('group', identity_fakes.group_name),
-            ('domain', identity_fakes.domain_name),
-            ('project', None),
-            ('role', identity_fakes.ROLE_2['name']),
-            ('inherited', self._is_inheritance_testcase()),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'group': identity_fakes.group_id,
-            'domain': identity_fakes.domain_id,
-            'os_inherit_extension_inherited': self._is_inheritance_testcase(),
-        }
-        # RoleManager.revoke(role, user=, group=, domain=, project=)
-        self.roles_mock.revoke.assert_called_with(
-            identity_fakes.ROLE_2['id'],
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestRoleSet(TestRole):
-
-    def setUp(self):
-        super(TestRoleSet, self).setUp()
-
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE),
-            loaded=True,
-        )
-        self.roles_mock.update.return_value = None
-
-        # Get the command object to test
-        self.cmd = role.SetRole(self.app, None)
-
-    def test_role_set_no_options(self):
-        arglist = [
-            '--name', 'over',
-            identity_fakes.role_name,
-        ]
-        verifylist = [
-            ('name', 'over'),
-            ('role', identity_fakes.role_name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': 'over',
-        }
-        # RoleManager.update(role, name=)
-        self.roles_mock.update.assert_called_with(
-            identity_fakes.role_id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_role_set_domain_role(self):
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE_2),
-            loaded=True,
-        )
-        arglist = [
-            '--name', 'over',
-            '--domain', identity_fakes.domain_name,
-            identity_fakes.ROLE_2['name'],
-        ]
-        verifylist = [
-            ('name', 'over'),
-            ('domain', identity_fakes.domain_name),
-            ('role', identity_fakes.ROLE_2['name']),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': 'over',
-        }
-        # RoleManager.update(role, name=)
-        self.roles_mock.update.assert_called_with(
-            identity_fakes.ROLE_2['id'],
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestRoleShow(TestRole):
-
-    def setUp(self):
-        super(TestRoleShow, self).setUp()
-
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE),
-            loaded=True,
-        )
-
-        # Get the command object to test
-        self.cmd = role.ShowRole(self.app, None)
-
-    def test_role_show(self):
-        arglist = [
-            identity_fakes.role_name,
-        ]
-        verifylist = [
-            ('role', identity_fakes.role_name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # RoleManager.get(role)
-        self.roles_mock.get.assert_called_with(
-            identity_fakes.role_name,
-        )
-
-        collist = ('domain', 'id', 'name')
-        self.assertEqual(collist, columns)
-        datalist = (
-            None,
-            identity_fakes.role_id,
-            identity_fakes.role_name,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_role_show_domain_role(self):
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE_2),
-            loaded=True,
-        )
-        arglist = [
-            '--domain', identity_fakes.domain_name,
-            identity_fakes.ROLE_2['name'],
-        ]
-        verifylist = [
-            ('domain', identity_fakes.domain_name),
-            ('role', identity_fakes.ROLE_2['name']),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # RoleManager.get(role). This is called from utils.find_resource().
-        # In fact, the current implementation calls the get(role) first with
-        # just the name, then with the name+domain_id. So technically we should
-        # mock this out with a call list, with the first call returning None
-        # and the second returning the object. However, if we did that we are
-        # then just testing the current sequencing within the utils method, and
-        # would become brittle to changes within that method. Hence we just
-        # check for the first call which is always lookup by name.
-        self.roles_mock.get.assert_called_with(
-            identity_fakes.ROLE_2['name'],
-        )
-
-        collist = ('domain', 'id', 'name')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.domain_id,
-            identity_fakes.ROLE_2['id'],
-            identity_fakes.ROLE_2['name'],
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/test_role_assignment.py b/openstackclient/tests/identity/v3/test_role_assignment.py
deleted file mode 100644
index 113cc493..00000000
--- a/openstackclient/tests/identity/v3/test_role_assignment.py
+++ /dev/null
@@ -1,683 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import copy
-import mock
-
-from openstackclient.identity.v3 import role_assignment
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestRoleAssignment(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestRoleAssignment, self).setUp()
-
-
-class TestRoleAssignmentList(TestRoleAssignment):
-
-    columns = (
-        'Role',
-        'User',
-        'Group',
-        'Project',
-        'Domain',
-        'Inherited',
-    )
-
-    def setUp(self):
-        super(TestRoleAssignment, self).setUp()
-
-        # Get a shortcut to the UserManager Mock
-        self.users_mock = self.app.client_manager.identity.users
-        self.users_mock.reset_mock()
-
-        # Get a shortcut to the GroupManager Mock
-        self.groups_mock = self.app.client_manager.identity.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.reset_mock()
-
-        # Get a shortcut to the ProjectManager Mock
-        self.projects_mock = self.app.client_manager.identity.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.reset_mock()
-
-        self.role_assignments_mock = self.app.client_manager.identity.\
-            role_assignments
-        self.role_assignments_mock.reset_mock()
-
-        # Get the command object to test
-        self.cmd = role_assignment.ListRoleAssignment(self.app, None)
-
-    def test_role_assignment_list_no_filters(self):
-
-        self.role_assignments_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID),
-                loaded=True,
-            ),
-        ]
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.role_assignments_mock.list.assert_called_with(
-            domain=None,
-            group=None,
-            effective=False,
-            role=None,
-            user=None,
-            project=None,
-            os_inherit_extension_inherited_to=None,
-            include_names=False)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.user_id,
-            '',
-            identity_fakes.project_id,
-            '',
-            False
-        ), (identity_fakes.role_id,
-            '',
-            identity_fakes.group_id,
-            identity_fakes.project_id,
-            '',
-            False
-            ),)
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_assignment_list_user(self):
-
-        self.role_assignments_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID),
-                loaded=True,
-            ),
-        ]
-
-        arglist = [
-            '--user', identity_fakes.user_name
-        ]
-        verifylist = [
-            ('user', identity_fakes.user_name),
-            ('group', None),
-            ('domain', None),
-            ('project', None),
-            ('role', None),
-            ('effective', False),
-            ('inherited', False),
-            ('names', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.role_assignments_mock.list.assert_called_with(
-            domain=None,
-            user=self.users_mock.get(),
-            group=None,
-            project=None,
-            role=None,
-            effective=False,
-            os_inherit_extension_inherited_to=None,
-            include_names=False)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.user_id,
-            '',
-            '',
-            identity_fakes.domain_id,
-            False
-        ), (identity_fakes.role_id,
-            identity_fakes.user_id,
-            '',
-            identity_fakes.project_id,
-            '',
-            False
-            ),)
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_assignment_list_group(self):
-
-        self.role_assignments_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_GROUP_ID),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID),
-                loaded=True,
-            ),
-        ]
-
-        arglist = [
-            '--group', identity_fakes.group_name
-        ]
-        verifylist = [
-            ('user', None),
-            ('group', identity_fakes.group_name),
-            ('domain', None),
-            ('project', None),
-            ('role', None),
-            ('effective', False),
-            ('inherited', False),
-            ('names', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.role_assignments_mock.list.assert_called_with(
-            domain=None,
-            group=self.groups_mock.get(),
-            effective=False,
-            project=None,
-            role=None,
-            user=None,
-            os_inherit_extension_inherited_to=None,
-            include_names=False)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            '',
-            identity_fakes.group_id,
-            '',
-            identity_fakes.domain_id,
-            False
-        ), (identity_fakes.role_id,
-            '',
-            identity_fakes.group_id,
-            identity_fakes.project_id,
-            '',
-            False
-            ),)
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_assignment_list_domain(self):
-
-        self.role_assignments_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_GROUP_ID),
-                loaded=True,
-            ),
-        ]
-
-        arglist = [
-            '--domain', identity_fakes.domain_name
-        ]
-        verifylist = [
-            ('user', None),
-            ('group', None),
-            ('domain', identity_fakes.domain_name),
-            ('project', None),
-            ('role', None),
-            ('effective', False),
-            ('inherited', False),
-            ('names', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.role_assignments_mock.list.assert_called_with(
-            domain=self.domains_mock.get(),
-            group=None,
-            effective=False,
-            project=None,
-            role=None,
-            user=None,
-            os_inherit_extension_inherited_to=None,
-            include_names=False)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.user_id,
-            '',
-            '',
-            identity_fakes.domain_id,
-            False
-        ), (identity_fakes.role_id,
-            '',
-            identity_fakes.group_id,
-            '',
-            identity_fakes.domain_id,
-            False
-            ),)
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_assignment_list_project(self):
-
-        self.role_assignments_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID),
-                loaded=True,
-            ),
-        ]
-
-        arglist = [
-            '--project', identity_fakes.project_name
-        ]
-        verifylist = [
-            ('user', None),
-            ('group', None),
-            ('domain', None),
-            ('project', identity_fakes.project_name),
-            ('role', None),
-            ('effective', False),
-            ('inherited', False),
-            ('names', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.role_assignments_mock.list.assert_called_with(
-            domain=None,
-            group=None,
-            effective=False,
-            project=self.projects_mock.get(),
-            role=None,
-            user=None,
-            os_inherit_extension_inherited_to=None,
-            include_names=False)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.user_id,
-            '',
-            identity_fakes.project_id,
-            '',
-            False
-        ), (identity_fakes.role_id,
-            '',
-            identity_fakes.group_id,
-            identity_fakes.project_id,
-            '',
-            False
-            ),)
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_assignment_list_def_creds(self):
-
-        auth_ref = self.app.client_manager.auth_ref = mock.MagicMock()
-        auth_ref.project_id.return_value = identity_fakes.project_id
-        auth_ref.user_id.return_value = identity_fakes.user_id
-
-        self.role_assignments_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID),
-                loaded=True,
-            ),
-        ]
-
-        arglist = [
-            '--auth-user',
-            '--auth-project',
-        ]
-        verifylist = [
-            ('user', None),
-            ('group', None),
-            ('domain', None),
-            ('project', None),
-            ('role', None),
-            ('effective', False),
-            ('inherited', False),
-            ('names', False),
-            ('authuser', True),
-            ('authproject', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.role_assignments_mock.list.assert_called_with(
-            domain=None,
-            user=self.users_mock.get(),
-            group=None,
-            project=self.projects_mock.get(),
-            role=None,
-            effective=False,
-            os_inherit_extension_inherited_to=None,
-            include_names=False)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.user_id,
-            '',
-            identity_fakes.project_id,
-            '',
-            False
-        ),)
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_assignment_list_effective(self):
-
-        self.role_assignments_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID),
-                loaded=True,
-            ),
-        ]
-
-        arglist = ['--effective']
-        verifylist = [
-            ('user', None),
-            ('group', None),
-            ('domain', None),
-            ('project', None),
-            ('role', None),
-            ('effective', True),
-            ('inherited', False),
-            ('names', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.role_assignments_mock.list.assert_called_with(
-            domain=None,
-            group=None,
-            effective=True,
-            project=None,
-            role=None,
-            user=None,
-            os_inherit_extension_inherited_to=None,
-            include_names=False)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.user_id,
-            '',
-            identity_fakes.project_id,
-            '',
-            False
-        ), (identity_fakes.role_id,
-            identity_fakes.user_id,
-            '',
-            '',
-            identity_fakes.domain_id,
-            False
-            ),)
-        self.assertEqual(tuple(data), datalist)
-
-    def test_role_assignment_list_inherited(self):
-
-        self.role_assignments_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    (identity_fakes.
-                        ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INHERITED)),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    (identity_fakes.
-                        ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INHERITED)),
-                loaded=True,
-            ),
-        ]
-
-        arglist = ['--inherited']
-        verifylist = [
-            ('user', None),
-            ('group', None),
-            ('domain', None),
-            ('project', None),
-            ('role', None),
-            ('effective', False),
-            ('inherited', True),
-            ('names', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.role_assignments_mock.list.assert_called_with(
-            domain=None,
-            group=None,
-            effective=False,
-            project=None,
-            role=None,
-            user=None,
-            os_inherit_extension_inherited_to='projects',
-            include_names=False)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.role_id,
-            identity_fakes.user_id,
-            '',
-            identity_fakes.project_id,
-            '',
-            True
-        ), (identity_fakes.role_id,
-            identity_fakes.user_id,
-            '',
-            '',
-            identity_fakes.domain_id,
-            True
-            ),)
-        self.assertEqual(datalist, tuple(data))
-
-    def test_role_assignment_list_include_names(self):
-
-        self.role_assignments_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes
-                    .ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INCLUDE_NAMES),
-                loaded=True,
-            ),
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes
-                    .ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INCLUDE_NAMES),
-                loaded=True,
-            ),
-        ]
-
-        arglist = ['--names']
-        verifylist = [
-            ('user', None),
-            ('group', None),
-            ('domain', None),
-            ('project', None),
-            ('role', None),
-            ('effective', False),
-            ('inherited', False),
-            ('names', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # DisplayCommandBase.take_action() returns two tuples
-
-        # This test will not run correctly until the patch in the python
-        # client is merged. Once that is done 'data' should return the
-        # correct information
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.role_assignments_mock.list.assert_called_with(
-            domain=None,
-            group=None,
-            effective=False,
-            project=None,
-            role=None,
-            user=None,
-            os_inherit_extension_inherited_to=None,
-            include_names=True)
-
-        collist = ('Role', 'User', 'Group', 'Project', 'Domain', 'Inherited')
-        self.assertEqual(columns, collist)
-
-        datalist1 = ((
-            identity_fakes.role_name,
-            '@'.join([identity_fakes.user_name, identity_fakes.domain_name]),
-            '',
-            '@'.join([identity_fakes.project_name,
-                      identity_fakes.domain_name]),
-            '',
-            False
-        ), (identity_fakes.role_name,
-            '@'.join([identity_fakes.user_name, identity_fakes.domain_name]),
-            '',
-            '',
-            identity_fakes.domain_name,
-            False
-            ),)
-        self.assertEqual(tuple(data), datalist1)
-
-    def test_role_assignment_list_domain_role(self):
-
-        self.role_assignments_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(
-                    identity_fakes.ASSIGNMENT_WITH_DOMAIN_ROLE),
-                loaded=True,
-            ),
-        ]
-
-        arglist = [
-            '--role', identity_fakes.ROLE_2['name'],
-            '--role-domain', identity_fakes.domain_name
-        ]
-        verifylist = [
-            ('user', None),
-            ('group', None),
-            ('domain', None),
-            ('project', None),
-            ('role', identity_fakes.ROLE_2['name']),
-            ('effective', False),
-            ('inherited', False),
-            ('names', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.role_assignments_mock.list.assert_called_with(
-            domain=None,
-            user=None,
-            group=None,
-            project=None,
-            role=self.roles_mock.get(),
-            effective=False,
-            os_inherit_extension_inherited_to=None,
-            include_names=False)
-
-        self.assertEqual(self.columns, columns)
-        datalist = ((
-            identity_fakes.ROLE_2['id'],
-            identity_fakes.user_id,
-            '',
-            '',
-            identity_fakes.domain_id,
-            False
-        ),)
-        self.assertEqual(datalist, tuple(data))
diff --git a/openstackclient/tests/identity/v3/test_service.py b/openstackclient/tests/identity/v3/test_service.py
deleted file mode 100644
index 76c66aa5..00000000
--- a/openstackclient/tests/identity/v3/test_service.py
+++ /dev/null
@@ -1,504 +0,0 @@
-#   Copyright 2013 Nebula Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-from keystoneclient import exceptions as identity_exc
-from osc_lib import exceptions
-
-from openstackclient.identity.v3 import service
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestService(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestService, self).setUp()
-
-        # Get a shortcut to the ServiceManager Mock
-        self.services_mock = self.app.client_manager.identity.services
-        self.services_mock.reset_mock()
-
-
-class TestServiceCreate(TestService):
-
-    columns = (
-        'description',
-        'enabled',
-        'id',
-        'name',
-        'type',
-    )
-
-    def setUp(self):
-        super(TestServiceCreate, self).setUp()
-
-        self.service = identity_fakes.FakeService.create_one_service()
-        self.datalist = (
-            self.service.description,
-            True,
-            self.service.id,
-            self.service.name,
-            self.service.type,
-        )
-        self.services_mock.create.return_value = self.service
-
-        # Get the command object to test
-        self.cmd = service.CreateService(self.app, None)
-
-    def test_service_create_name(self):
-        arglist = [
-            '--name', self.service.name,
-            self.service.type,
-        ]
-        verifylist = [
-            ('name', self.service.name),
-            ('description', None),
-            ('enable', False),
-            ('disable', False),
-            ('type', self.service.type),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ServiceManager.create(name=, type=, enabled=, **kwargs)
-        self.services_mock.create.assert_called_with(
-            name=self.service.name,
-            type=self.service.type,
-            description=None,
-            enabled=True,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_service_create_description(self):
-        arglist = [
-            '--description', self.service.description,
-            self.service.type,
-        ]
-        verifylist = [
-            ('name', None),
-            ('description', self.service.description),
-            ('enable', False),
-            ('disable', False),
-            ('type', self.service.type),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ServiceManager.create(name=, type=, enabled=, **kwargs)
-        self.services_mock.create.assert_called_with(
-            name=None,
-            type=self.service.type,
-            description=self.service.description,
-            enabled=True,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_service_create_enable(self):
-        arglist = [
-            '--enable',
-            self.service.type,
-        ]
-        verifylist = [
-            ('name', None),
-            ('description', None),
-            ('enable', True),
-            ('disable', False),
-            ('type', self.service.type),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ServiceManager.create(name=, type=, enabled=, **kwargs)
-        self.services_mock.create.assert_called_with(
-            name=None,
-            type=self.service.type,
-            description=None,
-            enabled=True,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_service_create_disable(self):
-        arglist = [
-            '--disable',
-            self.service.type,
-        ]
-        verifylist = [
-            ('name', None),
-            ('description', None),
-            ('enable', False),
-            ('disable', True),
-            ('type', self.service.type),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ServiceManager.create(name=, type=, enabled=, **kwargs)
-        self.services_mock.create.assert_called_with(
-            name=None,
-            type=self.service.type,
-            description=None,
-            enabled=False,
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-
-class TestServiceDelete(TestService):
-
-    service = identity_fakes.FakeService.create_one_service()
-
-    def setUp(self):
-        super(TestServiceDelete, self).setUp()
-
-        self.services_mock.get.side_effect = identity_exc.NotFound(None)
-        self.services_mock.find.return_value = self.service
-        self.services_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = service.DeleteService(self.app, None)
-
-    def test_service_delete_no_options(self):
-        arglist = [
-            self.service.name,
-        ]
-        verifylist = [
-            ('service', [self.service.name]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.services_mock.delete.assert_called_with(
-            self.service.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestServiceList(TestService):
-
-    service = identity_fakes.FakeService.create_one_service()
-
-    def setUp(self):
-        super(TestServiceList, self).setUp()
-
-        self.services_mock.list.return_value = [self.service]
-
-        # Get the command object to test
-        self.cmd = service.ListService(self.app, None)
-
-    def test_service_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.services_mock.list.assert_called_with()
-
-        collist = ('ID', 'Name', 'Type')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.service.id,
-            self.service.name,
-            self.service.type,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_service_list_long(self):
-        arglist = [
-            '--long',
-        ]
-        verifylist = [
-            ('long', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.services_mock.list.assert_called_with()
-
-        collist = ('ID', 'Name', 'Type', 'Description', 'Enabled')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            self.service.id,
-            self.service.name,
-            self.service.type,
-            self.service.description,
-            True,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestServiceSet(TestService):
-
-    service = identity_fakes.FakeService.create_one_service()
-
-    def setUp(self):
-        super(TestServiceSet, self).setUp()
-
-        self.services_mock.get.side_effect = identity_exc.NotFound(None)
-        self.services_mock.find.return_value = self.service
-        self.services_mock.update.return_value = self.service
-
-        # Get the command object to test
-        self.cmd = service.SetService(self.app, None)
-
-    def test_service_set_no_options(self):
-        arglist = [
-            self.service.name,
-        ]
-        verifylist = [
-            ('type', None),
-            ('name', None),
-            ('description', None),
-            ('enable', False),
-            ('disable', False),
-            ('service', self.service.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.assertIsNone(result)
-
-    def test_service_set_type(self):
-        arglist = [
-            '--type', self.service.type,
-            self.service.name,
-        ]
-        verifylist = [
-            ('type', self.service.type),
-            ('name', None),
-            ('description', None),
-            ('enable', False),
-            ('disable', False),
-            ('service', self.service.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'type': self.service.type,
-        }
-        # ServiceManager.update(service, name=, type=, enabled=, **kwargs)
-        self.services_mock.update.assert_called_with(
-            self.service.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_service_set_name(self):
-        arglist = [
-            '--name', self.service.name,
-            self.service.name,
-        ]
-        verifylist = [
-            ('type', None),
-            ('name', self.service.name),
-            ('description', None),
-            ('enable', False),
-            ('disable', False),
-            ('service', self.service.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.service.name,
-        }
-        # ServiceManager.update(service, name=, type=, enabled=, **kwargs)
-        self.services_mock.update.assert_called_with(
-            self.service.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_service_set_description(self):
-        arglist = [
-            '--description', self.service.description,
-            self.service.name,
-        ]
-        verifylist = [
-            ('type', None),
-            ('name', None),
-            ('description', self.service.description),
-            ('enable', False),
-            ('disable', False),
-            ('service', self.service.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': self.service.description,
-        }
-        # ServiceManager.update(service, name=, type=, enabled=, **kwargs)
-        self.services_mock.update.assert_called_with(
-            self.service.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_service_set_enable(self):
-        arglist = [
-            '--enable',
-            self.service.name,
-        ]
-        verifylist = [
-            ('type', None),
-            ('name', None),
-            ('description', None),
-            ('enable', True),
-            ('disable', False),
-            ('service', self.service.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-        }
-        # ServiceManager.update(service, name=, type=, enabled=, **kwargs)
-        self.services_mock.update.assert_called_with(
-            self.service.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_service_set_disable(self):
-        arglist = [
-            '--disable',
-            self.service.name,
-        ]
-        verifylist = [
-            ('type', None),
-            ('name', None),
-            ('description', None),
-            ('enable', False),
-            ('disable', True),
-            ('service', self.service.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': False,
-        }
-        # ServiceManager.update(service, name=, type=, enabled=, **kwargs)
-        self.services_mock.update.assert_called_with(
-            self.service.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestServiceShow(TestService):
-
-    service = identity_fakes.FakeService.create_one_service()
-
-    def setUp(self):
-        super(TestServiceShow, self).setUp()
-
-        self.services_mock.get.side_effect = identity_exc.NotFound(None)
-        self.services_mock.find.return_value = self.service
-
-        # Get the command object to test
-        self.cmd = service.ShowService(self.app, None)
-
-    def test_service_show(self):
-        arglist = [
-            self.service.name,
-        ]
-        verifylist = [
-            ('service', self.service.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # ServiceManager.get(id)
-        self.services_mock.find.assert_called_with(
-            name=self.service.name
-        )
-
-        collist = ('description', 'enabled', 'id', 'name', 'type')
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.service.description,
-            True,
-            self.service.id,
-            self.service.name,
-            self.service.type,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_service_show_nounique(self):
-        self.services_mock.find.side_effect = identity_exc.NoUniqueMatch(None)
-        arglist = [
-            'nounique_service',
-        ]
-        verifylist = [
-            ('service', 'nounique_service'),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        try:
-            self.cmd.take_action(parsed_args)
-            self.fail('CommandError should be raised.')
-        except exceptions.CommandError as e:
-            self.assertEqual(
-                "Multiple service matches found for 'nounique_service',"
-                " use an ID to be more specific.", str(e))
diff --git a/openstackclient/tests/identity/v3/test_service_provider.py b/openstackclient/tests/identity/v3/test_service_provider.py
deleted file mode 100644
index 873ab1e7..00000000
--- a/openstackclient/tests/identity/v3/test_service_provider.py
+++ /dev/null
@@ -1,408 +0,0 @@
-#   Copyright 2014 CERN.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-
-import copy
-
-from openstackclient.identity.v3 import service_provider
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as service_fakes
-
-
-class TestServiceProvider(service_fakes.TestFederatedIdentity):
-
-    def setUp(self):
-        super(TestServiceProvider, self).setUp()
-
-        federation_lib = self.app.client_manager.identity.federation
-        self.service_providers_mock = federation_lib.service_providers
-        self.service_providers_mock.reset_mock()
-
-
-class TestServiceProviderCreate(TestServiceProvider):
-
-    columns = (
-        'auth_url',
-        'description',
-        'enabled',
-        'id',
-        'sp_url',
-    )
-    datalist = (
-        service_fakes.sp_auth_url,
-        service_fakes.sp_description,
-        True,
-        service_fakes.sp_id,
-        service_fakes.service_provider_url
-    )
-
-    def setUp(self):
-        super(TestServiceProviderCreate, self).setUp()
-
-        copied_sp = copy.deepcopy(service_fakes.SERVICE_PROVIDER)
-        resource = fakes.FakeResource(None, copied_sp, loaded=True)
-        self.service_providers_mock.create.return_value = resource
-        self.cmd = service_provider.CreateServiceProvider(self.app, None)
-
-    def test_create_service_provider_required_options_only(self):
-        arglist = [
-            '--auth-url', service_fakes.sp_auth_url,
-            '--service-provider-url', service_fakes.service_provider_url,
-            service_fakes.sp_id,
-        ]
-        verifylist = [
-            ('auth_url', service_fakes.sp_auth_url),
-            ('service_provider_url', service_fakes.service_provider_url),
-            ('service_provider_id', service_fakes.sp_id),
-
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'description': None,
-            'auth_url': service_fakes.sp_auth_url,
-            'sp_url': service_fakes.service_provider_url
-        }
-
-        self.service_providers_mock.create.assert_called_with(
-            id=service_fakes.sp_id,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_create_service_provider_description(self):
-
-        arglist = [
-            '--description', service_fakes.sp_description,
-            '--auth-url', service_fakes.sp_auth_url,
-            '--service-provider-url', service_fakes.service_provider_url,
-            service_fakes.sp_id,
-        ]
-        verifylist = [
-            ('description', service_fakes.sp_description),
-            ('auth_url', service_fakes.sp_auth_url),
-            ('service_provider_url', service_fakes.service_provider_url),
-            ('service_provider_id', service_fakes.sp_id),
-        ]
-
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'description': service_fakes.sp_description,
-            'auth_url': service_fakes.sp_auth_url,
-            'sp_url': service_fakes.service_provider_url,
-            'enabled': True,
-        }
-
-        self.service_providers_mock.create.assert_called_with(
-            id=service_fakes.sp_id,
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_create_service_provider_disabled(self):
-
-        # Prepare FakeResource object
-        service_provider = copy.deepcopy(service_fakes.SERVICE_PROVIDER)
-        service_provider['enabled'] = False
-        service_provider['description'] = None
-
-        resource = fakes.FakeResource(None, service_provider, loaded=True)
-        self.service_providers_mock.create.return_value = resource
-
-        arglist = [
-            '--auth-url', service_fakes.sp_auth_url,
-            '--service-provider-url', service_fakes.service_provider_url,
-            '--disable',
-            service_fakes.sp_id,
-        ]
-        verifylist = [
-            ('auth_url', service_fakes.sp_auth_url),
-            ('service_provider_url', service_fakes.service_provider_url),
-            ('service_provider_id', service_fakes.sp_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        columns, data = self.cmd.take_action(parsed_args)
-        # Set expected values
-        kwargs = {
-            'auth_url': service_fakes.sp_auth_url,
-            'sp_url': service_fakes.service_provider_url,
-            'enabled': False,
-            'description': None,
-        }
-
-        self.service_providers_mock.create.assert_called_with(
-            id=service_fakes.sp_id,
-            **kwargs
-        )
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            service_fakes.sp_auth_url,
-            None,
-            False,
-            service_fakes.sp_id,
-            service_fakes.service_provider_url
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestServiceProviderDelete(TestServiceProvider):
-
-    def setUp(self):
-        super(TestServiceProviderDelete, self).setUp()
-
-        # This is the return value for utils.find_resource()
-        self.service_providers_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(service_fakes.SERVICE_PROVIDER),
-            loaded=True,
-        )
-
-        self.service_providers_mock.delete.return_value = None
-        self.cmd = service_provider.DeleteServiceProvider(self.app, None)
-
-    def test_delete_service_provider(self):
-        arglist = [
-            service_fakes.sp_id,
-        ]
-        verifylist = [
-            ('service_provider', [service_fakes.sp_id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.service_providers_mock.delete.assert_called_with(
-            service_fakes.sp_id,
-        )
-        self.assertIsNone(result)
-
-
-class TestServiceProviderList(TestServiceProvider):
-
-    def setUp(self):
-        super(TestServiceProviderList, self).setUp()
-
-        self.service_providers_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(service_fakes.SERVICE_PROVIDER),
-            loaded=True,
-        )
-        self.service_providers_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(service_fakes.SERVICE_PROVIDER),
-                loaded=True,
-            ),
-        ]
-
-        # Get the command object to test
-        self.cmd = service_provider.ListServiceProvider(self.app, None)
-
-    def test_service_provider_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.service_providers_mock.list.assert_called_with()
-
-        collist = ('ID', 'Enabled', 'Description', 'Auth URL')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            service_fakes.sp_id,
-            True,
-            service_fakes.sp_description,
-            service_fakes.sp_auth_url
-        ), )
-        self.assertEqual(tuple(data), datalist)
-
-
-class TestServiceProviderSet(TestServiceProvider):
-
-    columns = (
-        'auth_url',
-        'description',
-        'enabled',
-        'id',
-        'sp_url',
-    )
-    datalist = (
-        service_fakes.sp_auth_url,
-        service_fakes.sp_description,
-        False,
-        service_fakes.sp_id,
-        service_fakes.service_provider_url,
-    )
-
-    def setUp(self):
-        super(TestServiceProviderSet, self).setUp()
-        self.cmd = service_provider.SetServiceProvider(self.app, None)
-
-    def test_service_provider_disable(self):
-        """Disable Service Provider
-
-        Set Service Provider's ``enabled`` attribute to False.
-        """
-
-        def prepare(self):
-            """Prepare fake return objects before the test is executed"""
-            updated_sp = copy.deepcopy(service_fakes.SERVICE_PROVIDER)
-            updated_sp['enabled'] = False
-            resources = fakes.FakeResource(
-                None,
-                updated_sp,
-                loaded=True
-            )
-            self.service_providers_mock.update.return_value = resources
-
-        prepare(self)
-        arglist = [
-            '--disable', service_fakes.sp_id,
-        ]
-        verifylist = [
-            ('service_provider', service_fakes.sp_id),
-            ('enable', False),
-            ('disable', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        self.cmd.take_action(parsed_args)
-        self.service_providers_mock.update.assert_called_with(
-            service_fakes.sp_id,
-            enabled=False,
-            description=None,
-            auth_url=None,
-            sp_url=None
-        )
-
-    def test_service_provider_enable(self):
-        """Enable Service Provider.
-
-        Set Service Provider's ``enabled`` attribute to True.
-        """
-
-        def prepare(self):
-            """Prepare fake return objects before the test is executed"""
-            resources = fakes.FakeResource(
-                None,
-                copy.deepcopy(service_fakes.SERVICE_PROVIDER),
-                loaded=True
-            )
-            self.service_providers_mock.update.return_value = resources
-
-        prepare(self)
-        arglist = [
-            '--enable', service_fakes.sp_id,
-        ]
-        verifylist = [
-            ('service_provider', service_fakes.sp_id),
-            ('enable', True),
-            ('disable', False),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.cmd.take_action(parsed_args)
-        self.service_providers_mock.update.assert_called_with(
-            service_fakes.sp_id, enabled=True, description=None,
-            auth_url=None, sp_url=None)
-
-    def test_service_provider_no_options(self):
-        def prepare(self):
-            """Prepare fake return objects before the test is executed"""
-            resources = fakes.FakeResource(
-                None,
-                copy.deepcopy(service_fakes.SERVICE_PROVIDER),
-                loaded=True
-            )
-            self.service_providers_mock.get.return_value = resources
-
-            resources = fakes.FakeResource(
-                None,
-                copy.deepcopy(service_fakes.SERVICE_PROVIDER),
-                loaded=True,
-            )
-            self.service_providers_mock.update.return_value = resources
-
-        prepare(self)
-        arglist = [
-            service_fakes.sp_id,
-        ]
-        verifylist = [
-            ('service_provider', service_fakes.sp_id),
-            ('description', None),
-            ('enable', False),
-            ('disable', False),
-            ('auth_url', None),
-            ('service_provider_url', None),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.cmd.take_action(parsed_args)
-
-
-class TestServiceProviderShow(TestServiceProvider):
-
-    def setUp(self):
-        super(TestServiceProviderShow, self).setUp()
-
-        ret = fakes.FakeResource(
-            None,
-            copy.deepcopy(service_fakes.SERVICE_PROVIDER),
-            loaded=True,
-        )
-        self.service_providers_mock.get.side_effect = [Exception("Not found"),
-                                                       ret]
-        self.service_providers_mock.get.return_value = ret
-
-        # Get the command object to test
-        self.cmd = service_provider.ShowServiceProvider(self.app, None)
-
-    def test_service_provider_show(self):
-        arglist = [
-            service_fakes.sp_id,
-        ]
-        verifylist = [
-            ('service_provider', service_fakes.sp_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.service_providers_mock.get.assert_called_with(
-            service_fakes.sp_id,
-            id='BETA'
-        )
-
-        collist = ('auth_url', 'description', 'enabled', 'id', 'sp_url')
-        self.assertEqual(collist, columns)
-        datalist = (
-            service_fakes.sp_auth_url,
-            service_fakes.sp_description,
-            True,
-            service_fakes.sp_id,
-            service_fakes.service_provider_url
-        )
-        self.assertEqual(data, datalist)
diff --git a/openstackclient/tests/identity/v3/test_token.py b/openstackclient/tests/identity/v3/test_token.py
deleted file mode 100644
index d7225e6c..00000000
--- a/openstackclient/tests/identity/v3/test_token.py
+++ /dev/null
@@ -1,138 +0,0 @@
-#   Copyright 2014 eBay Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import mock
-
-from openstackclient.identity.v3 import token
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestToken(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestToken, self).setUp()
-
-        # Get a shortcut to the Auth Ref Mock
-        self.ar_mock = mock.PropertyMock()
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-
-class TestTokenIssue(TestToken):
-
-    def setUp(self):
-        super(TestTokenIssue, self).setUp()
-
-        self.cmd = token.IssueToken(self.app, None)
-
-    def test_token_issue_with_project_id(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.TOKEN_WITH_PROJECT_ID,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        collist = ('expires', 'id', 'project_id', 'user_id')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.token_expires,
-            identity_fakes.token_id,
-            identity_fakes.project_id,
-            identity_fakes.user_id,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_token_issue_with_domain_id(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.TOKEN_WITH_DOMAIN_ID,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        collist = ('domain_id', 'expires', 'id', 'user_id')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.domain_id,
-            identity_fakes.token_expires,
-            identity_fakes.token_id,
-            identity_fakes.user_id,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_token_issue_with_unscoped(self):
-        auth_ref = identity_fakes.fake_auth_ref(
-            identity_fakes.UNSCOPED_TOKEN,
-        )
-        self.ar_mock = mock.PropertyMock(return_value=auth_ref)
-        type(self.app.client_manager).auth_ref = self.ar_mock
-
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # DisplayCommandBase.take_action() returns two tuples
-        columns, data = self.cmd.take_action(parsed_args)
-
-        collist = (
-            'expires',
-            'id',
-            'user_id',
-        )
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.token_expires,
-            identity_fakes.token_id,
-            identity_fakes.user_id,
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestTokenRevoke(TestToken):
-
-    TOKEN = 'fob'
-
-    def setUp(self):
-        super(TestTokenRevoke, self).setUp()
-        self.tokens_mock = self.app.client_manager.identity.tokens
-        self.tokens_mock.reset_mock()
-        self.tokens_mock.revoke_token.return_value = True
-        self.cmd = token.RevokeToken(self.app, None)
-
-    def test_token_revoke(self):
-        arglist = [self.TOKEN]
-        verifylist = [('token', self.TOKEN)]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.tokens_mock.revoke_token.assert_called_with(self.TOKEN)
-        self.assertIsNone(result)
diff --git a/openstackclient/tests/identity/v3/test_trust.py b/openstackclient/tests/identity/v3/test_trust.py
deleted file mode 100644
index 1ea2feb4..00000000
--- a/openstackclient/tests/identity/v3/test_trust.py
+++ /dev/null
@@ -1,236 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import copy
-
-from openstackclient.identity.v3 import trust
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestTrust(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestTrust, self).setUp()
-
-        self.trusts_mock = self.app.client_manager.identity.trusts
-        self.trusts_mock.reset_mock()
-        self.projects_mock = self.app.client_manager.identity.projects
-        self.projects_mock.reset_mock()
-        self.users_mock = self.app.client_manager.identity.users
-        self.users_mock.reset_mock()
-        self.roles_mock = self.app.client_manager.identity.roles
-        self.roles_mock.reset_mock()
-
-
-class TestTrustCreate(TestTrust):
-
-    def setUp(self):
-        super(TestTrustCreate, self).setUp()
-
-        self.projects_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.PROJECT),
-            loaded=True,
-        )
-
-        self.users_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.USER),
-            loaded=True,
-        )
-
-        self.roles_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.ROLE),
-            loaded=True,
-        )
-
-        self.trusts_mock.create.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.TRUST),
-            loaded=True,
-        )
-
-        # Get the command object to test
-        self.cmd = trust.CreateTrust(self.app, None)
-
-    def test_trust_create_basic(self):
-        arglist = [
-            '--project', identity_fakes.project_id,
-            '--role', identity_fakes.role_id,
-            identity_fakes.user_id,
-            identity_fakes.user_id
-        ]
-        verifylist = [
-            ('project', identity_fakes.project_id),
-            ('impersonate', False),
-            ('role', [identity_fakes.role_id]),
-            ('trustor', identity_fakes.user_id),
-            ('trustee', identity_fakes.user_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'impersonation': False,
-            'project': identity_fakes.project_id,
-            'role_names': [identity_fakes.role_name],
-            'expires_at': None,
-        }
-        # TrustManager.create(trustee_id, trustor_id, impersonation=,
-        #   project=, role_names=, expires_at=)
-        self.trusts_mock.create.assert_called_with(
-            identity_fakes.user_id,
-            identity_fakes.user_id,
-            **kwargs
-        )
-
-        collist = ('expires_at', 'id', 'impersonation', 'project_id',
-                   'roles', 'trustee_user_id', 'trustor_user_id')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.trust_expires,
-            identity_fakes.trust_id,
-            identity_fakes.trust_impersonation,
-            identity_fakes.project_id,
-            identity_fakes.role_name,
-            identity_fakes.user_id,
-            identity_fakes.user_id
-        )
-        self.assertEqual(datalist, data)
-
-
-class TestTrustDelete(TestTrust):
-
-    def setUp(self):
-        super(TestTrustDelete, self).setUp()
-
-        # This is the return value for utils.find_resource()
-        self.trusts_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.TRUST),
-            loaded=True,
-        )
-        self.trusts_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = trust.DeleteTrust(self.app, None)
-
-    def test_trust_delete(self):
-        arglist = [
-            identity_fakes.trust_id,
-        ]
-        verifylist = [
-            ('trust', [identity_fakes.trust_id])
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.trusts_mock.delete.assert_called_with(
-            identity_fakes.trust_id,
-        )
-        self.assertIsNone(result)
-
-
-class TestTrustList(TestTrust):
-
-    def setUp(self):
-        super(TestTrustList, self).setUp()
-
-        self.trusts_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.TRUST),
-                loaded=True,
-            ),
-        ]
-
-        # Get the command object to test
-        self.cmd = trust.ListTrust(self.app, None)
-
-    def test_trust_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.trusts_mock.list.assert_called_with()
-
-        collist = ('ID', 'Expires At', 'Impersonation', 'Project ID',
-                   'Trustee User ID', 'Trustor User ID')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            identity_fakes.trust_id,
-            identity_fakes.trust_expires,
-            identity_fakes.trust_impersonation,
-            identity_fakes.project_id,
-            identity_fakes.user_id,
-            identity_fakes.user_id
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-
-class TestTrustShow(TestTrust):
-
-    def setUp(self):
-        super(TestTrustShow, self).setUp()
-
-        self.trusts_mock.get.return_value = fakes.FakeResource(
-            None,
-            copy.deepcopy(identity_fakes.TRUST),
-            loaded=True,
-        )
-
-        # Get the command object to test
-        self.cmd = trust.ShowTrust(self.app, None)
-
-    def test_trust_show(self):
-        arglist = [
-            identity_fakes.trust_id,
-        ]
-        verifylist = [
-            ('trust', identity_fakes.trust_id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.trusts_mock.get.assert_called_with(identity_fakes.trust_id)
-
-        collist = ('expires_at', 'id', 'impersonation', 'project_id',
-                   'roles', 'trustee_user_id', 'trustor_user_id')
-        self.assertEqual(collist, columns)
-        datalist = (
-            identity_fakes.trust_expires,
-            identity_fakes.trust_id,
-            identity_fakes.trust_impersonation,
-            identity_fakes.project_id,
-            identity_fakes.role_name,
-            identity_fakes.user_id,
-            identity_fakes.user_id
-        )
-        self.assertEqual(datalist, data)
diff --git a/openstackclient/tests/identity/v3/test_unscoped_saml.py b/openstackclient/tests/identity/v3/test_unscoped_saml.py
deleted file mode 100644
index 62623902..00000000
--- a/openstackclient/tests/identity/v3/test_unscoped_saml.py
+++ /dev/null
@@ -1,133 +0,0 @@
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-
-import copy
-
-from osc_lib import exceptions
-
-from openstackclient.identity.v3 import unscoped_saml
-from openstackclient.tests import fakes
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestUnscopedSAML(identity_fakes.TestFederatedIdentity):
-
-    def setUp(self):
-        super(TestUnscopedSAML, self).setUp()
-
-        federation_lib = self.app.client_manager.identity.federation
-        self.projects_mock = federation_lib.projects
-        self.projects_mock.reset_mock()
-        self.domains_mock = federation_lib.domains
-        self.domains_mock.reset_mock()
-
-
-class TestDomainList(TestUnscopedSAML):
-
-    def setUp(self):
-        super(TestDomainList, self).setUp()
-
-        self.domains_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.DOMAIN),
-                loaded=True,
-            ),
-        ]
-
-        # Get the command object to test
-        self.cmd = unscoped_saml.ListAccessibleDomains(self.app, None)
-
-    def test_accessible_domains_list(self):
-        self.app.client_manager.auth_plugin_name = 'v3unscopedsaml'
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.domains_mock.list.assert_called_with()
-
-        collist = ('ID', 'Enabled', 'Name', 'Description')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            identity_fakes.domain_id,
-            True,
-            identity_fakes.domain_name,
-            identity_fakes.domain_description,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_accessible_domains_list_wrong_auth(self):
-        auth = identity_fakes.FakeAuth("wrong auth")
-        self.app.client_manager.identity.session.auth = auth
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.assertRaises(exceptions.CommandError,
-                          self.cmd.take_action,
-                          parsed_args)
-
-
-class TestProjectList(TestUnscopedSAML):
-
-    def setUp(self):
-        super(TestProjectList, self).setUp()
-
-        self.projects_mock.list.return_value = [
-            fakes.FakeResource(
-                None,
-                copy.deepcopy(identity_fakes.PROJECT),
-                loaded=True,
-            ),
-        ]
-
-        # Get the command object to test
-        self.cmd = unscoped_saml.ListAccessibleProjects(self.app, None)
-
-    def test_accessible_projects_list(self):
-        self.app.client_manager.auth_plugin_name = 'v3unscopedsaml'
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.projects_mock.list.assert_called_with()
-
-        collist = ('ID', 'Domain ID', 'Enabled', 'Name')
-        self.assertEqual(collist, columns)
-        datalist = ((
-            identity_fakes.project_id,
-            identity_fakes.domain_id,
-            True,
-            identity_fakes.project_name,
-        ), )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_accessible_projects_list_wrong_auth(self):
-        auth = identity_fakes.FakeAuth("wrong auth")
-        self.app.client_manager.identity.session.auth = auth
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.assertRaises(exceptions.CommandError,
-                          self.cmd.take_action,
-                          parsed_args)
diff --git a/openstackclient/tests/identity/v3/test_user.py b/openstackclient/tests/identity/v3/test_user.py
deleted file mode 100644
index c3d9e749..00000000
--- a/openstackclient/tests/identity/v3/test_user.py
+++ /dev/null
@@ -1,1063 +0,0 @@
-#   Copyright 2013 Nebula Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License"); you may
-#   not use this file except in compliance with the License. You may obtain
-#   a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#   License for the specific language governing permissions and limitations
-#   under the License.
-#
-
-import contextlib
-import mock
-
-from openstackclient.identity.v3 import user
-from openstackclient.tests.identity.v3 import fakes as identity_fakes
-
-
-class TestUser(identity_fakes.TestIdentityv3):
-
-    def setUp(self):
-        super(TestUser, self).setUp()
-
-        # Get a shortcut to the DomainManager Mock
-        self.domains_mock = self.app.client_manager.identity.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.reset_mock()
-
-        # Get a shortcut to the GroupManager Mock
-        self.groups_mock = self.app.client_manager.identity.groups
-        self.groups_mock.reset_mock()
-
-        # Get a shortcut to the UserManager Mock
-        self.users_mock = self.app.client_manager.identity.users
-        self.users_mock.reset_mock()
-
-        # Shortcut for RoleAssignmentManager Mock
-        self.role_assignments_mock = self.app.client_manager.identity.\
-            role_assignments
-        self.role_assignments_mock.reset_mock()
-
-
-class TestUserCreate(TestUser):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-    project = identity_fakes.FakeProject.create_one_project()
-
-    columns = (
-        'default_project_id',
-        'domain_id',
-        'email',
-        'enabled',
-        'id',
-        'name',
-    )
-
-    def setUp(self):
-        super(TestUserCreate, self).setUp()
-
-        self.user = identity_fakes.FakeUser.create_one_user(
-            attrs={'domain_id': self.domain.id,
-                   'default_project_id': self.project.id}
-        )
-        self.datalist = (
-            self.project.id,
-            self.domain.id,
-            self.user.email,
-            True,
-            self.user.id,
-            self.user.name,
-        )
-
-        self.domains_mock.get.return_value = self.domain
-        self.projects_mock.get.return_value = self.project
-        self.users_mock.create.return_value = self.user
-
-        # Get the command object to test
-        self.cmd = user.CreateUser(self.app, None)
-
-    def test_user_create_no_options(self):
-        arglist = [
-            self.user.name,
-        ]
-        verifylist = [
-            ('enable', False),
-            ('disable', False),
-            ('name', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.user.name,
-            'default_project': None,
-            'description': None,
-            'domain': None,
-            'email': None,
-            'enabled': True,
-            'password': None,
-        }
-
-        # UserManager.create(name=, domain=, project=, password=, email=,
-        #   description=, enabled=, default_project=)
-        self.users_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_password(self):
-        arglist = [
-            '--password', 'secret',
-            self.user.name,
-        ]
-        verifylist = [
-            ('password', 'secret'),
-            ('password_prompt', False),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.user.name,
-            'default_project': None,
-            'description': None,
-            'domain': None,
-            'email': None,
-            'enabled': True,
-            'password': 'secret',
-        }
-        # UserManager.create(name=, domain=, project=, password=, email=,
-        #   description=, enabled=, default_project=)
-        self.users_mock.create.assert_called_with(
-            **kwargs
-        )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_password_prompt(self):
-        arglist = [
-            '--password-prompt',
-            self.user.name,
-        ]
-        verifylist = [
-            ('password', None),
-            ('password_prompt', True),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        mocker = mock.Mock()
-        mocker.return_value = 'abc123'
-        with mock.patch("osc_lib.utils.get_password", mocker):
-            columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.user.name,
-            'default_project': None,
-            'description': None,
-            'domain': None,
-            'email': None,
-            'enabled': True,
-            'password': 'abc123',
-        }
-        # UserManager.create(name=, domain=, project=, password=, email=,
-        #   description=, enabled=, default_project=)
-        self.users_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_email(self):
-        arglist = [
-            '--email', 'barney@example.com',
-            self.user.name,
-        ]
-        verifylist = [
-            ('email', 'barney@example.com'),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.user.name,
-            'default_project': None,
-            'description': None,
-            'domain': None,
-            'email': 'barney@example.com',
-            'enabled': True,
-            'password': None,
-        }
-        # UserManager.create(name=, domain=, project=, password=, email=,
-        #   description=, enabled=, default_project=)
-        self.users_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_project(self):
-        arglist = [
-            '--project', self.project.name,
-            self.user.name,
-        ]
-        verifylist = [
-            ('project', self.project.name),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.user.name,
-            'default_project': self.project.id,
-            'description': None,
-            'domain': None,
-            'email': None,
-            'enabled': True,
-            'password': None,
-        }
-        # UserManager.create(name=, domain=, project=, password=, email=,
-        #   description=, enabled=, default_project=)
-        self.users_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            self.project.id,
-            self.domain.id,
-            self.user.email,
-            True,
-            self.user.id,
-            self.user.name,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_user_create_project_domain(self):
-        arglist = [
-            '--project', self.project.name,
-            '--project-domain', self.project.domain_id,
-            self.user.name,
-        ]
-        verifylist = [
-            ('project', self.project.name),
-            ('project_domain', self.project.domain_id),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.user.name,
-            'default_project': self.project.id,
-            'description': None,
-            'domain': None,
-            'email': None,
-            'enabled': True,
-            'password': None,
-        }
-        # UserManager.create(name=, domain=, project=, password=, email=,
-        #   description=, enabled=, default_project=)
-        self.users_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        datalist = (
-            self.project.id,
-            self.domain.id,
-            self.user.email,
-            True,
-            self.user.id,
-            self.user.name,
-        )
-        self.assertEqual(datalist, data)
-
-    def test_user_create_domain(self):
-        arglist = [
-            '--domain', self.domain.name,
-            self.user.name,
-        ]
-        verifylist = [
-            ('domain', self.domain.name),
-            ('enable', False),
-            ('disable', False),
-            ('name', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.user.name,
-            'default_project': None,
-            'description': None,
-            'domain': self.domain.id,
-            'email': None,
-            'enabled': True,
-            'password': None,
-        }
-        # UserManager.create(name=, domain=, project=, password=, email=,
-        #   description=, enabled=, default_project=)
-        self.users_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_enable(self):
-        arglist = [
-            '--enable',
-            self.user.name,
-        ]
-        verifylist = [
-            ('enable', True),
-            ('disable', False),
-            ('name', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.user.name,
-            'default_project': None,
-            'description': None,
-            'domain': None,
-            'email': None,
-            'enabled': True,
-            'password': None,
-        }
-        # UserManager.create(name=, domain=, project=, password=, email=,
-        #   description=, enabled=, default_project=)
-        self.users_mock.create.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-    def test_user_create_disable(self):
-        arglist = [
-            '--disable',
-            self.user.name,
-        ]
-        verifylist = [
-            ('name', self.user.name),
-            ('enable', False),
-            ('disable', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'name': self.user.name,
-            'default_project': None,
-            'description': None,
-            'domain': None,
-            'email': None,
-            'enabled': False,
-            'password': None,
-        }
-        # users.create(name=, password, email, tenant_id=None, enabled=True)
-        self.users_mock.create.assert_called_with(
-            **kwargs
-        )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, data)
-
-
-class TestUserDelete(TestUser):
-
-    user = identity_fakes.FakeUser.create_one_user()
-
-    def setUp(self):
-        super(TestUserDelete, self).setUp()
-
-        # This is the return value for utils.find_resource()
-        self.users_mock.get.return_value = self.user
-        self.users_mock.delete.return_value = None
-
-        # Get the command object to test
-        self.cmd = user.DeleteUser(self.app, None)
-
-    def test_user_delete_no_options(self):
-        arglist = [
-            self.user.id,
-        ]
-        verifylist = [
-            ('users', [self.user.id]),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.users_mock.delete.assert_called_with(
-            self.user.id,
-        )
-        self.assertIsNone(result)
-
-
-class TestUserList(TestUser):
-
-    domain = identity_fakes.FakeDomain.create_one_domain()
-    project = identity_fakes.FakeProject.create_one_project()
-    user = identity_fakes.FakeUser.create_one_user(
-        attrs={'domain_id': domain.id,
-               'default_project_id': project.id}
-    )
-    group = identity_fakes.FakeGroup.create_one_group()
-    role_assignment = (
-        identity_fakes.FakeRoleAssignment.create_one_role_assignment(
-            attrs={'user': {'id': user.id}}))
-
-    columns = [
-        'ID',
-        'Name'
-    ]
-    datalist = (
-        (
-            user.id,
-            user.name,
-        ),
-    )
-
-    def setUp(self):
-        super(TestUserList, self).setUp()
-
-        self.users_mock.get.return_value = self.user
-        self.users_mock.list.return_value = [self.user]
-        self.domains_mock.get.return_value = self.domain
-        self.groups_mock.get.return_value = self.group
-        self.projects_mock.get.return_value = self.project
-        self.role_assignments_mock.list.return_value = [self.role_assignment]
-
-        # Get the command object to test
-        self.cmd = user.ListUser(self.app, None)
-
-    def test_user_list_no_options(self):
-        arglist = []
-        verifylist = []
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': None,
-            'group': None,
-        }
-
-        self.users_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_user_list_domain(self):
-        arglist = [
-            '--domain', self.domain.id,
-        ]
-        verifylist = [
-            ('domain', self.domain.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': self.domain.id,
-            'group': None,
-        }
-
-        self.users_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_user_list_group(self):
-        arglist = [
-            '--group', self.group.name,
-        ]
-        verifylist = [
-            ('group', self.group.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': None,
-            'group': self.group.id,
-        }
-
-        self.users_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-    def test_user_list_long(self):
-        arglist = [
-            '--long',
-        ]
-        verifylist = [
-            ('long', True),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'domain': None,
-            'group': None,
-        }
-
-        self.users_mock.list.assert_called_with(
-            **kwargs
-        )
-
-        collist = [
-            'ID',
-            'Name',
-            'Project',
-            'Domain',
-            'Description',
-            'Email',
-            'Enabled',
-        ]
-        self.assertEqual(collist, columns)
-        datalist = (
-            (
-                self.user.id,
-                self.user.name,
-                self.project.id,
-                self.domain.id,
-                '',
-                self.user.email,
-                True,
-            ),
-        )
-        self.assertEqual(datalist, tuple(data))
-
-    def test_user_list_project(self):
-        arglist = [
-            '--project', self.project.name,
-        ]
-        verifylist = [
-            ('project', self.project.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class Lister in cliff, abstract method take_action()
-        # returns a tuple containing the column names and an iterable
-        # containing the data to be listed.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        kwargs = {
-            'project': self.project.id,
-        }
-
-        self.role_assignments_mock.list.assert_called_with(**kwargs)
-        self.users_mock.get.assert_called_with(self.user.id)
-
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.datalist, tuple(data))
-
-
-class TestUserSet(TestUser):
-
-    project = identity_fakes.FakeProject.create_one_project()
-    user = identity_fakes.FakeUser.create_one_user(
-        attrs={'default_project_id': project.id}
-    )
-
-    def setUp(self):
-        super(TestUserSet, self).setUp()
-
-        self.projects_mock.get.return_value = self.project
-        self.users_mock.get.return_value = self.user
-        self.users_mock.update.return_value = self.user
-
-        # Get the command object to test
-        self.cmd = user.SetUser(self.app, None)
-
-    def test_user_set_no_options(self):
-        arglist = [
-            self.user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.assertIsNone(result)
-
-    def test_user_set_name(self):
-        arglist = [
-            '--name', 'qwerty',
-            self.user.name,
-        ]
-        verifylist = [
-            ('name', 'qwerty'),
-            ('password', None),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'name': 'qwerty',
-        }
-        # UserManager.update(user, name=, domain=, project=, password=,
-        #     email=, description=, enabled=, default_project=)
-        self.users_mock.update.assert_called_with(
-            self.user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_password(self):
-        arglist = [
-            '--password', 'secret',
-            self.user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', 'secret'),
-            ('password_prompt', False),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'password': 'secret',
-        }
-        # UserManager.update(user, name=, domain=, project=, password=,
-        #     email=, description=, enabled=, default_project=)
-        self.users_mock.update.assert_called_with(
-            self.user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_password_prompt(self):
-        arglist = [
-            '--password-prompt',
-            self.user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('password_prompt', True),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        mocker = mock.Mock()
-        mocker.return_value = 'abc123'
-        with mock.patch("osc_lib.utils.get_password", mocker):
-            result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'password': 'abc123',
-        }
-        # UserManager.update(user, name=, domain=, project=, password=,
-        #     email=, description=, enabled=, default_project=)
-        self.users_mock.update.assert_called_with(
-            self.user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_email(self):
-        arglist = [
-            '--email', 'barney@example.com',
-            self.user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', 'barney@example.com'),
-            ('project', None),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'email': 'barney@example.com',
-        }
-        # UserManager.update(user, name=, domain=, project=, password=,
-        #     email=, description=, enabled=, default_project=)
-        self.users_mock.update.assert_called_with(
-            self.user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_project(self):
-        arglist = [
-            '--project', self.project.id,
-            self.user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', None),
-            ('project', self.project.id),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'default_project': self.project.id,
-        }
-        # UserManager.update(user, name=, domain=, project=, password=,
-        #     email=, description=, enabled=, default_project=)
-        self.users_mock.update.assert_called_with(
-            self.user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_project_domain(self):
-        arglist = [
-            '--project', self.project.id,
-            '--project-domain', self.project.domain_id,
-            self.user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', None),
-            ('project', self.project.id),
-            ('project_domain', self.project.domain_id),
-            ('enable', False),
-            ('disable', False),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-            'default_project': self.project.id,
-        }
-        # UserManager.update(user, name=, domain=, project=, password=,
-        #     email=, description=, enabled=, default_project=)
-        self.users_mock.update.assert_called_with(
-            self.user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_enable(self):
-        arglist = [
-            '--enable',
-            self.user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', None),
-            ('project', None),
-            ('enable', True),
-            ('disable', False),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': True,
-        }
-        # UserManager.update(user, name=, domain=, project=, password=,
-        #     email=, description=, enabled=, default_project=)
-        self.users_mock.update.assert_called_with(
-            self.user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-    def test_user_set_disable(self):
-        arglist = [
-            '--disable',
-            self.user.name,
-        ]
-        verifylist = [
-            ('name', None),
-            ('password', None),
-            ('email', None),
-            ('project', None),
-            ('enable', False),
-            ('disable', True),
-            ('user', self.user.name),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        # Set expected values
-        kwargs = {
-            'enabled': False,
-        }
-        # UserManager.update(user, name=, domain=, project=, password=,
-        #     email=, description=, enabled=, default_project=)
-        self.users_mock.update.assert_called_with(
-            self.user.id,
-            **kwargs
-        )
-        self.assertIsNone(result)
-
-
-class TestUserSetPassword(TestUser):
-
-    def setUp(self):
-        super(TestUserSetPassword, self).setUp()
-        self.cmd = user.SetPasswordUser(self.app, None)
-
-    @staticmethod
-    @contextlib.contextmanager
-    def _mock_get_password(*passwords):
-        mocker = mock.Mock(side_effect=passwords)
-        with mock.patch("osc_lib.utils.get_password", mocker):
-            yield
-
-    def test_user_password_change(self):
-        current_pass = 'old_pass'
-        new_pass = 'new_pass'
-        arglist = [
-            '--password', new_pass,
-        ]
-        verifylist = [
-            ('password', new_pass),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Mock getting user current password.
-        with self._mock_get_password(current_pass):
-            result = self.cmd.take_action(parsed_args)
-
-        self.users_mock.update_password.assert_called_with(
-            current_pass, new_pass
-        )
-        self.assertIsNone(result)
-
-    def test_user_create_password_prompt(self):
-        current_pass = 'old_pass'
-        new_pass = 'new_pass'
-        parsed_args = self.check_parser(self.cmd, [], [])
-
-        # Mock getting user current and new password.
-        with self._mock_get_password(current_pass, new_pass):
-            result = self.cmd.take_action(parsed_args)
-
-        self.users_mock.update_password.assert_called_with(
-            current_pass, new_pass
-        )
-        self.assertIsNone(result)
-
-    def test_user_password_change_no_prompt(self):
-        current_pass = 'old_pass'
-        new_pass = 'new_pass'
-        arglist = [
-            '--password', new_pass,
-            '--original-password', current_pass,
-        ]
-        verifylist = [
-            ('password', new_pass),
-            ('original_password', current_pass),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        result = self.cmd.take_action(parsed_args)
-
-        self.users_mock.update_password.assert_called_with(
-            current_pass, new_pass
-        )
-        self.assertIsNone(result)
-
-
-class TestUserShow(TestUser):
-
-    user = identity_fakes.FakeUser.create_one_user()
-
-    def setUp(self):
-        super(TestUserShow, self).setUp()
-
-        self.users_mock.get.return_value = self.user
-
-        # Get the command object to test
-        self.cmd = user.ShowUser(self.app, None)
-        self.app.client_manager.identity.auth.client.get_user_id.\
-            return_value = self.user.id
-        self.app.client_manager.identity.tokens.get_token_data.return_value = \
-            {'token':
-             {'user':
-              {'domain': {},
-               'id': self.user.id,
-               'name': self.user.name,
-               }
-              }
-             }
-
-    def test_user_show(self):
-        arglist = [
-            self.user.id,
-        ]
-        verifylist = [
-            ('user', self.user.id),
-        ]
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.users_mock.get.assert_called_with(self.user.id)
-
-        collist = ('default_project_id', 'domain_id', 'email',
-                   'enabled', 'id', 'name')
-        self.assertEqual(collist, columns)
-        datalist = (
-            self.user.default_project_id,
-            self.user.domain_id,
-            self.user.email,
-            True,
-            self.user.id,
-            self.user.name,
-        )
-        self.assertEqual(datalist, data)