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

10 files changed, 0 insertions, 3540 deletions

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)