From aed521d426f45b335e1c69d8b2f6d103c916f75c Mon Sep 17 00:00:00 2001 From: Stephen Finucane Date: Mon, 8 May 2023 11:32:01 +0100 Subject: Blacken openstackclient.identity Black used with the '-l 79 -S' flags. A future change will ignore this commit in git-blame history by adding a 'git-blame-ignore-revs' file. Change-Id: I2eeade1ce6653be8e9179ecc40105182c5ff5f16 Signed-off-by: Stephen Finucane --- .../tests/functional/identity/v2/common.py | 111 +++-- .../tests/functional/identity/v2/test_catalog.py | 1 - .../functional/identity/v2/test_ec2_credentials.py | 1 - .../tests/functional/identity/v2/test_endpoint.py | 7 +- .../tests/functional/identity/v2/test_project.py | 23 +- .../tests/functional/identity/v2/test_role.py | 41 +- .../tests/functional/identity/v2/test_service.py | 7 +- .../tests/functional/identity/v2/test_token.py | 1 - .../tests/functional/identity/v2/test_user.py | 19 +- .../tests/functional/identity/v3/common.py | 315 ++++++++----- .../identity/v3/test_application_credential.py | 188 +++++--- .../tests/functional/identity/v3/test_catalog.py | 1 - .../tests/functional/identity/v3/test_domain.py | 20 +- .../tests/functional/identity/v3/test_endpoint.py | 44 +- .../tests/functional/identity/v3/test_group.py | 127 ++++-- .../tests/functional/identity/v3/test_idp.py | 32 +- .../tests/functional/identity/v3/test_limit.py | 51 +-- .../tests/functional/identity/v3/test_project.py | 43 +- .../tests/functional/identity/v3/test_region.py | 9 +- .../identity/v3/test_registered_limit.py | 61 ++- .../tests/functional/identity/v3/test_role.py | 77 ++-- .../tests/functional/identity/v3/test_service.py | 19 +- .../identity/v3/test_service_provider.py | 32 +- .../tests/functional/identity/v3/test_token.py | 1 - .../tests/functional/identity/v3/test_user.py | 95 ++-- openstackclient/tests/unit/identity/v2_0/fakes.py | 46 +- .../tests/unit/identity/v2_0/test_catalog.py | 42 +- .../tests/unit/identity/v2_0/test_endpoint.py | 86 ++-- .../tests/unit/identity/v2_0/test_project.py | 127 +++--- .../tests/unit/identity/v2_0/test_role.py | 40 +- .../unit/identity/v2_0/test_role_assignment.py | 106 ++--- .../tests/unit/identity/v2_0/test_service.py | 43 +- .../tests/unit/identity/v2_0/test_token.py | 3 - .../tests/unit/identity/v2_0/test_user.py | 124 ++--- openstackclient/tests/unit/identity/v3/fakes.py | 200 ++++----- .../tests/unit/identity/v3/test_access_rule.py | 52 +-- .../identity/v3/test_application_credential.py | 183 +++++--- .../tests/unit/identity/v3/test_catalog.py | 24 +- .../tests/unit/identity/v3/test_consumer.py | 25 +- .../tests/unit/identity/v3/test_credential.py | 112 ++--- .../tests/unit/identity/v3/test_domain.py | 160 +++---- .../tests/unit/identity/v3/test_endpoint.py | 152 +++---- .../tests/unit/identity/v3/test_endpoint_group.py | 117 +++-- .../tests/unit/identity/v3/test_group.py | 149 +++--- .../unit/identity/v3/test_identity_provider.py | 315 +++++++------ .../tests/unit/identity/v3/test_implied_role.py | 50 ++- .../tests/unit/identity/v3/test_limit.py | 193 ++++---- .../tests/unit/identity/v3/test_mappings.py | 104 ++--- .../tests/unit/identity/v3/test_oauth.py | 38 +- .../tests/unit/identity/v3/test_project.py | 499 +++++++++++---------- .../tests/unit/identity/v3/test_protocol.py | 105 +++-- .../tests/unit/identity/v3/test_region.py | 47 +- .../unit/identity/v3/test_registered_limit.py | 207 +++++---- .../tests/unit/identity/v3/test_role.py | 334 +++++++------- .../tests/unit/identity/v3/test_role_assignment.py | 498 ++++++++++---------- .../tests/unit/identity/v3/test_service.py | 82 ++-- .../unit/identity/v3/test_service_provider.py | 96 ++-- .../tests/unit/identity/v3/test_token.py | 3 - .../tests/unit/identity/v3/test_trust.py | 171 ++++--- .../tests/unit/identity/v3/test_unscoped_saml.py | 31 +- .../tests/unit/identity/v3/test_user.py | 411 +++++++---------- 61 files changed, 3263 insertions(+), 3038 deletions(-) (limited to 'openstackclient/tests') diff --git a/openstackclient/tests/functional/identity/v2/common.py b/openstackclient/tests/functional/identity/v2/common.py index 43c0cbf2..9d3601eb 100644 --- a/openstackclient/tests/functional/identity/v2/common.py +++ b/openstackclient/tests/functional/identity/v2/common.py @@ -23,21 +23,37 @@ BASIC_LIST_HEADERS = ['ID', 'Name'] class IdentityTests(base.TestCase): - """Functional tests for Identity commands. """ + """Functional tests for Identity commands.""" USER_FIELDS = ['email', 'enabled', 'id', 'name', 'project_id', 'username'] PROJECT_FIELDS = ['enabled', 'id', 'name', 'description'] TOKEN_FIELDS = ['expires', 'id', 'project_id', 'user_id'] ROLE_FIELDS = ['id', 'name', 'domain_id'] SERVICE_FIELDS = ['id', 'enabled', 'name', 'type', 'description'] - ENDPOINT_FIELDS = ['id', 'region', 'service_id', 'service_name', - 'service_type', 'publicurl', - 'adminurl', 'internalurl'] - - EC2_CREDENTIALS_FIELDS = ['access', 'project_id', 'secret', - 'trust_id', 'user_id'] - EC2_CREDENTIALS_LIST_HEADERS = ['Access', 'Secret', - 'Project ID', 'User ID'] + ENDPOINT_FIELDS = [ + 'id', + 'region', + 'service_id', + 'service_name', + 'service_type', + 'publicurl', + 'adminurl', + 'internalurl', + ] + + EC2_CREDENTIALS_FIELDS = [ + 'access', + 'project_id', + 'secret', + 'trust_id', + 'user_id', + ] + EC2_CREDENTIALS_LIST_HEADERS = [ + 'Access', + 'Secret', + 'Project ID', + 'User ID', + ] CATALOG_LIST_HEADERS = ['Name', 'Type', 'Endpoints'] ENDPOINT_LIST_HEADERS = ['ID', 'Region', 'Service Name', 'Service Type'] @@ -53,7 +69,8 @@ class IdentityTests(base.TestCase): 'project create ' '--description %(description)s ' '--enable ' - '%(name)s' % { + '%(name)s' + % { 'description': cls.project_description, 'name': cls.project_name, } @@ -70,7 +87,8 @@ class IdentityTests(base.TestCase): try: cls.openstack( '--os-identity-api-version 2 ' - 'project delete %s' % cls.project_name) + 'project delete %s' % cls.project_name + ) finally: super(IdentityTests, cls).tearDownClass() @@ -78,7 +96,8 @@ class IdentityTests(base.TestCase): super(IdentityTests, self).setUp() # prepare v2 env ver_fixture = fixtures.EnvironmentVariable( - 'OS_IDENTITY_API_VERSION', '2.0') + 'OS_IDENTITY_API_VERSION', '2.0' + ) self.useFixture(ver_fixture) auth_url = os.environ.get('OS_AUTH_URL') if auth_url: @@ -93,13 +112,14 @@ class IdentityTests(base.TestCase): raw_output = self.openstack( 'project create ' '--description %(description)s ' - '--enable %(name)s' % {'description': project_description, - 'name': project_name}) + '--enable %(name)s' + % {'description': project_description, 'name': project_name} + ) project = self.parse_show_as_object(raw_output) if add_clean_up: self.addCleanup( - self.openstack, - 'project delete %s' % project['id']) + self.openstack, 'project delete %s' % project['id'] + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.PROJECT_FIELDS) return project_name @@ -114,14 +134,19 @@ class IdentityTests(base.TestCase): '--password %(password)s ' '--email %(email)s ' '--enable ' - '%(name)s' % {'project': self.project_name, - 'email': email, - 'password': password, - 'name': username}) + '%(name)s' + % { + 'project': self.project_name, + 'email': email, + 'password': password, + 'name': username, + } + ) if add_clean_up: self.addCleanup( self.openstack, - 'user delete %s' % self.parse_show_as_object(raw_output)['id']) + 'user delete %s' % self.parse_show_as_object(raw_output)['id'], + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.USER_FIELDS) return username @@ -131,9 +156,7 @@ class IdentityTests(base.TestCase): raw_output = self.openstack('role create %s' % role_name) role = self.parse_show_as_object(raw_output) if add_clean_up: - self.addCleanup( - self.openstack, - 'role delete %s' % role['id']) + self.addCleanup(self.openstack, 'role delete %s' % role['id']) items = self.parse_show(raw_output) self.assert_show_fields(items, self.ROLE_FIELDS) self.assertEqual(role_name, role['name']) @@ -145,8 +168,8 @@ class IdentityTests(base.TestCase): access_key = ec2_credentials['access'] if add_clean_up: self.addCleanup( - self.openstack, - 'ec2 credentials delete %s' % access_key) + self.openstack, 'ec2 credentials delete %s' % access_key + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.EC2_CREDENTIALS_FIELDS) return access_key @@ -155,8 +178,7 @@ class IdentityTests(base.TestCase): raw_output = self.openstack('token issue') token = self.parse_show_as_object(raw_output) if add_clean_up: - self.addCleanup(self.openstack, - 'token revoke %s' % token['id']) + self.addCleanup(self.openstack, 'token revoke %s' % token['id']) items = self.parse_show(raw_output) self.assert_show_fields(items, self.TOKEN_FIELDS) return token['id'] @@ -169,13 +191,18 @@ class IdentityTests(base.TestCase): 'service create ' '--name %(name)s ' '--description %(description)s ' - '%(type)s' % {'name': service_name, - 'description': description, - 'type': type_name}) + '%(type)s' + % { + 'name': service_name, + 'description': description, + 'type': type_name, + } + ) if add_clean_up: service = self.parse_show_as_object(raw_output) - self.addCleanup(self.openstack, - 'service delete %s' % service['id']) + self.addCleanup( + self.openstack, 'service delete %s' % service['id'] + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.SERVICE_FIELDS) return service_name @@ -192,16 +219,20 @@ class IdentityTests(base.TestCase): '--adminurl %(adminurl)s ' '--internalurl %(internalurl)s ' '--region %(region)s ' - '%(service)s' % {'publicurl': public_url, - 'adminurl': admin_url, - 'internalurl': internal_url, - 'region': region_id, - 'service': service_name}) + '%(service)s' + % { + 'publicurl': public_url, + 'adminurl': admin_url, + 'internalurl': internal_url, + 'region': region_id, + 'service': service_name, + } + ) endpoint = self.parse_show_as_object(raw_output) if add_clean_up: self.addCleanup( - self.openstack, - 'endpoint delete %s' % endpoint['id']) + self.openstack, 'endpoint delete %s' % endpoint['id'] + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.ENDPOINT_FIELDS) return endpoint['id'] diff --git a/openstackclient/tests/functional/identity/v2/test_catalog.py b/openstackclient/tests/functional/identity/v2/test_catalog.py index f403fbfc..1cef314f 100644 --- a/openstackclient/tests/functional/identity/v2/test_catalog.py +++ b/openstackclient/tests/functional/identity/v2/test_catalog.py @@ -14,7 +14,6 @@ from openstackclient.tests.functional.identity.v2 import common class CatalogTests(common.IdentityTests): - def test_catalog_list(self): raw_output = self.openstack('catalog list') items = self.parse_listing(raw_output) diff --git a/openstackclient/tests/functional/identity/v2/test_ec2_credentials.py b/openstackclient/tests/functional/identity/v2/test_ec2_credentials.py index 43dff91f..6d25bdae 100644 --- a/openstackclient/tests/functional/identity/v2/test_ec2_credentials.py +++ b/openstackclient/tests/functional/identity/v2/test_ec2_credentials.py @@ -14,7 +14,6 @@ from openstackclient.tests.functional.identity.v2 import common class EC2CredentialsTests(common.IdentityTests): - def test_ec2_credentials_create(self): self._create_dummy_ec2_credentials() diff --git a/openstackclient/tests/functional/identity/v2/test_endpoint.py b/openstackclient/tests/functional/identity/v2/test_endpoint.py index 9df5ca8a..bafbfdae 100644 --- a/openstackclient/tests/functional/identity/v2/test_endpoint.py +++ b/openstackclient/tests/functional/identity/v2/test_endpoint.py @@ -14,21 +14,20 @@ from openstackclient.tests.functional.identity.v2 import common class EndpointTests(common.IdentityTests): - def test_endpoint_create(self): self._create_dummy_endpoint() def test_endpoint_delete(self): endpoint_id = self._create_dummy_endpoint(add_clean_up=False) - raw_output = self.openstack( - 'endpoint delete %s' % endpoint_id) + raw_output = self.openstack('endpoint delete %s' % endpoint_id) self.assertEqual(0, len(raw_output)) def test_endpoint_multi_delete(self): endpoint_id_1 = self._create_dummy_endpoint(add_clean_up=False) endpoint_id_2 = self._create_dummy_endpoint(add_clean_up=False) raw_output = self.openstack( - 'endpoint delete ' + endpoint_id_1 + ' ' + endpoint_id_2) + 'endpoint delete ' + endpoint_id_1 + ' ' + endpoint_id_2 + ) self.assertEqual(0, len(raw_output)) def test_endpoint_list(self): diff --git a/openstackclient/tests/functional/identity/v2/test_project.py b/openstackclient/tests/functional/identity/v2/test_project.py index 38777c36..1ad0edaa 100644 --- a/openstackclient/tests/functional/identity/v2/test_project.py +++ b/openstackclient/tests/functional/identity/v2/test_project.py @@ -16,7 +16,6 @@ from openstackclient.tests.functional.identity.v2 import common class ProjectTests(common.IdentityTests): - def test_project_create(self): project_name = data_utils.rand_name('TestProject') description = data_utils.rand_name('description') @@ -26,12 +25,9 @@ class ProjectTests(common.IdentityTests): '--enable ' '--property k1=v1 ' '--property k2=v2 ' - '%(name)s' % {'description': description, - 'name': project_name}) - self.addCleanup( - self.openstack, - 'project delete %s' % project_name + '%(name)s' % {'description': description, 'name': project_name} ) + self.addCleanup(self.openstack, 'project delete %s' % project_name) items = self.parse_show(raw_output) show_fields = list(self.PROJECT_FIELDS) show_fields.extend(['k1', 'k2']) @@ -42,8 +38,7 @@ class ProjectTests(common.IdentityTests): def test_project_delete(self): project_name = self._create_dummy_project(add_clean_up=False) - raw_output = self.openstack( - 'project delete %s' % project_name) + raw_output = self.openstack('project delete %s' % project_name) self.assertEqual(0, len(raw_output)) def test_project_list(self): @@ -59,13 +54,11 @@ class ProjectTests(common.IdentityTests): '--name %(new_name)s ' '--disable ' '--property k0=v0 ' - '%(name)s' % {'new_name': new_project_name, - 'name': project_name}) + '%(name)s' % {'new_name': new_project_name, 'name': project_name} + ) self.assertEqual(0, len(raw_output)) # check project details - raw_output = self.openstack( - 'project show %s' % new_project_name - ) + raw_output = self.openstack('project show %s' % new_project_name) items = self.parse_show(raw_output) fields = list(self.PROJECT_FIELDS) fields.extend(['properties']) @@ -77,9 +70,7 @@ class ProjectTests(common.IdentityTests): def test_project_show(self): project_name = self._create_dummy_project() - raw_output = self.openstack( - 'project show %s' % project_name - ) + raw_output = self.openstack('project show %s' % project_name) items = self.parse_show(raw_output) fields = list(self.PROJECT_FIELDS) fields.extend(['properties']) diff --git a/openstackclient/tests/functional/identity/v2/test_role.py b/openstackclient/tests/functional/identity/v2/test_role.py index 124603d8..fb22f018 100644 --- a/openstackclient/tests/functional/identity/v2/test_role.py +++ b/openstackclient/tests/functional/identity/v2/test_role.py @@ -14,7 +14,6 @@ from openstackclient.tests.functional.identity.v2 import common class RoleTests(common.IdentityTests): - def test_role_create(self): self._create_dummy_role() @@ -42,17 +41,25 @@ class RoleTests(common.IdentityTests): 'role add ' '--project %(project)s ' '--user %(user)s ' - '%(role)s' % {'project': self.project_name, - 'user': username, - 'role': role_name}) + '%(role)s' + % { + 'project': self.project_name, + 'user': username, + 'role': role_name, + } + ) self.addCleanup( self.openstack, 'role remove ' '--project %(project)s ' '--user %(user)s ' - '%(role)s' % {'project': self.project_name, - 'user': username, - 'role': role_name}) + '%(role)s' + % { + 'project': self.project_name, + 'user': username, + 'role': role_name, + }, + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.ROLE_FIELDS) @@ -63,16 +70,24 @@ class RoleTests(common.IdentityTests): 'role add ' '--project %(project)s ' '--user %(user)s ' - '%(role)s' % {'project': self.project_name, - 'user': username, - 'role': role_name}) + '%(role)s' + % { + 'project': self.project_name, + 'user': username, + 'role': role_name, + } + ) del_raw_output = self.openstack( 'role remove ' '--project %(project)s ' '--user %(user)s ' - '%(role)s' % {'project': self.project_name, - 'user': username, - 'role': role_name}) + '%(role)s' + % { + 'project': self.project_name, + 'user': username, + 'role': role_name, + } + ) items = self.parse_show(add_raw_output) self.assert_show_fields(items, self.ROLE_FIELDS) self.assertEqual(0, len(del_raw_output)) diff --git a/openstackclient/tests/functional/identity/v2/test_service.py b/openstackclient/tests/functional/identity/v2/test_service.py index d0e03804..7afa967d 100644 --- a/openstackclient/tests/functional/identity/v2/test_service.py +++ b/openstackclient/tests/functional/identity/v2/test_service.py @@ -14,7 +14,6 @@ from openstackclient.tests.functional.identity.v2 import common class ServiceTests(common.IdentityTests): - def test_service_create(self): self._create_dummy_service() @@ -27,7 +26,8 @@ class ServiceTests(common.IdentityTests): service_name_1 = self._create_dummy_service(add_clean_up=False) service_name_2 = self._create_dummy_service(add_clean_up=False) raw_output = self.openstack( - 'service delete ' + service_name_1 + ' ' + service_name_2) + 'service delete ' + service_name_1 + ' ' + service_name_2 + ) self.assertEqual(0, len(raw_output)) def test_service_list(self): @@ -38,7 +38,6 @@ class ServiceTests(common.IdentityTests): def test_service_show(self): service_name = self._create_dummy_service() - raw_output = self.openstack( - 'service show %s' % service_name) + raw_output = self.openstack('service show %s' % service_name) items = self.parse_show(raw_output) self.assert_show_fields(items, self.SERVICE_FIELDS) diff --git a/openstackclient/tests/functional/identity/v2/test_token.py b/openstackclient/tests/functional/identity/v2/test_token.py index f8569744..d2ef78e3 100644 --- a/openstackclient/tests/functional/identity/v2/test_token.py +++ b/openstackclient/tests/functional/identity/v2/test_token.py @@ -14,7 +14,6 @@ from openstackclient.tests.functional.identity.v2 import common class TokenTests(common.IdentityTests): - def test_token_issue(self): self._create_dummy_token() diff --git a/openstackclient/tests/functional/identity/v2/test_user.py b/openstackclient/tests/functional/identity/v2/test_user.py index ac609b94..d30e3c45 100644 --- a/openstackclient/tests/functional/identity/v2/test_user.py +++ b/openstackclient/tests/functional/identity/v2/test_user.py @@ -17,7 +17,6 @@ from openstackclient.tests.functional.identity.v2 import common class UserTests(common.IdentityTests): - def test_user_create(self): self._create_dummy_user() @@ -37,12 +36,13 @@ class UserTests(common.IdentityTests): user = self.parse_show_as_object(raw_output) new_username = data_utils.rand_name('NewTestUser') new_email = data_utils.rand_name() + '@example.com' - raw_output = self.openstack('user set ' - '--email %(email)s ' - '--name %(new_name)s ' - '%(id)s' % {'email': new_email, - 'new_name': new_username, - 'id': user['id']}) + raw_output = self.openstack( + 'user set ' + '--email %(email)s ' + '--name %(new_name)s ' + '%(id)s' + % {'email': new_email, 'new_name': new_username, 'id': user['id']} + ) self.assertEqual(0, len(raw_output)) raw_output = self.openstack('user show %s' % new_username) new_user = self.parse_show_as_object(raw_output) @@ -56,5 +56,6 @@ class UserTests(common.IdentityTests): self.assert_show_fields(items, self.USER_FIELDS) def test_bad_user_command(self): - self.assertRaises(exceptions.CommandFailed, - self.openstack, 'user unlist') + self.assertRaises( + exceptions.CommandFailed, self.openstack, 'user unlist' + ) diff --git a/openstackclient/tests/functional/identity/v3/common.py b/openstackclient/tests/functional/identity/v3/common.py index a5edd9a5..67eccddd 100644 --- a/openstackclient/tests/functional/identity/v3/common.py +++ b/openstackclient/tests/functional/identity/v3/common.py @@ -23,47 +23,121 @@ SYSTEM_CLOUD = os.environ.get('OS_SYSTEM_CLOUD', 'devstack-system-admin') class IdentityTests(base.TestCase): - """Functional tests for Identity commands. """ + """Functional tests for Identity commands.""" DOMAIN_FIELDS = ['description', 'enabled', 'id', 'name'] GROUP_FIELDS = ['description', 'domain_id', 'id', 'name'] TOKEN_FIELDS = ['expires', 'id', 'project_id', 'user_id'] - USER_FIELDS = ['email', 'enabled', 'id', 'name', 'name', - 'domain_id', 'default_project_id', 'description', - 'password_expires_at'] - PROJECT_FIELDS = ['description', 'id', 'domain_id', 'is_domain', - 'enabled', 'name', 'parent_id'] + USER_FIELDS = [ + 'email', + 'enabled', + 'id', + 'name', + 'name', + 'domain_id', + 'default_project_id', + 'description', + 'password_expires_at', + ] + PROJECT_FIELDS = [ + 'description', + 'id', + 'domain_id', + 'is_domain', + 'enabled', + 'name', + 'parent_id', + ] ROLE_FIELDS = ['id', 'name', 'domain_id', 'description'] SERVICE_FIELDS = ['id', 'enabled', 'name', 'type', 'description'] REGION_FIELDS = ['description', 'enabled', 'parent_region', 'region'] - ENDPOINT_FIELDS = ['id', 'region', 'region_id', 'service_id', - 'service_name', 'service_type', 'enabled', - 'interface', 'url'] + ENDPOINT_FIELDS = [ + 'id', + 'region', + 'region_id', + 'service_id', + 'service_name', + 'service_type', + 'enabled', + 'interface', + 'url', + ] REGION_LIST_HEADERS = ['Region', 'Parent Region', 'Description'] - ENDPOINT_LIST_HEADERS = ['ID', 'Region', 'Service Name', 'Service Type', - 'Enabled', 'Interface', 'URL'] + ENDPOINT_LIST_HEADERS = [ + 'ID', + 'Region', + 'Service Name', + 'Service Type', + 'Enabled', + 'Interface', + 'URL', + ] ENDPOINT_LIST_PROJECT_HEADERS = ['ID', 'Name'] - IDENTITY_PROVIDER_FIELDS = ['description', 'enabled', 'id', 'remote_ids', - 'domain_id'] + IDENTITY_PROVIDER_FIELDS = [ + 'description', + 'enabled', + 'id', + 'remote_ids', + 'domain_id', + ] IDENTITY_PROVIDER_LIST_HEADERS = ['ID', 'Enabled', 'Description'] - SERVICE_PROVIDER_FIELDS = ['auth_url', 'description', 'enabled', - 'id', 'relay_state_prefix', 'sp_url'] - SERVICE_PROVIDER_LIST_HEADERS = ['ID', 'Enabled', 'Description', - 'Auth URL'] - IMPLIED_ROLE_LIST_HEADERS = ['Prior Role ID', 'Prior Role Name', - 'Implied Role ID', 'Implied Role Name'] - REGISTERED_LIMIT_FIELDS = ['id', 'service_id', 'resource_name', - 'default_limit', 'description', 'region_id'] - REGISTERED_LIMIT_LIST_HEADERS = ['ID', 'Service ID', 'Resource Name', - 'Default Limit', 'Description', - 'Region ID'] - LIMIT_FIELDS = ['id', 'project_id', 'service_id', 'resource_name', - 'resource_limit', 'description', 'region_id'] - LIMIT_LIST_HEADERS = ['ID', 'Project ID', 'Service ID', 'Resource Name', - 'Resource Limit', 'Description', 'Region ID'] + SERVICE_PROVIDER_FIELDS = [ + 'auth_url', + 'description', + 'enabled', + 'id', + 'relay_state_prefix', + 'sp_url', + ] + SERVICE_PROVIDER_LIST_HEADERS = [ + 'ID', + 'Enabled', + 'Description', + 'Auth URL', + ] + IMPLIED_ROLE_LIST_HEADERS = [ + 'Prior Role ID', + 'Prior Role Name', + 'Implied Role ID', + 'Implied Role Name', + ] + REGISTERED_LIMIT_FIELDS = [ + 'id', + 'service_id', + 'resource_name', + 'default_limit', + 'description', + 'region_id', + ] + REGISTERED_LIMIT_LIST_HEADERS = [ + 'ID', + 'Service ID', + 'Resource Name', + 'Default Limit', + 'Description', + 'Region ID', + ] + LIMIT_FIELDS = [ + 'id', + 'project_id', + 'service_id', + 'resource_name', + 'resource_limit', + 'description', + 'region_id', + ] + LIMIT_LIST_HEADERS = [ + 'ID', + 'Project ID', + 'Service ID', + 'Resource Name', + 'Resource Limit', + 'Description', + 'Region ID', + ] @classmethod def setUpClass(cls): @@ -76,8 +150,9 @@ class IdentityTests(base.TestCase): 'domain create ' '--description %(description)s ' '--enable ' - '%(name)s' % {'description': cls.domain_description, - 'name': cls.domain_name}) + '%(name)s' + % {'description': cls.domain_description, 'name': cls.domain_name} + ) # create dummy project cls.project_name = data_utils.rand_name('TestProject') @@ -88,21 +163,31 @@ class IdentityTests(base.TestCase): '--domain %(domain)s ' '--description %(description)s ' '--enable ' - '%(name)s' % {'domain': cls.domain_name, - 'description': cls.project_description, - 'name': cls.project_name}) + '%(name)s' + % { + 'domain': cls.domain_name, + 'description': cls.project_description, + 'name': cls.project_name, + } + ) @classmethod def tearDownClass(cls): try: # delete dummy project - cls.openstack('--os-identity-api-version 3 ' - 'project delete %s' % cls.project_name) + cls.openstack( + '--os-identity-api-version 3 ' + 'project delete %s' % cls.project_name + ) # disable and delete dummy domain - cls.openstack('--os-identity-api-version 3 ' - 'domain set --disable %s' % cls.domain_name) - cls.openstack('--os-identity-api-version 3 ' - 'domain delete %s' % cls.domain_name) + cls.openstack( + '--os-identity-api-version 3 ' + 'domain set --disable %s' % cls.domain_name + ) + cls.openstack( + '--os-identity-api-version 3 ' + 'domain delete %s' % cls.domain_name + ) finally: super(IdentityTests, cls).tearDownClass() @@ -110,7 +195,8 @@ class IdentityTests(base.TestCase): super(IdentityTests, self).setUp() # prepare v3 env ver_fixture = fixtures.EnvironmentVariable( - 'OS_IDENTITY_API_VERSION', '3') + 'OS_IDENTITY_API_VERSION', '3' + ) self.useFixture(ver_fixture) auth_url = os.environ.get('OS_AUTH_URL') if auth_url: @@ -133,17 +219,22 @@ class IdentityTests(base.TestCase): '--email %(email)s ' '--description %(description)s ' '--enable ' - '%(name)s' % {'domain': self.domain_name, - 'project': self.project_name, - 'project_domain': self.domain_name, - 'email': email, - 'password': password, - 'description': description, - 'name': username}) + '%(name)s' + % { + 'domain': self.domain_name, + 'project': self.project_name, + 'project_domain': self.domain_name, + 'email': email, + 'password': password, + 'description': description, + 'name': username, + } + ) if add_clean_up: self.addCleanup( self.openstack, - 'user delete %s' % self.parse_show_as_object(raw_output)['id']) + 'user delete %s' % self.parse_show_as_object(raw_output)['id'], + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.USER_FIELDS) return username @@ -153,9 +244,7 @@ class IdentityTests(base.TestCase): raw_output = self.openstack('role create %s' % role_name) role = self.parse_show_as_object(raw_output) if add_clean_up: - self.addCleanup( - self.openstack, - 'role delete %s' % role['id']) + self.addCleanup(self.openstack, 'role delete %s' % role['id']) items = self.parse_show(raw_output) self.assert_show_fields(items, self.ROLE_FIELDS) self.assertEqual(role_name, role['name']) @@ -167,8 +256,8 @@ class IdentityTests(base.TestCase): self.openstack( 'implied role create ' '--implied-role %(implied_role)s ' - '%(role)s' % {'implied_role': implied_role_name, - 'role': role_name}) + '%(role)s' % {'implied_role': implied_role_name, 'role': role_name} + ) return implied_role_name, role_name @@ -179,16 +268,20 @@ class IdentityTests(base.TestCase): 'group create ' '--domain %(domain)s ' '--description %(description)s ' - '%(name)s' % {'domain': self.domain_name, - 'description': description, - 'name': group_name}) + '%(name)s' + % { + 'domain': self.domain_name, + 'description': description, + 'name': group_name, + } + ) if add_clean_up: self.addCleanup( self.openstack, 'group delete ' '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': group_name}) + '%(name)s' % {'domain': self.domain_name, 'name': group_name}, + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.GROUP_FIELDS) return group_name @@ -199,16 +292,13 @@ class IdentityTests(base.TestCase): self.openstack( 'domain create ' '--description %(description)s ' - '--enable %(name)s' % {'description': domain_description, - 'name': domain_name}) + '--enable %(name)s' + % {'description': domain_description, 'name': domain_name} + ) if add_clean_up: + self.addCleanup(self.openstack, 'domain delete %s' % domain_name) self.addCleanup( - self.openstack, - 'domain delete %s' % domain_name - ) - self.addCleanup( - self.openstack, - 'domain set --disable %s' % domain_name + self.openstack, 'domain set --disable %s' % domain_name ) return domain_name @@ -219,16 +309,21 @@ class IdentityTests(base.TestCase): 'project create ' '--domain %(domain)s ' '--description %(description)s ' - '--enable %(name)s' % {'domain': self.domain_name, - 'description': project_description, - 'name': project_name}) + '--enable %(name)s' + % { + 'domain': self.domain_name, + 'description': project_description, + 'name': project_name, + } + ) if add_clean_up: self.addCleanup( self.openstack, 'project delete ' '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': project_name}) + '%(name)s' + % {'domain': self.domain_name, 'name': project_name}, + ) return project_name def _create_dummy_region(self, parent_region=None, add_clean_up=True): @@ -241,12 +336,15 @@ class IdentityTests(base.TestCase): 'region create ' '%(parent_region_arg)s ' '--description %(description)s ' - '%(id)s' % {'parent_region_arg': parent_region_arg, - 'description': description, - 'id': region_id}) + '%(id)s' + % { + 'parent_region_arg': parent_region_arg, + 'description': description, + 'id': region_id, + } + ) if add_clean_up: - self.addCleanup(self.openstack, - 'region delete %s' % region_id) + self.addCleanup(self.openstack, 'region delete %s' % region_id) items = self.parse_show(raw_output) self.assert_show_fields(items, self.REGION_FIELDS) return region_id @@ -260,13 +358,18 @@ class IdentityTests(base.TestCase): '--name %(name)s ' '--description %(description)s ' '--enable ' - '%(type)s' % {'name': service_name, - 'description': description, - 'type': type_name}) + '%(type)s' + % { + 'name': service_name, + 'description': description, + 'type': type_name, + } + ) if add_clean_up: service = self.parse_show_as_object(raw_output) - self.addCleanup(self.openstack, - 'service delete %s' % service['id']) + self.addCleanup( + self.openstack, 'service delete %s' % service['id'] + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.SERVICE_FIELDS) return service_name @@ -281,15 +384,19 @@ class IdentityTests(base.TestCase): '--enable ' '%(service)s ' '%(interface)s ' - '%(url)s' % {'region': region_id, - 'service': service_name, - 'interface': interface, - 'url': endpoint_url}) + '%(url)s' + % { + 'region': region_id, + 'service': service_name, + 'interface': interface, + 'url': endpoint_url, + } + ) endpoint = self.parse_show_as_object(raw_output) if add_clean_up: self.addCleanup( - self.openstack, - 'endpoint delete %s' % endpoint['id']) + self.openstack, 'endpoint delete %s' % endpoint['id'] + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.ENDPOINT_FIELDS) return endpoint['id'] @@ -301,12 +408,14 @@ class IdentityTests(base.TestCase): 'identity provider create ' ' %(name)s ' '--description %(description)s ' - '--enable ' % {'name': identity_provider, - 'description': description}) + '--enable ' + % {'name': identity_provider, 'description': description} + ) if add_clean_up: self.addCleanup( self.openstack, - 'identity provider delete %s' % identity_provider) + 'identity provider delete %s' % identity_provider, + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.IDENTITY_PROVIDER_FIELDS) return identity_provider @@ -320,12 +429,13 @@ class IdentityTests(base.TestCase): '--description %(description)s ' '--auth-url https://sp.example.com:35357 ' '--service-provider-url https://sp.example.com:5000 ' - '--enable ' % {'name': service_provider, - 'description': description}) + '--enable ' + % {'name': service_provider, 'description': description} + ) if add_clean_up: self.addCleanup( - self.openstack, - 'service provider delete %s' % service_provider) + self.openstack, 'service provider delete %s' % service_provider + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.SERVICE_PROVIDER_FIELDS) return service_provider @@ -336,14 +446,14 @@ class IdentityTests(base.TestCase): params = { 'service_name': service_name, 'default_limit': 10, - 'resource_name': resource_name + 'resource_name': resource_name, } raw_output = self.openstack( 'registered limit create' ' --service %(service_name)s' ' --default-limit %(default_limit)s' ' %(resource_name)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) registered_limit_id = self._extract_value_from_items('id', items) @@ -352,7 +462,7 @@ class IdentityTests(base.TestCase): self.addCleanup( self.openstack, 'registered limit delete %s' % registered_limit_id, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) self.assert_show_fields(items, self.REGISTERED_LIMIT_FIELDS) @@ -369,7 +479,7 @@ class IdentityTests(base.TestCase): raw_output = self.openstack( 'registered limit show %s' % registered_limit_id, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) resource_name = self._extract_value_from_items('resource_name', items) @@ -385,7 +495,7 @@ class IdentityTests(base.TestCase): 'project_id': project_id, 'service_id': service_id, 'resource_name': resource_name, - 'resource_limit': resource_limit + 'resource_limit': resource_limit, } raw_output = self.openstack( @@ -394,15 +504,16 @@ class IdentityTests(base.TestCase): ' --service %(service_id)s' ' --resource-limit %(resource_limit)s' ' %(resource_name)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) limit_id = self._extract_value_from_items('id', items) if add_clean_up: self.addCleanup( - self.openstack, 'limit delete %s' % limit_id, - cloud=SYSTEM_CLOUD + self.openstack, + 'limit delete %s' % limit_id, + cloud=SYSTEM_CLOUD, ) self.assert_show_fields(items, self.LIMIT_FIELDS) diff --git a/openstackclient/tests/functional/identity/v3/test_application_credential.py b/openstackclient/tests/functional/identity/v3/test_application_credential.py index daf64607..dbec1cb2 100644 --- a/openstackclient/tests/functional/identity/v3/test_application_credential.py +++ b/openstackclient/tests/functional/identity/v3/test_application_credential.py @@ -20,124 +20,164 @@ from openstackclient.tests.functional.identity.v3 import common class ApplicationCredentialTests(common.IdentityTests): - - APPLICATION_CREDENTIAL_FIELDS = ['id', 'name', 'project_id', - 'description', 'roles', 'expires_at', - 'unrestricted'] - APPLICATION_CREDENTIAL_LIST_HEADERS = ['ID', 'Name', 'Project ID', - 'Description', 'Expires At'] + APPLICATION_CREDENTIAL_FIELDS = [ + 'id', + 'name', + 'project_id', + 'description', + 'roles', + 'expires_at', + 'unrestricted', + ] + APPLICATION_CREDENTIAL_LIST_HEADERS = [ + 'ID', + 'Name', + 'Project ID', + 'Description', + 'Expires At', + ] def test_application_credential_create(self): name = data_utils.rand_name('name') - raw_output = self.openstack('application credential create %(name)s' - % {'name': name}) + raw_output = self.openstack( + 'application credential create %(name)s' % {'name': name} + ) self.addCleanup( self.openstack, - 'application credential delete %(name)s' % {'name': name}) + 'application credential delete %(name)s' % {'name': name}, + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.APPLICATION_CREDENTIAL_FIELDS) def _create_role_assignments(self): try: - user = self.openstack('configuration show -f value' - ' -c auth.username') + user = self.openstack( + 'configuration show -f value' ' -c auth.username' + ) except Exception: - user = self.openstack('configuration show -f value' - ' -c auth.user_id') + user = self.openstack( + 'configuration show -f value' ' -c auth.user_id' + ) try: - user_domain = self.openstack('configuration show -f value' - ' -c auth.user_domain_name') + user_domain = self.openstack( + 'configuration show -f value' ' -c auth.user_domain_name' + ) except Exception: - user_domain = self.openstack('configuration show -f value' - ' -c auth.user_domain_id') + user_domain = self.openstack( + 'configuration show -f value' ' -c auth.user_domain_id' + ) try: - project = self.openstack('configuration show -f value' - ' -c auth.project_name') + project = self.openstack( + 'configuration show -f value' ' -c auth.project_name' + ) except Exception: - project = self.openstack('configuration show -f value' - ' -c auth.project_id') + project = self.openstack( + 'configuration show -f value' ' -c auth.project_id' + ) try: - project_domain = self.openstack('configuration show -f value' - ' -c auth.project_domain_name') + project_domain = self.openstack( + 'configuration show -f value' ' -c auth.project_domain_name' + ) except Exception: - project_domain = self.openstack('configuration show -f value' - ' -c auth.project_domain_id') + project_domain = self.openstack( + 'configuration show -f value' ' -c auth.project_domain_id' + ) role1 = self._create_dummy_role() role2 = self._create_dummy_role() for role in role1, role2: - self.openstack('role add' - ' --user %(user)s' - ' --user-domain %(user_domain)s' - ' --project %(project)s' - ' --project-domain %(project_domain)s' - ' %(role)s' - % {'user': user, - 'user_domain': user_domain, - 'project': project, - 'project_domain': project_domain, - 'role': role}) - self.addCleanup(self.openstack, - 'role remove' - ' --user %(user)s' - ' --user-domain %(user_domain)s' - ' --project %(project)s' - ' --project-domain %(project_domain)s' - ' %(role)s' - % {'user': user, - 'user_domain': user_domain, - 'project': project, - 'project_domain': project_domain, - 'role': role}) + self.openstack( + 'role add' + ' --user %(user)s' + ' --user-domain %(user_domain)s' + ' --project %(project)s' + ' --project-domain %(project_domain)s' + ' %(role)s' + % { + 'user': user, + 'user_domain': user_domain, + 'project': project, + 'project_domain': project_domain, + 'role': role, + } + ) + self.addCleanup( + self.openstack, + 'role remove' + ' --user %(user)s' + ' --user-domain %(user_domain)s' + ' --project %(project)s' + ' --project-domain %(project_domain)s' + ' %(role)s' + % { + 'user': user, + 'user_domain': user_domain, + 'project': project, + 'project_domain': project_domain, + 'role': role, + }, + ) return role1, role2 def test_application_credential_create_with_options(self): name = data_utils.rand_name('name') secret = data_utils.rand_name('secret') description = data_utils.rand_name('description') - tomorrow = (datetime.datetime.utcnow() + - datetime.timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S%z') + tomorrow = ( + datetime.datetime.utcnow() + datetime.timedelta(days=1) + ).strftime('%Y-%m-%dT%H:%M:%S%z') role1, role2 = self._create_role_assignments() - raw_output = self.openstack('application credential create %(name)s' - ' --secret %(secret)s' - ' --description %(description)s' - ' --expiration %(tomorrow)s' - ' --role %(role1)s' - ' --role %(role2)s' - ' --unrestricted' - % {'name': name, - 'secret': secret, - 'description': description, - 'tomorrow': tomorrow, - 'role1': role1, - 'role2': role2}) + raw_output = self.openstack( + 'application credential create %(name)s' + ' --secret %(secret)s' + ' --description %(description)s' + ' --expiration %(tomorrow)s' + ' --role %(role1)s' + ' --role %(role2)s' + ' --unrestricted' + % { + 'name': name, + 'secret': secret, + 'description': description, + 'tomorrow': tomorrow, + 'role1': role1, + 'role2': role2, + } + ) self.addCleanup( self.openstack, - 'application credential delete %(name)s' % {'name': name}) + 'application credential delete %(name)s' % {'name': name}, + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.APPLICATION_CREDENTIAL_FIELDS) def test_application_credential_delete(self): name = data_utils.rand_name('name') - self.openstack('application credential create %(name)s' - % {'name': name}) - raw_output = self.openstack('application credential delete ' - '%(name)s' % {'name': name}) + self.openstack( + 'application credential create %(name)s' % {'name': name} + ) + raw_output = self.openstack( + 'application credential delete ' '%(name)s' % {'name': name} + ) self.assertEqual(0, len(raw_output)) def test_application_credential_list(self): raw_output = self.openstack('application credential list') items = self.parse_listing(raw_output) self.assert_table_structure( - items, self.APPLICATION_CREDENTIAL_LIST_HEADERS) + items, self.APPLICATION_CREDENTIAL_LIST_HEADERS + ) def test_application_credential_show(self): name = data_utils.rand_name('name') - raw_output = self.openstack('application credential create %(name)s' - % {'name': name}) + raw_output = self.openstack( + 'application credential create %(name)s' % {'name': name} + ) self.addCleanup( self.openstack, - 'application credential delete %(name)s' % {'name': name}) - raw_output = self.openstack('application credential show ' - '%(name)s' % {'name': name}) + 'application credential delete %(name)s' % {'name': name}, + ) + raw_output = self.openstack( + 'application credential show ' '%(name)s' % {'name': name} + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.APPLICATION_CREDENTIAL_FIELDS) diff --git a/openstackclient/tests/functional/identity/v3/test_catalog.py b/openstackclient/tests/functional/identity/v3/test_catalog.py index c8361406..9b6df2d1 100644 --- a/openstackclient/tests/functional/identity/v3/test_catalog.py +++ b/openstackclient/tests/functional/identity/v3/test_catalog.py @@ -14,7 +14,6 @@ from openstackclient.tests.functional.identity.v3 import common class CatalogTests(common.IdentityTests): - def test_catalog_list(self): raw_output = self.openstack('catalog list') items = self.parse_listing(raw_output) diff --git a/openstackclient/tests/functional/identity/v3/test_domain.py b/openstackclient/tests/functional/identity/v3/test_domain.py index d8946d1e..bf5020ca 100644 --- a/openstackclient/tests/functional/identity/v3/test_domain.py +++ b/openstackclient/tests/functional/identity/v3/test_domain.py @@ -17,15 +17,14 @@ from openstackclient.tests.functional.identity.v3 import common class DomainTests(common.IdentityTests): - def test_domain_create(self): domain_name = data_utils.rand_name('TestDomain') raw_output = self.openstack('domain create %s' % domain_name) # disable domain first before deleting it - self.addCleanup(self.openstack, - 'domain delete %s' % domain_name) - self.addCleanup(self.openstack, - 'domain set --disable %s' % domain_name) + self.addCleanup(self.openstack, 'domain delete %s' % domain_name) + self.addCleanup( + self.openstack, 'domain set --disable %s' % domain_name + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.DOMAIN_FIELDS) @@ -52,15 +51,18 @@ class DomainTests(common.IdentityTests): raw_output = self.openstack('domain set --disable %s' % domain_2) self.assertEqual(0, len(raw_output)) raw_output = self.openstack( - 'domain delete %s %s' % (domain_1, domain_2)) + 'domain delete %s %s' % (domain_1, domain_2) + ) self.assertEqual(0, len(raw_output)) def test_domain_delete_failure(self): domain_name = self._create_dummy_domain() # cannot delete enabled domain - self.assertRaises(exceptions.CommandFailed, - self.openstack, - 'domain delete %s' % domain_name) + self.assertRaises( + exceptions.CommandFailed, + self.openstack, + 'domain delete %s' % domain_name, + ) def test_domain_show(self): domain_name = self._create_dummy_domain() diff --git a/openstackclient/tests/functional/identity/v3/test_endpoint.py b/openstackclient/tests/functional/identity/v3/test_endpoint.py index 41f0b4c8..53f2bd22 100644 --- a/openstackclient/tests/functional/identity/v3/test_endpoint.py +++ b/openstackclient/tests/functional/identity/v3/test_endpoint.py @@ -16,7 +16,6 @@ from openstackclient.tests.functional.identity.v3 import common class EndpointTests(common.IdentityTests): - def test_endpoint_create(self): self._create_dummy_endpoint(interface='public') self._create_dummy_endpoint(interface='admin') @@ -24,15 +23,15 @@ class EndpointTests(common.IdentityTests): def test_endpoint_delete(self): endpoint_id = self._create_dummy_endpoint(add_clean_up=False) - raw_output = self.openstack( - 'endpoint delete %s' % endpoint_id) + raw_output = self.openstack('endpoint delete %s' % endpoint_id) self.assertEqual(0, len(raw_output)) def test_endpoint_multi_delete(self): endpoint_1 = self._create_dummy_endpoint(add_clean_up=False) endpoint_2 = self._create_dummy_endpoint(add_clean_up=False) raw_output = self.openstack( - 'endpoint delete %s %s' % (endpoint_1, endpoint_2)) + 'endpoint delete %s %s' % (endpoint_1, endpoint_2) + ) self.assertEqual(0, len(raw_output)) def test_endpoint_list(self): @@ -48,19 +47,18 @@ class EndpointTests(common.IdentityTests): raw_output = self.openstack( 'endpoint add project ' '%(endpoint_id)s ' - '%(project_id)s' % { - 'project_id': project_id, - 'endpoint_id': endpoint_id}) + '%(project_id)s' + % {'project_id': project_id, 'endpoint_id': endpoint_id} + ) self.assertEqual(0, len(raw_output)) raw_output = self.openstack( - 'endpoint list --endpoint %s' % endpoint_id) + 'endpoint list --endpoint %s' % endpoint_id + ) self.assertIn(project_id, raw_output) items = self.parse_listing(raw_output) - self.assert_table_structure(items, - self.ENDPOINT_LIST_PROJECT_HEADERS) + self.assert_table_structure(items, self.ENDPOINT_LIST_PROJECT_HEADERS) - raw_output = self.openstack( - 'endpoint list --project %s' % project_id) + raw_output = self.openstack('endpoint list --project %s' % project_id) self.assertIn(endpoint_id, raw_output) items = self.parse_listing(raw_output) self.assert_table_structure(items, self.ENDPOINT_LIST_HEADERS) @@ -73,9 +71,13 @@ class EndpointTests(common.IdentityTests): '--interface %(interface)s ' '--url %(url)s ' '--disable ' - '%(endpoint_id)s' % {'interface': 'admin', - 'url': new_endpoint_url, - 'endpoint_id': endpoint_id}) + '%(endpoint_id)s' + % { + 'interface': 'admin', + 'url': new_endpoint_url, + 'endpoint_id': endpoint_id, + } + ) self.assertEqual(0, len(raw_output)) raw_output = self.openstack('endpoint show %s' % endpoint_id) endpoint = self.parse_show_as_object(raw_output) @@ -95,15 +97,15 @@ class EndpointTests(common.IdentityTests): raw_output = self.openstack( 'endpoint add project ' '%(endpoint_id)s ' - '%(project_id)s' % { - 'project_id': project_id, - 'endpoint_id': endpoint_id}) + '%(project_id)s' + % {'project_id': project_id, 'endpoint_id': endpoint_id} + ) self.assertEqual(0, len(raw_output)) raw_output = self.openstack( 'endpoint remove project ' '%(endpoint_id)s ' - '%(project_id)s' % { - 'project_id': project_id, - 'endpoint_id': endpoint_id}) + '%(project_id)s' + % {'project_id': project_id, 'endpoint_id': endpoint_id} + ) self.assertEqual(0, len(raw_output)) diff --git a/openstackclient/tests/functional/identity/v3/test_group.py b/openstackclient/tests/functional/identity/v3/test_group.py index 917d5df0..95d74cb7 100644 --- a/openstackclient/tests/functional/identity/v3/test_group.py +++ b/openstackclient/tests/functional/identity/v3/test_group.py @@ -16,7 +16,6 @@ from openstackclient.tests.functional.identity.v3 import common class GroupTests(common.IdentityTests): - def test_group_create(self): self._create_dummy_group() @@ -30,7 +29,8 @@ class GroupTests(common.IdentityTests): def test_group_list_with_domain(self): group_name = self._create_dummy_group() raw_output = self.openstack( - 'group list --domain %s' % self.domain_name) + 'group list --domain %s' % self.domain_name + ) items = self.parse_listing(raw_output) self.assert_table_structure(items, common.BASIC_LIST_HEADERS) self.assertIn(group_name, raw_output) @@ -40,8 +40,8 @@ class GroupTests(common.IdentityTests): raw_output = self.openstack( 'group delete ' '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': group_name}) + '%(name)s' % {'domain': self.domain_name, 'name': group_name} + ) self.assertEqual(0, len(raw_output)) def test_group_show(self): @@ -49,8 +49,8 @@ class GroupTests(common.IdentityTests): raw_output = self.openstack( 'group show ' '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': group_name}) + '%(name)s' % {'domain': self.domain_name, 'name': group_name} + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.GROUP_FIELDS) @@ -61,15 +61,19 @@ class GroupTests(common.IdentityTests): 'group set ' '--domain %(domain)s ' '--name %(new_group)s ' - '%(group)s' % {'domain': self.domain_name, - 'new_group': new_group_name, - 'group': group_name}) + '%(group)s' + % { + 'domain': self.domain_name, + 'new_group': new_group_name, + 'group': group_name, + } + ) self.assertEqual(0, len(raw_output)) raw_output = self.openstack( 'group show ' '--domain %(domain)s ' - '%(group)s' % {'domain': self.domain_name, - 'group': new_group_name}) + '%(group)s' % {'domain': self.domain_name, 'group': new_group_name} + ) group = self.parse_show_as_object(raw_output) self.assertEqual(new_group_name, group['name']) # reset group name to make sure it will be cleaned up @@ -77,9 +81,13 @@ class GroupTests(common.IdentityTests): 'group set ' '--domain %(domain)s ' '--name %(new_group)s ' - '%(group)s' % {'domain': self.domain_name, - 'new_group': group_name, - 'group': new_group_name}) + '%(group)s' + % { + 'domain': self.domain_name, + 'new_group': group_name, + 'group': new_group_name, + } + ) self.assertEqual(0, len(raw_output)) def test_group_add_user(self): @@ -89,19 +97,27 @@ class GroupTests(common.IdentityTests): 'group add user ' '--group-domain %(group_domain)s ' '--user-domain %(user_domain)s ' - '%(group)s %(user)s' % {'group_domain': self.domain_name, - 'user_domain': self.domain_name, - 'group': group_name, - 'user': username}) + '%(group)s %(user)s' + % { + 'group_domain': self.domain_name, + 'user_domain': self.domain_name, + 'group': group_name, + 'user': username, + } + ) self.addCleanup( self.openstack, 'group remove user ' '--group-domain %(group_domain)s ' '--user-domain %(user_domain)s ' - '%(group)s %(user)s' % {'group_domain': self.domain_name, - 'user_domain': self.domain_name, - 'group': group_name, - 'user': username}) + '%(group)s %(user)s' + % { + 'group_domain': self.domain_name, + 'user_domain': self.domain_name, + 'group': group_name, + 'user': username, + }, + ) self.assertOutput('', raw_output) def test_group_contains_user(self): @@ -111,32 +127,45 @@ class GroupTests(common.IdentityTests): 'group add user ' '--group-domain %(group_domain)s ' '--user-domain %(user_domain)s ' - '%(group)s %(user)s' % {'group_domain': self.domain_name, - 'user_domain': self.domain_name, - 'group': group_name, - 'user': username}) + '%(group)s %(user)s' + % { + 'group_domain': self.domain_name, + 'user_domain': self.domain_name, + 'group': group_name, + 'user': username, + } + ) self.addCleanup( self.openstack, 'group remove user ' '--group-domain %(group_domain)s ' '--user-domain %(user_domain)s ' - '%(group)s %(user)s' % {'group_domain': self.domain_name, - 'user_domain': self.domain_name, - 'group': group_name, - 'user': username}) + '%(group)s %(user)s' + % { + 'group_domain': self.domain_name, + 'user_domain': self.domain_name, + 'group': group_name, + 'user': username, + }, + ) self.assertOutput('', raw_output) raw_output = self.openstack( 'group contains user ' '--group-domain %(group_domain)s ' '--user-domain %(user_domain)s ' - '%(group)s %(user)s' % {'group_domain': self.domain_name, - 'user_domain': self.domain_name, - 'group': group_name, - 'user': username}) + '%(group)s %(user)s' + % { + 'group_domain': self.domain_name, + 'user_domain': self.domain_name, + 'group': group_name, + 'user': username, + } + ) self.assertEqual( - '%(user)s in group %(group)s\n' % {'user': username, - 'group': group_name}, - raw_output) + '%(user)s in group %(group)s\n' + % {'user': username, 'group': group_name}, + raw_output, + ) def test_group_remove_user(self): group_name = self._create_dummy_group() @@ -145,17 +174,25 @@ class GroupTests(common.IdentityTests): 'group add user ' '--group-domain %(group_domain)s ' '--user-domain %(user_domain)s ' - '%(group)s %(user)s' % {'group_domain': self.domain_name, - 'user_domain': self.domain_name, - 'group': group_name, - 'user': username}) + '%(group)s %(user)s' + % { + 'group_domain': self.domain_name, + 'user_domain': self.domain_name, + 'group': group_name, + 'user': username, + } + ) remove_raw_output = self.openstack( 'group remove user ' '--group-domain %(group_domain)s ' '--user-domain %(user_domain)s ' - '%(group)s %(user)s' % {'group_domain': self.domain_name, - 'user_domain': self.domain_name, - 'group': group_name, - 'user': username}) + '%(group)s %(user)s' + % { + 'group_domain': self.domain_name, + 'user_domain': self.domain_name, + 'group': group_name, + 'user': username, + } + ) self.assertOutput('', add_raw_output) self.assertOutput('', remove_raw_output) diff --git a/openstackclient/tests/functional/identity/v3/test_idp.py b/openstackclient/tests/functional/identity/v3/test_idp.py index 5db3610a..b359da7c 100644 --- a/openstackclient/tests/functional/identity/v3/test_idp.py +++ b/openstackclient/tests/functional/identity/v3/test_idp.py @@ -23,21 +23,24 @@ class IdentityProviderTests(common.IdentityTests): def test_idp_delete(self): identity_provider = self._create_dummy_idp(add_clean_up=False) - raw_output = self.openstack('identity provider delete %s' - % identity_provider) + raw_output = self.openstack( + 'identity provider delete %s' % identity_provider + ) self.assertEqual(0, len(raw_output)) def test_idp_multi_delete(self): idp_1 = self._create_dummy_idp(add_clean_up=False) idp_2 = self._create_dummy_idp(add_clean_up=False) raw_output = self.openstack( - 'identity provider delete %s %s' % (idp_1, idp_2)) + 'identity provider delete %s %s' % (idp_1, idp_2) + ) self.assertEqual(0, len(raw_output)) def test_idp_show(self): identity_provider = self._create_dummy_idp(add_clean_up=True) - raw_output = self.openstack('identity provider show %s' - % identity_provider) + raw_output = self.openstack( + 'identity provider show %s' % identity_provider + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.IDENTITY_PROVIDER_FIELDS) @@ -50,13 +53,18 @@ class IdentityProviderTests(common.IdentityTests): def test_idp_set(self): identity_provider = self._create_dummy_idp(add_clean_up=True) new_remoteid = data_utils.rand_name('newRemoteId') - raw_output = self.openstack('identity provider set ' - '%(identity-provider)s ' - '--remote-id %(remote-id)s ' - % {'identity-provider': identity_provider, - 'remote-id': new_remoteid}) + raw_output = self.openstack( + 'identity provider set ' + '%(identity-provider)s ' + '--remote-id %(remote-id)s ' + % { + 'identity-provider': identity_provider, + 'remote-id': new_remoteid, + } + ) self.assertEqual(0, len(raw_output)) - raw_output = self.openstack('identity provider show %s' - % identity_provider) + raw_output = self.openstack( + 'identity provider show %s' % identity_provider + ) updated_value = self.parse_show_as_object(raw_output) self.assertIn(new_remoteid, updated_value['remote_ids']) diff --git a/openstackclient/tests/functional/identity/v3/test_limit.py b/openstackclient/tests/functional/identity/v3/test_limit.py index b03f0f28..32c65107 100644 --- a/openstackclient/tests/functional/identity/v3/test_limit.py +++ b/openstackclient/tests/functional/identity/v3/test_limit.py @@ -20,12 +20,11 @@ SYSTEM_CLOUD = os.environ.get('OS_SYSTEM_CLOUD', 'devstack-system-admin') class LimitTestCase(common.IdentityTests): - def test_limit_create_with_service_name(self): registered_limit_id = self._create_dummy_registered_limit() raw_output = self.openstack( 'registered limit show %s' % registered_limit_id, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) service_id = self._extract_value_from_items('service_id', items) @@ -44,7 +43,7 @@ class LimitTestCase(common.IdentityTests): 'project_id': project_id, 'service_name': service_name, 'resource_name': resource_name, - 'resource_limit': 15 + 'resource_limit': 15, } raw_output = self.openstack( 'limit create' @@ -52,14 +51,12 @@ class LimitTestCase(common.IdentityTests): ' --service %(service_name)s' ' --resource-limit %(resource_limit)s' ' %(resource_name)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) limit_id = self._extract_value_from_items('id', items) self.addCleanup( - self.openstack, - 'limit delete %s' % limit_id, - cloud=SYSTEM_CLOUD + self.openstack, 'limit delete %s' % limit_id, cloud=SYSTEM_CLOUD ) self.assert_show_fields(items, self.LIMIT_FIELDS) @@ -68,7 +65,7 @@ class LimitTestCase(common.IdentityTests): registered_limit_id = self._create_dummy_registered_limit() raw_output = self.openstack( 'registered limit show %s' % registered_limit_id, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) service_id = self._extract_value_from_items('service_id', items) @@ -84,7 +81,7 @@ class LimitTestCase(common.IdentityTests): 'project_name': project_name, 'service_name': service_name, 'resource_name': resource_name, - 'resource_limit': 15 + 'resource_limit': 15, } raw_output = self.openstack( 'limit create' @@ -92,14 +89,12 @@ class LimitTestCase(common.IdentityTests): ' --service %(service_name)s' ' --resource-limit %(resource_limit)s' ' %(resource_name)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) limit_id = self._extract_value_from_items('id', items) self.addCleanup( - self.openstack, - 'limit delete %s' % limit_id, - cloud=SYSTEM_CLOUD + self.openstack, 'limit delete %s' % limit_id, cloud=SYSTEM_CLOUD ) self.assert_show_fields(items, self.LIMIT_FIELDS) @@ -117,14 +112,14 @@ class LimitTestCase(common.IdentityTests): params = { 'region_id': region_id, - 'registered_limit_id': registered_limit_id + 'registered_limit_id': registered_limit_id, } raw_output = self.openstack( 'registered limit set' ' %(registered_limit_id)s' ' --region %(region_id)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) service_id = self._extract_value_from_items('service_id', items) @@ -142,7 +137,7 @@ class LimitTestCase(common.IdentityTests): 'resource_name': resource_name, 'resource_limit': 15, 'region_id': region_id, - 'description': description + 'description': description, } raw_output = self.openstack( 'limit create' @@ -152,14 +147,12 @@ class LimitTestCase(common.IdentityTests): ' --region %(region_id)s' ' --description %(description)s' ' %(resource_name)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) limit_id = self._extract_value_from_items('id', items) self.addCleanup( - self.openstack, - 'limit delete %s' % limit_id, - cloud=SYSTEM_CLOUD + self.openstack, 'limit delete %s' % limit_id, cloud=SYSTEM_CLOUD ) self.assert_show_fields(items, self.LIMIT_FIELDS) @@ -167,8 +160,7 @@ class LimitTestCase(common.IdentityTests): def test_limit_show(self): limit_id = self._create_dummy_limit() raw_output = self.openstack( - 'limit show %s' % limit_id, - cloud=SYSTEM_CLOUD + 'limit show %s' % limit_id, cloud=SYSTEM_CLOUD ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.LIMIT_FIELDS) @@ -178,14 +170,14 @@ class LimitTestCase(common.IdentityTests): params = { 'description': data_utils.arbitrary_string(), - 'limit_id': limit_id + 'limit_id': limit_id, } raw_output = self.openstack( 'limit set' ' --description %(description)s' ' %(limit_id)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.LIMIT_FIELDS) @@ -193,16 +185,13 @@ class LimitTestCase(common.IdentityTests): def test_limit_set_resource_limit(self): limit_id = self._create_dummy_limit() - params = { - 'resource_limit': 5, - 'limit_id': limit_id - } + params = {'resource_limit': 5, 'limit_id': limit_id} raw_output = self.openstack( 'limit set' ' --resource-limit %(resource_limit)s' ' %(limit_id)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.LIMIT_FIELDS) @@ -216,6 +205,6 @@ class LimitTestCase(common.IdentityTests): def test_limit_delete(self): limit_id = self._create_dummy_limit(add_clean_up=False) raw_output = self.openstack( - 'limit delete %s' % limit_id, - cloud=SYSTEM_CLOUD) + 'limit delete %s' % limit_id, cloud=SYSTEM_CLOUD + ) self.assertEqual(0, len(raw_output)) diff --git a/openstackclient/tests/functional/identity/v3/test_project.py b/openstackclient/tests/functional/identity/v3/test_project.py index b3d31aa7..d91ba87a 100644 --- a/openstackclient/tests/functional/identity/v3/test_project.py +++ b/openstackclient/tests/functional/identity/v3/test_project.py @@ -16,7 +16,6 @@ from openstackclient.tests.functional.identity.v3 import common class ProjectTests(common.IdentityTests): - def test_project_create(self): project_name = data_utils.rand_name('TestProject') description = data_utils.rand_name('description') @@ -27,15 +26,18 @@ class ProjectTests(common.IdentityTests): '--enable ' '--property k1=v1 ' '--property k2=v2 ' - '%(name)s' % {'domain': self.domain_name, - 'description': description, - 'name': project_name}) + '%(name)s' + % { + 'domain': self.domain_name, + 'description': description, + 'name': project_name, + } + ) self.addCleanup( self.openstack, 'project delete ' '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': project_name} + '%(name)s' % {'domain': self.domain_name, 'name': project_name}, ) items = self.parse_show(raw_output) show_fields = list(self.PROJECT_FIELDS) @@ -50,8 +52,8 @@ class ProjectTests(common.IdentityTests): raw_output = self.openstack( 'project delete ' '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': project_name}) + '%(name)s' % {'domain': self.domain_name, 'name': project_name} + ) self.assertEqual(0, len(raw_output)) def test_project_list(self): @@ -62,7 +64,8 @@ class ProjectTests(common.IdentityTests): def test_project_list_with_domain(self): project_name = self._create_dummy_project() raw_output = self.openstack( - 'project list --domain %s' % self.domain_name) + 'project list --domain %s' % self.domain_name + ) items = self.parse_listing(raw_output) self.assert_table_structure(items, common.BASIC_LIST_HEADERS) self.assertIn(project_name, raw_output) @@ -76,15 +79,14 @@ class ProjectTests(common.IdentityTests): '--name %(new_name)s ' '--disable ' '--property k0=v0 ' - '%(name)s' % {'new_name': new_project_name, - 'name': project_name}) + '%(name)s' % {'new_name': new_project_name, 'name': project_name} + ) self.assertEqual(0, len(raw_output)) # check project details raw_output = self.openstack( 'project show ' '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': new_project_name} + '%(name)s' % {'domain': self.domain_name, 'name': new_project_name} ) items = self.parse_show(raw_output) fields = list(self.PROJECT_FIELDS) @@ -99,15 +101,16 @@ class ProjectTests(common.IdentityTests): 'project set ' '--name %(new_name)s ' '--enable ' - '%(name)s' % {'new_name': project_name, - 'name': new_project_name}) + '%(name)s' % {'new_name': project_name, 'name': new_project_name} + ) def test_project_show(self): raw_output = self.openstack( 'project show ' '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': self.project_name}) + '%(name)s' + % {'domain': self.domain_name, 'name': self.project_name} + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.PROJECT_FIELDS) @@ -116,10 +119,10 @@ class ProjectTests(common.IdentityTests): 'project show ' '--parents --children ' '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': self.project_name}, + '%(name)s' + % {'domain': self.domain_name, 'name': self.project_name}, parse_output=True, ) - for attr_name in (self.PROJECT_FIELDS + ['parents', 'subtree']): + for attr_name in self.PROJECT_FIELDS + ['parents', 'subtree']: self.assertIn(attr_name, output) self.assertEqual(self.project_name, output.get('name')) diff --git a/openstackclient/tests/functional/identity/v3/test_region.py b/openstackclient/tests/functional/identity/v3/test_region.py index 2a402bd1..bc014737 100644 --- a/openstackclient/tests/functional/identity/v3/test_region.py +++ b/openstackclient/tests/functional/identity/v3/test_region.py @@ -14,7 +14,6 @@ from openstackclient.tests.functional.identity.v3 import common class RegionTests(common.IdentityTests): - def test_region_create(self): self._create_dummy_region() @@ -31,7 +30,8 @@ class RegionTests(common.IdentityTests): region_1 = self._create_dummy_region(add_clean_up=False) region_2 = self._create_dummy_region(add_clean_up=False) raw_output = self.openstack( - 'region delete %s %s' % (region_1, region_2)) + 'region delete %s %s' % (region_1, region_2) + ) self.assertEqual(0, len(raw_output)) def test_region_list(self): @@ -53,8 +53,9 @@ class RegionTests(common.IdentityTests): raw_output = self.openstack( 'region set ' '--parent-region %(parent_region)s ' - '%(region)s' % {'parent_region': new_parent_region_id, - 'region': region_id}) + '%(region)s' + % {'parent_region': new_parent_region_id, 'region': region_id} + ) self.assertEqual(0, len(raw_output)) # check updated region details raw_output = self.openstack('region show %s' % region_id) diff --git a/openstackclient/tests/functional/identity/v3/test_registered_limit.py b/openstackclient/tests/functional/identity/v3/test_registered_limit.py index 80f51ad9..6e3c30ae 100644 --- a/openstackclient/tests/functional/identity/v3/test_registered_limit.py +++ b/openstackclient/tests/functional/identity/v3/test_registered_limit.py @@ -20,15 +20,13 @@ SYSTEM_CLOUD = os.environ.get('OS_SYSTEM_CLOUD', 'devstack-system-admin') class RegisteredLimitTestCase(common.IdentityTests): - def test_registered_limit_create_with_service_name(self): self._create_dummy_registered_limit() def test_registered_limit_create_with_service_id(self): service_name = self._create_dummy_service() raw_output = self.openstack( - 'service show' - ' %(service_name)s' % {'service_name': service_name} + 'service show' ' %(service_name)s' % {'service_name': service_name} ) service_items = self.parse_show(raw_output) service_id = self._extract_value_from_items('id', service_items) @@ -37,22 +35,22 @@ class RegisteredLimitTestCase(common.IdentityTests): 'registered limit create' ' --service %(service_id)s' ' --default-limit %(default_limit)s' - ' %(resource_name)s' % { + ' %(resource_name)s' + % { 'service_id': service_id, 'default_limit': 10, - 'resource_name': 'cores' + 'resource_name': 'cores', }, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) registered_limit_id = self._extract_value_from_items('id', items) self.addCleanup( self.openstack, 'registered limit delete' - ' %(registered_limit_id)s' % { - 'registered_limit_id': registered_limit_id - }, - cloud=SYSTEM_CLOUD + ' %(registered_limit_id)s' + % {'registered_limit_id': registered_limit_id}, + cloud=SYSTEM_CLOUD, ) self.assert_show_fields(items, self.REGISTERED_LIMIT_FIELDS) @@ -65,7 +63,7 @@ class RegisteredLimitTestCase(common.IdentityTests): 'resource_name': 'cores', 'default_limit': 10, 'description': 'default limit for cores', - 'region_id': region_id + 'region_id': region_id, } raw_output = self.openstack( @@ -75,16 +73,15 @@ class RegisteredLimitTestCase(common.IdentityTests): ' --service %(service_name)s' ' --default-limit %(default_limit)s' ' %(resource_name)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) registered_limit_id = self._extract_value_from_items('id', items) self.addCleanup( self.openstack, - 'registered limit delete %(registered_limit_id)s' % { - 'registered_limit_id': registered_limit_id - }, - cloud=SYSTEM_CLOUD + 'registered limit delete %(registered_limit_id)s' + % {'registered_limit_id': registered_limit_id}, + cloud=SYSTEM_CLOUD, ) self.assert_show_fields(items, self.REGISTERED_LIMIT_FIELDS) @@ -92,9 +89,8 @@ class RegisteredLimitTestCase(common.IdentityTests): def test_registered_limit_show(self): registered_limit_id = self._create_dummy_registered_limit() raw_output = self.openstack( - 'registered limit show %(registered_limit_id)s' % { - 'registered_limit_id': registered_limit_id - } + 'registered limit show %(registered_limit_id)s' + % {'registered_limit_id': registered_limit_id} ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.REGISTERED_LIMIT_FIELDS) @@ -105,13 +101,13 @@ class RegisteredLimitTestCase(common.IdentityTests): params = { 'registered_limit_id': registered_limit_id, - 'region_id': region_id + 'region_id': region_id, } raw_output = self.openstack( 'registered limit set' ' %(registered_limit_id)s' ' --region %(region_id)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.REGISTERED_LIMIT_FIELDS) @@ -120,13 +116,13 @@ class RegisteredLimitTestCase(common.IdentityTests): registered_limit_id = self._create_dummy_registered_limit() params = { 'registered_limit_id': registered_limit_id, - 'description': 'updated description' + 'description': 'updated description', } raw_output = self.openstack( 'registered limit set' ' %(registered_limit_id)s' ' --description \'%(description)s\'' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.REGISTERED_LIMIT_FIELDS) @@ -136,13 +132,13 @@ class RegisteredLimitTestCase(common.IdentityTests): service_name = self._create_dummy_service() params = { 'registered_limit_id': registered_limit_id, - 'service': service_name + 'service': service_name, } raw_output = self.openstack( 'registered limit set' ' %(registered_limit_id)s' ' --service %(service)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.REGISTERED_LIMIT_FIELDS) @@ -151,13 +147,13 @@ class RegisteredLimitTestCase(common.IdentityTests): registered_limit_id = self._create_dummy_registered_limit() params = { 'registered_limit_id': registered_limit_id, - 'default_limit': 20 + 'default_limit': 20, } raw_output = self.openstack( 'registered limit set' ' %(registered_limit_id)s' ' --default-limit %(default_limit)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.REGISTERED_LIMIT_FIELDS) @@ -167,13 +163,13 @@ class RegisteredLimitTestCase(common.IdentityTests): resource_name = data_utils.rand_name('resource_name') params = { 'registered_limit_id': registered_limit_id, - 'resource_name': resource_name + 'resource_name': resource_name, } raw_output = self.openstack( 'registered limit set' ' %(registered_limit_id)s' ' --resource-name %(resource_name)s' % params, - cloud=SYSTEM_CLOUD + cloud=SYSTEM_CLOUD, ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.REGISTERED_LIMIT_FIELDS) @@ -190,9 +186,8 @@ class RegisteredLimitTestCase(common.IdentityTests): ) raw_output = self.openstack( 'registered limit delete' - ' %(registered_limit_id)s' % { - 'registered_limit_id': registered_limit_id - }, - cloud=SYSTEM_CLOUD + ' %(registered_limit_id)s' + % {'registered_limit_id': registered_limit_id}, + cloud=SYSTEM_CLOUD, ) self.assertEqual(0, len(raw_output)) diff --git a/openstackclient/tests/functional/identity/v3/test_role.py b/openstackclient/tests/functional/identity/v3/test_role.py index 3954c4e3..328a14c3 100644 --- a/openstackclient/tests/functional/identity/v3/test_role.py +++ b/openstackclient/tests/functional/identity/v3/test_role.py @@ -16,7 +16,6 @@ from openstackclient.tests.functional.identity.v3 import common class RoleTests(common.IdentityTests): - def test_role_create(self): self._create_dummy_role() @@ -26,8 +25,8 @@ class RoleTests(common.IdentityTests): raw_output = self.openstack( 'role create ' '--description %(description)s ' - '%(name)s' % {'description': description, - 'name': role_name}) + '%(name)s' % {'description': description, 'name': role_name} + ) role = self.parse_show_as_object(raw_output) self.addCleanup(self.openstack, 'role delete %s' % role['id']) items = self.parse_show(raw_output) @@ -56,7 +55,8 @@ class RoleTests(common.IdentityTests): role_name = self._create_dummy_role() new_role_name = data_utils.rand_name('NewTestRole') raw_output = self.openstack( - 'role set --name %s %s' % (new_role_name, role_name)) + 'role set --name %s %s' % (new_role_name, role_name) + ) self.assertEqual(0, len(raw_output)) raw_output = self.openstack('role show %s' % new_role_name) role = self.parse_show_as_object(raw_output) @@ -65,8 +65,9 @@ class RoleTests(common.IdentityTests): def test_role_set_description(self): role_name = self._create_dummy_role() description = data_utils.rand_name("NewDescription") - raw_output = self.openstack('role set --description %s %s' - % (description, role_name)) + raw_output = self.openstack( + 'role set --description %s %s' % (description, role_name) + ) self.assertEqual(0, len(raw_output)) raw_output = self.openstack('role show %s' % role_name) role = self.parse_show_as_object(raw_output) @@ -81,11 +82,15 @@ class RoleTests(common.IdentityTests): '--project-domain %(project_domain)s ' '--user %(user)s ' '--user-domain %(user_domain)s ' - '%(role)s' % {'project': self.project_name, - 'project_domain': self.domain_name, - 'user': username, - 'user_domain': self.domain_name, - 'role': role_name}) + '%(role)s' + % { + 'project': self.project_name, + 'project_domain': self.domain_name, + 'user': username, + 'user_domain': self.domain_name, + 'role': role_name, + } + ) self.addCleanup( self.openstack, 'role remove ' @@ -93,11 +98,15 @@ class RoleTests(common.IdentityTests): '--project-domain %(project_domain)s ' '--user %(user)s ' '--user-domain %(user_domain)s ' - '%(role)s' % {'project': self.project_name, - 'project_domain': self.domain_name, - 'user': username, - 'user_domain': self.domain_name, - 'role': role_name}) + '%(role)s' + % { + 'project': self.project_name, + 'project_domain': self.domain_name, + 'user': username, + 'user_domain': self.domain_name, + 'role': role_name, + }, + ) self.assertEqual(0, len(raw_output)) def test_role_remove(self): @@ -109,22 +118,30 @@ class RoleTests(common.IdentityTests): '--project-domain %(project_domain)s ' '--user %(user)s ' '--user-domain %(user_domain)s ' - '%(role)s' % {'project': self.project_name, - 'project_domain': self.domain_name, - 'user': username, - 'user_domain': self.domain_name, - 'role': role_name}) + '%(role)s' + % { + 'project': self.project_name, + 'project_domain': self.domain_name, + 'user': username, + 'user_domain': self.domain_name, + 'role': role_name, + } + ) remove_raw_output = self.openstack( 'role remove ' '--project %(project)s ' '--project-domain %(project_domain)s ' '--user %(user)s ' '--user-domain %(user_domain)s ' - '%(role)s' % {'project': self.project_name, - 'project_domain': self.domain_name, - 'user': username, - 'user_domain': self.domain_name, - 'role': role_name}) + '%(role)s' + % { + 'project': self.project_name, + 'project_domain': self.domain_name, + 'user': username, + 'user_domain': self.domain_name, + 'role': role_name, + } + ) self.assertEqual(0, len(add_raw_output)) self.assertEqual(0, len(remove_raw_output)) @@ -141,14 +158,14 @@ class RoleTests(common.IdentityTests): self.openstack( 'implied role create ' '--implied-role %(implied_role)s ' - '%(role)s' % {'implied_role': implied_role_name, - 'role': role_name}) + '%(role)s' % {'implied_role': implied_role_name, 'role': role_name} + ) def test_implied_role_delete(self): implied_role_name, role_name = self._create_dummy_implied_role() raw_output = self.openstack( 'implied role delete ' '--implied-role %(implied_role)s ' - '%(role)s' % {'implied_role': implied_role_name, - 'role': role_name}) + '%(role)s' % {'implied_role': implied_role_name, 'role': role_name} + ) self.assertEqual(0, len(raw_output)) diff --git a/openstackclient/tests/functional/identity/v3/test_service.py b/openstackclient/tests/functional/identity/v3/test_service.py index 1ecda45a..5d59b65e 100644 --- a/openstackclient/tests/functional/identity/v3/test_service.py +++ b/openstackclient/tests/functional/identity/v3/test_service.py @@ -16,7 +16,6 @@ from openstackclient.tests.functional.identity.v3 import common class ServiceTests(common.IdentityTests): - def test_service_create(self): self._create_dummy_service() @@ -29,7 +28,8 @@ class ServiceTests(common.IdentityTests): service_1 = self._create_dummy_service(add_clean_up=False) service_2 = self._create_dummy_service(add_clean_up=False) raw_output = self.openstack( - 'service delete %s %s' % (service_1, service_2)) + 'service delete %s %s' % (service_1, service_2) + ) self.assertEqual(0, len(raw_output)) def test_service_list(self): @@ -50,10 +50,14 @@ class ServiceTests(common.IdentityTests): '--name %(name)s ' '--description %(description)s ' '--disable ' - '%(service)s' % {'type': new_service_type, - 'name': new_service_name, - 'description': new_service_description, - 'service': service_name}) + '%(service)s' + % { + 'type': new_service_type, + 'name': new_service_name, + 'description': new_service_description, + 'service': service_name, + } + ) self.assertEqual(0, len(raw_output)) # get service details raw_output = self.openstack('service show %s' % new_service_name) @@ -65,7 +69,6 @@ class ServiceTests(common.IdentityTests): def test_service_show(self): service_name = self._create_dummy_service() - raw_output = self.openstack( - 'service show %s' % service_name) + raw_output = self.openstack('service show %s' % service_name) items = self.parse_show(raw_output) self.assert_show_fields(items, self.SERVICE_FIELDS) diff --git a/openstackclient/tests/functional/identity/v3/test_service_provider.py b/openstackclient/tests/functional/identity/v3/test_service_provider.py index 32b7a463..d6750595 100644 --- a/openstackclient/tests/functional/identity/v3/test_service_provider.py +++ b/openstackclient/tests/functional/identity/v3/test_service_provider.py @@ -23,21 +23,24 @@ class ServiceProviderTests(common.IdentityTests): def test_sp_delete(self): service_provider = self._create_dummy_sp(add_clean_up=False) - raw_output = self.openstack('service provider delete %s' - % service_provider) + raw_output = self.openstack( + 'service provider delete %s' % service_provider + ) self.assertEqual(0, len(raw_output)) def test_sp_multi_delete(self): sp1 = self._create_dummy_sp(add_clean_up=False) sp2 = self._create_dummy_sp(add_clean_up=False) raw_output = self.openstack( - 'service provider delete %s %s' % (sp1, sp2)) + 'service provider delete %s %s' % (sp1, sp2) + ) self.assertEqual(0, len(raw_output)) def test_sp_show(self): service_provider = self._create_dummy_sp(add_clean_up=True) - raw_output = self.openstack('service provider show %s' - % service_provider) + raw_output = self.openstack( + 'service provider show %s' % service_provider + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.SERVICE_PROVIDER_FIELDS) @@ -50,13 +53,18 @@ class ServiceProviderTests(common.IdentityTests): def test_sp_set(self): service_provider = self._create_dummy_sp(add_clean_up=True) new_description = data_utils.rand_name('newDescription') - raw_output = self.openstack('service provider set ' - '%(service-provider)s ' - '--description %(description)s ' - % {'service-provider': service_provider, - 'description': new_description}) + raw_output = self.openstack( + 'service provider set ' + '%(service-provider)s ' + '--description %(description)s ' + % { + 'service-provider': service_provider, + 'description': new_description, + } + ) self.assertEqual(0, len(raw_output)) - raw_output = self.openstack('service provider show %s' - % service_provider) + raw_output = self.openstack( + 'service provider show %s' % service_provider + ) updated_value = self.parse_show_as_object(raw_output) self.assertIn(new_description, updated_value['description']) diff --git a/openstackclient/tests/functional/identity/v3/test_token.py b/openstackclient/tests/functional/identity/v3/test_token.py index 62e90003..b6b0d8b1 100644 --- a/openstackclient/tests/functional/identity/v3/test_token.py +++ b/openstackclient/tests/functional/identity/v3/test_token.py @@ -14,7 +14,6 @@ from openstackclient.tests.functional.identity.v3 import common class TokenTests(common.IdentityTests): - def test_token_issue(self): raw_output = self.openstack('token issue') items = self.parse_show(raw_output) diff --git a/openstackclient/tests/functional/identity/v3/test_user.py b/openstackclient/tests/functional/identity/v3/test_user.py index 9e9bde96..917da4a3 100644 --- a/openstackclient/tests/functional/identity/v3/test_user.py +++ b/openstackclient/tests/functional/identity/v3/test_user.py @@ -16,16 +16,16 @@ from openstackclient.tests.functional.identity.v3 import common class UserTests(common.IdentityTests): - def test_user_create(self): self._create_dummy_user() def test_user_delete(self): username = self._create_dummy_user(add_clean_up=False) - raw_output = self.openstack('user delete ' - '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': username}) + raw_output = self.openstack( + 'user delete ' + '--domain %(domain)s ' + '%(name)s' % {'domain': self.domain_name, 'name': username} + ) self.assertEqual(0, len(raw_output)) def test_user_list(self): @@ -35,24 +35,27 @@ class UserTests(common.IdentityTests): def test_user_set(self): username = self._create_dummy_user() - raw_output = self.openstack('user show ' - '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': username}) + raw_output = self.openstack( + 'user show ' + '--domain %(domain)s ' + '%(name)s' % {'domain': self.domain_name, 'name': username} + ) user = self.parse_show_as_object(raw_output) new_username = data_utils.rand_name('NewTestUser') new_email = data_utils.rand_name() + '@example.com' - raw_output = self.openstack('user set ' - '--email %(email)s ' - '--name %(new_name)s ' - '%(id)s' % {'email': new_email, - 'new_name': new_username, - 'id': user['id']}) + raw_output = self.openstack( + 'user set ' + '--email %(email)s ' + '--name %(new_name)s ' + '%(id)s' + % {'email': new_email, 'new_name': new_username, 'id': user['id']} + ) self.assertEqual(0, len(raw_output)) - raw_output = self.openstack('user show ' - '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': new_username}) + raw_output = self.openstack( + 'user show ' + '--domain %(domain)s ' + '%(name)s' % {'domain': self.domain_name, 'name': new_username} + ) updated_user = self.parse_show_as_object(raw_output) self.assertEqual(user['id'], updated_user['id']) self.assertEqual(new_email, updated_user['email']) @@ -61,31 +64,38 @@ class UserTests(common.IdentityTests): username = self._create_dummy_user() project_name = self._create_dummy_project() # get original user details - raw_output = self.openstack('user show ' - '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': username}) + raw_output = self.openstack( + 'user show ' + '--domain %(domain)s ' + '%(name)s' % {'domain': self.domain_name, 'name': username} + ) user = self.parse_show_as_object(raw_output) # update user - raw_output = self.openstack('user set ' - '--project %(project)s ' - '--project-domain %(project_domain)s ' - '%(id)s' % {'project': project_name, - 'project_domain': - self.domain_name, - 'id': user['id']}) + raw_output = self.openstack( + 'user set ' + '--project %(project)s ' + '--project-domain %(project_domain)s ' + '%(id)s' + % { + 'project': project_name, + 'project_domain': self.domain_name, + 'id': user['id'], + } + ) self.assertEqual(0, len(raw_output)) # get updated user details - raw_output = self.openstack('user show ' - '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': username}) + raw_output = self.openstack( + 'user show ' + '--domain %(domain)s ' + '%(name)s' % {'domain': self.domain_name, 'name': username} + ) updated_user = self.parse_show_as_object(raw_output) # get project details - raw_output = self.openstack('project show ' - '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': project_name}) + raw_output = self.openstack( + 'project show ' + '--domain %(domain)s ' + '%(name)s' % {'domain': self.domain_name, 'name': project_name} + ) project = self.parse_show_as_object(raw_output) # check updated user details self.assertEqual(user['id'], updated_user['id']) @@ -93,9 +103,10 @@ class UserTests(common.IdentityTests): def test_user_show(self): username = self._create_dummy_user() - raw_output = self.openstack('user show ' - '--domain %(domain)s ' - '%(name)s' % {'domain': self.domain_name, - 'name': username}) + raw_output = self.openstack( + 'user show ' + '--domain %(domain)s ' + '%(name)s' % {'domain': self.domain_name, 'name': username} + ) items = self.parse_show(raw_output) self.assert_show_fields(items, self.USER_FIELDS) diff --git a/openstackclient/tests/unit/identity/v2_0/fakes.py b/openstackclient/tests/unit/identity/v2_0/fakes.py index bd76a784..708f9a83 100644 --- a/openstackclient/tests/unit/identity/v2_0/fakes.py +++ b/openstackclient/tests/unit/identity/v2_0/fakes.py @@ -155,7 +155,6 @@ def fake_auth_ref(fake_token, fake_service=None): class FakeIdentityv2Client(object): - def __init__(self, **kwargs): self.roles = mock.Mock() self.roles.resource_class = fakes.FakeResource(None, {}) @@ -185,7 +184,6 @@ class FakeIdentityv2Client(object): class TestIdentityv2(utils.TestCommand): - def setUp(self): super(TestIdentityv2, self).setUp() @@ -212,22 +210,25 @@ class FakeExtension(object): # Set default attributes. extension_info = { 'name': 'name-' + uuid.uuid4().hex, - 'namespace': ('http://docs.openstack.org/identity/' - 'api/ext/OS-KSCRUD/v1.0'), + '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"}]') + '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) + info=copy.deepcopy(extension_info), loaded=True + ) return extension @@ -275,8 +276,8 @@ class FakeCatalog(object): catalog_info.update(attrs) catalog = fakes.FakeResource( - info=copy.deepcopy(catalog_info), - loaded=True) + info=copy.deepcopy(catalog_info), loaded=True + ) return catalog @@ -305,8 +306,9 @@ class FakeProject(object): } project_info.update(attrs) - project = fakes.FakeResource(info=copy.deepcopy(project_info), - loaded=True) + project = fakes.FakeResource( + info=copy.deepcopy(project_info), loaded=True + ) return project @staticmethod @@ -352,12 +354,12 @@ class FakeEndpoint(object): '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) + endpoint = fakes.FakeResource( + info=copy.deepcopy(endpoint_info), loaded=True + ) return endpoint @staticmethod @@ -399,12 +401,12 @@ class FakeService(object): '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) + service = fakes.FakeResource( + info=copy.deepcopy(service_info), loaded=True + ) return service @staticmethod @@ -447,8 +449,7 @@ class FakeRole(object): } role_info.update(attrs) - role = fakes.FakeResource(info=copy.deepcopy(role_info), - loaded=True) + role = fakes.FakeResource(info=copy.deepcopy(role_info), loaded=True) return role @staticmethod @@ -493,8 +494,7 @@ class FakeUser(object): } user_info.update(attrs) - user = fakes.FakeResource(info=copy.deepcopy(user_info), - loaded=True) + user = fakes.FakeResource(info=copy.deepcopy(user_info), loaded=True) return user @staticmethod diff --git a/openstackclient/tests/unit/identity/v2_0/test_catalog.py b/openstackclient/tests/unit/identity/v2_0/test_catalog.py index bfb28f69..c420d33c 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_catalog.py +++ b/openstackclient/tests/unit/identity/v2_0/test_catalog.py @@ -19,7 +19,6 @@ from openstackclient.tests.unit import utils class TestCatalog(utils.TestCommand): - service_catalog = identity_fakes.FakeCatalog.create_catalog() def setUp(self): @@ -37,7 +36,6 @@ class TestCatalog(utils.TestCommand): class TestCatalogList(TestCatalog): - columns = ( 'Name', 'Type', @@ -68,12 +66,15 @@ class TestCatalogList(TestCatalog): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.columns, columns) - datalist = (( - 'supernova', - 'compute', - catalog.EndpointsColumn( - auth_ref.service_catalog.catalog[0]['endpoints']), - ), ) + datalist = ( + ( + 'supernova', + 'compute', + catalog.EndpointsColumn( + auth_ref.service_catalog.catalog[0]['endpoints'] + ), + ), + ) self.assertCountEqual(datalist, tuple(data)) def test_catalog_list_with_endpoint_url(self): @@ -111,17 +112,19 @@ class TestCatalogList(TestCatalog): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.columns, columns) - datalist = (( - 'supernova', - 'compute', - catalog.EndpointsColumn( - auth_ref.service_catalog.catalog[0]['endpoints']), - ), ) + datalist = ( + ( + 'supernova', + 'compute', + catalog.EndpointsColumn( + auth_ref.service_catalog.catalog[0]['endpoints'] + ), + ), + ) self.assertCountEqual(datalist, tuple(data)) class TestCatalogShow(TestCatalog): - def setUp(self): super(TestCatalogShow, self).setUp() @@ -153,7 +156,8 @@ class TestCatalogShow(TestCatalog): self.assertEqual(collist, columns) datalist = ( catalog.EndpointsColumn( - auth_ref.service_catalog.catalog[0]['endpoints']), + auth_ref.service_catalog.catalog[0]['endpoints'] + ), self.service_catalog.id, 'supernova', 'compute', @@ -174,7 +178,8 @@ class TestFormatColumns(TestCatalog): '\n publicURL: https://public.none.example.com\n ' 'internalURL: https://internal.none.example.com\n ' 'adminURL: https://admin.none.example.com\n', - col.human_readable()) + col.human_readable(), + ) def test_endpoints_column_human_readable_with_partial_endpoint_urls(self): endpoints = [ @@ -193,4 +198,5 @@ class TestFormatColumns(TestCatalog): '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', - col.human_readable()) + col.human_readable(), + ) diff --git a/openstackclient/tests/unit/identity/v2_0/test_endpoint.py b/openstackclient/tests/unit/identity/v2_0/test_endpoint.py index 915e04a5..5de396c4 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_endpoint.py +++ b/openstackclient/tests/unit/identity/v2_0/test_endpoint.py @@ -16,7 +16,6 @@ from openstackclient.tests.unit.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, @@ -37,7 +36,6 @@ class TestEndpoint(identity_fakes.TestIdentityv2): class TestEndpointCreate(TestEndpoint): - def setUp(self): super(TestEndpointCreate, self).setUp() @@ -50,10 +48,14 @@ class TestEndpointCreate(TestEndpoint): 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, + '--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 = [ @@ -80,8 +82,16 @@ class TestEndpointCreate(TestEndpoint): self.fake_endpoint.internalurl, ) - collist = ('adminurl', 'id', 'internalurl', 'publicurl', - 'region', 'service_id', 'service_name', 'service_type') + collist = ( + 'adminurl', + 'id', + 'internalurl', + 'publicurl', + 'region', + 'service_id', + 'service_name', + 'service_type', + ) self.assertEqual(collist, columns) datalist = ( self.fake_endpoint.adminurl, @@ -98,7 +108,6 @@ class TestEndpointCreate(TestEndpoint): class TestEndpointDelete(TestEndpoint): - def setUp(self): super(TestEndpointDelete, self).setUp() @@ -126,7 +135,6 @@ class TestEndpointDelete(TestEndpoint): class TestEndpointList(TestEndpoint): - def setUp(self): super(TestEndpointList, self).setUp() @@ -151,12 +159,14 @@ class TestEndpointList(TestEndpoint): 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, - ), ) + 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): @@ -175,23 +185,31 @@ class TestEndpointList(TestEndpoint): self.endpoints_mock.list.assert_called_with() - collist = ('ID', 'Region', 'Service Name', 'Service Type', - 'PublicURL', 'AdminURL', 'InternalURL') + 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, - ), ) + 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() @@ -223,8 +241,16 @@ class TestEndpointShow(TestEndpoint): self.fake_endpoint.service_id, ) - collist = ('adminurl', 'id', 'internalurl', 'publicurl', - 'region', 'service_id', 'service_name', 'service_type') + collist = ( + 'adminurl', + 'id', + 'internalurl', + 'publicurl', + 'region', + 'service_id', + 'service_name', + 'service_type', + ) self.assertEqual(collist, columns) datalist = ( self.fake_endpoint.adminurl, diff --git a/openstackclient/tests/unit/identity/v2_0/test_project.py b/openstackclient/tests/unit/identity/v2_0/test_project.py index 496214aa..68ec9f02 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_project.py +++ b/openstackclient/tests/unit/identity/v2_0/test_project.py @@ -25,7 +25,6 @@ from openstackclient.tests.unit.identity.v2_0 import fakes as identity_fakes class TestProject(identity_fakes.TestIdentityv2): - fake_project = identity_fakes.FakeProject.create_one_project() fake_projects = identity_fakes.FakeProject.create_projects() @@ -42,10 +41,18 @@ class TestProject(identity_fakes.TestIdentityv2): fake_project.name, ) datalists = ( - (fake_projects[0].description, True, - fake_projects[0].id, fake_projects[0].name,), - (fake_projects[1].description, True, - fake_projects[1].id, fake_projects[1].name,), + ( + fake_projects[0].description, + True, + fake_projects[0].id, + fake_projects[0].name, + ), + ( + fake_projects[1].description, + True, + fake_projects[1].id, + fake_projects[1].name, + ), ) def setUp(self): @@ -57,7 +64,6 @@ class TestProject(identity_fakes.TestIdentityv2): class TestProjectCreate(TestProject): - def setUp(self): super(TestProjectCreate, self).setUp() @@ -88,15 +94,15 @@ class TestProjectCreate(TestProject): 'enabled': True, } self.projects_mock.create.assert_called_with( - self.fake_project.name, - **kwargs + 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', + '--description', + 'new desc', self.fake_project.name, ] verifylist = [ @@ -116,8 +122,7 @@ class TestProjectCreate(TestProject): 'enabled': True, } self.projects_mock.create.assert_called_with( - self.fake_project.name, - **kwargs + self.fake_project.name, **kwargs ) self.assertEqual(self.columns, columns) @@ -146,8 +151,7 @@ class TestProjectCreate(TestProject): 'enabled': True, } self.projects_mock.create.assert_called_with( - self.fake_project.name, - **kwargs + self.fake_project.name, **kwargs ) self.assertEqual(self.columns, columns) @@ -176,8 +180,7 @@ class TestProjectCreate(TestProject): 'enabled': False, } self.projects_mock.create.assert_called_with( - self.fake_project.name, - **kwargs + self.fake_project.name, **kwargs ) self.assertEqual(self.columns, columns) @@ -185,8 +188,10 @@ class TestProjectCreate(TestProject): def test_project_create_property(self): arglist = [ - '--property', 'fee=fi', - '--property', 'fo=fum', + '--property', + 'fee=fi', + '--property', + 'fo=fum', self.fake_project.name, ] verifylist = [ @@ -208,8 +213,7 @@ class TestProjectCreate(TestProject): 'fo': 'fum', } self.projects_mock.create.assert_called_with( - self.fake_project.name, - **kwargs + self.fake_project.name, **kwargs ) self.assertEqual(self.columns, columns) @@ -248,8 +252,7 @@ class TestProjectCreate(TestProject): 'enabled': True, } self.projects_mock.create.assert_called_with( - self.fake_project.name, - **kwargs + self.fake_project.name, **kwargs ) self.assertEqual(self.columns, columns) @@ -277,8 +280,7 @@ class TestProjectCreate(TestProject): 'enabled': True, } self.projects_mock.create.assert_called_with( - self.fake_project.name, - **kwargs + self.fake_project.name, **kwargs ) self.assertEqual(self.columns, columns) @@ -286,7 +288,6 @@ class TestProjectCreate(TestProject): class TestProjectDelete(TestProject): - def setUp(self): super(TestProjectDelete, self).setUp() @@ -315,8 +316,7 @@ class TestProjectDelete(TestProject): @mock.patch.object(utils, 'find_resource') def test_delete_multi_projects_with_exception(self, find_mock): - find_mock.side_effect = [self.fake_project, - exceptions.CommandError] + find_mock.side_effect = [self.fake_project, exceptions.CommandError] arglist = [ self.fake_project.id, 'unexist_project', @@ -330,8 +330,7 @@ class TestProjectDelete(TestProject): self.cmd.take_action(parsed_args) self.fail('CommandError should be raised.') except exceptions.CommandError as e: - self.assertEqual('1 of 2 projects failed to delete.', - str(e)) + self.assertEqual('1 of 2 projects failed to delete.', str(e)) find_mock.assert_any_call(self.projects_mock, self.fake_project.id) find_mock.assert_any_call(self.projects_mock, 'unexist_project') @@ -341,7 +340,6 @@ class TestProjectDelete(TestProject): class TestProjectList(TestProject): - def setUp(self): super(TestProjectList, self).setUp() @@ -363,10 +361,12 @@ class TestProjectList(TestProject): collist = ('ID', 'Name') self.assertEqual(collist, columns) - datalist = (( - self.fake_project.id, - self.fake_project.name, - ), ) + datalist = ( + ( + self.fake_project.id, + self.fake_project.name, + ), + ) self.assertEqual(datalist, tuple(data)) def test_project_list_long(self): @@ -386,18 +386,23 @@ class TestProjectList(TestProject): collist = ('ID', 'Name', 'Description', 'Enabled') self.assertEqual(collist, columns) - datalist = (( - self.fake_project.id, - self.fake_project.name, - self.fake_project.description, - True, - ), ) + datalist = ( + ( + self.fake_project.id, + self.fake_project.name, + self.fake_project.description, + True, + ), + ) self.assertEqual(datalist, tuple(data)) def test_project_list_sort(self): self.projects_mock.list.return_value = self.fake_projects - arglist = ['--sort', 'name:asc', ] + arglist = [ + '--sort', + 'name:asc', + ] verifylist = [] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -425,7 +430,6 @@ class TestProjectList(TestProject): class TestProjectSet(TestProject): - def setUp(self): super(TestProjectSet, self).setUp() @@ -468,11 +472,13 @@ class TestProjectSet(TestProject): parsed_args = self.check_parser(self.cmd, arglist, verifylist) self.assertRaises( - exceptions.CommandError, self.cmd.take_action, parsed_args) + exceptions.CommandError, self.cmd.take_action, parsed_args + ) def test_project_set_name(self): arglist = [ - '--name', self.fake_project.name, + '--name', + self.fake_project.name, self.fake_project.name, ] verifylist = [ @@ -492,14 +498,14 @@ class TestProjectSet(TestProject): 'tenant_name': self.fake_project.name, } self.projects_mock.update.assert_called_with( - self.fake_project.id, - **kwargs + self.fake_project.id, **kwargs ) self.assertIsNone(result) def test_project_set_description(self): arglist = [ - '--description', self.fake_project.description, + '--description', + self.fake_project.description, self.fake_project.name, ] verifylist = [ @@ -519,8 +525,7 @@ class TestProjectSet(TestProject): 'tenant_name': self.fake_project.name, } self.projects_mock.update.assert_called_with( - self.fake_project.id, - **kwargs + self.fake_project.id, **kwargs ) self.assertIsNone(result) @@ -545,8 +550,7 @@ class TestProjectSet(TestProject): 'tenant_name': self.fake_project.name, } self.projects_mock.update.assert_called_with( - self.fake_project.id, - **kwargs + self.fake_project.id, **kwargs ) self.assertIsNone(result) @@ -571,15 +575,16 @@ class TestProjectSet(TestProject): 'tenant_name': self.fake_project.name, } self.projects_mock.update.assert_called_with( - self.fake_project.id, - **kwargs + self.fake_project.id, **kwargs ) self.assertIsNone(result) def test_project_set_property(self): arglist = [ - '--property', 'fee=fi', - '--property', 'fo=fum', + '--property', + 'fee=fi', + '--property', + 'fo=fum', self.fake_project.name, ] verifylist = [ @@ -599,14 +604,12 @@ class TestProjectSet(TestProject): 'fo': 'fum', } self.projects_mock.update.assert_called_with( - self.fake_project.id, - **kwargs + self.fake_project.id, **kwargs ) self.assertIsNone(result) class TestProjectShow(TestProject): - fake_proj_show = identity_fakes.FakeProject.create_one_project() def setUp(self): @@ -647,7 +650,6 @@ class TestProjectShow(TestProject): class TestProjectUnset(TestProject): - attr = {'fee': 'fi', 'fo': 'fum'} fake_proj = identity_fakes.FakeProject.create_one_project(attr) @@ -674,8 +676,10 @@ class TestProjectUnset(TestProject): def test_project_unset_key(self): arglist = [ - '--property', 'fee', - '--property', 'fo', + '--property', + 'fee', + '--property', + 'fo', self.fake_proj.name, ] verifylist = [ @@ -695,7 +699,6 @@ class TestProjectUnset(TestProject): } self.projects_mock.update.assert_called_with( - self.fake_proj.id, - **kwargs + self.fake_proj.id, **kwargs ) self.assertIsNone(result) diff --git a/openstackclient/tests/unit/identity/v2_0/test_role.py b/openstackclient/tests/unit/identity/v2_0/test_role.py index 423884d9..738982db 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_role.py +++ b/openstackclient/tests/unit/identity/v2_0/test_role.py @@ -24,7 +24,6 @@ from openstackclient.tests.unit.identity.v2_0 import fakes as identity_fakes class TestRole(identity_fakes.TestIdentityv2): - attr = {} attr['endpoints'] = [ { @@ -64,7 +63,6 @@ class TestRole(identity_fakes.TestIdentityv2): class TestRoleAdd(TestRole): - def setUp(self): super(TestRoleAdd, self).setUp() @@ -80,8 +78,10 @@ class TestRoleAdd(TestRole): def test_role_add(self): arglist = [ - '--project', self.fake_project.name, - '--user', self.fake_user.name, + '--project', + self.fake_project.name, + '--user', + self.fake_user.name, self.fake_role.name, ] verifylist = [ @@ -113,12 +113,8 @@ class TestRoleAdd(TestRole): class TestRoleCreate(TestRole): - fake_role_c = identity_fakes.FakeRole.create_one_role() - columns = ( - 'id', - 'name' - ) + columns = ('id', 'name') datalist = ( fake_role_c.id, fake_role_c.name, @@ -215,7 +211,6 @@ class TestRoleCreate(TestRole): class TestRoleDelete(TestRole): - def setUp(self): super(TestRoleDelete, self).setUp() @@ -243,8 +238,7 @@ class TestRoleDelete(TestRole): @mock.patch.object(utils, 'find_resource') def test_delete_multi_roles_with_exception(self, find_mock): - find_mock.side_effect = [self.fake_role, - exceptions.CommandError] + find_mock.side_effect = [self.fake_role, exceptions.CommandError] arglist = [ self.fake_role.id, 'unexist_role', @@ -258,8 +252,7 @@ class TestRoleDelete(TestRole): self.cmd.take_action(parsed_args) self.fail('CommandError should be raised.') except exceptions.CommandError as e: - self.assertEqual('1 of 2 roles failed to delete.', - str(e)) + self.assertEqual('1 of 2 roles failed to delete.', str(e)) find_mock.assert_any_call(self.roles_mock, self.fake_role.id) find_mock.assert_any_call(self.roles_mock, 'unexist_role') @@ -269,7 +262,6 @@ class TestRoleDelete(TestRole): class TestRoleList(TestRole): - def setUp(self): super(TestRoleList, self).setUp() @@ -292,15 +284,16 @@ class TestRoleList(TestRole): collist = ('ID', 'Name') self.assertEqual(collist, columns) - datalist = (( - self.fake_role.id, - self.fake_role.name, - ), ) + datalist = ( + ( + self.fake_role.id, + self.fake_role.name, + ), + ) self.assertEqual(datalist, tuple(data)) class TestRoleRemove(TestRole): - def setUp(self): super(TestRoleRemove, self).setUp() @@ -316,8 +309,10 @@ class TestRoleRemove(TestRole): def test_role_remove(self): arglist = [ - '--project', self.fake_project.name, - '--user', self.fake_user.name, + '--project', + self.fake_project.name, + '--user', + self.fake_user.name, self.fake_role.name, ] verifylist = [ @@ -339,7 +334,6 @@ class TestRoleRemove(TestRole): class TestRoleShow(TestRole): - def setUp(self): super(TestRoleShow, self).setUp() diff --git a/openstackclient/tests/unit/identity/v2_0/test_role_assignment.py b/openstackclient/tests/unit/identity/v2_0/test_role_assignment.py index 3e1231aa..248f689e 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_role_assignment.py +++ b/openstackclient/tests/unit/identity/v2_0/test_role_assignment.py @@ -22,13 +22,11 @@ from openstackclient.tests.unit.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', @@ -74,7 +72,6 @@ class TestRoleAssignmentList(TestRoleAssignment): 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) @@ -87,9 +84,9 @@ class TestRoleAssignmentList(TestRoleAssignment): ) def test_role_assignment_list_only_project_filter(self): - arglist = [ - '--project', identity_fakes.project_name, + '--project', + identity_fakes.project_name, ] verifylist = [ ('project', identity_fakes.project_name), @@ -104,9 +101,9 @@ class TestRoleAssignmentList(TestRoleAssignment): ) def test_role_assignment_list_only_user_filter(self): - arglist = [ - '--user', identity_fakes.user_name, + '--user', + identity_fakes.user_name, ] verifylist = [ ('user', identity_fakes.user_name), @@ -121,25 +118,24 @@ class TestRoleAssignmentList(TestRoleAssignment): ) 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), + copy.deepcopy(identity_fakes.ROLE), loaded=True, ), fakes.FakeResource( None, - copy.deepcopy( - identity_fakes.ROLE_2), + copy.deepcopy(identity_fakes.ROLE_2), loaded=True, ), ] arglist = [ - '--project', identity_fakes.project_name, - '--user', identity_fakes.user_name, + '--project', + identity_fakes.project_name, + '--user', + identity_fakes.user_name, ] verifylist = [ ('user', identity_fakes.user_name), @@ -158,18 +154,21 @@ class TestRoleAssignmentList(TestRoleAssignment): ) 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, - ),) + 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.Mock() auth_ref.project_id.return_value = identity_fakes.project_id auth_ref.user_id.return_value = identity_fakes.user_id @@ -177,14 +176,12 @@ class TestRoleAssignmentList(TestRoleAssignment): self.roles_mock.roles_for_user.return_value = [ fakes.FakeResource( None, - copy.deepcopy( - identity_fakes.ROLE), + copy.deepcopy(identity_fakes.ROLE), loaded=True, ), fakes.FakeResource( None, - copy.deepcopy( - identity_fakes.ROLE_2), + copy.deepcopy(identity_fakes.ROLE_2), loaded=True, ), ] @@ -210,37 +207,40 @@ class TestRoleAssignmentList(TestRoleAssignment): ) 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, - ),) + 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), + copy.deepcopy(identity_fakes.ROLE), loaded=True, ), fakes.FakeResource( None, - copy.deepcopy( - identity_fakes.ROLE_2), + copy.deepcopy(identity_fakes.ROLE_2), loaded=True, ), ] arglist = [ - '--project', identity_fakes.project_name, - '--user', identity_fakes.user_name, - '--names' + '--project', + identity_fakes.project_name, + '--user', + identity_fakes.user_name, + '--names', ] verifylist = [ ('user', identity_fakes.user_name), @@ -260,12 +260,16 @@ class TestRoleAssignmentList(TestRoleAssignment): ) 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, - ),) + 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/unit/identity/v2_0/test_service.py b/openstackclient/tests/unit/identity/v2_0/test_service.py index 6c4374ef..844f395b 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_service.py +++ b/openstackclient/tests/unit/identity/v2_0/test_service.py @@ -32,7 +32,6 @@ class TestService(identity_fakes.TestIdentityv2): class TestServiceCreate(TestService): - fake_service_c = identity_fakes.FakeService.create_one_service() columns = ( 'description', @@ -83,7 +82,8 @@ class TestServiceCreate(TestService): def test_service_create_with_name_option(self): arglist = [ - '--name', self.fake_service_c.name, + '--name', + self.fake_service_c.name, self.fake_service_c.type, ] verifylist = [ @@ -110,8 +110,10 @@ class TestServiceCreate(TestService): def test_service_create_description(self): arglist = [ - '--name', self.fake_service_c.name, - '--description', self.fake_service_c.description, + '--name', + self.fake_service_c.name, + '--description', + self.fake_service_c.description, self.fake_service_c.type, ] verifylist = [ @@ -138,7 +140,6 @@ class TestServiceCreate(TestService): class TestServiceDelete(TestService): - def setUp(self): super(TestServiceDelete, self).setUp() @@ -167,7 +168,6 @@ class TestServiceDelete(TestService): class TestServiceList(TestService): - def setUp(self): super(TestServiceList, self).setUp() @@ -190,11 +190,13 @@ class TestServiceList(TestService): collist = ('ID', 'Name', 'Type') self.assertEqual(collist, columns) - datalist = (( - self.fake_service.id, - self.fake_service.name, - self.fake_service.type, - ), ) + datalist = ( + ( + self.fake_service.id, + self.fake_service.name, + self.fake_service.type, + ), + ) self.assertEqual(datalist, tuple(data)) def test_service_list_long(self): @@ -215,17 +217,18 @@ class TestServiceList(TestService): 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, - ), ) + 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): @@ -282,4 +285,6 @@ class TestServiceShow(TestService): except exceptions.CommandError as e: self.assertEqual( "Multiple service matches found for 'nounique_service'," - " use an ID to be more specific.", str(e)) + " use an ID to be more specific.", + str(e), + ) diff --git a/openstackclient/tests/unit/identity/v2_0/test_token.py b/openstackclient/tests/unit/identity/v2_0/test_token.py index c079ce67..33cb0d9c 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_token.py +++ b/openstackclient/tests/unit/identity/v2_0/test_token.py @@ -20,7 +20,6 @@ from openstackclient.tests.unit.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() @@ -33,7 +32,6 @@ class TestToken(identity_fakes.TestIdentityv2): class TestTokenIssue(TestToken): - def setUp(self): super(TestTokenIssue, self).setUp() @@ -94,7 +92,6 @@ class TestTokenIssue(TestToken): class TestTokenRevoke(TestToken): - TOKEN = 'fob' def setUp(self): diff --git a/openstackclient/tests/unit/identity/v2_0/test_user.py b/openstackclient/tests/unit/identity/v2_0/test_user.py index c3f5f1d7..a8baf61a 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_user.py +++ b/openstackclient/tests/unit/identity/v2_0/test_user.py @@ -24,7 +24,6 @@ from openstackclient.tests.unit.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, @@ -44,7 +43,6 @@ class TestUser(identity_fakes.TestIdentityv2): class TestUserCreate(TestUser): - fake_project_c = identity_fakes.FakeProject.create_one_project() attr = { 'tenantId': fake_project_c.id, @@ -99,10 +97,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name, password, email, tenant_id=, enabled=) self.users_mock.create.assert_called_with( - self.fake_user_c.name, - None, - None, - **kwargs + self.fake_user_c.name, None, None, **kwargs ) self.assertEqual(self.columns, columns) @@ -110,13 +105,14 @@ class TestUserCreate(TestUser): def test_user_create_password(self): arglist = [ - '--password', 'secret', + '--password', + 'secret', self.fake_user_c.name, ] verifylist = [ ('name', self.fake_user_c.name), ('password_prompt', False), - ('password', 'secret') + ('password', 'secret'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -132,10 +128,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name, password, email, tenant_id=, enabled=) self.users_mock.create.assert_called_with( - self.fake_user_c.name, - 'secret', - None, - **kwargs + self.fake_user_c.name, 'secret', None, **kwargs ) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -147,7 +140,7 @@ class TestUserCreate(TestUser): ] verifylist = [ ('name', self.fake_user_c.name), - ('password_prompt', True) + ('password_prompt', True), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -166,10 +159,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name, password, email, tenant_id=, enabled=) self.users_mock.create.assert_called_with( - self.fake_user_c.name, - 'abc123', - None, - **kwargs + self.fake_user_c.name, 'abc123', None, **kwargs ) self.assertEqual(self.columns, columns) @@ -177,7 +167,8 @@ class TestUserCreate(TestUser): def test_user_create_email(self): arglist = [ - '--email', 'barney@example.com', + '--email', + 'barney@example.com', self.fake_user_c.name, ] verifylist = [ @@ -198,10 +189,7 @@ class TestUserCreate(TestUser): } # 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.fake_user_c.name, None, 'barney@example.com', **kwargs ) self.assertEqual(self.columns, columns) @@ -219,7 +207,8 @@ class TestUserCreate(TestUser): self.users_mock.create.return_value = user_2 arglist = [ - '--project', self.fake_project_c.name, + '--project', + self.fake_project_c.name, user_2.name, ] verifylist = [ @@ -240,10 +229,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name, password, email, tenant_id=, enabled=) self.users_mock.create.assert_called_with( - user_2.name, - None, - None, - **kwargs + user_2.name, None, None, **kwargs ) self.assertEqual(self.columns, columns) @@ -280,10 +266,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name, password, email, tenant_id=, enabled=) self.users_mock.create.assert_called_with( - self.fake_user_c.name, - None, - None, - **kwargs + self.fake_user_c.name, None, None, **kwargs ) self.assertEqual(self.columns, columns) @@ -313,10 +296,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name, password, email, tenant_id=, enabled=) self.users_mock.create.assert_called_with( - self.fake_user_c.name, - None, - None, - **kwargs + self.fake_user_c.name, None, None, **kwargs ) self.assertEqual(self.columns, columns) @@ -375,17 +355,13 @@ class TestUserCreate(TestUser): } # UserManager.create(name, password, email, tenant_id=, enabled=) self.users_mock.create.assert_called_with( - self.fake_user_c.name, - None, - None, - **kwargs + 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() @@ -414,8 +390,7 @@ class TestUserDelete(TestUser): @mock.patch.object(utils, 'find_resource') def test_delete_multi_users_with_exception(self, find_mock): - find_mock.side_effect = [self.fake_user, - exceptions.CommandError] + find_mock.side_effect = [self.fake_user, exceptions.CommandError] arglist = [ self.fake_user.id, 'unexist_user', @@ -429,8 +404,7 @@ class TestUserDelete(TestUser): self.cmd.take_action(parsed_args) self.fail('CommandError should be raised.') except exceptions.CommandError as e: - self.assertEqual('1 of 2 users failed to delete.', - str(e)) + self.assertEqual('1 of 2 users failed to delete.', str(e)) find_mock.assert_any_call(self.users_mock, self.fake_user.id) find_mock.assert_any_call(self.users_mock, 'unexist_user') @@ -440,7 +414,6 @@ class TestUserDelete(TestUser): class TestUserList(TestUser): - fake_project_l = identity_fakes.FakeProject.create_one_project() attr = { 'tenantId': fake_project_l.id, @@ -486,7 +459,8 @@ class TestUserList(TestUser): def test_user_list_project(self): arglist = [ - '--project', self.fake_project_l.id, + '--project', + self.fake_project_l.id, ] verifylist = [ ('project', self.fake_project_l.id), @@ -522,20 +496,22 @@ class TestUserList(TestUser): collist = ('ID', 'Name', 'Project', 'Email', 'Enabled') self.assertEqual(collist, columns) - datalist = (( - self.fake_user_l.id, - self.fake_user_l.name, - user.ProjectColumn( - self.fake_project_l.id, - {self.fake_project_l.id: self.fake_project_l}), - self.fake_user_l.email, - True, - ), ) + datalist = ( + ( + self.fake_user_l.id, + self.fake_user_l.name, + user.ProjectColumn( + self.fake_project_l.id, + {self.fake_project_l.id: self.fake_project_l}, + ), + self.fake_user_l.email, + True, + ), + ) self.assertCountEqual(datalist, tuple(data)) class TestUserSet(TestUser): - def setUp(self): super(TestUserSet, self).setUp() @@ -583,11 +559,13 @@ class TestUserSet(TestUser): parsed_args = self.check_parser(self.cmd, arglist, verifylist) self.assertRaises( - exceptions.CommandError, self.cmd.take_action, parsed_args) + exceptions.CommandError, self.cmd.take_action, parsed_args + ) def test_user_set_name(self): arglist = [ - '--name', 'qwerty', + '--name', + 'qwerty', self.fake_user.name, ] verifylist = [ @@ -609,15 +587,13 @@ class TestUserSet(TestUser): 'name': 'qwerty', } # UserManager.update(user, **kwargs) - self.users_mock.update.assert_called_with( - self.fake_user.id, - **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', + '--password', + 'secret', self.fake_user.name, ] verifylist = [ @@ -672,7 +648,8 @@ class TestUserSet(TestUser): def test_user_set_email(self): arglist = [ - '--email', 'barney@example.com', + '--email', + 'barney@example.com', self.fake_user.name, ] verifylist = [ @@ -694,15 +671,13 @@ class TestUserSet(TestUser): 'enabled': True, } # UserManager.update(user, **kwargs) - self.users_mock.update.assert_called_with( - self.fake_user.id, - **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, + '--project', + self.fake_project.id, self.fake_user.name, ] verifylist = [ @@ -748,10 +723,7 @@ class TestUserSet(TestUser): 'enabled': True, } # UserManager.update(user, **kwargs) - self.users_mock.update.assert_called_with( - self.fake_user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.fake_user.id, **kwargs) self.assertIsNone(result) def test_user_set_disable(self): @@ -777,15 +749,11 @@ class TestUserSet(TestUser): 'enabled': False, } # UserManager.update(user, **kwargs) - self.users_mock.update.assert_called_with( - self.fake_user.id, - **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() diff --git a/openstackclient/tests/unit/identity/v3/fakes.py b/openstackclient/tests/unit/identity/v3/fakes.py index 58d5d14d..0626df87 100644 --- a/openstackclient/tests/unit/identity/v3/fakes.py +++ b/openstackclient/tests/unit/identity/v3/fakes.py @@ -58,55 +58,24 @@ EMPLOYEE_GROUP_ID = "0cd5e9" DEVELOPER_GROUP_ID = "xyz" MAPPING_RULES = [ { - "local": [ - { - "group": { - "id": EMPLOYEE_GROUP_ID - } - } - ], + "local": [{"group": {"id": EMPLOYEE_GROUP_ID}}], "remote": [ - { - "type": "orgPersonType", - "not_any_of": [ - "Contractor", - "Guest" - ] - } - ] + {"type": "orgPersonType", "not_any_of": ["Contractor", "Guest"]} + ], } ] MAPPING_RULES_2 = [ { - "local": [ - { - "group": { - "id": DEVELOPER_GROUP_ID - } - } - ], - "remote": [ - { - "type": "orgPersonType", - "any_one_of": [ - "Contractor" - ] - } - ] + "local": [{"group": {"id": DEVELOPER_GROUP_ID}}], + "remote": [{"type": "orgPersonType", "any_one_of": ["Contractor"]}], } ] -MAPPING_RESPONSE = { - "id": mapping_id, - "rules": MAPPING_RULES -} +MAPPING_RESPONSE = {"id": mapping_id, "rules": MAPPING_RULES} -MAPPING_RESPONSE_2 = { - "id": mapping_id, - "rules": MAPPING_RULES_2 -} +MAPPING_RESPONSE_2 = {"id": mapping_id, "rules": MAPPING_RULES_2} mfa_opt1 = 'password,totp' mfa_opt2 = 'password' @@ -270,7 +239,7 @@ USER = { trust_id = 't-456' trust_expires = None trust_impersonation = False -trust_roles = {"id": role_id, "name": role_name}, +trust_roles = ({"id": role_id, "name": role_name},) TRUST = { 'expires_at': trust_expires, @@ -327,32 +296,31 @@ mapping_id_updated = 'prod_mapping' sp_id = 'BETA' sp_description = 'Service Provider to burst into' service_provider_url = 'https://beta.example.com/Shibboleth.sso/POST/SAML' -sp_auth_url = ('https://beta.example.com/v3/OS-FEDERATION/identity_providers/' - 'idp/protocol/saml2/auth') +sp_auth_url = ( + 'https://beta.example.com/v3/OS-FEDERATION/identity_providers/' + 'idp/protocol/saml2/auth' +) SERVICE_PROVIDER = { 'id': sp_id, 'enabled': True, 'description': sp_description, 'sp_url': service_provider_url, - 'auth_url': sp_auth_url + 'auth_url': sp_auth_url, } -PROTOCOL_ID_MAPPING = { - 'id': protocol_id, - 'mapping': mapping_id -} +PROTOCOL_ID_MAPPING = {'id': protocol_id, 'mapping': mapping_id} PROTOCOL_OUTPUT = { 'id': protocol_id, 'mapping_id': mapping_id, - 'identity_provider': idp_id + 'identity_provider': idp_id, } PROTOCOL_OUTPUT_UPDATED = { 'id': protocol_id, 'mapping_id': mapping_id_updated, - 'identity_provider': idp_id + 'identity_provider': idp_id, } # Assignments @@ -366,22 +334,24 @@ ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID = { ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INCLUDE_NAMES = { 'scope': { 'project': { - 'domain': {'id': domain_id, - 'name': domain_name}, + 'domain': {'id': domain_id, 'name': domain_name}, 'id': project_id, - 'name': project_name}}, + 'name': project_name, + } + }, 'user': { - 'domain': {'id': domain_id, - 'name': domain_name}, + 'domain': {'id': domain_id, 'name': domain_name}, 'id': user_id, - 'name': user_name}, - 'role': {'id': role_id, - 'name': role_name}, + 'name': user_name, + }, + 'role': {'id': role_id, 'name': role_name}, } ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INHERITED = { - 'scope': {'project': {'id': project_id}, - 'OS-INHERIT:inherited_to': 'projects'}, + 'scope': { + 'project': {'id': project_id}, + 'OS-INHERIT:inherited_to': 'projects', + }, 'user': {'id': user_id}, 'role': {'id': role_id}, } @@ -405,21 +375,20 @@ ASSIGNMENT_WITH_DOMAIN_ROLE = { } ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INCLUDE_NAMES = { - 'scope': { - 'domain': {'id': domain_id, - 'name': domain_name}}, + 'scope': {'domain': {'id': domain_id, 'name': domain_name}}, 'user': { - 'domain': {'id': domain_id, - 'name': domain_name}, + 'domain': {'id': domain_id, 'name': domain_name}, 'id': user_id, - 'name': user_name}, - 'role': {'id': role_id, - 'name': role_name}, + 'name': user_name, + }, + 'role': {'id': role_id, 'name': role_name}, } ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INHERITED = { - 'scope': {'domain': {'id': domain_id}, - 'OS-INHERIT:inherited_to': 'projects'}, + 'scope': { + 'domain': {'id': domain_id}, + 'OS-INHERIT:inherited_to': 'projects', + }, 'user': {'id': user_id}, 'role': {'id': role_id}, } @@ -437,7 +406,7 @@ consumer_secret = 'test consumer secret' OAUTH_CONSUMER = { 'id': consumer_id, 'secret': consumer_secret, - 'description': consumer_description + 'description': consumer_description, } access_token_id = 'test access token id' @@ -448,7 +417,7 @@ OAUTH_ACCESS_TOKEN = { 'id': access_token_id, 'expires': access_token_expires, 'key': access_token_id, - 'secret': access_token_secret + 'secret': access_token_secret, } request_token_id = 'test request token id' @@ -459,17 +428,15 @@ OAUTH_REQUEST_TOKEN = { 'id': request_token_id, 'expires': request_token_expires, 'key': request_token_id, - 'secret': request_token_secret + 'secret': request_token_secret, } oauth_verifier_pin = '6d74XaDS' -OAUTH_VERIFIER = { - 'oauth_verifier': oauth_verifier_pin -} +OAUTH_VERIFIER = {'oauth_verifier': oauth_verifier_pin} app_cred_id = 'app-cred-id' app_cred_name = 'testing_app_cred' -app_cred_role = {"id": role_id, "name": role_name, "domain": None}, +app_cred_role = ({"id": role_id, "name": role_name, "domain": None},) app_cred_description = 'app credential for testing' app_cred_expires = datetime.datetime(2022, 1, 1, 0, 0) app_cred_expires_str = app_cred_expires.strftime('%Y-%m-%dT%H:%M:%S%z') @@ -491,7 +458,7 @@ APP_CRED_BASIC = { 'expires_at': None, 'unrestricted': False, 'secret': app_cred_secret, - 'access_rules': None + 'access_rules': None, } APP_CRED_OPTIONS = { 'id': app_cred_id, @@ -519,7 +486,7 @@ APP_CRED_ACCESS_RULES = { 'expires_at': None, 'unrestricted': False, 'secret': app_cred_secret, - 'access_rules': app_cred_access_rules + 'access_rules': app_cred_access_rules, } registered_limit_id = 'registered-limit-id' @@ -532,7 +499,7 @@ REGISTERED_LIMIT = { 'resource_name': registered_limit_resource_name, 'service_id': service_id, 'description': None, - 'region_id': None + 'region_id': None, } REGISTERED_LIMIT_OPTIONS = { 'id': registered_limit_id, @@ -540,7 +507,7 @@ REGISTERED_LIMIT_OPTIONS = { 'resource_name': registered_limit_resource_name, 'service_id': service_id, 'description': registered_limit_description, - 'region_id': region_id + 'region_id': region_id, } limit_id = 'limit-id' @@ -554,7 +521,7 @@ LIMIT = { 'resource_name': limit_resource_name, 'service_id': service_id, 'description': None, - 'region_id': None + 'region_id': None, } LIMIT_OPTIONS = { 'id': limit_id, @@ -563,7 +530,7 @@ LIMIT_OPTIONS = { 'resource_name': limit_resource_name, 'service_id': service_id, 'description': limit_description, - 'region_id': region_id + 'region_id': region_id, } @@ -598,7 +565,6 @@ def fake_auth_ref(fake_token, fake_service=None): class FakeAuth(object): - def __init__(self, auth_method_class=None): self._auth_method_class = auth_method_class @@ -607,13 +573,11 @@ class FakeAuth(object): class FakeSession(object): - def __init__(self, **kwargs): self.auth = FakeAuth() class FakeIdentityv3Client(object): - def __init__(self, **kwargs): self.domains = mock.Mock() self.domains.resource_class = fakes.FakeResource(None, {}) @@ -638,8 +602,9 @@ class FakeIdentityv3Client(object): self.services = mock.Mock() self.services.resource_class = fakes.FakeResource(None, {}) self.session = mock.Mock() - self.session.auth.auth_ref.service_catalog.resource_class = \ + self.session.auth.auth_ref.service_catalog.resource_class = ( fakes.FakeResource(None, {}) + ) self.tokens = mock.Mock() self.tokens.resource_class = fakes.FakeResource(None, {}) self.trusts = mock.Mock() @@ -654,8 +619,9 @@ class FakeIdentityv3Client(object): self.auth.client = mock.Mock() self.auth.client.resource_class = fakes.FakeResource(None, {}) self.application_credentials = mock.Mock() - self.application_credentials.resource_class = fakes.FakeResource(None, - {}) + self.application_credentials.resource_class = fakes.FakeResource( + None, {} + ) self.access_rules = mock.Mock() self.access_rules.resource_class = fakes.FakeResource(None, {}) self.inference_rules = mock.Mock() @@ -667,7 +633,6 @@ class FakeIdentityv3Client(object): class FakeFederationManager(object): - def __init__(self, **kwargs): self.identity_providers = mock.Mock() self.identity_providers.resource_class = fakes.FakeResource(None, {}) @@ -684,14 +649,12 @@ class FakeFederationManager(object): class FakeFederatedClient(FakeIdentityv3Client): - def __init__(self, **kwargs): super(FakeFederatedClient, self).__init__(**kwargs) self.federation = FakeFederationManager() class FakeOAuth1Client(FakeIdentityv3Client): - def __init__(self, **kwargs): super(FakeOAuth1Client, self).__init__(**kwargs) @@ -704,7 +667,6 @@ class FakeOAuth1Client(FakeIdentityv3Client): class TestIdentityv3(utils.TestCommand): - def setUp(self): super(TestIdentityv3, self).setUp() @@ -715,24 +677,20 @@ class TestIdentityv3(utils.TestCommand): class TestFederatedIdentity(utils.TestCommand): - def setUp(self): super(TestFederatedIdentity, self).setUp() self.app.client_manager.identity = FakeFederatedClient( - endpoint=fakes.AUTH_URL, - token=fakes.AUTH_TOKEN + endpoint=fakes.AUTH_URL, token=fakes.AUTH_TOKEN ) class TestOAuth1(utils.TestCommand): - def setUp(self): super(TestOAuth1, self).setUp() self.app.client_manager.identity = FakeOAuth1Client( - endpoint=fakes.AUTH_URL, - token=fakes.AUTH_TOKEN + endpoint=fakes.AUTH_URL, token=fakes.AUTH_TOKEN ) @@ -765,8 +723,9 @@ class FakeProject(object): } project_info.update(attrs) - project = fakes.FakeResource(info=copy.deepcopy(project_info), - loaded=True) + project = fakes.FakeResource( + info=copy.deepcopy(project_info), loaded=True + ) return project @staticmethod @@ -813,8 +772,9 @@ class FakeDomain(object): } domain_info.update(attrs) - domain = fakes.FakeResource(info=copy.deepcopy(domain_info), - loaded=True) + domain = fakes.FakeResource( + info=copy.deepcopy(domain_info), loaded=True + ) return domain @@ -845,7 +805,8 @@ class FakeCredential(object): credential_info.update(attrs) credential = fakes.FakeResource( - info=copy.deepcopy(credential_info), loaded=True) + info=copy.deepcopy(credential_info), loaded=True + ) return credential @staticmethod @@ -914,8 +875,7 @@ class FakeUser(object): } user_info.update(attrs) - user = fakes.FakeResource(info=copy.deepcopy(user_info), - loaded=True) + user = fakes.FakeResource(info=copy.deepcopy(user_info), loaded=True) return user @staticmethod @@ -982,8 +942,7 @@ class FakeGroup(object): } group_info.update(attrs) - group = fakes.FakeResource(info=copy.deepcopy(group_info), - loaded=True) + group = fakes.FakeResource(info=copy.deepcopy(group_info), loaded=True) return group @staticmethod @@ -1052,8 +1011,9 @@ class FakeEndpoint(object): } endpoint_info.update(attrs) - endpoint = fakes.FakeResource(info=copy.deepcopy(endpoint_info), - loaded=True) + endpoint = fakes.FakeResource( + info=copy.deepcopy(endpoint_info), loaded=True + ) return endpoint @staticmethod @@ -1076,8 +1036,7 @@ class FakeEndpoint(object): # Overwrite default attributes if there are some attributes set endpoint_filter_info.update(attrs) - endpoint_filter = fakes.FakeModel( - copy.deepcopy(endpoint_filter_info)) + endpoint_filter = fakes.FakeModel(copy.deepcopy(endpoint_filter_info)) return endpoint_filter @@ -1110,8 +1069,9 @@ class FakeEndpointGroup(object): } endpointgroup_info.update(attrs) - endpoint = fakes.FakeResource(info=copy.deepcopy(endpointgroup_info), - loaded=True) + endpoint = fakes.FakeResource( + info=copy.deepcopy(endpointgroup_info), loaded=True + ) return endpoint @staticmethod @@ -1135,7 +1095,8 @@ class FakeEndpointGroup(object): endpointgroup_filter_info.update(attrs) endpointgroup_filter = fakes.FakeModel( - copy.deepcopy(endpointgroup_filter_info)) + copy.deepcopy(endpointgroup_filter_info) + ) return endpointgroup_filter @@ -1166,8 +1127,9 @@ class FakeService(object): } service_info.update(attrs) - service = fakes.FakeResource(info=copy.deepcopy(service_info), - loaded=True) + service = fakes.FakeResource( + info=copy.deepcopy(service_info), loaded=True + ) return service @@ -1195,13 +1157,15 @@ class FakeRoleAssignment(object): role_assignment_info.update(attrs) role_assignment = fakes.FakeResource( - info=copy.deepcopy(role_assignment_info), loaded=True) + info=copy.deepcopy(role_assignment_info), loaded=True + ) return role_assignment class FakeImpliedRoleResponse(object): """Fake one or more role assignment.""" + def __init__(self, prior_role, implied_roles): self.prior_role = prior_role self.implies = [role for role in implied_roles] @@ -1215,8 +1179,6 @@ class FakeImpliedRoleResponse(object): """ # set default attributes. - implied_roles = [ - FakeImpliedRoleResponse(ROLES[0], [ROLES[1]]) - ] + implied_roles = [FakeImpliedRoleResponse(ROLES[0], [ROLES[1]])] return implied_roles diff --git a/openstackclient/tests/unit/identity/v3/test_access_rule.py b/openstackclient/tests/unit/identity/v3/test_access_rule.py index 904fe323..3727dcfe 100644 --- a/openstackclient/tests/unit/identity/v3/test_access_rule.py +++ b/openstackclient/tests/unit/identity/v3/test_access_rule.py @@ -25,7 +25,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestAccessRule(identity_fakes.TestIdentityv3): - def setUp(self): super(TestAccessRule, self).setUp() @@ -37,7 +36,6 @@ class TestAccessRule(identity_fakes.TestIdentityv3): class TestAccessRuleDelete(TestAccessRule): - def setUp(self): super(TestAccessRuleDelete, self).setUp() @@ -50,16 +48,13 @@ class TestAccessRuleDelete(TestAccessRule): self.access_rules_mock.delete.return_value = None # Get the command object to test - self.cmd = access_rule.DeleteAccessRule( - self.app, None) + self.cmd = access_rule.DeleteAccessRule(self.app, None) def test_access_rule_delete(self): arglist = [ identity_fakes.access_rule_id, ] - verifylist = [ - ('access_rule', [identity_fakes.access_rule_id]) - ] + verifylist = [('access_rule', [identity_fakes.access_rule_id])] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) @@ -71,8 +66,10 @@ class TestAccessRuleDelete(TestAccessRule): @mock.patch.object(utils, 'find_resource') def test_delete_multi_access_rules_with_exception(self, find_mock): - find_mock.side_effect = [self.access_rules_mock.get.return_value, - exceptions.CommandError] + find_mock.side_effect = [ + self.access_rules_mock.get.return_value, + exceptions.CommandError, + ] arglist = [ identity_fakes.access_rule_id, 'nonexistent_access_rule', @@ -86,21 +83,24 @@ class TestAccessRuleDelete(TestAccessRule): self.cmd.take_action(parsed_args) self.fail('CommandError should be raised.') except exceptions.CommandError as e: - self.assertEqual('1 of 2 access rules failed to' - ' delete.', str(e)) + self.assertEqual( + '1 of 2 access rules failed to' ' delete.', str(e) + ) - find_mock.assert_any_call(self.access_rules_mock, - identity_fakes.access_rule_id) - find_mock.assert_any_call(self.access_rules_mock, - 'nonexistent_access_rule') + find_mock.assert_any_call( + self.access_rules_mock, identity_fakes.access_rule_id + ) + find_mock.assert_any_call( + self.access_rules_mock, 'nonexistent_access_rule' + ) self.assertEqual(2, find_mock.call_count) self.access_rules_mock.delete.assert_called_once_with( - identity_fakes.access_rule_id) + identity_fakes.access_rule_id + ) class TestAccessRuleList(TestAccessRule): - def setUp(self): super(TestAccessRuleList, self).setUp() @@ -126,17 +126,18 @@ class TestAccessRuleList(TestAccessRule): collist = ('ID', 'Service', 'Method', 'Path') self.assertEqual(collist, columns) - datalist = (( - identity_fakes.access_rule_id, - identity_fakes.access_rule_service, - identity_fakes.access_rule_method, - identity_fakes.access_rule_path, - ), ) + datalist = ( + ( + identity_fakes.access_rule_id, + identity_fakes.access_rule_service, + identity_fakes.access_rule_method, + identity_fakes.access_rule_path, + ), + ) self.assertEqual(datalist, tuple(data)) class TestAccessRuleShow(TestAccessRule): - def setUp(self): super(TestAccessRuleShow, self).setUp() @@ -161,7 +162,8 @@ class TestAccessRuleShow(TestAccessRule): columns, data = self.cmd.take_action(parsed_args) self.access_rules_mock.get.assert_called_with( - identity_fakes.access_rule_id) + identity_fakes.access_rule_id + ) collist = ('id', 'method', 'path', 'service') self.assertEqual(collist, columns) diff --git a/openstackclient/tests/unit/identity/v3/test_application_credential.py b/openstackclient/tests/unit/identity/v3/test_application_credential.py index 24bafc9f..68ed750d 100644 --- a/openstackclient/tests/unit/identity/v3/test_application_credential.py +++ b/openstackclient/tests/unit/identity/v3/test_application_credential.py @@ -26,7 +26,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestApplicationCredential(identity_fakes.TestIdentityv3): - def setUp(self): super(TestApplicationCredential, self).setUp() @@ -38,7 +37,6 @@ class TestApplicationCredential(identity_fakes.TestIdentityv3): class TestApplicationCredentialCreate(TestApplicationCredential): - def setUp(self): super(TestApplicationCredentialCreate, self).setUp() @@ -50,7 +48,8 @@ class TestApplicationCredentialCreate(TestApplicationCredential): # Get the command object to test self.cmd = application_credential.CreateApplicationCredential( - self.app, None) + self.app, None + ) def test_application_credential_create_basic(self): self.app_creds_mock.create.return_value = fakes.FakeResource( @@ -60,12 +59,8 @@ class TestApplicationCredentialCreate(TestApplicationCredential): ) name = identity_fakes.app_cred_name - arglist = [ - name - ] - verifylist = [ - ('name', identity_fakes.app_cred_name) - ] + arglist = [name] + verifylist = [('name', identity_fakes.app_cred_name)] parsed_args = self.check_parser(self.cmd, arglist, verifylist) # In base command class ShowOne in cliff, abstract method take_action() @@ -82,13 +77,19 @@ class TestApplicationCredentialCreate(TestApplicationCredential): 'unrestricted': False, 'access_rules': None, } - self.app_creds_mock.create.assert_called_with( - name, - **kwargs + self.app_creds_mock.create.assert_called_with(name, **kwargs) + + collist = ( + 'access_rules', + 'description', + 'expires_at', + 'id', + 'name', + 'project_id', + 'roles', + 'secret', + 'unrestricted', ) - - collist = ('access_rules', 'description', 'expires_at', 'id', 'name', - 'project_id', 'roles', 'secret', 'unrestricted') self.assertEqual(collist, columns) datalist = ( None, @@ -113,17 +114,21 @@ class TestApplicationCredentialCreate(TestApplicationCredential): arglist = [ name, - '--secret', 'moresecuresecret', - '--role', identity_fakes.role_id, - '--expiration', identity_fakes.app_cred_expires_str, - '--description', 'credential for testing' + '--secret', + 'moresecuresecret', + '--role', + identity_fakes.role_id, + '--expiration', + identity_fakes.app_cred_expires_str, + '--description', + 'credential for testing', ] verifylist = [ ('name', identity_fakes.app_cred_name), ('secret', 'moresecuresecret'), ('role', [identity_fakes.role_id]), ('expiration', identity_fakes.app_cred_expires_str), - ('description', 'credential for testing') + ('description', 'credential for testing'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -141,13 +146,19 @@ class TestApplicationCredentialCreate(TestApplicationCredential): 'unrestricted': False, 'access_rules': None, } - self.app_creds_mock.create.assert_called_with( - name, - **kwargs + self.app_creds_mock.create.assert_called_with(name, **kwargs) + + collist = ( + 'access_rules', + 'description', + 'expires_at', + 'id', + 'name', + 'project_id', + 'roles', + 'secret', + 'unrestricted', ) - - collist = ('access_rules', 'description', 'expires_at', 'id', 'name', - 'project_id', 'roles', 'secret', 'unrestricted') self.assertEqual(collist, columns) datalist = ( None, @@ -172,7 +183,8 @@ class TestApplicationCredentialCreate(TestApplicationCredential): arglist = [ name, - '--access-rules', identity_fakes.app_cred_access_rules, + '--access-rules', + identity_fakes.app_cred_access_rules, ] verifylist = [ ('name', identity_fakes.app_cred_name), @@ -189,15 +201,21 @@ class TestApplicationCredentialCreate(TestApplicationCredential): 'expires_at': None, 'description': None, 'unrestricted': False, - 'access_rules': json.loads(identity_fakes.app_cred_access_rules) + 'access_rules': json.loads(identity_fakes.app_cred_access_rules), } - self.app_creds_mock.create.assert_called_with( - name, - **kwargs + self.app_creds_mock.create.assert_called_with(name, **kwargs) + + collist = ( + 'access_rules', + 'description', + 'expires_at', + 'id', + 'name', + 'project_id', + 'roles', + 'secret', + 'unrestricted', ) - - collist = ('access_rules', 'description', 'expires_at', 'id', 'name', - 'project_id', 'roles', 'secret', 'unrestricted') self.assertEqual(collist, columns) datalist = ( identity_fakes.app_cred_access_rules, @@ -215,7 +233,8 @@ class TestApplicationCredentialCreate(TestApplicationCredential): @mock.patch('openstackclient.identity.v3.application_credential.json.load') @mock.patch('openstackclient.identity.v3.application_credential.open') def test_application_credential_create_with_access_rules_file( - self, _, mock_json_load): + self, _, mock_json_load + ): mock_json_load.return_value = identity_fakes.app_cred_access_rules name = identity_fakes.app_cred_name @@ -227,7 +246,8 @@ class TestApplicationCredentialCreate(TestApplicationCredential): arglist = [ name, - '--access-rules', identity_fakes.app_cred_access_rules_path, + '--access-rules', + identity_fakes.app_cred_access_rules_path, ] verifylist = [ ('name', identity_fakes.app_cred_name), @@ -244,15 +264,21 @@ class TestApplicationCredentialCreate(TestApplicationCredential): 'expires_at': None, 'description': None, 'unrestricted': False, - 'access_rules': identity_fakes.app_cred_access_rules + 'access_rules': identity_fakes.app_cred_access_rules, } - self.app_creds_mock.create.assert_called_with( - name, - **kwargs + self.app_creds_mock.create.assert_called_with(name, **kwargs) + + collist = ( + 'access_rules', + 'description', + 'expires_at', + 'id', + 'name', + 'project_id', + 'roles', + 'secret', + 'unrestricted', ) - - collist = ('access_rules', 'description', 'expires_at', 'id', 'name', - 'project_id', 'roles', 'secret', 'unrestricted') self.assertEqual(collist, columns) datalist = ( identity_fakes.app_cred_access_rules, @@ -269,7 +295,6 @@ class TestApplicationCredentialCreate(TestApplicationCredential): class TestApplicationCredentialDelete(TestApplicationCredential): - def setUp(self): super(TestApplicationCredentialDelete, self).setUp() @@ -283,15 +308,14 @@ class TestApplicationCredentialDelete(TestApplicationCredential): # Get the command object to test self.cmd = application_credential.DeleteApplicationCredential( - self.app, None) + self.app, None + ) def test_application_credential_delete(self): arglist = [ identity_fakes.app_cred_id, ] - verifylist = [ - ('application_credential', [identity_fakes.app_cred_id]) - ] + verifylist = [('application_credential', [identity_fakes.app_cred_id])] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) @@ -303,8 +327,10 @@ class TestApplicationCredentialDelete(TestApplicationCredential): @mock.patch.object(utils, 'find_resource') def test_delete_multi_app_creds_with_exception(self, find_mock): - find_mock.side_effect = [self.app_creds_mock.get.return_value, - exceptions.CommandError] + find_mock.side_effect = [ + self.app_creds_mock.get.return_value, + exceptions.CommandError, + ] arglist = [ identity_fakes.app_cred_id, 'nonexistent_app_cred', @@ -318,21 +344,22 @@ class TestApplicationCredentialDelete(TestApplicationCredential): self.cmd.take_action(parsed_args) self.fail('CommandError should be raised.') except exceptions.CommandError as e: - self.assertEqual('1 of 2 application credentials failed to' - ' delete.', str(e)) + self.assertEqual( + '1 of 2 application credentials failed to' ' delete.', str(e) + ) - find_mock.assert_any_call(self.app_creds_mock, - identity_fakes.app_cred_id) - find_mock.assert_any_call(self.app_creds_mock, - 'nonexistent_app_cred') + find_mock.assert_any_call( + self.app_creds_mock, identity_fakes.app_cred_id + ) + find_mock.assert_any_call(self.app_creds_mock, 'nonexistent_app_cred') self.assertEqual(2, find_mock.call_count) self.app_creds_mock.delete.assert_called_once_with( - identity_fakes.app_cred_id) + identity_fakes.app_cred_id + ) class TestApplicationCredentialList(TestApplicationCredential): - def setUp(self): super(TestApplicationCredentialList, self).setUp() @@ -345,8 +372,9 @@ class TestApplicationCredentialList(TestApplicationCredential): ] # Get the command object to test - self.cmd = application_credential.ListApplicationCredential(self.app, - None) + self.cmd = application_credential.ListApplicationCredential( + self.app, None + ) def test_application_credential_list(self): arglist = [] @@ -362,18 +390,19 @@ class TestApplicationCredentialList(TestApplicationCredential): collist = ('ID', 'Name', 'Project ID', 'Description', 'Expires At') self.assertEqual(collist, columns) - datalist = (( - identity_fakes.app_cred_id, - identity_fakes.app_cred_name, - identity_fakes.project_id, - None, - None - ), ) + datalist = ( + ( + identity_fakes.app_cred_id, + identity_fakes.app_cred_name, + identity_fakes.project_id, + None, + None, + ), + ) self.assertEqual(datalist, tuple(data)) class TestApplicationCredentialShow(TestApplicationCredential): - def setUp(self): super(TestApplicationCredentialShow, self).setUp() @@ -384,8 +413,9 @@ class TestApplicationCredentialShow(TestApplicationCredential): ) # Get the command object to test - self.cmd = application_credential.ShowApplicationCredential(self.app, - None) + self.cmd = application_credential.ShowApplicationCredential( + self.app, None + ) def test_application_credential_show(self): arglist = [ @@ -403,8 +433,17 @@ class TestApplicationCredentialShow(TestApplicationCredential): self.app_creds_mock.get.assert_called_with(identity_fakes.app_cred_id) - collist = ('access_rules', 'description', 'expires_at', 'id', 'name', - 'project_id', 'roles', 'secret', 'unrestricted') + collist = ( + 'access_rules', + 'description', + 'expires_at', + 'id', + 'name', + 'project_id', + 'roles', + 'secret', + 'unrestricted', + ) self.assertEqual(collist, columns) datalist = ( None, diff --git a/openstackclient/tests/unit/identity/v3/test_catalog.py b/openstackclient/tests/unit/identity/v3/test_catalog.py index 802a9017..a157859e 100644 --- a/openstackclient/tests/unit/identity/v3/test_catalog.py +++ b/openstackclient/tests/unit/identity/v3/test_catalog.py @@ -19,7 +19,6 @@ from openstackclient.tests.unit import utils class TestCatalog(utils.TestCommand): - fake_service = { 'id': 'qwertyuiop', 'type': 'compute', @@ -62,7 +61,6 @@ class TestCatalog(utils.TestCommand): class TestCatalogList(TestCatalog): - def setUp(self): super(TestCatalogList, self).setUp() @@ -88,17 +86,19 @@ class TestCatalogList(TestCatalog): collist = ('Name', 'Type', 'Endpoints') self.assertEqual(collist, columns) - datalist = (( - 'supernova', - 'compute', - catalog.EndpointsColumn( - auth_ref.service_catalog.catalog[0]['endpoints']), - ), ) + datalist = ( + ( + 'supernova', + 'compute', + catalog.EndpointsColumn( + auth_ref.service_catalog.catalog[0]['endpoints'] + ), + ), + ) self.assertCountEqual(datalist, tuple(data)) class TestCatalogShow(TestCatalog): - def setUp(self): super(TestCatalogShow, self).setUp() @@ -130,7 +130,8 @@ class TestCatalogShow(TestCatalog): self.assertEqual(collist, columns) datalist = ( catalog.EndpointsColumn( - auth_ref.service_catalog.catalog[0]['endpoints']), + auth_ref.service_catalog.catalog[0]['endpoints'] + ), 'qwertyuiop', 'supernova', 'compute', @@ -146,4 +147,5 @@ class TestFormatColumns(TestCatalog): 'onlyone\n admin: https://admin.example.com\n' '\n internal: https://internal.example.com\n' '\n none: https://none.example.com\n', - col.human_readable()) + col.human_readable(), + ) diff --git a/openstackclient/tests/unit/identity/v3/test_consumer.py b/openstackclient/tests/unit/identity/v3/test_consumer.py index 403250ef..fd13ef4a 100644 --- a/openstackclient/tests/unit/identity/v3/test_consumer.py +++ b/openstackclient/tests/unit/identity/v3/test_consumer.py @@ -18,7 +18,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestOAuth1(identity_fakes.TestOAuth1): - def setUp(self): super(TestOAuth1, self).setUp() identity_client = self.app.client_manager.identity @@ -27,7 +26,6 @@ class TestOAuth1(identity_fakes.TestOAuth1): class TestConsumerCreate(TestOAuth1): - def setUp(self): super(TestConsumerCreate, self).setUp() @@ -41,7 +39,8 @@ class TestConsumerCreate(TestOAuth1): def test_create_consumer(self): arglist = [ - '--description', identity_fakes.consumer_description, + '--description', + identity_fakes.consumer_description, ] verifylist = [ ('description', identity_fakes.consumer_description), @@ -64,7 +63,6 @@ class TestConsumerCreate(TestOAuth1): class TestConsumerDelete(TestOAuth1): - def setUp(self): super(TestConsumerDelete, self).setUp() @@ -96,7 +94,6 @@ class TestConsumerDelete(TestOAuth1): class TestConsumerList(TestOAuth1): - def setUp(self): super(TestConsumerList, self).setUp() @@ -129,15 +126,16 @@ class TestConsumerList(TestOAuth1): collist = ('ID', 'Description') self.assertEqual(collist, columns) - datalist = (( - identity_fakes.consumer_id, - identity_fakes.consumer_description, - ), ) + datalist = ( + ( + identity_fakes.consumer_id, + identity_fakes.consumer_description, + ), + ) self.assertEqual(datalist, tuple(data)) class TestConsumerSet(TestOAuth1): - def setUp(self): super(TestConsumerSet, self).setUp() @@ -161,7 +159,8 @@ class TestConsumerSet(TestOAuth1): new_description = "consumer new description" arglist = [ - '--description', new_description, + '--description', + new_description, identity_fakes.consumer_id, ] verifylist = [ @@ -174,14 +173,12 @@ class TestConsumerSet(TestOAuth1): kwargs = {'description': new_description} self.consumers_mock.update.assert_called_with( - identity_fakes.consumer_id, - **kwargs + identity_fakes.consumer_id, **kwargs ) self.assertIsNone(result) class TestConsumerShow(TestOAuth1): - def setUp(self): super(TestConsumerShow, self).setUp() diff --git a/openstackclient/tests/unit/identity/v3/test_credential.py b/openstackclient/tests/unit/identity/v3/test_credential.py index 40596d58..e6c2be67 100644 --- a/openstackclient/tests/unit/identity/v3/test_credential.py +++ b/openstackclient/tests/unit/identity/v3/test_credential.py @@ -21,7 +21,6 @@ from openstackclient.tests.unit import utils class TestCredential(identity_fakes.TestIdentityv3): - def setUp(self): super(TestCredential, self).setUp() @@ -39,7 +38,6 @@ class TestCredential(identity_fakes.TestIdentityv3): class TestCredentialCreate(TestCredential): - user = identity_fakes.FakeUser.create_one_user() project = identity_fakes.FakeProject.create_one_project() columns = ( @@ -54,7 +52,8 @@ class TestCredentialCreate(TestCredential): super(TestCredentialCreate, self).setUp() self.credential = identity_fakes.FakeCredential.create_one_credential( - attrs={'user_id': self.user.id, 'project_id': self.project.id}) + attrs={'user_id': self.user.id, 'project_id': self.project.id} + ) self.credentials_mock.create.return_value = self.credential self.users_mock.get.return_value = self.user self.projects_mock.get.return_value = self.project @@ -87,9 +86,7 @@ class TestCredentialCreate(TestCredential): 'blob': self.credential.blob, 'project': None, } - self.credentials_mock.create.assert_called_once_with( - **kwargs - ) + self.credentials_mock.create.assert_called_once_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.data, data) @@ -98,8 +95,10 @@ class TestCredentialCreate(TestCredential): arglist = [ self.credential.user_id, self.credential.blob, - '--type', self.credential.type, - '--project', self.credential.project_id, + '--type', + self.credential.type, + '--project', + self.credential.project_id, ] verifylist = [ ('user', self.credential.user_id), @@ -117,16 +116,13 @@ class TestCredentialCreate(TestCredential): 'blob': self.credential.blob, 'project': self.credential.project_id, } - self.credentials_mock.create.assert_called_once_with( - **kwargs - ) + self.credentials_mock.create.assert_called_once_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.data, data) class TestCredentialDelete(TestCredential): - credentials = identity_fakes.FakeCredential.create_credentials(count=2) def setUp(self): @@ -181,8 +177,8 @@ class TestCredentialDelete(TestCredential): parsed_args = self.check_parser(self.cmd, arglist, verifylist) delete_mock_result = [None, exceptions.CommandError] - self.credentials_mock.delete = ( - mock.Mock(side_effect=delete_mock_result) + self.credentials_mock.delete = mock.Mock( + side_effect=delete_mock_result ) try: @@ -196,17 +192,18 @@ class TestCredentialDelete(TestCredential): class TestCredentialList(TestCredential): - credential = identity_fakes.FakeCredential.create_one_credential() columns = ('ID', 'Type', 'User ID', 'Data', 'Project ID') - data = (( - credential.id, - credential.type, - credential.user_id, - credential.blob, - credential.project_id, - ), ) + data = ( + ( + credential.id, + credential.type, + credential.user_id, + credential.blob, + credential.project_id, + ), + ) def setUp(self): super(TestCredentialList, self).setUp() @@ -232,8 +229,10 @@ class TestCredentialList(TestCredential): def test_credential_list_with_options(self): arglist = [ - '--user', self.credential.user_id, - '--type', self.credential.type, + '--user', + self.credential.user_id, + '--type', + self.credential.type, ] verifylist = [ ('user', self.credential.user_id), @@ -248,16 +247,13 @@ class TestCredentialList(TestCredential): 'type': self.credential.type, } self.users_mock.get.assert_called_with(self.credential.user_id) - self.credentials_mock.list.assert_called_with( - **kwargs - ) + self.credentials_mock.list.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.data, tuple(data)) class TestCredentialSet(TestCredential): - credential = identity_fakes.FakeCredential.create_one_credential() def setUp(self): @@ -269,44 +265,57 @@ class TestCredentialSet(TestCredential): self.credential.id, ] - self.assertRaises(utils.ParserException, - self.check_parser, self.cmd, arglist, []) + self.assertRaises( + utils.ParserException, self.check_parser, self.cmd, arglist, [] + ) def test_credential_set_missing_user(self): arglist = [ - '--type', 'ec2', - '--data', self.credential.blob, + '--type', + 'ec2', + '--data', + self.credential.blob, self.credential.id, ] - self.assertRaises(utils.ParserException, - self.check_parser, self.cmd, arglist, []) + self.assertRaises( + utils.ParserException, self.check_parser, self.cmd, arglist, [] + ) def test_credential_set_missing_type(self): arglist = [ - '--user', self.credential.user_id, - '--data', self.credential.blob, + '--user', + self.credential.user_id, + '--data', + self.credential.blob, self.credential.id, ] - self.assertRaises(utils.ParserException, - self.check_parser, self.cmd, arglist, []) + self.assertRaises( + utils.ParserException, self.check_parser, self.cmd, arglist, [] + ) def test_credential_set_missing_data(self): arglist = [ - '--user', self.credential.user_id, - '--type', 'ec2', + '--user', + self.credential.user_id, + '--type', + 'ec2', self.credential.id, ] - self.assertRaises(utils.ParserException, - self.check_parser, self.cmd, arglist, []) + self.assertRaises( + utils.ParserException, self.check_parser, self.cmd, arglist, [] + ) def test_credential_set_valid(self): arglist = [ - '--user', self.credential.user_id, - '--type', 'ec2', - '--data', self.credential.blob, + '--user', + self.credential.user_id, + '--type', + 'ec2', + '--data', + self.credential.blob, self.credential.id, ] parsed_args = self.check_parser(self.cmd, arglist, []) @@ -317,10 +326,14 @@ class TestCredentialSet(TestCredential): def test_credential_set_valid_with_project(self): arglist = [ - '--user', self.credential.user_id, - '--type', 'ec2', - '--data', self.credential.blob, - '--project', self.credential.project_id, + '--user', + self.credential.user_id, + '--type', + 'ec2', + '--data', + self.credential.blob, + '--project', + self.credential.project_id, self.credential.id, ] parsed_args = self.check_parser(self.cmd, arglist, []) @@ -331,7 +344,6 @@ class TestCredentialSet(TestCredential): class TestCredentialShow(TestCredential): - columns = ( 'blob', 'id', diff --git a/openstackclient/tests/unit/identity/v3/test_domain.py b/openstackclient/tests/unit/identity/v3/test_domain.py index c39f1bd3..08fbbaac 100644 --- a/openstackclient/tests/unit/identity/v3/test_domain.py +++ b/openstackclient/tests/unit/identity/v3/test_domain.py @@ -15,7 +15,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestDomain(identity_fakes.TestIdentityv3): - def setUp(self): super(TestDomain, self).setUp() @@ -25,14 +24,7 @@ class TestDomain(identity_fakes.TestIdentityv3): class TestDomainCreate(TestDomain): - - columns = ( - 'description', - 'enabled', - 'id', - 'name', - 'tags' - ) + columns = ('description', 'enabled', 'id', 'name', 'tags') def setUp(self): super(TestDomainCreate, self).setUp() @@ -44,7 +36,7 @@ class TestDomainCreate(TestDomain): True, self.domain.id, self.domain.name, - self.domain.tags + self.domain.tags, ) # Get the command object to test @@ -71,16 +63,15 @@ class TestDomainCreate(TestDomain): 'options': {}, 'enabled': True, } - self.domains_mock.create.assert_called_with( - **kwargs - ) + self.domains_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_domain_create_description(self): arglist = [ - '--description', 'new desc', + '--description', + 'new desc', self.domain.name, ] verifylist = [ @@ -101,9 +92,7 @@ class TestDomainCreate(TestDomain): 'options': {}, 'enabled': True, } - self.domains_mock.create.assert_called_with( - **kwargs - ) + self.domains_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -131,9 +120,7 @@ class TestDomainCreate(TestDomain): 'options': {}, 'enabled': True, } - self.domains_mock.create.assert_called_with( - **kwargs - ) + self.domains_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -161,9 +148,7 @@ class TestDomainCreate(TestDomain): 'options': {}, 'enabled': False, } - self.domains_mock.create.assert_called_with( - **kwargs - ) + self.domains_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -191,9 +176,7 @@ class TestDomainCreate(TestDomain): 'options': {'immutable': True}, 'enabled': True, } - self.domains_mock.create.assert_called_with( - **kwargs - ) + self.domains_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -221,16 +204,13 @@ class TestDomainCreate(TestDomain): 'options': {'immutable': False}, 'enabled': True, } - self.domains_mock.create.assert_called_with( - **kwargs - ) + self.domains_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) class TestDomainDelete(TestDomain): - domain = identity_fakes.FakeDomain.create_one_domain() def setUp(self): @@ -261,7 +241,6 @@ class TestDomainDelete(TestDomain): class TestDomainList(TestDomain): - domain = identity_fakes.FakeDomain.create_one_domain() def setUp(self): @@ -285,20 +264,19 @@ class TestDomainList(TestDomain): collist = ('ID', 'Name', 'Enabled', 'Description') self.assertEqual(collist, columns) - datalist = (( - self.domain.id, - self.domain.name, - True, - self.domain.description, - ), ) + datalist = ( + ( + self.domain.id, + self.domain.name, + True, + self.domain.description, + ), + ) self.assertEqual(datalist, tuple(data)) def test_domain_list_with_option_name(self): - arglist = ['--name', - self.domain.name] - verifylist = [ - ('name', self.domain.name) - ] + arglist = ['--name', self.domain.name] + verifylist = [('name', self.domain.name)] parsed_args = self.check_parser(self.cmd, arglist, verifylist) # In base command class Lister in cliff, abstract method take_action() @@ -306,26 +284,24 @@ class TestDomainList(TestDomain): # containing the data to be listed. columns, data = self.cmd.take_action(parsed_args) - kwargs = { - 'name': self.domain.name - } + kwargs = {'name': self.domain.name} self.domains_mock.list.assert_called_with(**kwargs) collist = ('ID', 'Name', 'Enabled', 'Description') self.assertEqual(collist, columns) - datalist = (( - self.domain.id, - self.domain.name, - True, - self.domain.description, - ), ) + datalist = ( + ( + self.domain.id, + self.domain.name, + True, + self.domain.description, + ), + ) self.assertEqual(datalist, tuple(data)) def test_domain_list_with_option_enabled(self): arglist = ['--enabled'] - verifylist = [ - ('enabled', True) - ] + verifylist = [('enabled', True)] parsed_args = self.check_parser(self.cmd, arglist, verifylist) # In base command class Lister in cliff, abstract method take_action() @@ -333,24 +309,23 @@ class TestDomainList(TestDomain): # containing the data to be listed. columns, data = self.cmd.take_action(parsed_args) - kwargs = { - 'enabled': True - } + kwargs = {'enabled': True} self.domains_mock.list.assert_called_with(**kwargs) collist = ('ID', 'Name', 'Enabled', 'Description') self.assertEqual(collist, columns) - datalist = (( - self.domain.id, - self.domain.name, - True, - self.domain.description, - ), ) + datalist = ( + ( + self.domain.id, + self.domain.name, + True, + self.domain.description, + ), + ) self.assertEqual(datalist, tuple(data)) class TestDomainSet(TestDomain): - domain = identity_fakes.FakeDomain.create_one_domain() def setUp(self): @@ -375,15 +350,13 @@ class TestDomainSet(TestDomain): result = self.cmd.take_action(parsed_args) kwargs = {} - self.domains_mock.update.assert_called_with( - self.domain.id, - **kwargs - ) + self.domains_mock.update.assert_called_with(self.domain.id, **kwargs) self.assertIsNone(result) def test_domain_set_name(self): arglist = [ - '--name', 'qwerty', + '--name', + 'qwerty', self.domain.id, ] verifylist = [ @@ -398,15 +371,13 @@ class TestDomainSet(TestDomain): kwargs = { 'name': 'qwerty', } - self.domains_mock.update.assert_called_with( - self.domain.id, - **kwargs - ) + self.domains_mock.update.assert_called_with(self.domain.id, **kwargs) self.assertIsNone(result) def test_domain_set_description(self): arglist = [ - '--description', 'new desc', + '--description', + 'new desc', self.domain.id, ] verifylist = [ @@ -421,10 +392,7 @@ class TestDomainSet(TestDomain): kwargs = { 'description': 'new desc', } - self.domains_mock.update.assert_called_with( - self.domain.id, - **kwargs - ) + self.domains_mock.update.assert_called_with(self.domain.id, **kwargs) self.assertIsNone(result) def test_domain_set_enable(self): @@ -444,10 +412,7 @@ class TestDomainSet(TestDomain): kwargs = { 'enabled': True, } - self.domains_mock.update.assert_called_with( - self.domain.id, - **kwargs - ) + self.domains_mock.update.assert_called_with(self.domain.id, **kwargs) self.assertIsNone(result) def test_domain_set_disable(self): @@ -467,10 +432,7 @@ class TestDomainSet(TestDomain): kwargs = { 'enabled': False, } - self.domains_mock.update.assert_called_with( - self.domain.id, - **kwargs - ) + self.domains_mock.update.assert_called_with(self.domain.id, **kwargs) self.assertIsNone(result) def test_domain_set_immutable_option(self): @@ -490,10 +452,7 @@ class TestDomainSet(TestDomain): kwargs = { 'options': {'immutable': True}, } - self.domains_mock.update.assert_called_with( - self.domain.id, - **kwargs - ) + self.domains_mock.update.assert_called_with(self.domain.id, **kwargs) self.assertIsNone(result) def test_domain_set_no_immutable_option(self): @@ -513,15 +472,11 @@ class TestDomainSet(TestDomain): kwargs = { 'options': {'immutable': False}, } - self.domains_mock.update.assert_called_with( - self.domain.id, - **kwargs - ) + self.domains_mock.update.assert_called_with(self.domain.id, **kwargs) self.assertIsNone(result) class TestDomainShow(TestDomain): - def setUp(self): super(TestDomainShow, self).setUp() @@ -538,16 +493,9 @@ class TestDomainShow(TestDomain): ('domain', self.domain.id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.app.client_manager.identity.tokens.get_token_data.return_value = \ - {'token': - {'project': - {'domain': - {'id': 'd1', - 'name': 'd1' - } - } - } - } + self.app.client_manager.identity.tokens.get_token_data.return_value = { + 'token': {'project': {'domain': {'id': 'd1', 'name': 'd1'}}} + } # In base command class ShowOne in cliff, abstract method take_action() # returns a two-part tuple with a tuple of column names and a tuple of @@ -564,6 +512,6 @@ class TestDomainShow(TestDomain): True, self.domain.id, self.domain.name, - self.domain.tags + self.domain.tags, ) self.assertEqual(datalist, data) diff --git a/openstackclient/tests/unit/identity/v3/test_endpoint.py b/openstackclient/tests/unit/identity/v3/test_endpoint.py index 62dcf58d..39159432 100644 --- a/openstackclient/tests/unit/identity/v3/test_endpoint.py +++ b/openstackclient/tests/unit/identity/v3/test_endpoint.py @@ -15,16 +15,13 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestEndpoint(identity_fakes.TestIdentityv3): - def setUp(self): super(TestEndpoint, self).setUp() # Get a shortcut to the EndpointManager Mock self.endpoints_mock = self.app.client_manager.identity.endpoints self.endpoints_mock.reset_mock() - self.ep_filter_mock = ( - self.app.client_manager.identity.endpoint_filter - ) + self.ep_filter_mock = self.app.client_manager.identity.endpoint_filter self.ep_filter_mock.reset_mock() # Get a shortcut to the ServiceManager Mock @@ -41,7 +38,6 @@ class TestEndpoint(identity_fakes.TestIdentityv3): class TestEndpointCreate(TestEndpoint): - service = identity_fakes.FakeService.create_one_service() columns = ( @@ -59,7 +55,8 @@ class TestEndpointCreate(TestEndpoint): super(TestEndpointCreate, self).setUp() self.endpoint = identity_fakes.FakeEndpoint.create_one_endpoint( - attrs={'service_id': self.service.id}) + attrs={'service_id': self.service.id} + ) self.endpoints_mock.create.return_value = self.endpoint # This is the return value for common.find_resource(service) @@ -96,9 +93,7 @@ class TestEndpointCreate(TestEndpoint): 'region': None, } - self.endpoints_mock.create.assert_called_with( - **kwargs - ) + self.endpoints_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) datalist = ( @@ -118,7 +113,8 @@ class TestEndpointCreate(TestEndpoint): self.service.id, self.endpoint.interface, self.endpoint.url, - '--region', self.endpoint.region, + '--region', + self.endpoint.region, ] verifylist = [ ('enabled', True), @@ -143,9 +139,7 @@ class TestEndpointCreate(TestEndpoint): 'region': self.endpoint.region, } - self.endpoints_mock.create.assert_called_with( - **kwargs - ) + self.endpoints_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) datalist = ( @@ -165,7 +159,7 @@ class TestEndpointCreate(TestEndpoint): self.service.id, self.endpoint.interface, self.endpoint.url, - '--enable' + '--enable', ] verifylist = [ ('enabled', True), @@ -189,9 +183,7 @@ class TestEndpointCreate(TestEndpoint): 'region': None, } - self.endpoints_mock.create.assert_called_with( - **kwargs - ) + self.endpoints_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) datalist = ( @@ -235,9 +227,7 @@ class TestEndpointCreate(TestEndpoint): 'region': None, } - self.endpoints_mock.create.assert_called_with( - **kwargs - ) + self.endpoints_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) datalist = ( @@ -254,7 +244,6 @@ class TestEndpointCreate(TestEndpoint): class TestEndpointDelete(TestEndpoint): - endpoint = identity_fakes.FakeEndpoint.create_one_endpoint() def setUp(self): @@ -285,10 +274,10 @@ class TestEndpointDelete(TestEndpoint): class TestEndpointList(TestEndpoint): - service = identity_fakes.FakeService.create_one_service() endpoint = identity_fakes.FakeEndpoint.create_one_endpoint( - attrs={'service_id': service.id}) + attrs={'service_id': service.id} + ) columns = ( 'ID', @@ -339,7 +328,8 @@ class TestEndpointList(TestEndpoint): def test_endpoint_list_service(self): arglist = [ - '--service', self.service.id, + '--service', + self.service.id, ] verifylist = [ ('service', self.service.id), @@ -373,7 +363,8 @@ class TestEndpointList(TestEndpoint): def test_endpoint_list_interface(self): arglist = [ - '--interface', self.endpoint.interface, + '--interface', + self.endpoint.interface, ] verifylist = [ ('interface', self.endpoint.interface), @@ -407,7 +398,8 @@ class TestEndpointList(TestEndpoint): def test_endpoint_list_region(self): arglist = [ - '--region', self.endpoint.region, + '--region', + self.endpoint.region, ] verifylist = [ ('region', self.endpoint.region), @@ -448,10 +440,7 @@ class TestEndpointList(TestEndpoint): ] self.projects_mock.get.return_value = project - arglist = [ - '--project', project.name, - '--project-domain', domain.name - ] + arglist = ['--project', project.name, '--project-domain', domain.name] verifylist = [ ('project', project.name), ('project_domain', domain.name), @@ -482,10 +471,10 @@ class TestEndpointList(TestEndpoint): class TestEndpointSet(TestEndpoint): - service = identity_fakes.FakeService.create_one_service() endpoint = identity_fakes.FakeEndpoint.create_one_endpoint( - attrs={'service_id': service.id}) + attrs={'service_id': service.id} + ) def setUp(self): super(TestEndpointSet, self).setUp() @@ -520,16 +509,12 @@ class TestEndpointSet(TestEndpoint): 'url': None, } self.endpoints_mock.update.assert_called_with( - self.endpoint.id, - **kwargs + self.endpoint.id, **kwargs ) self.assertIsNone(result) def test_endpoint_set_interface(self): - arglist = [ - '--interface', 'public', - self.endpoint.id - ] + arglist = ['--interface', 'public', self.endpoint.id] verifylist = [ ('interface', 'public'), ('endpoint', self.endpoint.id), @@ -547,16 +532,12 @@ class TestEndpointSet(TestEndpoint): 'service': None, } self.endpoints_mock.update.assert_called_with( - self.endpoint.id, - **kwargs + self.endpoint.id, **kwargs ) self.assertIsNone(result) def test_endpoint_set_url(self): - arglist = [ - '--url', 'http://localhost:5000', - self.endpoint.id - ] + arglist = ['--url', 'http://localhost:5000', self.endpoint.id] verifylist = [ ('url', 'http://localhost:5000'), ('endpoint', self.endpoint.id), @@ -574,16 +555,12 @@ class TestEndpointSet(TestEndpoint): 'service': None, } self.endpoints_mock.update.assert_called_with( - self.endpoint.id, - **kwargs + self.endpoint.id, **kwargs ) self.assertIsNone(result) def test_endpoint_set_service(self): - arglist = [ - '--service', self.service.id, - self.endpoint.id - ] + arglist = ['--service', self.service.id, self.endpoint.id] verifylist = [ ('service', self.service.id), ('endpoint', self.endpoint.id), @@ -601,16 +578,12 @@ class TestEndpointSet(TestEndpoint): 'service': self.service.id, } self.endpoints_mock.update.assert_called_with( - self.endpoint.id, - **kwargs + self.endpoint.id, **kwargs ) self.assertIsNone(result) def test_endpoint_set_region(self): - arglist = [ - '--region', 'e-rzzz', - self.endpoint.id - ] + arglist = ['--region', 'e-rzzz', self.endpoint.id] verifylist = [ ('region', 'e-rzzz'), ('endpoint', self.endpoint.id), @@ -628,16 +601,12 @@ class TestEndpointSet(TestEndpoint): 'service': None, } self.endpoints_mock.update.assert_called_with( - self.endpoint.id, - **kwargs + self.endpoint.id, **kwargs ) self.assertIsNone(result) def test_endpoint_set_enable(self): - arglist = [ - '--enable', - self.endpoint.id - ] + arglist = ['--enable', self.endpoint.id] verifylist = [ ('enabled', True), ('endpoint', self.endpoint.id), @@ -655,16 +624,12 @@ class TestEndpointSet(TestEndpoint): 'service': None, } self.endpoints_mock.update.assert_called_with( - self.endpoint.id, - **kwargs + self.endpoint.id, **kwargs ) self.assertIsNone(result) def test_endpoint_set_disable(self): - arglist = [ - '--disable', - self.endpoint.id - ] + arglist = ['--disable', self.endpoint.id] verifylist = [ ('disabled', True), ('endpoint', self.endpoint.id), @@ -682,17 +647,16 @@ class TestEndpointSet(TestEndpoint): 'service': None, } self.endpoints_mock.update.assert_called_with( - self.endpoint.id, - **kwargs + self.endpoint.id, **kwargs ) self.assertIsNone(result) class TestEndpointShow(TestEndpoint): - service = identity_fakes.FakeService.create_one_service() endpoint = identity_fakes.FakeEndpoint.create_one_endpoint( - attrs={'service_id': service.id}) + attrs={'service_id': service.id} + ) def setUp(self): super(TestEndpointShow, self).setUp() @@ -747,15 +711,16 @@ class TestEndpointShow(TestEndpoint): class TestEndpointCreateServiceWithoutName(TestEndpointCreate): - service = identity_fakes.FakeService.create_one_service( - attrs={'service_name': ''}) + attrs={'service_name': ''} + ) def setUp(self): super(TestEndpointCreate, self).setUp() self.endpoint = identity_fakes.FakeEndpoint.create_one_endpoint( - attrs={'service_id': self.service.id}) + attrs={'service_id': self.service.id} + ) self.endpoints_mock.create.return_value = self.endpoint @@ -767,11 +732,12 @@ class TestEndpointCreateServiceWithoutName(TestEndpointCreate): class TestEndpointListServiceWithoutName(TestEndpointList): - service = identity_fakes.FakeService.create_one_service( - attrs={'service_name': ''}) + attrs={'service_name': ''} + ) endpoint = identity_fakes.FakeEndpoint.create_one_endpoint( - attrs={'service_id': service.id}) + attrs={'service_id': service.id} + ) def setUp(self): super(TestEndpointList, self).setUp() @@ -787,11 +753,12 @@ class TestEndpointListServiceWithoutName(TestEndpointList): class TestEndpointShowServiceWithoutName(TestEndpointShow): - service = identity_fakes.FakeService.create_one_service( - attrs={'service_name': ''}) + attrs={'service_name': ''} + ) endpoint = identity_fakes.FakeEndpoint.create_one_endpoint( - attrs={'service_id': service.id}) + attrs={'service_id': service.id} + ) def setUp(self): super(TestEndpointShow, self).setUp() @@ -806,16 +773,15 @@ class TestEndpointShowServiceWithoutName(TestEndpointShow): class TestAddProjectToEndpoint(TestEndpoint): - project = identity_fakes.FakeProject.create_one_project() domain = identity_fakes.FakeDomain.create_one_domain() service = identity_fakes.FakeService.create_one_service() endpoint = identity_fakes.FakeEndpoint.create_one_endpoint( - attrs={'service_id': service.id}) + attrs={'service_id': service.id} + ) new_ep_filter = identity_fakes.FakeEndpoint.create_one_endpoint_filter( - attrs={'endpoint': endpoint.id, - 'project': project.id} + attrs={'endpoint': endpoint.id, 'project': project.id} ) def setUp(self): @@ -844,8 +810,7 @@ class TestAddProjectToEndpoint(TestEndpoint): result = self.cmd.take_action(parsed_args) self.ep_filter_mock.add_endpoint_to_project.assert_called_with( - project=self.project.id, - endpoint=self.endpoint.id + project=self.project.id, endpoint=self.endpoint.id ) self.assertIsNone(result) @@ -853,7 +818,8 @@ class TestAddProjectToEndpoint(TestEndpoint): arglist = [ self.endpoint.id, self.project.id, - '--project-domain', self.domain.id, + '--project-domain', + self.domain.id, ] verifylist = [ ('endpoint', self.endpoint.id), @@ -864,19 +830,18 @@ class TestAddProjectToEndpoint(TestEndpoint): result = self.cmd.take_action(parsed_args) self.ep_filter_mock.add_endpoint_to_project.assert_called_with( - project=self.project.id, - endpoint=self.endpoint.id + project=self.project.id, endpoint=self.endpoint.id ) self.assertIsNone(result) class TestRemoveProjectEndpoint(TestEndpoint): - project = identity_fakes.FakeProject.create_one_project() domain = identity_fakes.FakeDomain.create_one_domain() service = identity_fakes.FakeService.create_one_service() endpoint = identity_fakes.FakeEndpoint.create_one_endpoint( - attrs={'service_id': service.id}) + attrs={'service_id': service.id} + ) def setUp(self): super(TestRemoveProjectEndpoint, self).setUp() @@ -914,7 +879,8 @@ class TestRemoveProjectEndpoint(TestEndpoint): arglist = [ self.endpoint.id, self.project.id, - '--project-domain', self.domain.id, + '--project-domain', + self.domain.id, ] verifylist = [ ('endpoint', self.endpoint.id), diff --git a/openstackclient/tests/unit/identity/v3/test_endpoint_group.py b/openstackclient/tests/unit/identity/v3/test_endpoint_group.py index c081fa1f..66d06dd9 100644 --- a/openstackclient/tests/unit/identity/v3/test_endpoint_group.py +++ b/openstackclient/tests/unit/identity/v3/test_endpoint_group.py @@ -18,7 +18,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestEndpointGroup(identity_fakes.TestIdentityv3): - def setUp(self): super(TestEndpointGroup, self).setUp() @@ -27,9 +26,7 @@ class TestEndpointGroup(identity_fakes.TestIdentityv3): self.app.client_manager.identity.endpoint_groups ) self.endpoint_groups_mock.reset_mock() - self.epf_mock = ( - self.app.client_manager.identity.endpoint_filter - ) + self.epf_mock = self.app.client_manager.identity.endpoint_filter self.epf_mock.reset_mock() # Get a shortcut to the ServiceManager Mock @@ -46,7 +43,6 @@ class TestEndpointGroup(identity_fakes.TestIdentityv3): class TestEndpointGroupCreate(TestEndpointGroup): - columns = ( 'description', 'filters', @@ -59,7 +55,9 @@ class TestEndpointGroupCreate(TestEndpointGroup): self.endpoint_group = ( identity_fakes.FakeEndpointGroup.create_one_endpointgroup( - attrs={'filters': identity_fakes.endpoint_group_filters})) + attrs={'filters': identity_fakes.endpoint_group_filters} + ) + ) self.endpoint_groups_mock.create.return_value = self.endpoint_group @@ -68,7 +66,8 @@ class TestEndpointGroupCreate(TestEndpointGroup): def test_endpointgroup_create_no_options(self): arglist = [ - '--description', self.endpoint_group.description, + '--description', + self.endpoint_group.description, self.endpoint_group.name, identity_fakes.endpoint_group_file_path, ] @@ -81,8 +80,11 @@ class TestEndpointGroupCreate(TestEndpointGroup): mocker = mock.Mock() mocker.return_value = identity_fakes.endpoint_group_filters - with mock.patch("openstackclient.identity.v3.endpoint_group." - "CreateEndpointGroup._read_filters", mocker): + with mock.patch( + "openstackclient.identity.v3.endpoint_group." + "CreateEndpointGroup._read_filters", + mocker, + ): columns, data = self.cmd.take_action(parsed_args) # Set expected values @@ -92,9 +94,7 @@ class TestEndpointGroupCreate(TestEndpointGroup): 'description': self.endpoint_group.description, } - self.endpoint_groups_mock.create.assert_called_with( - **kwargs - ) + self.endpoint_groups_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) datalist = ( @@ -107,9 +107,9 @@ class TestEndpointGroupCreate(TestEndpointGroup): class TestEndpointGroupDelete(TestEndpointGroup): - endpoint_group = ( - identity_fakes.FakeEndpointGroup.create_one_endpointgroup()) + identity_fakes.FakeEndpointGroup.create_one_endpointgroup() + ) def setUp(self): super(TestEndpointGroupDelete, self).setUp() @@ -139,9 +139,9 @@ class TestEndpointGroupDelete(TestEndpointGroup): class TestEndpointGroupList(TestEndpointGroup): - endpoint_group = ( - identity_fakes.FakeEndpointGroup.create_one_endpointgroup()) + identity_fakes.FakeEndpointGroup.create_one_endpointgroup() + ) project = identity_fakes.FakeProject.create_one_project() domain = identity_fakes.FakeDomain.create_one_domain() @@ -157,9 +157,11 @@ class TestEndpointGroupList(TestEndpointGroup): self.endpoint_groups_mock.list.return_value = [self.endpoint_group] self.endpoint_groups_mock.get.return_value = self.endpoint_group self.epf_mock.list_projects_for_endpoint_group.return_value = [ - self.project] + self.project + ] self.epf_mock.list_endpoint_groups_for_project.return_value = [ - self.endpoint_group] + self.endpoint_group + ] # Get the command object to test self.cmd = endpoint_group.ListEndpointGroup(self.app, None) @@ -187,7 +189,8 @@ class TestEndpointGroupList(TestEndpointGroup): def test_endpoint_group_list_projects_by_endpoint_group(self): arglist = [ - '--endpointgroup', self.endpoint_group.id, + '--endpointgroup', + self.endpoint_group.id, ] verifylist = [ ('endpointgroup', self.endpoint_group.id), @@ -219,8 +222,10 @@ class TestEndpointGroupList(TestEndpointGroup): self.projects_mock.get.return_value = self.project arglist = [ - '--project', self.project.name, - '--domain', self.domain.name + '--project', + self.project.name, + '--domain', + self.domain.name, ] verifylist = [ ('project', self.project.name), @@ -248,9 +253,9 @@ class TestEndpointGroupList(TestEndpointGroup): class TestEndpointGroupSet(TestEndpointGroup): - endpoint_group = ( - identity_fakes.FakeEndpointGroup.create_one_endpointgroup()) + identity_fakes.FakeEndpointGroup.create_one_endpointgroup() + ) def setUp(self): super(TestEndpointGroupSet, self).setUp() @@ -274,22 +279,14 @@ class TestEndpointGroupSet(TestEndpointGroup): result = self.cmd.take_action(parsed_args) - kwargs = { - 'name': None, - 'filters': None, - 'description': '' - } + kwargs = {'name': None, 'filters': None, 'description': ''} self.endpoint_groups_mock.update.assert_called_with( - self.endpoint_group.id, - **kwargs + self.endpoint_group.id, **kwargs ) self.assertIsNone(result) def test_endpoint_group_set_name(self): - arglist = [ - '--name', 'qwerty', - self.endpoint_group.id - ] + arglist = ['--name', 'qwerty', self.endpoint_group.id] verifylist = [ ('name', 'qwerty'), ('endpointgroup', self.endpoint_group.id), @@ -299,20 +296,16 @@ class TestEndpointGroupSet(TestEndpointGroup): result = self.cmd.take_action(parsed_args) # Set expected values - kwargs = { - 'name': 'qwerty', - 'filters': None, - 'description': '' - } + kwargs = {'name': 'qwerty', 'filters': None, 'description': ''} self.endpoint_groups_mock.update.assert_called_with( - self.endpoint_group.id, - **kwargs + self.endpoint_group.id, **kwargs ) self.assertIsNone(result) def test_endpoint_group_set_filters(self): arglist = [ - '--filters', identity_fakes.endpoint_group_file_path, + '--filters', + identity_fakes.endpoint_group_file_path, self.endpoint_group.id, ] verifylist = [ @@ -324,8 +317,11 @@ class TestEndpointGroupSet(TestEndpointGroup): mocker = mock.Mock() mocker.return_value = identity_fakes.endpoint_group_filters_2 - with mock.patch("openstackclient.identity.v3.endpoint_group." - "SetEndpointGroup._read_filters", mocker): + with mock.patch( + "openstackclient.identity.v3.endpoint_group." + "SetEndpointGroup._read_filters", + mocker, + ): result = self.cmd.take_action(parsed_args) # Set expected values @@ -336,17 +332,13 @@ class TestEndpointGroupSet(TestEndpointGroup): } self.endpoint_groups_mock.update.assert_called_with( - self.endpoint_group.id, - **kwargs + self.endpoint_group.id, **kwargs ) self.assertIsNone(result) def test_endpoint_group_set_description(self): - arglist = [ - '--description', 'qwerty', - self.endpoint_group.id - ] + arglist = ['--description', 'qwerty', self.endpoint_group.id] verifylist = [ ('description', 'qwerty'), ('endpointgroup', self.endpoint_group.id), @@ -362,23 +354,23 @@ class TestEndpointGroupSet(TestEndpointGroup): 'description': 'qwerty', } self.endpoint_groups_mock.update.assert_called_with( - self.endpoint_group.id, - **kwargs + self.endpoint_group.id, **kwargs ) self.assertIsNone(result) class TestAddProjectToEndpointGroup(TestEndpointGroup): - project = identity_fakes.FakeProject.create_one_project() domain = identity_fakes.FakeDomain.create_one_domain() endpoint_group = ( - identity_fakes.FakeEndpointGroup.create_one_endpointgroup()) + identity_fakes.FakeEndpointGroup.create_one_endpointgroup() + ) new_ep_filter = ( identity_fakes.FakeEndpointGroup.create_one_endpointgroup_filter( - attrs={'endpointgroup': endpoint_group.id, - 'project': project.id})) + attrs={'endpointgroup': endpoint_group.id, 'project': project.id} + ) + ) def setUp(self): super(TestAddProjectToEndpointGroup, self).setUp() @@ -416,7 +408,8 @@ class TestAddProjectToEndpointGroup(TestEndpointGroup): arglist = [ self.endpoint_group.id, self.project.id, - '--project-domain', self.domain.id, + '--project-domain', + self.domain.id, ] verifylist = [ ('endpointgroup', self.endpoint_group.id), @@ -434,11 +427,11 @@ class TestAddProjectToEndpointGroup(TestEndpointGroup): class TestRemoveProjectEndpointGroup(TestEndpointGroup): - project = identity_fakes.FakeProject.create_one_project() domain = identity_fakes.FakeDomain.create_one_domain() endpoint_group = ( - identity_fakes.FakeEndpointGroup.create_one_endpointgroup()) + identity_fakes.FakeEndpointGroup.create_one_endpointgroup() + ) def setUp(self): super(TestRemoveProjectEndpointGroup, self).setUp() @@ -452,7 +445,8 @@ class TestRemoveProjectEndpointGroup(TestEndpointGroup): # Get the command object to test self.cmd = endpoint_group.RemoveProjectFromEndpointGroup( - self.app, None) + self.app, None + ) def test_remove_project_endpoint_no_options(self): arglist = [ @@ -477,7 +471,8 @@ class TestRemoveProjectEndpointGroup(TestEndpointGroup): arglist = [ self.endpoint_group.id, self.project.id, - '--project-domain', self.domain.id, + '--project-domain', + self.domain.id, ] verifylist = [ ('endpointgroup', self.endpoint_group.id), diff --git a/openstackclient/tests/unit/identity/v3/test_group.py b/openstackclient/tests/unit/identity/v3/test_group.py index 04ba0dbe..3c95931c 100644 --- a/openstackclient/tests/unit/identity/v3/test_group.py +++ b/openstackclient/tests/unit/identity/v3/test_group.py @@ -23,7 +23,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestGroup(identity_fakes.TestIdentityv3): - def setUp(self): super(TestGroup, self).setUp() @@ -41,7 +40,6 @@ class TestGroup(identity_fakes.TestIdentityv3): class TestGroupAddUser(TestGroup): - _group = identity_fakes.FakeGroup.create_one_group() users = identity_fakes.FakeUser.create_users(count=2) @@ -49,8 +47,7 @@ class TestGroupAddUser(TestGroup): super(TestGroupAddUser, self).setUp() self.groups_mock.get.return_value = self._group - self.users_mock.get = ( - identity_fakes.FakeUser.get_users(self.users)) + self.users_mock.get = identity_fakes.FakeUser.get_users(self.users) self.users_mock.add_to_group.return_value = None self.cmd = group.AddUserToGroup(self.app, None) @@ -68,7 +65,8 @@ class TestGroupAddUser(TestGroup): result = self.cmd.take_action(parsed_args) self.users_mock.add_to_group.assert_called_once_with( - self.users[0].id, self._group.id) + self.users[0].id, self._group.id + ) self.assertIsNone(result) def test_group_add_multi_users(self): @@ -84,15 +82,19 @@ class TestGroupAddUser(TestGroup): parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - calls = [call(self.users[0].id, self._group.id), - call(self.users[1].id, self._group.id)] + calls = [ + call(self.users[0].id, self._group.id), + call(self.users[1].id, self._group.id), + ] self.users_mock.add_to_group.assert_has_calls(calls) self.assertIsNone(result) @mock.patch.object(group.LOG, 'error') def test_group_add_user_with_error(self, mock_error): self.users_mock.add_to_group.side_effect = [ - exceptions.CommandError(), None] + exceptions.CommandError(), + None, + ] arglist = [ self._group.name, self.users[0].name, @@ -117,7 +119,6 @@ class TestGroupAddUser(TestGroup): class TestGroupCheckUser(TestGroup): - group = identity_fakes.FakeGroup.create_one_group() user = identity_fakes.FakeUser.create_one_user() @@ -143,12 +144,14 @@ class TestGroupCheckUser(TestGroup): result = self.cmd.take_action(parsed_args) self.users_mock.check_in_group.assert_called_once_with( - self.user.id, self.group.id) + self.user.id, self.group.id + ) self.assertIsNone(result) def test_group_check_user_server_error(self): def server_error(*args): raise ks_exc.http.InternalServerError + self.users_mock.check_in_group.side_effect = server_error arglist = [ self.group.name, @@ -160,12 +163,12 @@ class TestGroupCheckUser(TestGroup): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.assertRaises(ks_exc.http.InternalServerError, - self.cmd.take_action, parsed_args) + self.assertRaises( + ks_exc.http.InternalServerError, self.cmd.take_action, parsed_args + ) class TestGroupCreate(TestGroup): - domain = identity_fakes.FakeDomain.create_one_domain() columns = ( @@ -178,7 +181,8 @@ class TestGroupCreate(TestGroup): def setUp(self): super(TestGroupCreate, self).setUp() self.group = identity_fakes.FakeGroup.create_one_group( - attrs={'domain_id': self.domain.id}) + attrs={'domain_id': self.domain.id} + ) self.data = ( self.group.description, self.group.domain_id, @@ -212,8 +216,10 @@ class TestGroupCreate(TestGroup): def test_group_create_with_options(self): arglist = [ - '--domain', self.domain.name, - '--description', self.group.description, + '--domain', + self.domain.name, + '--description', + self.group.description, self.group.name, ] verifylist = [ @@ -251,16 +257,15 @@ class TestGroupCreate(TestGroup): class TestGroupDelete(TestGroup): - domain = identity_fakes.FakeDomain.create_one_domain() groups = identity_fakes.FakeGroup.create_groups( - attrs={'domain_id': domain.id}, count=2) + attrs={'domain_id': domain.id}, count=2 + ) def setUp(self): super(TestGroupDelete, self).setUp() - self.groups_mock.get = ( - identity_fakes.FakeGroup.get_groups(self.groups)) + self.groups_mock.get = identity_fakes.FakeGroup.get_groups(self.groups) self.groups_mock.delete.return_value = None self.domains_mock.get.return_value = self.domain @@ -301,11 +306,11 @@ class TestGroupDelete(TestGroup): def test_group_delete_with_domain(self): get_mock_result = [exceptions.CommandError, self.groups[0]] - self.groups_mock.get = ( - mock.Mock(side_effect=get_mock_result)) + self.groups_mock.get = mock.Mock(side_effect=get_mock_result) arglist = [ - '--domain', self.domain.id, + '--domain', + self.domain.id, self.groups[0].id, ] verifylist = [ @@ -316,14 +321,14 @@ class TestGroupDelete(TestGroup): result = self.cmd.take_action(parsed_args) self.groups_mock.get.assert_any_call( - self.groups[0].id, domain_id=self.domain.id) + self.groups[0].id, domain_id=self.domain.id + ) self.groups_mock.delete.assert_called_once_with(self.groups[0].id) self.assertIsNone(result) @mock.patch.object(utils, 'find_resource') def test_delete_multi_groups_with_exception(self, find_mock): - find_mock.side_effect = [self.groups[0], - exceptions.CommandError] + find_mock.side_effect = [self.groups[0], exceptions.CommandError] arglist = [ self.groups[0].id, 'unexist_group', @@ -337,8 +342,7 @@ class TestGroupDelete(TestGroup): self.cmd.take_action(parsed_args) self.fail('CommandError should be raised.') except exceptions.CommandError as e: - self.assertEqual('1 of 2 groups failed to delete.', - str(e)) + self.assertEqual('1 of 2 groups failed to delete.', str(e)) find_mock.assert_any_call(self.groups_mock, self.groups[0].id) find_mock.assert_any_call(self.groups_mock, 'unexist_group') @@ -348,7 +352,6 @@ class TestGroupDelete(TestGroup): class TestGroupList(TestGroup): - domain = identity_fakes.FakeDomain.create_one_domain() group = identity_fakes.FakeGroup.create_one_group() user = identity_fakes.FakeUser.create_one_user() @@ -393,16 +396,15 @@ class TestGroupList(TestGroup): 'user': None, } - self.groups_mock.list.assert_called_with( - **kwargs - ) + self.groups_mock.list.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, tuple(data)) def test_group_list_domain(self): arglist = [ - '--domain', self.domain.id, + '--domain', + self.domain.id, ] verifylist = [ ('domain', self.domain.id), @@ -420,16 +422,15 @@ class TestGroupList(TestGroup): 'user': None, } - self.groups_mock.list.assert_called_with( - **kwargs - ) + self.groups_mock.list.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, tuple(data)) def test_group_list_user(self): arglist = [ - '--user', self.user.name, + '--user', + self.user.name, ] verifylist = [ ('user', self.user.name), @@ -447,9 +448,7 @@ class TestGroupList(TestGroup): 'user': self.user.id, } - self.groups_mock.list.assert_called_with( - **kwargs - ) + self.groups_mock.list.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, tuple(data)) @@ -474,26 +473,25 @@ class TestGroupList(TestGroup): 'user': None, } - self.groups_mock.list.assert_called_with( - **kwargs - ) + self.groups_mock.list.assert_called_with(**kwargs) columns = self.columns + ( 'Domain ID', 'Description', ) - datalist = (( - self.group.id, - self.group.name, - self.group.domain_id, - self.group.description, - ), ) + datalist = ( + ( + self.group.id, + self.group.name, + self.group.domain_id, + self.group.description, + ), + ) self.assertEqual(columns, columns) self.assertEqual(datalist, tuple(data)) class TestGroupRemoveUser(TestGroup): - _group = identity_fakes.FakeGroup.create_one_group() users = identity_fakes.FakeUser.create_users(count=2) @@ -501,8 +499,7 @@ class TestGroupRemoveUser(TestGroup): super(TestGroupRemoveUser, self).setUp() self.groups_mock.get.return_value = self._group - self.users_mock.get = ( - identity_fakes.FakeUser.get_users(self.users)) + self.users_mock.get = identity_fakes.FakeUser.get_users(self.users) self.users_mock.remove_from_group.return_value = None self.cmd = group.RemoveUserFromGroup(self.app, None) @@ -520,7 +517,8 @@ class TestGroupRemoveUser(TestGroup): result = self.cmd.take_action(parsed_args) self.users_mock.remove_from_group.assert_called_once_with( - self.users[0].id, self._group.id) + self.users[0].id, self._group.id + ) self.assertIsNone(result) def test_group_remove_multi_users(self): @@ -536,15 +534,19 @@ class TestGroupRemoveUser(TestGroup): parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - calls = [call(self.users[0].id, self._group.id), - call(self.users[1].id, self._group.id)] + calls = [ + call(self.users[0].id, self._group.id), + call(self.users[1].id, self._group.id), + ] self.users_mock.remove_from_group.assert_has_calls(calls) self.assertIsNone(result) @mock.patch.object(group.LOG, 'error') def test_group_remove_user_with_error(self, mock_error): self.users_mock.remove_from_group.side_effect = [ - exceptions.CommandError(), None] + exceptions.CommandError(), + None, + ] arglist = [ self._group.id, self.users[0].id, @@ -569,10 +571,10 @@ class TestGroupRemoveUser(TestGroup): class TestGroupSet(TestGroup): - domain = identity_fakes.FakeDomain.create_one_domain() group = identity_fakes.FakeGroup.create_one_group( - attrs={'domain_id': domain.id}) + attrs={'domain_id': domain.id} + ) def setUp(self): super(TestGroupSet, self).setUp() @@ -598,8 +600,10 @@ class TestGroupSet(TestGroup): def test_group_set_name_and_description(self): arglist = [ - '--name', 'new_name', - '--description', 'new_description', + '--name', + 'new_name', + '--description', + 'new_description', self.group.id, ] verifylist = [ @@ -615,16 +619,17 @@ class TestGroupSet(TestGroup): 'description': 'new_description', } self.groups_mock.update.assert_called_once_with( - self.group.id, **kwargs) + self.group.id, **kwargs + ) self.assertIsNone(result) def test_group_set_with_domain(self): get_mock_result = [exceptions.CommandError, self.group] - self.groups_mock.get = ( - mock.Mock(side_effect=get_mock_result)) + self.groups_mock.get = mock.Mock(side_effect=get_mock_result) arglist = [ - '--domain', self.domain.id, + '--domain', + self.domain.id, self.group.id, ] verifylist = [ @@ -635,13 +640,13 @@ class TestGroupSet(TestGroup): result = self.cmd.take_action(parsed_args) self.groups_mock.get.assert_any_call( - self.group.id, domain_id=self.domain.id) + self.group.id, domain_id=self.domain.id + ) self.groups_mock.update.assert_called_once_with(self.group.id) self.assertIsNone(result) class TestGroupShow(TestGroup): - domain = identity_fakes.FakeDomain.create_one_domain() columns = ( @@ -654,7 +659,8 @@ class TestGroupShow(TestGroup): def setUp(self): super(TestGroupShow, self).setUp() self.group = identity_fakes.FakeGroup.create_one_group( - attrs={'domain_id': self.domain.id}) + attrs={'domain_id': self.domain.id} + ) self.data = ( self.group.description, self.group.domain_id, @@ -683,11 +689,11 @@ class TestGroupShow(TestGroup): def test_group_show_with_domain(self): get_mock_result = [exceptions.CommandError, self.group] - self.groups_mock.get = ( - mock.Mock(side_effect=get_mock_result)) + self.groups_mock.get = mock.Mock(side_effect=get_mock_result) arglist = [ - '--domain', self.domain.id, + '--domain', + self.domain.id, self.group.id, ] verifylist = [ @@ -698,6 +704,7 @@ class TestGroupShow(TestGroup): columns, data = self.cmd.take_action(parsed_args) self.groups_mock.get.assert_any_call( - self.group.id, domain_id=self.domain.id) + self.group.id, domain_id=self.domain.id + ) self.assertEqual(self.columns, columns) self.assertEqual(self.data, data) diff --git a/openstackclient/tests/unit/identity/v3/test_identity_provider.py b/openstackclient/tests/unit/identity/v3/test_identity_provider.py index 480bae59..f45f53a3 100644 --- a/openstackclient/tests/unit/identity/v3/test_identity_provider.py +++ b/openstackclient/tests/unit/identity/v3/test_identity_provider.py @@ -24,7 +24,6 @@ from openstackclient.tests.unit import utils as test_utils class TestIdentityProvider(identity_fakes.TestFederatedIdentity): - def setUp(self): super(TestIdentityProvider, self).setUp() @@ -44,7 +43,6 @@ class TestIdentityProvider(identity_fakes.TestFederatedIdentity): class TestIdentityProviderCreate(TestIdentityProvider): - columns = ( 'description', 'domain_id', @@ -87,8 +85,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): } self.identity_providers_mock.create.assert_called_with( - id=identity_fakes.idp_id, - **kwargs + id=identity_fakes.idp_id, **kwargs ) self.assertEqual(self.columns, columns) @@ -96,7 +93,8 @@ class TestIdentityProviderCreate(TestIdentityProvider): def test_create_identity_provider_description(self): arglist = [ - '--description', identity_fakes.idp_description, + '--description', + identity_fakes.idp_description, identity_fakes.idp_id, ] verifylist = [ @@ -115,8 +113,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): } self.identity_providers_mock.create.assert_called_with( - id=identity_fakes.idp_id, - **kwargs + id=identity_fakes.idp_id, **kwargs ) self.assertEqual(self.columns, columns) @@ -125,7 +122,8 @@ class TestIdentityProviderCreate(TestIdentityProvider): def test_create_identity_provider_remote_id(self): arglist = [ identity_fakes.idp_id, - '--remote-id', identity_fakes.idp_remote_ids[0] + '--remote-id', + identity_fakes.idp_remote_ids[0], ] verifylist = [ ('identity_provider_id', identity_fakes.idp_id), @@ -143,8 +141,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): } self.identity_providers_mock.create.assert_called_with( - id=identity_fakes.idp_id, - **kwargs + id=identity_fakes.idp_id, **kwargs ) self.assertEqual(self.columns, columns) @@ -152,9 +149,11 @@ class TestIdentityProviderCreate(TestIdentityProvider): def test_create_identity_provider_remote_ids_multiple(self): arglist = [ - '--remote-id', identity_fakes.idp_remote_ids[0], - '--remote-id', identity_fakes.idp_remote_ids[1], - identity_fakes.idp_id + '--remote-id', + identity_fakes.idp_remote_ids[0], + '--remote-id', + identity_fakes.idp_remote_ids[1], + identity_fakes.idp_id, ] verifylist = [ ('identity_provider_id', identity_fakes.idp_id), @@ -172,8 +171,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): } self.identity_providers_mock.create.assert_called_with( - id=identity_fakes.idp_id, - **kwargs + id=identity_fakes.idp_id, **kwargs ) self.assertEqual(self.columns, columns) @@ -181,7 +179,8 @@ class TestIdentityProviderCreate(TestIdentityProvider): def test_create_identity_provider_remote_ids_file(self): arglist = [ - '--remote-id-file', '/tmp/file_name', + '--remote-id-file', + '/tmp/file_name', identity_fakes.idp_id, ] verifylist = [ @@ -192,8 +191,11 @@ class TestIdentityProviderCreate(TestIdentityProvider): mocker = mock.Mock() mocker.return_value = "\n".join(identity_fakes.idp_remote_ids) - with mock.patch("openstackclient.identity.v3.identity_provider." - "utils.read_blob_file_contents", mocker): + with mock.patch( + "openstackclient.identity.v3.identity_provider." + "utils.read_blob_file_contents", + mocker, + ): columns, data = self.cmd.take_action(parsed_args) # Set expected values @@ -205,15 +207,13 @@ class TestIdentityProviderCreate(TestIdentityProvider): } self.identity_providers_mock.create.assert_called_with( - id=identity_fakes.idp_id, - **kwargs + id=identity_fakes.idp_id, **kwargs ) self.assertEqual(self.columns, columns) self.assertCountEqual(self.datalist, data) def test_create_identity_provider_disabled(self): - # Prepare FakeResource object IDENTITY_PROVIDER = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER) IDENTITY_PROVIDER['enabled'] = False @@ -241,8 +241,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): } self.identity_providers_mock.create.assert_called_with( - id=identity_fakes.idp_id, - **kwargs + id=identity_fakes.idp_id, **kwargs ) self.assertEqual(self.columns, columns) @@ -251,13 +250,14 @@ class TestIdentityProviderCreate(TestIdentityProvider): identity_fakes.domain_id, False, identity_fakes.idp_id, - identity_fakes.formatted_idp_remote_ids + identity_fakes.formatted_idp_remote_ids, ) self.assertCountEqual(datalist, data) def test_create_identity_provider_domain_name(self): arglist = [ - '--domain', identity_fakes.domain_name, + '--domain', + identity_fakes.domain_name, identity_fakes.idp_id, ] verifylist = [ @@ -276,8 +276,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): } self.identity_providers_mock.create.assert_called_with( - id=identity_fakes.idp_id, - **kwargs + id=identity_fakes.idp_id, **kwargs ) self.assertEqual(self.columns, columns) @@ -285,7 +284,8 @@ class TestIdentityProviderCreate(TestIdentityProvider): def test_create_identity_provider_domain_id(self): arglist = [ - '--domain', identity_fakes.domain_id, + '--domain', + identity_fakes.domain_id, identity_fakes.idp_id, ] verifylist = [ @@ -304,8 +304,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): } self.identity_providers_mock.create.assert_called_with( - id=identity_fakes.idp_id, - **kwargs + id=identity_fakes.idp_id, **kwargs ) self.assertEqual(self.columns, columns) @@ -313,7 +312,8 @@ class TestIdentityProviderCreate(TestIdentityProvider): def test_create_identity_provider_authttl_positive(self): arglist = [ - '--authorization-ttl', '60', + '--authorization-ttl', + '60', identity_fakes.idp_id, ] verifylist = [ @@ -333,8 +333,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): } self.identity_providers_mock.create.assert_called_with( - id=identity_fakes.idp_id, - **kwargs + id=identity_fakes.idp_id, **kwargs ) self.assertEqual(self.columns, columns) @@ -342,7 +341,8 @@ class TestIdentityProviderCreate(TestIdentityProvider): def test_create_identity_provider_authttl_zero(self): arglist = [ - '--authorization-ttl', '0', + '--authorization-ttl', + '0', identity_fakes.idp_id, ] verifylist = [ @@ -362,8 +362,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): } self.identity_providers_mock.create.assert_called_with( - id=identity_fakes.idp_id, - **kwargs + id=identity_fakes.idp_id, **kwargs ) self.assertEqual(self.columns, columns) @@ -371,7 +370,8 @@ class TestIdentityProviderCreate(TestIdentityProvider): def test_create_identity_provider_authttl_negative(self): arglist = [ - '--authorization-ttl', '-60', + '--authorization-ttl', + '-60', identity_fakes.idp_id, ] verifylist = [ @@ -379,21 +379,27 @@ class TestIdentityProviderCreate(TestIdentityProvider): ('authorization_ttl', -60), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.assertRaises(exceptions.CommandError, self.cmd.take_action, - parsed_args) + self.assertRaises( + exceptions.CommandError, self.cmd.take_action, parsed_args + ) def test_create_identity_provider_authttl_not_int(self): arglist = [ - '--authorization-ttl', 'spam', + '--authorization-ttl', + 'spam', identity_fakes.idp_id, ] verifylist = [] - self.assertRaises(test_utils.ParserException, self.check_parser, - self.cmd, arglist, verifylist) + self.assertRaises( + test_utils.ParserException, + self.check_parser, + self.cmd, + arglist, + verifylist, + ) class TestIdentityProviderDelete(TestIdentityProvider): - def setUp(self): super(TestIdentityProviderDelete, self).setUp() @@ -425,7 +431,6 @@ class TestIdentityProviderDelete(TestIdentityProvider): class TestIdentityProviderList(TestIdentityProvider): - def setUp(self): super(TestIdentityProviderList, self).setUp() @@ -459,20 +464,19 @@ class TestIdentityProviderList(TestIdentityProvider): collist = ('ID', 'Enabled', 'Domain ID', 'Description') self.assertEqual(collist, columns) - datalist = (( - identity_fakes.idp_id, - True, - identity_fakes.domain_id, - identity_fakes.idp_description, - ), ) + datalist = ( + ( + identity_fakes.idp_id, + True, + identity_fakes.domain_id, + identity_fakes.idp_description, + ), + ) self.assertCountEqual(datalist, tuple(data)) def test_identity_provider_list_ID_option(self): - arglist = ['--id', - identity_fakes.idp_id] - verifylist = [ - ('id', identity_fakes.idp_id) - ] + arglist = ['--id', identity_fakes.idp_id] + verifylist = [('id', identity_fakes.idp_id)] parsed_args = self.check_parser(self.cmd, arglist, verifylist) # In base command class Lister in cliff, abstract method take_action() @@ -480,26 +484,24 @@ class TestIdentityProviderList(TestIdentityProvider): # containing the data to be listed. columns, data = self.cmd.take_action(parsed_args) - kwargs = { - 'id': identity_fakes.idp_id - } + kwargs = {'id': identity_fakes.idp_id} self.identity_providers_mock.list.assert_called_with(**kwargs) collist = ('ID', 'Enabled', 'Domain ID', 'Description') self.assertEqual(collist, columns) - datalist = (( - identity_fakes.idp_id, - True, - identity_fakes.domain_id, - identity_fakes.idp_description, - ), ) + datalist = ( + ( + identity_fakes.idp_id, + True, + identity_fakes.domain_id, + identity_fakes.idp_description, + ), + ) self.assertCountEqual(datalist, tuple(data)) def test_identity_provider_list_enabled_option(self): arglist = ['--enabled'] - verifylist = [ - ('enabled', True) - ] + verifylist = [('enabled', True)] parsed_args = self.check_parser(self.cmd, arglist, verifylist) # In base command class Lister in cliff, abstract method take_action() @@ -507,24 +509,23 @@ class TestIdentityProviderList(TestIdentityProvider): # containing the data to be listed. columns, data = self.cmd.take_action(parsed_args) - kwargs = { - 'enabled': True - } + kwargs = {'enabled': True} self.identity_providers_mock.list.assert_called_with(**kwargs) collist = ('ID', 'Enabled', 'Domain ID', 'Description') self.assertEqual(collist, columns) - datalist = (( - identity_fakes.idp_id, - True, - identity_fakes.domain_id, - identity_fakes.idp_description, - ), ) + datalist = ( + ( + identity_fakes.idp_id, + True, + identity_fakes.domain_id, + identity_fakes.idp_description, + ), + ) self.assertCountEqual(datalist, tuple(data)) class TestIdentityProviderSet(TestIdentityProvider): - columns = ( 'description', 'enabled', @@ -543,31 +544,24 @@ class TestIdentityProviderSet(TestIdentityProvider): self.cmd = identity_provider.SetIdentityProvider(self.app, None) def test_identity_provider_set_description(self): - """Set Identity Provider's description. """ + """Set Identity Provider's description.""" def prepare(self): """Prepare fake return objects before the test is executed""" updated_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER) updated_idp['enabled'] = False - resources = fakes.FakeResource( - None, - updated_idp, - loaded=True - ) + resources = fakes.FakeResource(None, updated_idp, loaded=True) self.identity_providers_mock.update.return_value = resources prepare(self) new_description = 'new desc' - arglist = [ - '--description', new_description, - identity_fakes.idp_id - ] + arglist = ['--description', new_description, identity_fakes.idp_id] verifylist = [ ('identity_provider', identity_fakes.idp_id), ('description', new_description), ('enable', False), ('disable', False), - ('remote_id', None) + ('remote_id', None), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) self.cmd.take_action(parsed_args) @@ -586,25 +580,24 @@ class TestIdentityProviderSet(TestIdentityProvider): """Prepare fake return objects before the test is executed""" updated_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER) updated_idp['enabled'] = False - resources = fakes.FakeResource( - None, - updated_idp, - loaded=True - ) + resources = fakes.FakeResource(None, updated_idp, loaded=True) self.identity_providers_mock.update.return_value = resources prepare(self) arglist = [ - '--disable', identity_fakes.idp_id, - '--remote-id', identity_fakes.idp_remote_ids[0], - '--remote-id', identity_fakes.idp_remote_ids[1] + '--disable', + identity_fakes.idp_id, + '--remote-id', + identity_fakes.idp_remote_ids[0], + '--remote-id', + identity_fakes.idp_remote_ids[1], ] verifylist = [ ('identity_provider', identity_fakes.idp_id), ('description', None), ('enable', False), ('disable', True), - ('remote_id', identity_fakes.idp_remote_ids) + ('remote_id', identity_fakes.idp_remote_ids), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -612,7 +605,7 @@ class TestIdentityProviderSet(TestIdentityProvider): self.identity_providers_mock.update.assert_called_with( identity_fakes.idp_id, enabled=False, - remote_ids=identity_fakes.idp_remote_ids + remote_ids=identity_fakes.idp_remote_ids, ) def test_identity_provider_enable(self): @@ -626,29 +619,34 @@ class TestIdentityProviderSet(TestIdentityProvider): resources = fakes.FakeResource( None, copy.deepcopy(identity_fakes.IDENTITY_PROVIDER), - loaded=True + loaded=True, ) self.identity_providers_mock.update.return_value = resources prepare(self) arglist = [ - '--enable', identity_fakes.idp_id, - '--remote-id', identity_fakes.idp_remote_ids[0], - '--remote-id', identity_fakes.idp_remote_ids[1] + '--enable', + identity_fakes.idp_id, + '--remote-id', + identity_fakes.idp_remote_ids[0], + '--remote-id', + identity_fakes.idp_remote_ids[1], ] verifylist = [ ('identity_provider', identity_fakes.idp_id), ('description', None), ('enable', True), ('disable', False), - ('remote_id', identity_fakes.idp_remote_ids) + ('remote_id', identity_fakes.idp_remote_ids), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) self.cmd.take_action(parsed_args) self.identity_providers_mock.update.assert_called_with( - identity_fakes.idp_id, enabled=True, - remote_ids=identity_fakes.idp_remote_ids) + identity_fakes.idp_id, + enabled=True, + remote_ids=identity_fakes.idp_remote_ids, + ) def test_identity_provider_replace_remote_ids(self): """Enable Identity Provider. @@ -662,31 +660,31 @@ class TestIdentityProviderSet(TestIdentityProvider): updated_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER) updated_idp['remote_ids'] = [self.new_remote_id] - resources = fakes.FakeResource( - None, - updated_idp, - loaded=True - ) + resources = fakes.FakeResource(None, updated_idp, loaded=True) self.identity_providers_mock.update.return_value = resources prepare(self) arglist = [ - '--enable', identity_fakes.idp_id, - '--remote-id', self.new_remote_id + '--enable', + identity_fakes.idp_id, + '--remote-id', + self.new_remote_id, ] verifylist = [ ('identity_provider', identity_fakes.idp_id), ('description', None), ('enable', True), ('disable', False), - ('remote_id', [self.new_remote_id]) + ('remote_id', [self.new_remote_id]), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) self.cmd.take_action(parsed_args) self.identity_providers_mock.update.assert_called_with( - identity_fakes.idp_id, enabled=True, - remote_ids=[self.new_remote_id]) + identity_fakes.idp_id, + enabled=True, + remote_ids=[self.new_remote_id], + ) def test_identity_provider_replace_remote_ids_file(self): """Enable Identity Provider. @@ -700,17 +698,15 @@ class TestIdentityProviderSet(TestIdentityProvider): updated_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER) updated_idp['remote_ids'] = [self.new_remote_id] - resources = fakes.FakeResource( - None, - updated_idp, - loaded=True - ) + resources = fakes.FakeResource(None, updated_idp, loaded=True) self.identity_providers_mock.update.return_value = resources prepare(self) arglist = [ - '--enable', identity_fakes.idp_id, - '--remote-id-file', self.new_remote_id, + '--enable', + identity_fakes.idp_id, + '--remote-id-file', + self.new_remote_id, ] verifylist = [ ('identity_provider', identity_fakes.idp_id), @@ -723,12 +719,17 @@ class TestIdentityProviderSet(TestIdentityProvider): mocker = mock.Mock() mocker.return_value = self.new_remote_id - with mock.patch("openstackclient.identity.v3.identity_provider." - "utils.read_blob_file_contents", mocker): + with mock.patch( + "openstackclient.identity.v3.identity_provider." + "utils.read_blob_file_contents", + mocker, + ): self.cmd.take_action(parsed_args) self.identity_providers_mock.update.assert_called_with( - identity_fakes.idp_id, enabled=True, - remote_ids=[self.new_remote_id]) + identity_fakes.idp_id, + enabled=True, + remote_ids=[self.new_remote_id], + ) def test_identity_provider_no_options(self): def prepare(self): @@ -736,7 +737,7 @@ class TestIdentityProviderSet(TestIdentityProvider): resources = fakes.FakeResource( None, copy.deepcopy(identity_fakes.IDENTITY_PROVIDER), - loaded=True + loaded=True, ) self.identity_providers_mock.get.return_value = resources @@ -755,7 +756,7 @@ class TestIdentityProviderSet(TestIdentityProvider): ('identity_provider', identity_fakes.idp_id), ('enable', False), ('disable', False), - ('remote_id', None) + ('remote_id', None), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -766,18 +767,11 @@ class TestIdentityProviderSet(TestIdentityProvider): """Prepare fake return objects before the test is executed""" updated_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER) updated_idp['authorization_ttl'] = 60 - resources = fakes.FakeResource( - None, - updated_idp, - loaded=True - ) + resources = fakes.FakeResource(None, updated_idp, loaded=True) self.identity_providers_mock.update.return_value = resources prepare(self) - arglist = [ - '--authorization-ttl', '60', - identity_fakes.idp_id - ] + arglist = ['--authorization-ttl', '60', identity_fakes.idp_id] verifylist = [ ('identity_provider', identity_fakes.idp_id), ('enable', False), @@ -797,18 +791,11 @@ class TestIdentityProviderSet(TestIdentityProvider): """Prepare fake return objects before the test is executed""" updated_idp = copy.deepcopy(identity_fakes.IDENTITY_PROVIDER) updated_idp['authorization_ttl'] = 0 - resources = fakes.FakeResource( - None, - updated_idp, - loaded=True - ) + resources = fakes.FakeResource(None, updated_idp, loaded=True) self.identity_providers_mock.update.return_value = resources prepare(self) - arglist = [ - '--authorization-ttl', '0', - identity_fakes.idp_id - ] + arglist = ['--authorization-ttl', '0', identity_fakes.idp_id] verifylist = [ ('identity_provider', identity_fakes.idp_id), ('enable', False), @@ -824,10 +811,7 @@ class TestIdentityProviderSet(TestIdentityProvider): ) def test_identity_provider_set_authttl_negative(self): - arglist = [ - '--authorization-ttl', '-1', - identity_fakes.idp_id - ] + arglist = ['--authorization-ttl', '-1', identity_fakes.idp_id] verifylist = [ ('identity_provider', identity_fakes.idp_id), ('enable', False), @@ -836,21 +820,23 @@ class TestIdentityProviderSet(TestIdentityProvider): ('authorization_ttl', -1), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.assertRaises(exceptions.CommandError, self.cmd.take_action, - parsed_args) + self.assertRaises( + exceptions.CommandError, self.cmd.take_action, parsed_args + ) def test_identity_provider_set_authttl_not_int(self): - arglist = [ - '--authorization-ttl', 'spam', - identity_fakes.idp_id - ] + arglist = ['--authorization-ttl', 'spam', identity_fakes.idp_id] verifylist = [] - self.assertRaises(test_utils.ParserException, self.check_parser, - self.cmd, arglist, verifylist) + self.assertRaises( + test_utils.ParserException, + self.check_parser, + self.cmd, + arglist, + verifylist, + ) class TestIdentityProviderShow(TestIdentityProvider): - def setUp(self): super(TestIdentityProviderShow, self).setUp() @@ -860,8 +846,10 @@ class TestIdentityProviderShow(TestIdentityProvider): loaded=True, ) - self.identity_providers_mock.get.side_effect = [Exception("Not found"), - ret] + self.identity_providers_mock.get.side_effect = [ + Exception("Not found"), + ret, + ] self.identity_providers_mock.get.return_value = ret # Get the command object to test @@ -879,8 +867,7 @@ class TestIdentityProviderShow(TestIdentityProvider): columns, data = self.cmd.take_action(parsed_args) self.identity_providers_mock.get.assert_called_with( - identity_fakes.idp_id, - id='test_idp' + identity_fakes.idp_id, id='test_idp' ) collist = ('description', 'domain_id', 'enabled', 'id', 'remote_ids') @@ -890,6 +877,6 @@ class TestIdentityProviderShow(TestIdentityProvider): identity_fakes.domain_id, True, identity_fakes.idp_id, - identity_fakes.formatted_idp_remote_ids + identity_fakes.formatted_idp_remote_ids, ) self.assertCountEqual(datalist, data) diff --git a/openstackclient/tests/unit/identity/v3/test_implied_role.py b/openstackclient/tests/unit/identity/v3/test_implied_role.py index 74968129..ea9c7596 100644 --- a/openstackclient/tests/unit/identity/v3/test_implied_role.py +++ b/openstackclient/tests/unit/identity/v3/test_implied_role.py @@ -21,7 +21,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestRole(identity_fakes.TestIdentityv3): - def setUp(self): super(TestRole, self).setUp() @@ -56,7 +55,6 @@ class TestRole(identity_fakes.TestIdentityv3): class TestImpliedRoleCreate(TestRole): - def setUp(self): super(TestImpliedRoleCreate, self).setUp() @@ -75,8 +73,10 @@ class TestImpliedRoleCreate(TestRole): fake_resource = fakes.FakeResource( None, - {'prior_role': copy.deepcopy(identity_fakes.ROLES[0]), - 'implied': copy.deepcopy(identity_fakes.ROLES[1]), }, + { + 'prior_role': copy.deepcopy(identity_fakes.ROLES[0]), + 'implied': copy.deepcopy(identity_fakes.ROLES[1]), + }, loaded=True, ) self.inference_rules_mock.create.return_value = fake_resource @@ -84,10 +84,10 @@ class TestImpliedRoleCreate(TestRole): self.cmd = implied_role.CreateImpliedRole(self.app, None) def test_implied_role_create(self): - arglist = [ identity_fakes.ROLES[0]['id'], - '--implied-role', identity_fakes.ROLES[1]['id'], + '--implied-role', + identity_fakes.ROLES[1]['id'], ] verifylist = [ ('role', identity_fakes.ROLES[0]['id']), @@ -102,21 +102,19 @@ class TestImpliedRoleCreate(TestRole): # InferenceRuleManager.create(prior, implied) self.inference_rules_mock.create.assert_called_with( - identity_fakes.ROLES[0]['id'], - identity_fakes.ROLES[1]['id'] + identity_fakes.ROLES[0]['id'], identity_fakes.ROLES[1]['id'] ) collist = ('implied', 'prior_role') self.assertEqual(collist, columns) datalist = ( identity_fakes.ROLES[1]['id'], - identity_fakes.ROLES[0]['id'] + identity_fakes.ROLES[0]['id'], ) self.assertEqual(datalist, data) class TestImpliedRoleDelete(TestRole): - def setUp(self): super(TestImpliedRoleDelete, self).setUp() @@ -135,8 +133,10 @@ class TestImpliedRoleDelete(TestRole): fake_resource = fakes.FakeResource( None, - {'prior-role': copy.deepcopy(identity_fakes.ROLES[0]), - 'implied': copy.deepcopy(identity_fakes.ROLES[1]), }, + { + 'prior-role': copy.deepcopy(identity_fakes.ROLES[0]), + 'implied': copy.deepcopy(identity_fakes.ROLES[1]), + }, loaded=True, ) self.inference_rules_mock.delete.return_value = fake_resource @@ -146,7 +146,8 @@ class TestImpliedRoleDelete(TestRole): def test_implied_role_delete(self): arglist = [ identity_fakes.ROLES[0]['id'], - '--implied-role', identity_fakes.ROLES[1]['id'], + '--implied-role', + identity_fakes.ROLES[1]['id'], ] verifylist = [ ('role', identity_fakes.ROLES[0]['id']), @@ -156,18 +157,17 @@ class TestImpliedRoleDelete(TestRole): self.cmd.take_action(parsed_args) self.inference_rules_mock.delete.assert_called_with( - identity_fakes.ROLES[0]['id'], - identity_fakes.ROLES[1]['id'] + identity_fakes.ROLES[0]['id'], identity_fakes.ROLES[1]['id'] ) class TestImpliedRoleList(TestRole): - def setUp(self): super(TestImpliedRoleList, self).setUp() self.inference_rules_mock.list_inference_roles.return_value = ( - identity_fakes.FakeImpliedRoleResponse.create_list()) + identity_fakes.FakeImpliedRoleResponse.create_list() + ) self.cmd = implied_role.ListImpliedRole(self.app, None) @@ -178,12 +178,20 @@ class TestImpliedRoleList(TestRole): columns, data = self.cmd.take_action(parsed_args) self.inference_rules_mock.list_inference_roles.assert_called_with() - collist = ['Prior Role ID', 'Prior Role Name', - 'Implied Role ID', 'Implied Role Name'] + collist = [ + 'Prior Role ID', + 'Prior Role Name', + 'Implied Role ID', + 'Implied Role Name', + ] self.assertEqual(collist, columns) datalist = [ - (identity_fakes.ROLES[0]['id'], identity_fakes.ROLES[0]['name'], - identity_fakes.ROLES[1]['id'], identity_fakes.ROLES[1]['name']) + ( + identity_fakes.ROLES[0]['id'], + identity_fakes.ROLES[0]['name'], + identity_fakes.ROLES[1]['id'], + identity_fakes.ROLES[1]['name'], + ) ] x = [d for d in data] self.assertEqual(datalist, x) diff --git a/openstackclient/tests/unit/identity/v3/test_limit.py b/openstackclient/tests/unit/identity/v3/test_limit.py index e5cd87b8..d5895afe 100644 --- a/openstackclient/tests/unit/identity/v3/test_limit.py +++ b/openstackclient/tests/unit/identity/v3/test_limit.py @@ -21,7 +21,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestLimit(identity_fakes.TestIdentityv3): - def setUp(self): super(TestLimit, self).setUp() @@ -40,28 +39,21 @@ class TestLimit(identity_fakes.TestIdentityv3): class TestLimitCreate(TestLimit): - def setUp(self): super(TestLimitCreate, self).setUp() self.service = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.SERVICE), - loaded=True + None, copy.deepcopy(identity_fakes.SERVICE), loaded=True ) self.services_mock.get.return_value = self.service self.project = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.PROJECT), - loaded=True + None, copy.deepcopy(identity_fakes.PROJECT), loaded=True ) self.projects_mock.get.return_value = self.project self.region = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.REGION), - loaded=True + None, copy.deepcopy(identity_fakes.REGION), loaded=True ) self.regions_mock.get.return_value = self.region @@ -69,23 +61,24 @@ class TestLimitCreate(TestLimit): def test_limit_create_without_options(self): self.limit_mock.create.return_value = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.LIMIT), - loaded=True + None, copy.deepcopy(identity_fakes.LIMIT), loaded=True ) resource_limit = 15 arglist = [ - '--project', identity_fakes.project_id, - '--service', identity_fakes.service_id, - '--resource-limit', str(resource_limit), - identity_fakes.limit_resource_name + '--project', + identity_fakes.project_id, + '--service', + identity_fakes.service_id, + '--resource-limit', + str(resource_limit), + identity_fakes.limit_resource_name, ] verifylist = [ ('project', identity_fakes.project_id), ('service', identity_fakes.service_id), ('resource_name', identity_fakes.limit_resource_name), - ('resource_limit', resource_limit) + ('resource_limit', resource_limit), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -100,8 +93,15 @@ class TestLimitCreate(TestLimit): **kwargs ) - collist = ('description', 'id', 'project_id', 'region_id', - 'resource_limit', 'resource_name', 'service_id') + collist = ( + 'description', + 'id', + 'project_id', + 'region_id', + 'resource_limit', + 'resource_name', + 'service_id', + ) self.assertEqual(collist, columns) datalist = ( None, @@ -110,25 +110,28 @@ class TestLimitCreate(TestLimit): None, resource_limit, identity_fakes.limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) def test_limit_create_with_options(self): self.limit_mock.create.return_value = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.LIMIT_OPTIONS), - loaded=True + None, copy.deepcopy(identity_fakes.LIMIT_OPTIONS), loaded=True ) resource_limit = 15 arglist = [ - '--project', identity_fakes.project_id, - '--service', identity_fakes.service_id, - '--resource-limit', str(resource_limit), - '--region', identity_fakes.region_id, - '--description', identity_fakes.limit_description, - identity_fakes.limit_resource_name + '--project', + identity_fakes.project_id, + '--service', + identity_fakes.service_id, + '--resource-limit', + str(resource_limit), + '--region', + identity_fakes.region_id, + '--description', + identity_fakes.limit_description, + identity_fakes.limit_resource_name, ] verifylist = [ ('project', identity_fakes.project_id), @@ -136,7 +139,7 @@ class TestLimitCreate(TestLimit): ('resource_name', identity_fakes.limit_resource_name), ('resource_limit', resource_limit), ('region', identity_fakes.region_id), - ('description', identity_fakes.limit_description) + ('description', identity_fakes.limit_description), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -144,7 +147,7 @@ class TestLimitCreate(TestLimit): kwargs = { 'description': identity_fakes.limit_description, - 'region': self.region + 'region': self.region, } self.limit_mock.create.assert_called_with( self.project, @@ -154,8 +157,15 @@ class TestLimitCreate(TestLimit): **kwargs ) - collist = ('description', 'id', 'project_id', 'region_id', - 'resource_limit', 'resource_name', 'service_id') + collist = ( + 'description', + 'id', + 'project_id', + 'region_id', + 'resource_limit', + 'resource_name', + 'service_id', + ) self.assertEqual(collist, columns) datalist = ( identity_fakes.limit_description, @@ -164,13 +174,12 @@ class TestLimitCreate(TestLimit): identity_fakes.region_id, resource_limit, identity_fakes.limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) class TestLimitDelete(TestLimit): - def setUp(self): super(TestLimitDelete, self).setUp() self.cmd = limit.DeleteLimit(self.app, None) @@ -179,16 +188,12 @@ class TestLimitDelete(TestLimit): self.limit_mock.delete.return_value = None arglist = [identity_fakes.limit_id] - verifylist = [ - ('limit_id', [identity_fakes.limit_id]) - ] + verifylist = [('limit_id', [identity_fakes.limit_id])] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.limit_mock.delete.assert_called_with( - identity_fakes.limit_id - ) + self.limit_mock.delete.assert_called_with(identity_fakes.limit_id) self.assertIsNone(result) def test_limit_delete_with_exception(self): @@ -196,29 +201,22 @@ class TestLimitDelete(TestLimit): self.limit_mock.delete.side_effect = return_value arglist = ['fake-limit-id'] - verifylist = [ - ('limit_id', ['fake-limit-id']) - ] + verifylist = [('limit_id', ['fake-limit-id'])] 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( - '1 of 1 limits failed to delete.', str(e) - ) + self.assertEqual('1 of 1 limits failed to delete.', str(e)) class TestLimitShow(TestLimit): - def setUp(self): super(TestLimitShow, self).setUp() self.limit_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.LIMIT), - loaded=True + None, copy.deepcopy(identity_fakes.LIMIT), loaded=True ) self.cmd = limit.ShowLimit(self.app, None) @@ -233,8 +231,13 @@ class TestLimitShow(TestLimit): self.limit_mock.get.assert_called_with(identity_fakes.limit_id) collist = ( - 'description', 'id', 'project_id', 'region_id', 'resource_limit', - 'resource_name', 'service_id' + 'description', + 'id', + 'project_id', + 'region_id', + 'resource_limit', + 'resource_name', + 'service_id', ) self.assertEqual(collist, columns) datalist = ( @@ -244,13 +247,12 @@ class TestLimitShow(TestLimit): None, identity_fakes.limit_resource_limit, identity_fakes.limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) class TestLimitSet(TestLimit): - def setUp(self): super(TestLimitSet, self).setUp() self.cmd = limit.SetLimit(self.app, None) @@ -263,12 +265,13 @@ class TestLimitSet(TestLimit): ) arglist = [ - '--description', identity_fakes.limit_description, - identity_fakes.limit_id + '--description', + identity_fakes.limit_description, + identity_fakes.limit_id, ] verifylist = [ ('description', identity_fakes.limit_description), - ('limit_id', identity_fakes.limit_id) + ('limit_id', identity_fakes.limit_id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -277,12 +280,17 @@ class TestLimitSet(TestLimit): self.limit_mock.update.assert_called_with( identity_fakes.limit_id, description=identity_fakes.limit_description, - resource_limit=None + resource_limit=None, ) collist = ( - 'description', 'id', 'project_id', 'region_id', 'resource_limit', - 'resource_name', 'service_id' + 'description', + 'id', + 'project_id', + 'region_id', + 'resource_limit', + 'resource_name', + 'service_id', ) self.assertEqual(collist, columns) datalist = ( @@ -292,7 +300,7 @@ class TestLimitSet(TestLimit): None, identity_fakes.limit_resource_limit, identity_fakes.limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) @@ -305,12 +313,13 @@ class TestLimitSet(TestLimit): ) arglist = [ - '--resource-limit', str(resource_limit), - identity_fakes.limit_id + '--resource-limit', + str(resource_limit), + identity_fakes.limit_id, ] verifylist = [ ('resource_limit', resource_limit), - ('limit_id', identity_fakes.limit_id) + ('limit_id', identity_fakes.limit_id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -319,12 +328,17 @@ class TestLimitSet(TestLimit): self.limit_mock.update.assert_called_with( identity_fakes.limit_id, description=None, - resource_limit=resource_limit + resource_limit=resource_limit, ) collist = ( - 'description', 'id', 'project_id', 'region_id', 'resource_limit', - 'resource_name', 'service_id' + 'description', + 'id', + 'project_id', + 'region_id', + 'resource_limit', + 'resource_name', + 'service_id', ) self.assertEqual(collist, columns) datalist = ( @@ -334,21 +348,18 @@ class TestLimitSet(TestLimit): None, resource_limit, identity_fakes.limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) class TestLimitList(TestLimit): - def setUp(self): super(TestLimitList, self).setUp() self.limit_mock.list.return_value = [ fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.LIMIT), - loaded=True + None, copy.deepcopy(identity_fakes.LIMIT), loaded=True ) ] @@ -362,22 +373,28 @@ class TestLimitList(TestLimit): columns, data = self.cmd.take_action(parsed_args) self.limit_mock.list.assert_called_with( - service=None, resource_name=None, region=None, - project=None + service=None, resource_name=None, region=None, project=None ) collist = ( - 'ID', 'Project ID', 'Service ID', 'Resource Name', - 'Resource Limit', 'Description', 'Region ID' + 'ID', + 'Project ID', + 'Service ID', + 'Resource Name', + 'Resource Limit', + 'Description', + 'Region ID', ) self.assertEqual(collist, columns) - datalist = (( - identity_fakes.limit_id, - identity_fakes.project_id, - identity_fakes.service_id, - identity_fakes.limit_resource_name, - identity_fakes.limit_resource_limit, - None, - None - ), ) + datalist = ( + ( + identity_fakes.limit_id, + identity_fakes.project_id, + identity_fakes.service_id, + identity_fakes.limit_resource_name, + identity_fakes.limit_resource_limit, + None, + None, + ), + ) self.assertEqual(datalist, tuple(data)) diff --git a/openstackclient/tests/unit/identity/v3/test_mappings.py b/openstackclient/tests/unit/identity/v3/test_mappings.py index 184bd2a2..e594a96b 100644 --- a/openstackclient/tests/unit/identity/v3/test_mappings.py +++ b/openstackclient/tests/unit/identity/v3/test_mappings.py @@ -23,7 +23,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestMapping(identity_fakes.TestFederatedIdentity): - def setUp(self): super(TestMapping, self).setUp() @@ -33,82 +32,73 @@ class TestMapping(identity_fakes.TestFederatedIdentity): class TestMappingCreate(TestMapping): - def setUp(self): super(TestMappingCreate, self).setUp() self.mapping_mock.create.return_value = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.MAPPING_RESPONSE), - loaded=True + None, copy.deepcopy(identity_fakes.MAPPING_RESPONSE), loaded=True ) self.cmd = mapping.CreateMapping(self.app, None) def test_create_mapping(self): arglist = [ - '--rules', identity_fakes.mapping_rules_file_path, - identity_fakes.mapping_id + '--rules', + identity_fakes.mapping_rules_file_path, + identity_fakes.mapping_id, ] verifylist = [ ('mapping', identity_fakes.mapping_id), - ('rules', identity_fakes.mapping_rules_file_path) + ('rules', identity_fakes.mapping_rules_file_path), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) mocker = mock.Mock() mocker.return_value = identity_fakes.MAPPING_RULES - with mock.patch("openstackclient.identity.v3.mapping." - "CreateMapping._read_rules", mocker): + with mock.patch( + "openstackclient.identity.v3.mapping." "CreateMapping._read_rules", + mocker, + ): columns, data = self.cmd.take_action(parsed_args) self.mapping_mock.create.assert_called_with( mapping_id=identity_fakes.mapping_id, - rules=identity_fakes.MAPPING_RULES) + rules=identity_fakes.MAPPING_RULES, + ) collist = ('id', 'rules') self.assertEqual(collist, columns) - datalist = (identity_fakes.mapping_id, - identity_fakes.MAPPING_RULES) + datalist = (identity_fakes.mapping_id, identity_fakes.MAPPING_RULES) self.assertEqual(datalist, data) class TestMappingDelete(TestMapping): - def setUp(self): super(TestMappingDelete, self).setUp() self.mapping_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.MAPPING_RESPONSE), - loaded=True) + None, copy.deepcopy(identity_fakes.MAPPING_RESPONSE), loaded=True + ) self.mapping_mock.delete.return_value = None self.cmd = mapping.DeleteMapping(self.app, None) def test_delete_mapping(self): - arglist = [ - identity_fakes.mapping_id - ] - verifylist = [ - ('mapping', [identity_fakes.mapping_id]) - ] + arglist = [identity_fakes.mapping_id] + verifylist = [('mapping', [identity_fakes.mapping_id])] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.mapping_mock.delete.assert_called_with( - identity_fakes.mapping_id) + self.mapping_mock.delete.assert_called_with(identity_fakes.mapping_id) self.assertIsNone(result) class TestMappingList(TestMapping): - def setUp(self): super(TestMappingList, self).setUp() self.mapping_mock.get.return_value = fakes.FakeResource( - None, - {'id': identity_fakes.mapping_id}, - loaded=True) + None, {'id': identity_fakes.mapping_id}, loaded=True + ) # Pretend list command returns list of two mappings. # NOTE(marek-denis): We are returning FakeResources with mapping id # only as ShowMapping class is implemented in a way where rules will @@ -146,20 +136,15 @@ class TestMappingList(TestMapping): class TestMappingSet(TestMapping): - def setUp(self): super(TestMappingSet, self).setUp() self.mapping_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.MAPPING_RESPONSE), - loaded=True + None, copy.deepcopy(identity_fakes.MAPPING_RESPONSE), loaded=True ) self.mapping_mock.update.return_value = fakes.FakeResource( - None, - identity_fakes.MAPPING_RESPONSE_2, - loaded=True + None, identity_fakes.MAPPING_RESPONSE_2, loaded=True ) # Get the command object to test @@ -167,74 +152,69 @@ class TestMappingSet(TestMapping): def test_set_new_rules(self): arglist = [ - '--rules', identity_fakes.mapping_rules_file_path, - identity_fakes.mapping_id + '--rules', + identity_fakes.mapping_rules_file_path, + identity_fakes.mapping_id, ] verifylist = [ ('mapping', identity_fakes.mapping_id), - ('rules', identity_fakes.mapping_rules_file_path) + ('rules', identity_fakes.mapping_rules_file_path), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) mocker = mock.Mock() mocker.return_value = identity_fakes.MAPPING_RULES_2 - with mock.patch("openstackclient.identity.v3.mapping." - "SetMapping._read_rules", mocker): + with mock.patch( + "openstackclient.identity.v3.mapping." "SetMapping._read_rules", + mocker, + ): result = self.cmd.take_action(parsed_args) self.mapping_mock.update.assert_called_with( mapping=identity_fakes.mapping_id, - rules=identity_fakes.MAPPING_RULES_2) + rules=identity_fakes.MAPPING_RULES_2, + ) self.assertIsNone(result) def test_set_rules_wrong_file_path(self): arglist = [ - '--rules', identity_fakes.mapping_rules_file_path, - identity_fakes.mapping_id + '--rules', + identity_fakes.mapping_rules_file_path, + identity_fakes.mapping_id, ] verifylist = [ ('mapping', identity_fakes.mapping_id), - ('rules', identity_fakes.mapping_rules_file_path) + ('rules', identity_fakes.mapping_rules_file_path), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) self.assertRaises( - exceptions.CommandError, - self.cmd.take_action, - parsed_args) + exceptions.CommandError, self.cmd.take_action, parsed_args + ) class TestMappingShow(TestMapping): - def setUp(self): super(TestMappingShow, self).setUp() self.mapping_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.MAPPING_RESPONSE), - loaded=True + None, copy.deepcopy(identity_fakes.MAPPING_RESPONSE), loaded=True ) self.cmd = mapping.ShowMapping(self.app, None) def test_mapping_show(self): - arglist = [ - identity_fakes.mapping_id - ] - verifylist = [ - ('mapping', identity_fakes.mapping_id) - ] + arglist = [identity_fakes.mapping_id] + verifylist = [('mapping', identity_fakes.mapping_id)] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.mapping_mock.get.assert_called_with( - identity_fakes.mapping_id) + self.mapping_mock.get.assert_called_with(identity_fakes.mapping_id) collist = ('id', 'rules') self.assertEqual(collist, columns) - datalist = (identity_fakes.mapping_id, - identity_fakes.MAPPING_RULES) + datalist = (identity_fakes.mapping_id, identity_fakes.MAPPING_RULES) self.assertEqual(datalist, data) diff --git a/openstackclient/tests/unit/identity/v3/test_oauth.py b/openstackclient/tests/unit/identity/v3/test_oauth.py index 3aabd9b8..0a4a6155 100644 --- a/openstackclient/tests/unit/identity/v3/test_oauth.py +++ b/openstackclient/tests/unit/identity/v3/test_oauth.py @@ -18,7 +18,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestOAuth1(identity_fakes.TestOAuth1): - def setUp(self): super(TestOAuth1, self).setUp() identity_client = self.app.client_manager.identity @@ -33,7 +32,6 @@ class TestOAuth1(identity_fakes.TestOAuth1): class TestAccessTokenCreate(TestOAuth1): - def setUp(self): super(TestAccessTokenCreate, self).setUp() @@ -47,11 +45,16 @@ class TestAccessTokenCreate(TestOAuth1): def test_create_access_tokens(self): arglist = [ - '--consumer-key', identity_fakes.consumer_id, - '--consumer-secret', identity_fakes.consumer_secret, - '--request-key', identity_fakes.request_token_id, - '--request-secret', identity_fakes.request_token_secret, - '--verifier', identity_fakes.oauth_verifier_pin, + '--consumer-key', + identity_fakes.consumer_id, + '--consumer-secret', + identity_fakes.consumer_secret, + '--request-key', + identity_fakes.request_token_id, + '--request-secret', + identity_fakes.request_token_secret, + '--verifier', + identity_fakes.oauth_verifier_pin, ] verifylist = [ ('consumer_key', identity_fakes.consumer_id), @@ -83,7 +86,6 @@ class TestAccessTokenCreate(TestOAuth1): class TestRequestTokenAuthorize(TestOAuth1): - def setUp(self): super(TestRequestTokenAuthorize, self).setUp() @@ -100,8 +102,10 @@ class TestRequestTokenAuthorize(TestOAuth1): def test_authorize_request_tokens(self): arglist = [ - '--request-key', identity_fakes.request_token_id, - '--role', identity_fakes.role_name, + '--request-key', + identity_fakes.request_token_id, + '--role', + identity_fakes.role_name, ] verifylist = [ ('request_key', identity_fakes.request_token_id), @@ -117,14 +121,11 @@ class TestRequestTokenAuthorize(TestOAuth1): collist = ('oauth_verifier',) self.assertEqual(collist, columns) - datalist = ( - identity_fakes.oauth_verifier_pin, - ) + datalist = (identity_fakes.oauth_verifier_pin,) self.assertEqual(datalist, data) class TestRequestTokenCreate(TestOAuth1): - def setUp(self): super(TestRequestTokenCreate, self).setUp() @@ -144,9 +145,12 @@ class TestRequestTokenCreate(TestOAuth1): def test_create_request_tokens(self): arglist = [ - '--consumer-key', identity_fakes.consumer_id, - '--consumer-secret', identity_fakes.consumer_secret, - '--project', identity_fakes.project_id, + '--consumer-key', + identity_fakes.consumer_id, + '--consumer-secret', + identity_fakes.consumer_secret, + '--project', + identity_fakes.project_id, ] verifylist = [ ('consumer_key', identity_fakes.consumer_id), diff --git a/openstackclient/tests/unit/identity/v3/test_project.py b/openstackclient/tests/unit/identity/v3/test_project.py index dfd0805b..d5d3bb1f 100644 --- a/openstackclient/tests/unit/identity/v3/test_project.py +++ b/openstackclient/tests/unit/identity/v3/test_project.py @@ -25,7 +25,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestProject(identity_fakes.TestIdentityv3): - def setUp(self): super(TestProject, self).setUp() @@ -39,7 +38,6 @@ class TestProject(identity_fakes.TestIdentityv3): class TestProjectCreate(TestProject): - domain = identity_fakes.FakeDomain.create_one_domain() columns = ( @@ -50,14 +48,15 @@ class TestProjectCreate(TestProject): 'is_domain', 'name', 'parent_id', - 'tags' + 'tags', ) def setUp(self): super(TestProjectCreate, self).setUp() self.project = identity_fakes.FakeProject.create_one_project( - attrs={'domain_id': self.domain.id}) + attrs={'domain_id': self.domain.id} + ) self.domains_mock.get.return_value = self.domain self.projects_mock.create.return_value = self.project self.datalist = ( @@ -68,7 +67,7 @@ class TestProjectCreate(TestProject): False, self.project.name, self.project.parent_id, - self.project.tags + self.project.tags, ) # Get the command object to test self.cmd = project.CreateProject(self.app, None) @@ -82,7 +81,7 @@ class TestProjectCreate(TestProject): ('enable', False), ('disable', False), ('name', self.project.name), - ('tags', []) + ('tags', []), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -103,9 +102,7 @@ class TestProjectCreate(TestProject): } # ProjectManager.create(name=, domain=, description=, # enabled=, **kwargs) - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) collist = ( 'description', @@ -115,7 +112,7 @@ class TestProjectCreate(TestProject): 'is_domain', 'name', 'parent_id', - 'tags' + 'tags', ) self.assertEqual(collist, columns) datalist = ( @@ -126,13 +123,14 @@ class TestProjectCreate(TestProject): False, self.project.name, self.project.parent_id, - self.project.tags + self.project.tags, ) self.assertEqual(datalist, data) def test_project_create_description(self): arglist = [ - '--description', 'new desc', + '--description', + 'new desc', self.project.name, ] verifylist = [ @@ -141,7 +139,7 @@ class TestProjectCreate(TestProject): ('disable', False), ('name', self.project.name), ('parent', None), - ('tags', []) + ('tags', []), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -162,16 +160,15 @@ class TestProjectCreate(TestProject): } # ProjectManager.create(name=, domain=, description=, # enabled=, **kwargs) - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_project_create_domain(self): arglist = [ - '--domain', self.project.domain_id, + '--domain', + self.project.domain_id, self.project.name, ] verifylist = [ @@ -180,7 +177,7 @@ class TestProjectCreate(TestProject): ('disable', False), ('name', self.project.name), ('parent', None), - ('tags', []) + ('tags', []), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -201,16 +198,15 @@ class TestProjectCreate(TestProject): } # ProjectManager.create(name=, domain=, description=, # enabled=, **kwargs) - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_project_create_domain_no_perms(self): arglist = [ - '--domain', self.project.domain_id, + '--domain', + self.project.domain_id, self.project.name, ] verifylist = [ @@ -219,7 +215,7 @@ class TestProjectCreate(TestProject): ('disable', False), ('name', self.project.name), ('parent', None), - ('tags', []) + ('tags', []), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) mocker = mock.Mock() @@ -238,9 +234,7 @@ class TestProjectCreate(TestProject): 'tags': [], 'options': {}, } - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -254,7 +248,7 @@ class TestProjectCreate(TestProject): ('disable', False), ('name', self.project.name), ('parent', None), - ('tags', []) + ('tags', []), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -275,9 +269,7 @@ class TestProjectCreate(TestProject): } # ProjectManager.create(name=, domain=, description=, # enabled=, **kwargs) - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -312,17 +304,17 @@ class TestProjectCreate(TestProject): } # ProjectManager.create(name=, domain=, # description=, enabled=, **kwargs) - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_project_create_property(self): arglist = [ - '--property', 'fee=fi', - '--property', 'fo=fum', + '--property', + 'fee=fi', + '--property', + 'fo=fum', self.project.name, ] verifylist = [ @@ -350,16 +342,15 @@ class TestProjectCreate(TestProject): } # ProjectManager.create(name=, domain=, description=, # enabled=, **kwargs) - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_project_create_is_domain_false_property(self): arglist = [ - '--property', 'is_domain=false', + '--property', + 'is_domain=false', self.project.name, ] verifylist = [ @@ -390,16 +381,15 @@ class TestProjectCreate(TestProject): 'tags': [], 'options': {}, } - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_project_create_is_domain_true_property(self): arglist = [ - '--property', 'is_domain=true', + '--property', + 'is_domain=true', self.project.name, ] verifylist = [ @@ -430,16 +420,15 @@ class TestProjectCreate(TestProject): 'tags': [], 'options': {}, } - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_project_create_is_domain_none_property(self): arglist = [ - '--property', 'is_domain=none', + '--property', + 'is_domain=none', self.project.name, ] verifylist = [ @@ -470,9 +459,7 @@ class TestProjectCreate(TestProject): 'tags': [], 'options': {}, } - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -480,13 +467,16 @@ class TestProjectCreate(TestProject): def test_project_create_parent(self): self.parent = identity_fakes.FakeProject.create_one_project() self.project = identity_fakes.FakeProject.create_one_project( - attrs={'domain_id': self.domain.id, 'parent_id': self.parent.id}) + attrs={'domain_id': self.domain.id, 'parent_id': self.parent.id} + ) self.projects_mock.get.return_value = self.parent self.projects_mock.create.return_value = self.project arglist = [ - '--domain', self.project.domain_id, - '--parent', self.parent.name, + '--domain', + self.project.domain_id, + '--parent', + self.parent.name, self.project.name, ] verifylist = [ @@ -495,7 +485,7 @@ class TestProjectCreate(TestProject): ('enable', False), ('disable', False), ('name', self.project.name), - ('tags', []) + ('tags', []), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -511,9 +501,7 @@ class TestProjectCreate(TestProject): 'options': {}, } - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) collist = ( 'description', @@ -523,7 +511,7 @@ class TestProjectCreate(TestProject): 'is_domain', 'name', 'parent_id', - 'tags' + 'tags', ) self.assertEqual(columns, collist) datalist = ( @@ -534,20 +522,24 @@ class TestProjectCreate(TestProject): self.project.is_domain, self.project.name, self.parent.id, - self.project.tags + self.project.tags, ) self.assertEqual(data, datalist) def test_project_create_invalid_parent(self): self.projects_mock.resource_class.__name__ = 'Project' self.projects_mock.get.side_effect = exceptions.NotFound( - 'Invalid parent') + 'Invalid parent' + ) self.projects_mock.find.side_effect = exceptions.NotFound( - 'Invalid parent') + 'Invalid parent' + ) arglist = [ - '--domain', self.project.domain_id, - '--parent', 'invalid', + '--domain', + self.project.domain_id, + '--parent', + 'invalid', self.project.name, ] verifylist = [ @@ -567,8 +559,10 @@ class TestProjectCreate(TestProject): def test_project_create_with_tags(self): arglist = [ - '--domain', self.project.domain_id, - '--tag', 'foo', + '--domain', + self.project.domain_id, + '--tag', + 'foo', self.project.name, ] verifylist = [ @@ -577,7 +571,7 @@ class TestProjectCreate(TestProject): ('disable', False), ('name', self.project.name), ('parent', None), - ('tags', ['foo']) + ('tags', ['foo']), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -596,9 +590,7 @@ class TestProjectCreate(TestProject): 'tags': ['foo'], 'options': {}, } - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -615,7 +607,7 @@ class TestProjectCreate(TestProject): ('disable', False), ('name', self.project.name), ('parent', None), - ('tags', []) + ('tags', []), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -636,9 +628,7 @@ class TestProjectCreate(TestProject): } # ProjectManager.create(name=, domain=, description=, # enabled=, **kwargs) - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -655,7 +645,7 @@ class TestProjectCreate(TestProject): ('disable', False), ('name', self.project.name), ('parent', None), - ('tags', []) + ('tags', []), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -676,16 +666,13 @@ class TestProjectCreate(TestProject): } # ProjectManager.create(name=, domain=, description=, # enabled=, **kwargs) - self.projects_mock.create.assert_called_with( - **kwargs - ) + self.projects_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) class TestProjectDelete(TestProject): - project = identity_fakes.FakeProject.create_one_project() def setUp(self): @@ -716,8 +703,7 @@ class TestProjectDelete(TestProject): @mock.patch.object(utils, 'find_resource') def test_delete_multi_projects_with_exception(self, find_mock): - find_mock.side_effect = [self.project, - exceptions.CommandError] + find_mock.side_effect = [self.project, exceptions.CommandError] arglist = [ self.project.id, 'unexist_project', @@ -731,8 +717,7 @@ class TestProjectDelete(TestProject): self.cmd.take_action(parsed_args) self.fail('CommandError should be raised.') except exceptions.CommandError as e: - self.assertEqual('1 of 2 projects failed to delete.', - str(e)) + self.assertEqual('1 of 2 projects failed to delete.', str(e)) find_mock.assert_any_call(self.projects_mock, self.project.id) find_mock.assert_any_call(self.projects_mock, 'unexist_project') @@ -742,10 +727,10 @@ class TestProjectDelete(TestProject): class TestProjectList(TestProject): - domain = identity_fakes.FakeDomain.create_one_domain() project = identity_fakes.FakeProject.create_one_project( - attrs={'domain_id': domain.id}) + attrs={'domain_id': domain.id} + ) projects = identity_fakes.FakeProject.create_projects() columns = ( @@ -759,10 +744,18 @@ class TestProjectList(TestProject): ), ) datalists = ( - (projects[0].description, True, - projects[0].id, projects[0].name,), - (projects[1].description, True, - projects[1].id, projects[1].name,), + ( + projects[0].description, + True, + projects[0].id, + projects[0].name, + ), + ( + projects[1].description, + True, + projects[1].id, + projects[1].name, + ), ) def setUp(self): @@ -804,18 +797,21 @@ class TestProjectList(TestProject): collist = ('ID', 'Name', 'Domain ID', 'Description', 'Enabled') self.assertEqual(collist, columns) - datalist = (( - self.project.id, - self.project.name, - self.project.domain_id, - self.project.description, - True, - ), ) + datalist = ( + ( + self.project.id, + self.project.name, + self.project.domain_id, + self.project.description, + True, + ), + ) self.assertEqual(datalist, tuple(data)) def test_project_list_domain(self): arglist = [ - '--domain', self.project.domain_id, + '--domain', + self.project.domain_id, ] verifylist = [ ('domain', self.project.domain_id), @@ -830,14 +826,16 @@ class TestProjectList(TestProject): # containing the data to be listed. columns, data = self.cmd.take_action(parsed_args) self.projects_mock.list.assert_called_with( - domain=self.project.domain_id) + domain=self.project.domain_id + ) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, tuple(data)) def test_project_list_domain_no_perms(self): arglist = [ - '--domain', self.project.domain_id, + '--domain', + self.project.domain_id, ] verifylist = [ ('domain', self.project.domain_id), @@ -850,17 +848,20 @@ class TestProjectList(TestProject): columns, data = self.cmd.take_action(parsed_args) self.projects_mock.list.assert_called_with( - domain=self.project.domain_id) + domain=self.project.domain_id + ) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, tuple(data)) def test_project_list_parent(self): self.parent = identity_fakes.FakeProject.create_one_project() self.project = identity_fakes.FakeProject.create_one_project( - attrs={'domain_id': self.domain.id, 'parent_id': self.parent.id}) + attrs={'domain_id': self.domain.id, 'parent_id': self.parent.id} + ) arglist = [ - '--parent', self.parent.id, + '--parent', + self.parent.id, ] verifylist = [ ('parent', self.parent.id), @@ -879,7 +880,10 @@ class TestProjectList(TestProject): def test_project_list_sort(self): self.projects_mock.list.return_value = self.projects - arglist = ['--sort', 'name:asc', ] + arglist = [ + '--sort', + 'name:asc', + ] verifylist = [] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -926,22 +930,25 @@ class TestProjectList(TestProject): # containing the data to be listed. columns, data = self.cmd.take_action(parsed_args) self.projects_mock.list.assert_called_with( - user=self.app.client_manager.auth_ref.user_id) + user=self.app.client_manager.auth_ref.user_id + ) collist = ('ID', 'Name') self.assertEqual(collist, columns) - datalist = (( - self.project.id, - self.project.name, - ), ) + datalist = ( + ( + self.project.id, + self.project.name, + ), + ) self.assertEqual(datalist, tuple(data)) class TestProjectSet(TestProject): - domain = identity_fakes.FakeDomain.create_one_domain() project = identity_fakes.FakeProject.create_one_project( - attrs={'domain_id': domain.id}) + attrs={'domain_id': domain.id} + ) def setUp(self): super(TestProjectSet, self).setUp() @@ -971,8 +978,10 @@ class TestProjectSet(TestProject): def test_project_set_name(self): arglist = [ - '--name', 'qwerty', - '--domain', self.project.domain_id, + '--name', + 'qwerty', + '--domain', + self.project.domain_id, self.project.name, ] verifylist = [ @@ -992,16 +1001,15 @@ class TestProjectSet(TestProject): } # ProjectManager.update(project, name=, domain=, description=, # enabled=, **kwargs) - self.projects_mock.update.assert_called_with( - self.project.id, - **kwargs - ) + self.projects_mock.update.assert_called_with(self.project.id, **kwargs) self.assertIsNone(result) def test_project_set_description(self): arglist = [ - '--domain', self.project.domain_id, - '--description', 'new desc', + '--domain', + self.project.domain_id, + '--description', + 'new desc', self.project.name, ] verifylist = [ @@ -1019,15 +1027,13 @@ class TestProjectSet(TestProject): kwargs = { 'description': 'new desc', } - self.projects_mock.update.assert_called_with( - self.project.id, - **kwargs - ) + self.projects_mock.update.assert_called_with(self.project.id, **kwargs) self.assertIsNone(result) def test_project_set_enable(self): arglist = [ - '--domain', self.project.domain_id, + '--domain', + self.project.domain_id, '--enable', self.project.name, ] @@ -1045,15 +1051,13 @@ class TestProjectSet(TestProject): kwargs = { 'enabled': True, } - self.projects_mock.update.assert_called_with( - self.project.id, - **kwargs - ) + self.projects_mock.update.assert_called_with(self.project.id, **kwargs) self.assertIsNone(result) def test_project_set_disable(self): arglist = [ - '--domain', self.project.domain_id, + '--domain', + self.project.domain_id, '--disable', self.project.name, ] @@ -1071,17 +1075,17 @@ class TestProjectSet(TestProject): kwargs = { 'enabled': False, } - self.projects_mock.update.assert_called_with( - self.project.id, - **kwargs - ) + self.projects_mock.update.assert_called_with(self.project.id, **kwargs) self.assertIsNone(result) def test_project_set_property(self): arglist = [ - '--domain', self.project.domain_id, - '--property', 'fee=fi', - '--property', 'fo=fum', + '--domain', + self.project.domain_id, + '--property', + 'fee=fi', + '--property', + 'fo=fum', self.project.name, ] verifylist = [ @@ -1098,17 +1102,17 @@ class TestProjectSet(TestProject): 'fee': 'fi', 'fo': 'fum', } - self.projects_mock.update.assert_called_with( - self.project.id, - **kwargs - ) + self.projects_mock.update.assert_called_with(self.project.id, **kwargs) self.assertIsNone(result) def test_project_set_tags(self): arglist = [ - '--name', 'qwerty', - '--domain', self.project.domain_id, - '--tag', 'foo', + '--name', + 'qwerty', + '--domain', + self.project.domain_id, + '--tag', + 'foo', self.project.name, ] verifylist = [ @@ -1117,28 +1121,23 @@ class TestProjectSet(TestProject): ('enable', False), ('disable', False), ('project', self.project.name), - ('tags', ['foo']) + ('tags', ['foo']), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) # Set expected values - kwargs = { - 'name': 'qwerty', - 'tags': ['foo'] - } + kwargs = {'name': 'qwerty', 'tags': ['foo']} # ProjectManager.update(project, name=, domain=, description=, # enabled=, **kwargs) - self.projects_mock.update.assert_called_with( - self.project.id, - **kwargs - ) + self.projects_mock.update.assert_called_with(self.project.id, **kwargs) self.assertIsNone(result) def test_project_set_with_immutable_option(self): arglist = [ - '--domain', self.project.domain_id, + '--domain', + self.project.domain_id, '--immutable', self.project.name, ] @@ -1157,15 +1156,13 @@ class TestProjectSet(TestProject): kwargs = { 'options': {'immutable': True}, } - self.projects_mock.update.assert_called_with( - self.project.id, - **kwargs - ) + self.projects_mock.update.assert_called_with(self.project.id, **kwargs) self.assertIsNone(result) def test_project_set_with_no_immutable_option(self): arglist = [ - '--domain', self.project.domain_id, + '--domain', + self.project.domain_id, '--no-immutable', self.project.name, ] @@ -1184,28 +1181,24 @@ class TestProjectSet(TestProject): kwargs = { 'options': {'immutable': False}, } - self.projects_mock.update.assert_called_with( - self.project.id, - **kwargs - ) + self.projects_mock.update.assert_called_with(self.project.id, **kwargs) self.assertIsNone(result) class TestProjectShow(TestProject): - domain = identity_fakes.FakeDomain.create_one_domain() def setUp(self): super(TestProjectShow, self).setUp() self.project = identity_fakes.FakeProject.create_one_project( - attrs={'domain_id': self.domain.id}) + attrs={'domain_id': self.domain.id} + ) # Get the command object to test self.cmd = project.ShowProject(self.app, None) def test_project_show(self): - self.projects_mock.get.return_value = self.project arglist = [ @@ -1216,15 +1209,15 @@ class TestProjectShow(TestProject): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.app.client_manager.identity.tokens.get_token_data.return_value = \ - {'token': - {'project': - {'domain': {}, - 'name': parsed_args.project, - 'id': parsed_args.project - } - } - } + self.app.client_manager.identity.tokens.get_token_data.return_value = { + 'token': { + 'project': { + 'domain': {}, + 'name': parsed_args.project, + 'id': parsed_args.project, + } + } + } # In base command class ShowOne in cliff, abstract method take_action() # returns a two-part tuple with a tuple of column names and a tuple of @@ -1241,7 +1234,7 @@ class TestProjectShow(TestProject): 'is_domain', 'name', 'parent_id', - 'tags' + 'tags', ) self.assertEqual(collist, columns) datalist = ( @@ -1252,7 +1245,7 @@ class TestProjectShow(TestProject): False, self.project.name, self.project.parent_id, - self.project.tags + self.project.tags, ) self.assertEqual(datalist, data) @@ -1260,7 +1253,7 @@ class TestProjectShow(TestProject): self.project = identity_fakes.FakeProject.create_one_project( attrs={ 'parent_id': self.project.parent_id, - 'parents': [{'project': {'id': self.project.parent_id}}] + 'parents': [{'project': {'id': self.project.parent_id}}], } ) self.projects_mock.get.return_value = self.project @@ -1275,23 +1268,28 @@ class TestProjectShow(TestProject): ('children', False), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.app.client_manager.identity.tokens.get_token_data.return_value = \ - {'token': - {'project': - {'domain': {}, - 'name': parsed_args.project, - 'id': parsed_args.project - } - } - } + self.app.client_manager.identity.tokens.get_token_data.return_value = { + 'token': { + 'project': { + 'domain': {}, + 'name': parsed_args.project, + 'id': parsed_args.project, + } + } + } columns, data = self.cmd.take_action(parsed_args) - self.projects_mock.get.assert_has_calls([call(self.project.id), - call(self.project.id, - parents_as_ids=True, - subtree_as_ids=False, - )]) + self.projects_mock.get.assert_has_calls( + [ + call(self.project.id), + call( + self.project.id, + parents_as_ids=True, + subtree_as_ids=False, + ), + ] + ) collist = ( 'description', @@ -1302,7 +1300,7 @@ class TestProjectShow(TestProject): 'name', 'parent_id', 'parents', - 'tags' + 'tags', ) self.assertEqual(columns, collist) datalist = ( @@ -1314,7 +1312,7 @@ class TestProjectShow(TestProject): self.project.name, self.project.parent_id, [{'project': {'id': self.project.parent_id}}], - self.project.tags + self.project.tags, ) self.assertEqual(data, datalist) @@ -1322,7 +1320,7 @@ class TestProjectShow(TestProject): self.project = identity_fakes.FakeProject.create_one_project( attrs={ 'parent_id': self.project.parent_id, - 'subtree': [{'project': {'id': 'children-id'}}] + 'subtree': [{'project': {'id': 'children-id'}}], } ) self.projects_mock.get.return_value = self.project @@ -1337,22 +1335,27 @@ class TestProjectShow(TestProject): ('children', True), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.app.client_manager.identity.tokens.get_token_data.return_value = \ - {'token': - {'project': - {'domain': {}, - 'name': parsed_args.project, - 'id': parsed_args.project - } - } - } + self.app.client_manager.identity.tokens.get_token_data.return_value = { + 'token': { + 'project': { + 'domain': {}, + 'name': parsed_args.project, + 'id': parsed_args.project, + } + } + } columns, data = self.cmd.take_action(parsed_args) - self.projects_mock.get.assert_has_calls([call(self.project.id), - call(self.project.id, - parents_as_ids=False, - subtree_as_ids=True, - )]) + self.projects_mock.get.assert_has_calls( + [ + call(self.project.id), + call( + self.project.id, + parents_as_ids=False, + subtree_as_ids=True, + ), + ] + ) collist = ( 'description', @@ -1363,7 +1366,7 @@ class TestProjectShow(TestProject): 'name', 'parent_id', 'subtree', - 'tags' + 'tags', ) self.assertEqual(columns, collist) datalist = ( @@ -1375,7 +1378,7 @@ class TestProjectShow(TestProject): self.project.name, self.project.parent_id, [{'project': {'id': 'children-id'}}], - self.project.tags + self.project.tags, ) self.assertEqual(data, datalist) @@ -1384,7 +1387,7 @@ class TestProjectShow(TestProject): attrs={ 'parent_id': self.project.parent_id, 'parents': [{'project': {'id': self.project.parent_id}}], - 'subtree': [{'project': {'id': 'children-id'}}] + 'subtree': [{'project': {'id': 'children-id'}}], } ) self.projects_mock.get.return_value = self.project @@ -1400,22 +1403,27 @@ class TestProjectShow(TestProject): ('children', True), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.app.client_manager.identity.tokens.get_token_data.return_value = \ - {'token': - {'project': - {'domain': {}, - 'name': parsed_args.project, - 'id': parsed_args.project - } - } - } + self.app.client_manager.identity.tokens.get_token_data.return_value = { + 'token': { + 'project': { + 'domain': {}, + 'name': parsed_args.project, + 'id': parsed_args.project, + } + } + } columns, data = self.cmd.take_action(parsed_args) - self.projects_mock.get.assert_has_calls([call(self.project.id), - call(self.project.id, - parents_as_ids=True, - subtree_as_ids=True, - )]) + self.projects_mock.get.assert_has_calls( + [ + call(self.project.id), + call( + self.project.id, + parents_as_ids=True, + subtree_as_ids=True, + ), + ] + ) collist = ( 'description', @@ -1427,7 +1435,7 @@ class TestProjectShow(TestProject): 'parent_id', 'parents', 'subtree', - 'tags' + 'tags', ) self.assertEqual(columns, collist) datalist = ( @@ -1440,27 +1448,29 @@ class TestProjectShow(TestProject): self.project.parent_id, [{'project': {'id': self.project.parent_id}}], [{'project': {'id': 'children-id'}}], - self.project.tags + self.project.tags, ) self.assertEqual(data, datalist) def test_project_show_with_domain(self): project = identity_fakes.FakeProject.create_one_project( - {"name": self.project.name}) - - self.app.client_manager.identity.tokens.get_token_data.return_value = \ - {'token': - {'project': - {'domain': {"id": self.project.domain_id}, - 'name': self.project.name, - 'id': self.project.id - } - } - } + {"name": self.project.name} + ) + + self.app.client_manager.identity.tokens.get_token_data.return_value = { + 'token': { + 'project': { + 'domain': {"id": self.project.domain_id}, + 'name': self.project.name, + 'id': self.project.id, + } + } + } identity_client = self.app.client_manager.identity arglist = [ - "--domain", self.domain.id, + "--domain", + self.domain.id, project.name, ] verifylist = [ @@ -1469,13 +1479,14 @@ class TestProjectShow(TestProject): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - project_str = common._get_token_resource(identity_client, 'project', - parsed_args.project, - parsed_args.domain) + project_str = common._get_token_resource( + identity_client, 'project', parsed_args.project, parsed_args.domain + ) self.assertEqual(self.project.id, project_str) arglist = [ - "--domain", project.domain_id, + "--domain", + project.domain_id, project.name, ] verifylist = [ @@ -1484,7 +1495,7 @@ class TestProjectShow(TestProject): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - project_str = common._get_token_resource(identity_client, 'project', - parsed_args.project, - parsed_args.domain) + project_str = common._get_token_resource( + identity_client, 'project', parsed_args.project, parsed_args.domain + ) self.assertEqual(project.name, project_str) diff --git a/openstackclient/tests/unit/identity/v3/test_protocol.py b/openstackclient/tests/unit/identity/v3/test_protocol.py index 30b4aa4a..bb27910c 100644 --- a/openstackclient/tests/unit/identity/v3/test_protocol.py +++ b/openstackclient/tests/unit/identity/v3/test_protocol.py @@ -20,7 +20,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestProtocol(identity_fakes.TestFederatedIdentity): - def setUp(self): super(TestProtocol, self).setUp() @@ -30,7 +29,6 @@ class TestProtocol(identity_fakes.TestFederatedIdentity): class TestProtocolCreate(TestProtocol): - def setUp(self): super(TestProtocolCreate, self).setUp() @@ -42,33 +40,37 @@ class TestProtocolCreate(TestProtocol): def test_create_protocol(self): argslist = [ identity_fakes.protocol_id, - '--identity-provider', identity_fakes.idp_id, - '--mapping', identity_fakes.mapping_id + '--identity-provider', + identity_fakes.idp_id, + '--mapping', + identity_fakes.mapping_id, ] verifylist = [ ('federation_protocol', identity_fakes.protocol_id), ('identity_provider', identity_fakes.idp_id), - ('mapping', identity_fakes.mapping_id) + ('mapping', identity_fakes.mapping_id), ] parsed_args = self.check_parser(self.cmd, argslist, verifylist) columns, data = self.cmd.take_action(parsed_args) self.protocols_mock.create.assert_called_with( protocol_id=identity_fakes.protocol_id, identity_provider=identity_fakes.idp_id, - mapping=identity_fakes.mapping_id) + mapping=identity_fakes.mapping_id, + ) collist = ('id', 'identity_provider', 'mapping') self.assertEqual(collist, columns) - datalist = (identity_fakes.protocol_id, - identity_fakes.idp_id, - identity_fakes.mapping_id) + datalist = ( + identity_fakes.protocol_id, + identity_fakes.idp_id, + identity_fakes.mapping_id, + ) self.assertEqual(datalist, data) class TestProtocolDelete(TestProtocol): - def setUp(self): super(TestProtocolDelete, self).setUp() @@ -84,8 +86,9 @@ class TestProtocolDelete(TestProtocol): def test_delete_identity_provider(self): arglist = [ - '--identity-provider', identity_fakes.idp_id, - identity_fakes.protocol_id + '--identity-provider', + identity_fakes.idp_id, + identity_fakes.protocol_id, ] verifylist = [ ('federation_protocol', [identity_fakes.protocol_id]), @@ -96,20 +99,24 @@ class TestProtocolDelete(TestProtocol): result = self.cmd.take_action(parsed_args) self.protocols_mock.delete.assert_called_with( - identity_fakes.idp_id, identity_fakes.protocol_id) + identity_fakes.idp_id, identity_fakes.protocol_id + ) self.assertIsNone(result) class TestProtocolList(TestProtocol): - def setUp(self): super(TestProtocolList, self).setUp() self.protocols_mock.get.return_value = fakes.FakeResource( - None, identity_fakes.PROTOCOL_ID_MAPPING, loaded=True) + None, identity_fakes.PROTOCOL_ID_MAPPING, loaded=True + ) - self.protocols_mock.list.return_value = [fakes.FakeResource( - None, identity_fakes.PROTOCOL_ID_MAPPING, loaded=True)] + self.protocols_mock.list.return_value = [ + fakes.FakeResource( + None, identity_fakes.PROTOCOL_ID_MAPPING, loaded=True + ) + ] self.cmd = federation_protocol.ListProtocols(self.app, None) @@ -124,65 +131,83 @@ class TestProtocolList(TestProtocol): class TestProtocolSet(TestProtocol): - def setUp(self): super(TestProtocolSet, self).setUp() self.protocols_mock.get.return_value = fakes.FakeResource( - None, identity_fakes.PROTOCOL_OUTPUT, loaded=True) + None, identity_fakes.PROTOCOL_OUTPUT, loaded=True + ) self.protocols_mock.update.return_value = fakes.FakeResource( - None, identity_fakes.PROTOCOL_OUTPUT_UPDATED, loaded=True) + None, identity_fakes.PROTOCOL_OUTPUT_UPDATED, loaded=True + ) self.cmd = federation_protocol.SetProtocol(self.app, None) def test_set_new_mapping(self): arglist = [ identity_fakes.protocol_id, - '--identity-provider', identity_fakes.idp_id, - '--mapping', identity_fakes.mapping_id + '--identity-provider', + identity_fakes.idp_id, + '--mapping', + identity_fakes.mapping_id, + ] + verifylist = [ + ('identity_provider', identity_fakes.idp_id), + ('federation_protocol', identity_fakes.protocol_id), + ('mapping', identity_fakes.mapping_id), ] - verifylist = [('identity_provider', identity_fakes.idp_id), - ('federation_protocol', identity_fakes.protocol_id), - ('mapping', identity_fakes.mapping_id)] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) self.protocols_mock.update.assert_called_with( - identity_fakes.idp_id, identity_fakes.protocol_id, - identity_fakes.mapping_id) + identity_fakes.idp_id, + identity_fakes.protocol_id, + identity_fakes.mapping_id, + ) collist = ('id', 'identity_provider', 'mapping') self.assertEqual(collist, columns) - datalist = (identity_fakes.protocol_id, identity_fakes.idp_id, - identity_fakes.mapping_id_updated) + datalist = ( + identity_fakes.protocol_id, + identity_fakes.idp_id, + identity_fakes.mapping_id_updated, + ) self.assertEqual(datalist, data) class TestProtocolShow(TestProtocol): - def setUp(self): super(TestProtocolShow, self).setUp() self.protocols_mock.get.return_value = fakes.FakeResource( - None, identity_fakes.PROTOCOL_OUTPUT, loaded=False) + None, identity_fakes.PROTOCOL_OUTPUT, loaded=False + ) self.cmd = federation_protocol.ShowProtocol(self.app, None) def test_show_protocol(self): - arglist = [identity_fakes.protocol_id, '--identity-provider', - identity_fakes.idp_id] - verifylist = [('federation_protocol', identity_fakes.protocol_id), - ('identity_provider', identity_fakes.idp_id)] + arglist = [ + identity_fakes.protocol_id, + '--identity-provider', + identity_fakes.idp_id, + ] + verifylist = [ + ('federation_protocol', identity_fakes.protocol_id), + ('identity_provider', identity_fakes.idp_id), + ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.protocols_mock.get.assert_called_with(identity_fakes.idp_id, - identity_fakes.protocol_id) + self.protocols_mock.get.assert_called_with( + identity_fakes.idp_id, identity_fakes.protocol_id + ) collist = ('id', 'identity_provider', 'mapping') self.assertEqual(collist, columns) - datalist = (identity_fakes.protocol_id, - identity_fakes.idp_id, - identity_fakes.mapping_id) + datalist = ( + identity_fakes.protocol_id, + identity_fakes.idp_id, + identity_fakes.mapping_id, + ) self.assertEqual(datalist, data) diff --git a/openstackclient/tests/unit/identity/v3/test_region.py b/openstackclient/tests/unit/identity/v3/test_region.py index e83a4e9f..9e83b7a8 100644 --- a/openstackclient/tests/unit/identity/v3/test_region.py +++ b/openstackclient/tests/unit/identity/v3/test_region.py @@ -19,7 +19,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestRegion(identity_fakes.TestIdentityv3): - def setUp(self): super(TestRegion, self).setUp() @@ -29,7 +28,6 @@ class TestRegion(identity_fakes.TestIdentityv3): class TestRegionCreate(TestRegion): - columns = ( 'description', 'parent_region', @@ -56,11 +54,12 @@ class TestRegionCreate(TestRegion): def test_region_create_description(self): arglist = [ identity_fakes.region_id, - '--description', identity_fakes.region_description, + '--description', + identity_fakes.region_description, ] verifylist = [ ('region', identity_fakes.region_id), - ('description', identity_fakes.region_description) + ('description', identity_fakes.region_description), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -75,9 +74,7 @@ class TestRegionCreate(TestRegion): 'id': identity_fakes.region_id, 'parent_region': None, } - self.regions_mock.create.assert_called_with( - **kwargs - ) + self.regions_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -102,9 +99,7 @@ class TestRegionCreate(TestRegion): 'id': identity_fakes.region_id, 'parent_region': None, } - self.regions_mock.create.assert_called_with( - **kwargs - ) + self.regions_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -112,7 +107,8 @@ class TestRegionCreate(TestRegion): def test_region_create_parent_region_id(self): arglist = [ identity_fakes.region_id, - '--parent-region', identity_fakes.region_parent_region_id, + '--parent-region', + identity_fakes.region_parent_region_id, ] verifylist = [ ('region', identity_fakes.region_id), @@ -131,15 +127,12 @@ class TestRegionCreate(TestRegion): 'id': identity_fakes.region_id, 'parent_region': identity_fakes.region_parent_region_id, } - self.regions_mock.create.assert_called_with( - **kwargs - ) + self.regions_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) class TestRegionDelete(TestRegion): - def setUp(self): super(TestRegionDelete, self).setUp() @@ -166,7 +159,6 @@ class TestRegionDelete(TestRegion): class TestRegionList(TestRegion): - columns = ( 'Region', 'Parent Region', @@ -210,7 +202,8 @@ class TestRegionList(TestRegion): def test_region_list_parent_region_id(self): arglist = [ - '--parent-region', identity_fakes.region_parent_region_id, + '--parent-region', + identity_fakes.region_parent_region_id, ] verifylist = [ ('parent_region', identity_fakes.region_parent_region_id), @@ -222,14 +215,14 @@ class TestRegionList(TestRegion): # containing the data to be listed. columns, data = self.cmd.take_action(parsed_args) self.regions_mock.list.assert_called_with( - parent_region_id=identity_fakes.region_parent_region_id) + parent_region_id=identity_fakes.region_parent_region_id + ) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, tuple(data)) class TestRegionSet(TestRegion): - def setUp(self): super(TestRegionSet, self).setUp() @@ -255,14 +248,14 @@ class TestRegionSet(TestRegion): kwargs = {} self.regions_mock.update.assert_called_with( - identity_fakes.region_id, - **kwargs + identity_fakes.region_id, **kwargs ) self.assertIsNone(result) def test_region_set_description(self): arglist = [ - '--description', 'qwerty', + '--description', + 'qwerty', identity_fakes.region_id, ] verifylist = [ @@ -278,14 +271,14 @@ class TestRegionSet(TestRegion): 'description': 'qwerty', } self.regions_mock.update.assert_called_with( - identity_fakes.region_id, - **kwargs + identity_fakes.region_id, **kwargs ) self.assertIsNone(result) def test_region_set_parent_region_id(self): arglist = [ - '--parent-region', 'new_parent', + '--parent-region', + 'new_parent', identity_fakes.region_id, ] verifylist = [ @@ -301,14 +294,12 @@ class TestRegionSet(TestRegion): 'parent_region': 'new_parent', } self.regions_mock.update.assert_called_with( - identity_fakes.region_id, - **kwargs + identity_fakes.region_id, **kwargs ) self.assertIsNone(result) class TestRegionShow(TestRegion): - def setUp(self): super(TestRegionShow, self).setUp() diff --git a/openstackclient/tests/unit/identity/v3/test_registered_limit.py b/openstackclient/tests/unit/identity/v3/test_registered_limit.py index 262ca4f9..1ba6737e 100644 --- a/openstackclient/tests/unit/identity/v3/test_registered_limit.py +++ b/openstackclient/tests/unit/identity/v3/test_registered_limit.py @@ -21,7 +21,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestRegisteredLimit(identity_fakes.TestIdentityv3): - def setUp(self): super(TestRegisteredLimit, self).setUp() @@ -36,21 +35,16 @@ class TestRegisteredLimit(identity_fakes.TestIdentityv3): class TestRegisteredLimitCreate(TestRegisteredLimit): - def setUp(self): super(TestRegisteredLimitCreate, self).setUp() self.service = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.SERVICE), - loaded=True + None, copy.deepcopy(identity_fakes.SERVICE), loaded=True ) self.services_mock.get.return_value = self.service self.region = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.REGION), - loaded=True + None, copy.deepcopy(identity_fakes.REGION), loaded=True ) self.regions_mock.get.return_value = self.region @@ -58,23 +52,23 @@ class TestRegisteredLimitCreate(TestRegisteredLimit): def test_registered_limit_create_without_options(self): self.registered_limit_mock.create.return_value = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.REGISTERED_LIMIT), - loaded=True + None, copy.deepcopy(identity_fakes.REGISTERED_LIMIT), loaded=True ) resource_name = identity_fakes.registered_limit_resource_name default_limit = identity_fakes.registered_limit_default_limit arglist = [ - '--service', identity_fakes.service_id, - '--default-limit', '10', + '--service', + identity_fakes.service_id, + '--default-limit', + '10', resource_name, ] verifylist = [ ('service', identity_fakes.service_id), ('default_limit', default_limit), - ('resource_name', resource_name) + ('resource_name', resource_name), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -85,8 +79,14 @@ class TestRegisteredLimitCreate(TestRegisteredLimit): self.service, resource_name, default_limit, **kwargs ) - collist = ('default_limit', 'description', 'id', 'region_id', - 'resource_name', 'service_id') + collist = ( + 'default_limit', + 'description', + 'id', + 'region_id', + 'resource_name', + 'service_id', + ) self.assertEqual(collist, columns) datalist = ( @@ -95,7 +95,7 @@ class TestRegisteredLimitCreate(TestRegisteredLimit): identity_fakes.registered_limit_id, None, identity_fakes.registered_limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) @@ -103,18 +103,22 @@ class TestRegisteredLimitCreate(TestRegisteredLimit): self.registered_limit_mock.create.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.REGISTERED_LIMIT_OPTIONS), - loaded=True + loaded=True, ) resource_name = identity_fakes.registered_limit_resource_name default_limit = identity_fakes.registered_limit_default_limit description = identity_fakes.registered_limit_description arglist = [ - '--region', identity_fakes.region_id, - '--description', description, - '--service', identity_fakes.service_id, - '--default-limit', '10', - resource_name + '--region', + identity_fakes.region_id, + '--description', + description, + '--service', + identity_fakes.service_id, + '--default-limit', + '10', + resource_name, ] verifylist = [ @@ -122,7 +126,7 @@ class TestRegisteredLimitCreate(TestRegisteredLimit): ('description', description), ('service', identity_fakes.service_id), ('default_limit', default_limit), - ('resource_name', resource_name) + ('resource_name', resource_name), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -133,8 +137,14 @@ class TestRegisteredLimitCreate(TestRegisteredLimit): self.service, resource_name, default_limit, **kwargs ) - collist = ('default_limit', 'description', 'id', 'region_id', - 'resource_name', 'service_id') + collist = ( + 'default_limit', + 'description', + 'id', + 'region_id', + 'resource_name', + 'service_id', + ) self.assertEqual(collist, columns) datalist = ( @@ -143,13 +153,12 @@ class TestRegisteredLimitCreate(TestRegisteredLimit): identity_fakes.registered_limit_id, identity_fakes.region_id, identity_fakes.registered_limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) class TestRegisteredLimitDelete(TestRegisteredLimit): - def setUp(self): super(TestRegisteredLimitDelete, self).setUp() @@ -176,9 +185,7 @@ class TestRegisteredLimitDelete(TestRegisteredLimit): self.registered_limit_mock.delete.side_effect = return_value arglist = ['fake-registered-limit-id'] - verifylist = [ - ('registered_limit_id', ['fake-registered-limit-id']) - ] + verifylist = [('registered_limit_id', ['fake-registered-limit-id'])] parsed_args = self.check_parser(self.cmd, arglist, verifylist) try: @@ -191,14 +198,11 @@ class TestRegisteredLimitDelete(TestRegisteredLimit): class TestRegisteredLimitShow(TestRegisteredLimit): - def setUp(self): super(TestRegisteredLimitShow, self).setUp() self.registered_limit_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.REGISTERED_LIMIT), - loaded=True + None, copy.deepcopy(identity_fakes.REGISTERED_LIMIT), loaded=True ) self.cmd = registered_limit.ShowRegisteredLimit(self.app, None) @@ -217,8 +221,12 @@ class TestRegisteredLimitShow(TestRegisteredLimit): ) collist = ( - 'default_limit', 'description', 'id', 'region_id', 'resource_name', - 'service_id' + 'default_limit', + 'description', + 'id', + 'region_id', + 'resource_name', + 'service_id', ) self.assertEqual(collist, columns) datalist = ( @@ -227,33 +235,33 @@ class TestRegisteredLimitShow(TestRegisteredLimit): identity_fakes.registered_limit_id, None, identity_fakes.registered_limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) class TestRegisteredLimitSet(TestRegisteredLimit): - def setUp(self): super(TestRegisteredLimitSet, self).setUp() self.cmd = registered_limit.SetRegisteredLimit(self.app, None) def test_registered_limit_set_description(self): registered_limit = copy.deepcopy(identity_fakes.REGISTERED_LIMIT) - registered_limit['description'] = ( - identity_fakes.registered_limit_description - ) + registered_limit[ + 'description' + ] = identity_fakes.registered_limit_description self.registered_limit_mock.update.return_value = fakes.FakeResource( None, registered_limit, loaded=True ) arglist = [ - '--description', identity_fakes.registered_limit_description, - identity_fakes.registered_limit_id + '--description', + identity_fakes.registered_limit_description, + identity_fakes.registered_limit_id, ] verifylist = [ ('description', identity_fakes.registered_limit_description), - ('registered_limit_id', identity_fakes.registered_limit_id) + ('registered_limit_id', identity_fakes.registered_limit_id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -265,12 +273,16 @@ class TestRegisteredLimitSet(TestRegisteredLimit): resource_name=None, default_limit=None, description=identity_fakes.registered_limit_description, - region=None + region=None, ) collist = ( - 'default_limit', 'description', 'id', 'region_id', 'resource_name', - 'service_id' + 'default_limit', + 'description', + 'id', + 'region_id', + 'resource_name', + 'service_id', ) self.assertEqual(collist, columns) datalist = ( @@ -279,7 +291,7 @@ class TestRegisteredLimitSet(TestRegisteredLimit): identity_fakes.registered_limit_id, None, identity_fakes.registered_limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) @@ -292,12 +304,13 @@ class TestRegisteredLimitSet(TestRegisteredLimit): ) arglist = [ - '--default-limit', str(default_limit), - identity_fakes.registered_limit_id + '--default-limit', + str(default_limit), + identity_fakes.registered_limit_id, ] verifylist = [ ('default_limit', default_limit), - ('registered_limit_id', identity_fakes.registered_limit_id) + ('registered_limit_id', identity_fakes.registered_limit_id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -309,12 +322,16 @@ class TestRegisteredLimitSet(TestRegisteredLimit): resource_name=None, default_limit=default_limit, description=None, - region=None + region=None, ) collist = ( - 'default_limit', 'description', 'id', 'region_id', 'resource_name', - 'service_id' + 'default_limit', + 'description', + 'id', + 'region_id', + 'resource_name', + 'service_id', ) self.assertEqual(collist, columns) datalist = ( @@ -323,7 +340,7 @@ class TestRegisteredLimitSet(TestRegisteredLimit): identity_fakes.registered_limit_id, None, identity_fakes.registered_limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) @@ -336,12 +353,13 @@ class TestRegisteredLimitSet(TestRegisteredLimit): ) arglist = [ - '--resource-name', resource_name, - identity_fakes.registered_limit_id + '--resource-name', + resource_name, + identity_fakes.registered_limit_id, ] verifylist = [ ('resource_name', resource_name), - ('registered_limit_id', identity_fakes.registered_limit_id) + ('registered_limit_id', identity_fakes.registered_limit_id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -353,12 +371,16 @@ class TestRegisteredLimitSet(TestRegisteredLimit): resource_name=resource_name, default_limit=None, description=None, - region=None + region=None, ) collist = ( - 'default_limit', 'description', 'id', 'region_id', 'resource_name', - 'service_id' + 'default_limit', + 'description', + 'id', + 'region_id', + 'resource_name', + 'service_id', ) self.assertEqual(collist, columns) datalist = ( @@ -367,7 +389,7 @@ class TestRegisteredLimitSet(TestRegisteredLimit): identity_fakes.registered_limit_id, None, resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) @@ -380,13 +402,10 @@ class TestRegisteredLimitSet(TestRegisteredLimit): ) self.services_mock.get.return_value = service - arglist = [ - '--service', service.id, - identity_fakes.registered_limit_id - ] + arglist = ['--service', service.id, identity_fakes.registered_limit_id] verifylist = [ ('service', service.id), - ('registered_limit_id', identity_fakes.registered_limit_id) + ('registered_limit_id', identity_fakes.registered_limit_id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -398,12 +417,16 @@ class TestRegisteredLimitSet(TestRegisteredLimit): resource_name=None, default_limit=None, description=None, - region=None + region=None, ) collist = ( - 'default_limit', 'description', 'id', 'region_id', 'resource_name', - 'service_id' + 'default_limit', + 'description', + 'id', + 'region_id', + 'resource_name', + 'service_id', ) self.assertEqual(collist, columns) datalist = ( @@ -412,7 +435,7 @@ class TestRegisteredLimitSet(TestRegisteredLimit): identity_fakes.registered_limit_id, None, identity_fakes.registered_limit_resource_name, - service.id + service.id, ) self.assertEqual(datalist, data) @@ -420,24 +443,17 @@ class TestRegisteredLimitSet(TestRegisteredLimit): registered_limit = copy.deepcopy(identity_fakes.REGISTERED_LIMIT) region = identity_fakes.REGION region['id'] = 'RegionTwo' - region = fakes.FakeResource( - None, - copy.deepcopy(region), - loaded=True - ) + region = fakes.FakeResource(None, copy.deepcopy(region), loaded=True) registered_limit['region_id'] = region.id self.registered_limit_mock.update.return_value = fakes.FakeResource( None, registered_limit, loaded=True ) self.regions_mock.get.return_value = region - arglist = [ - '--region', region.id, - identity_fakes.registered_limit_id - ] + arglist = ['--region', region.id, identity_fakes.registered_limit_id] verifylist = [ ('region', region.id), - ('registered_limit_id', identity_fakes.registered_limit_id) + ('registered_limit_id', identity_fakes.registered_limit_id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -449,12 +465,16 @@ class TestRegisteredLimitSet(TestRegisteredLimit): resource_name=None, default_limit=None, description=None, - region=region + region=region, ) collist = ( - 'default_limit', 'description', 'id', 'region_id', 'resource_name', - 'service_id' + 'default_limit', + 'description', + 'id', + 'region_id', + 'resource_name', + 'service_id', ) self.assertEqual(collist, columns) datalist = ( @@ -463,20 +483,17 @@ class TestRegisteredLimitSet(TestRegisteredLimit): identity_fakes.registered_limit_id, region.id, identity_fakes.registered_limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) class TestRegisteredLimitList(TestRegisteredLimit): - def setUp(self): super(TestRegisteredLimitList, self).setUp() self.registered_limit_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(identity_fakes.REGISTERED_LIMIT), - loaded=True + None, copy.deepcopy(identity_fakes.REGISTERED_LIMIT), loaded=True ) self.cmd = registered_limit.ShowRegisteredLimit(self.app, None) @@ -495,8 +512,12 @@ class TestRegisteredLimitList(TestRegisteredLimit): ) collist = ( - 'default_limit', 'description', 'id', 'region_id', 'resource_name', - 'service_id' + 'default_limit', + 'description', + 'id', + 'region_id', + 'resource_name', + 'service_id', ) self.assertEqual(collist, columns) datalist = ( @@ -505,6 +526,6 @@ class TestRegisteredLimitList(TestRegisteredLimit): identity_fakes.registered_limit_id, None, identity_fakes.registered_limit_resource_name, - identity_fakes.service_id + identity_fakes.service_id, ) self.assertEqual(datalist, data) diff --git a/openstackclient/tests/unit/identity/v3/test_role.py b/openstackclient/tests/unit/identity/v3/test_role.py index 774b2c2b..12fd1611 100644 --- a/openstackclient/tests/unit/identity/v3/test_role.py +++ b/openstackclient/tests/unit/identity/v3/test_role.py @@ -26,7 +26,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestRole(identity_fakes.TestIdentityv3): - def setUp(self): super(TestRole, self).setUp() @@ -55,13 +54,11 @@ class TestRole(identity_fakes.TestIdentityv3): class TestRoleInherited(TestRole): - def _is_inheritance_testcase(self): return True class TestRoleAdd(TestRole): - def setUp(self): super(TestRoleAdd, self).setUp() @@ -105,8 +102,10 @@ class TestRoleAdd(TestRole): def test_role_add_user_system(self): arglist = [ - '--user', identity_fakes.user_name, - '--system', 'all', + '--user', + identity_fakes.user_name, + '--system', + 'all', identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -132,15 +131,16 @@ class TestRoleAdd(TestRole): } # RoleManager.grant(role, user=, group=, domain=, project=) self.roles_mock.grant.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) def test_role_add_user_domain(self): arglist = [ - '--user', identity_fakes.user_name, - '--domain', identity_fakes.domain_name, + '--user', + identity_fakes.user_name, + '--domain', + identity_fakes.domain_name, identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -165,15 +165,16 @@ class TestRoleAdd(TestRole): } # RoleManager.grant(role, user=, group=, domain=, project=) self.roles_mock.grant.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) def test_role_add_user_project(self): arglist = [ - '--user', identity_fakes.user_name, - '--project', identity_fakes.project_name, + '--user', + identity_fakes.user_name, + '--project', + identity_fakes.project_name, identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -198,15 +199,16 @@ class TestRoleAdd(TestRole): } # RoleManager.grant(role, user=, group=, domain=, project=) self.roles_mock.grant.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) def test_role_add_group_system(self): arglist = [ - '--group', identity_fakes.group_name, - '--system', 'all', + '--group', + identity_fakes.group_name, + '--system', + 'all', identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -232,15 +234,16 @@ class TestRoleAdd(TestRole): } # RoleManager.grant(role, user=, group=, domain=, project=) self.roles_mock.grant.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) def test_role_add_group_domain(self): arglist = [ - '--group', identity_fakes.group_name, - '--domain', identity_fakes.domain_name, + '--group', + identity_fakes.group_name, + '--domain', + identity_fakes.domain_name, identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -265,15 +268,16 @@ class TestRoleAdd(TestRole): } # RoleManager.grant(role, user=, group=, domain=, project=) self.roles_mock.grant.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) def test_role_add_group_project(self): arglist = [ - '--group', identity_fakes.group_name, - '--project', identity_fakes.project_name, + '--group', + identity_fakes.group_name, + '--project', + identity_fakes.project_name, identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -298,8 +302,7 @@ class TestRoleAdd(TestRole): } # RoleManager.grant(role, user=, group=, domain=, project=) self.roles_mock.grant.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) @@ -310,9 +313,12 @@ class TestRoleAdd(TestRole): loaded=True, ) arglist = [ - '--user', identity_fakes.user_name, - '--project', identity_fakes.project_name, - '--role-domain', identity_fakes.domain_name, + '--user', + identity_fakes.user_name, + '--project', + identity_fakes.project_name, + '--role-domain', + identity_fakes.domain_name, identity_fakes.ROLE_2['name'], ] if self._is_inheritance_testcase(): @@ -337,8 +343,7 @@ class TestRoleAdd(TestRole): } # RoleManager.grant(role, user=, group=, domain=, project=) self.roles_mock.grant.assert_called_with( - identity_fakes.ROLE_2['id'], - **kwargs + identity_fakes.ROLE_2['id'], **kwargs ) self.assertIsNone(result) @@ -355,8 +360,9 @@ class TestRoleAdd(TestRole): ('inherited', False), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.assertRaises(exceptions.CommandError, - self.cmd.take_action, parsed_args) + self.assertRaises( + exceptions.CommandError, self.cmd.take_action, parsed_args + ) class TestRoleAddInherited(TestRoleAdd, TestRoleInherited): @@ -364,7 +370,6 @@ class TestRoleAddInherited(TestRoleAdd, TestRoleInherited): class TestRoleCreate(TestRole): - def setUp(self): super(TestRoleCreate, self).setUp() @@ -406,9 +411,7 @@ class TestRoleCreate(TestRole): } # RoleManager.create(name=, domain=) - self.roles_mock.create.assert_called_with( - **kwargs - ) + self.roles_mock.create.assert_called_with(**kwargs) collist = ('domain', 'id', 'name') self.assertEqual(collist, columns) @@ -420,7 +423,6 @@ class TestRoleCreate(TestRole): self.assertEqual(datalist, data) def test_role_create_with_domain(self): - self.roles_mock.create.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.ROLE_2), @@ -428,7 +430,8 @@ class TestRoleCreate(TestRole): ) arglist = [ - '--domain', identity_fakes.domain_name, + '--domain', + identity_fakes.domain_name, identity_fakes.ROLE_2['name'], ] verifylist = [ @@ -451,9 +454,7 @@ class TestRoleCreate(TestRole): } # RoleManager.create(name=, domain=) - self.roles_mock.create.assert_called_with( - **kwargs - ) + self.roles_mock.create.assert_called_with(**kwargs) collist = ('domain', 'id', 'name') self.assertEqual(collist, columns) @@ -465,14 +466,14 @@ class TestRoleCreate(TestRole): self.assertEqual(datalist, data) def test_role_create_with_description(self): - self.roles_mock.create.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.ROLE_2), loaded=True, ) arglist = [ - '--description', identity_fakes.role_description, + '--description', + identity_fakes.role_description, identity_fakes.ROLE_2['name'], ] verifylist = [ @@ -495,9 +496,7 @@ class TestRoleCreate(TestRole): } # RoleManager.create(name=, domain=) - self.roles_mock.create.assert_called_with( - **kwargs - ) + self.roles_mock.create.assert_called_with(**kwargs) collist = ('domain', 'id', 'name') self.assertEqual(collist, columns) @@ -509,7 +508,6 @@ class TestRoleCreate(TestRole): self.assertEqual(datalist, data) def test_role_create_with_immutable_option(self): - self.roles_mock.create.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.ROLE_2), @@ -532,7 +530,6 @@ class TestRoleCreate(TestRole): # Set expected values kwargs = { - 'options': {'immutable': True}, 'description': None, 'name': identity_fakes.ROLE_2['name'], @@ -540,9 +537,7 @@ class TestRoleCreate(TestRole): } # RoleManager.create(name=, domain=) - self.roles_mock.create.assert_called_with( - **kwargs - ) + self.roles_mock.create.assert_called_with(**kwargs) collist = ('domain', 'id', 'name') self.assertEqual(collist, columns) @@ -554,7 +549,6 @@ class TestRoleCreate(TestRole): self.assertEqual(datalist, data) def test_role_create_with_no_immutable_option(self): - self.roles_mock.create.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.ROLE_2), @@ -577,7 +571,6 @@ class TestRoleCreate(TestRole): # Set expected values kwargs = { - 'options': {'immutable': False}, 'description': None, 'name': identity_fakes.ROLE_2['name'], @@ -585,9 +578,7 @@ class TestRoleCreate(TestRole): } # RoleManager.create(name=, domain=) - self.roles_mock.create.assert_called_with( - **kwargs - ) + self.roles_mock.create.assert_called_with(**kwargs) collist = ('domain', 'id', 'name') self.assertEqual(collist, columns) @@ -600,7 +591,6 @@ class TestRoleCreate(TestRole): class TestRoleDelete(TestRole): - def setUp(self): super(TestRoleDelete, self).setUp() @@ -639,7 +629,8 @@ class TestRoleDelete(TestRole): self.roles_mock.delete.return_value = None arglist = [ - '--domain', identity_fakes.domain_name, + '--domain', + identity_fakes.domain_name, identity_fakes.ROLE_2['name'], ] verifylist = [ @@ -657,8 +648,10 @@ class TestRoleDelete(TestRole): @mock.patch.object(utils, 'find_resource') def test_delete_multi_roles_with_exception(self, find_mock): - find_mock.side_effect = [self.roles_mock.get.return_value, - exceptions.CommandError] + find_mock.side_effect = [ + self.roles_mock.get.return_value, + exceptions.CommandError, + ] arglist = [ identity_fakes.role_name, 'unexist_role', @@ -672,22 +665,20 @@ class TestRoleDelete(TestRole): self.cmd.take_action(parsed_args) self.fail('CommandError should be raised.') except exceptions.CommandError as e: - self.assertEqual('1 of 2 roles failed to delete.', - str(e)) + self.assertEqual('1 of 2 roles failed to delete.', str(e)) - find_mock.assert_any_call(self.roles_mock, - identity_fakes.role_name, - domain_id=None) - find_mock.assert_any_call(self.roles_mock, - 'unexist_role', - domain_id=None) + find_mock.assert_any_call( + self.roles_mock, identity_fakes.role_name, domain_id=None + ) + find_mock.assert_any_call( + self.roles_mock, 'unexist_role', domain_id=None + ) self.assertEqual(2, find_mock.call_count) self.roles_mock.delete.assert_called_once_with(identity_fakes.role_id) class TestRoleList(TestRole): - columns = ( 'ID', 'Name', @@ -743,7 +734,8 @@ class TestRoleList(TestRole): ), ] arglist = [ - '--domain', identity_fakes.domain_name, + '--domain', + identity_fakes.domain_name, ] verifylist = [ ('domain', identity_fakes.domain_name), @@ -756,26 +748,23 @@ class TestRoleList(TestRole): columns, data = self.cmd.take_action(parsed_args) # Set expected values - kwargs = { - 'domain_id': identity_fakes.domain_id - } + kwargs = {'domain_id': identity_fakes.domain_id} # RoleManager.list(user=, group=, domain=, project=, **kwargs) - self.roles_mock.list.assert_called_with( - **kwargs - ) + self.roles_mock.list.assert_called_with(**kwargs) collist = ('ID', 'Name', 'Domain') self.assertEqual(collist, columns) - datalist = (( - identity_fakes.ROLE_2['id'], - identity_fakes.ROLE_2['name'], - identity_fakes.domain_name, - ), ) + datalist = ( + ( + identity_fakes.ROLE_2['id'], + identity_fakes.ROLE_2['name'], + identity_fakes.domain_name, + ), + ) self.assertEqual(datalist, tuple(data)) class TestRoleRemove(TestRole): - def setUp(self): super(TestRoleRemove, self).setUp() @@ -815,9 +804,11 @@ class TestRoleRemove(TestRole): def test_role_remove_user_system(self): arglist = [ - '--user', identity_fakes.user_name, - '--system', 'all', - identity_fakes.role_name + '--user', + identity_fakes.user_name, + '--system', + 'all', + identity_fakes.role_name, ] if self._is_inheritance_testcase(): arglist.append('--inherited') @@ -842,8 +833,7 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) @@ -856,9 +846,11 @@ class TestRoleRemove(TestRole): find_mock.side_effect = exceptions.CommandError arglist = [ - '--user', identity_fakes.user_id, - '--system', 'all', - identity_fakes.role_name + '--user', + identity_fakes.user_id, + '--system', + 'all', + identity_fakes.role_name, ] if self._is_inheritance_testcase(): arglist.append('--inherited') @@ -883,15 +875,16 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) def test_role_remove_user_domain(self): arglist = [ - '--user', identity_fakes.user_name, - '--domain', identity_fakes.domain_name, + '--user', + identity_fakes.user_name, + '--domain', + identity_fakes.domain_name, identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -916,8 +909,7 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) @@ -929,9 +921,11 @@ class TestRoleRemove(TestRole): find_mock.side_effect = exceptions.CommandError arglist = [ - '--user', identity_fakes.user_id, - '--domain', identity_fakes.domain_name, - identity_fakes.role_name + '--user', + identity_fakes.user_id, + '--domain', + identity_fakes.domain_name, + identity_fakes.role_name, ] if self._is_inheritance_testcase(): arglist.append('--inherited') @@ -956,15 +950,16 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) def test_role_remove_user_project(self): arglist = [ - '--user', identity_fakes.user_name, - '--project', identity_fakes.project_name, + '--user', + identity_fakes.user_name, + '--project', + identity_fakes.project_name, identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -989,8 +984,7 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) @@ -1002,9 +996,11 @@ class TestRoleRemove(TestRole): find_mock.side_effect = exceptions.CommandError arglist = [ - '--user', identity_fakes.user_id, - '--project', identity_fakes.project_name, - identity_fakes.role_name + '--user', + identity_fakes.user_id, + '--project', + identity_fakes.project_name, + identity_fakes.role_name, ] if self._is_inheritance_testcase(): arglist.append('--inherited') @@ -1029,15 +1025,16 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) def test_role_remove_group_system(self): arglist = [ - '--group', identity_fakes.group_name, - '--system', 'all', + '--group', + identity_fakes.group_name, + '--system', + 'all', identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -1064,8 +1061,7 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) @@ -1077,9 +1073,11 @@ class TestRoleRemove(TestRole): find_mock.side_effect = exceptions.CommandError arglist = [ - '--group', identity_fakes.group_id, - '--system', 'all', - identity_fakes.role_name + '--group', + identity_fakes.group_id, + '--system', + 'all', + identity_fakes.role_name, ] if self._is_inheritance_testcase(): arglist.append('--inherited') @@ -1104,15 +1102,16 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) def test_role_remove_group_domain(self): arglist = [ - '--group', identity_fakes.group_name, - '--domain', identity_fakes.domain_name, + '--group', + identity_fakes.group_name, + '--domain', + identity_fakes.domain_name, identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -1138,8 +1137,7 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) @@ -1151,9 +1149,11 @@ class TestRoleRemove(TestRole): find_mock.side_effect = exceptions.CommandError arglist = [ - '--group', identity_fakes.group_id, - '--domain', identity_fakes.domain_name, - identity_fakes.role_name + '--group', + identity_fakes.group_id, + '--domain', + identity_fakes.domain_name, + identity_fakes.role_name, ] if self._is_inheritance_testcase(): arglist.append('--inherited') @@ -1178,15 +1178,16 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) def test_role_remove_group_project(self): arglist = [ - '--group', identity_fakes.group_name, - '--project', identity_fakes.project_name, + '--group', + identity_fakes.group_name, + '--project', + identity_fakes.project_name, identity_fakes.role_name, ] if self._is_inheritance_testcase(): @@ -1211,8 +1212,7 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) @@ -1224,9 +1224,11 @@ class TestRoleRemove(TestRole): find_mock.side_effect = exceptions.CommandError arglist = [ - '--group', identity_fakes.group_id, - '--project', identity_fakes.project_name, - identity_fakes.role_name + '--group', + identity_fakes.group_id, + '--project', + identity_fakes.project_name, + identity_fakes.role_name, ] if self._is_inheritance_testcase(): arglist.append('--inherited') @@ -1251,8 +1253,7 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) @@ -1263,8 +1264,10 @@ class TestRoleRemove(TestRole): loaded=True, ) arglist = [ - '--group', identity_fakes.group_name, - '--domain', identity_fakes.domain_name, + '--group', + identity_fakes.group_name, + '--domain', + identity_fakes.domain_name, identity_fakes.ROLE_2['name'], ] if self._is_inheritance_testcase(): @@ -1289,8 +1292,7 @@ class TestRoleRemove(TestRole): } # RoleManager.revoke(role, user=, group=, domain=, project=) self.roles_mock.revoke.assert_called_with( - identity_fakes.ROLE_2['id'], - **kwargs + identity_fakes.ROLE_2['id'], **kwargs ) self.assertIsNone(result) @@ -1307,12 +1309,12 @@ class TestRoleRemove(TestRole): ('inherited', False), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.assertRaises(exceptions.CommandError, - self.cmd.take_action, parsed_args) + self.assertRaises( + exceptions.CommandError, self.cmd.take_action, parsed_args + ) class TestRoleSet(TestRole): - def setUp(self): super(TestRoleSet, self).setUp() @@ -1328,7 +1330,8 @@ class TestRoleSet(TestRole): def test_role_set_no_options(self): arglist = [ - '--name', 'over', + '--name', + 'over', identity_fakes.role_name, ] verifylist = [ @@ -1347,8 +1350,7 @@ class TestRoleSet(TestRole): } # RoleManager.update(role, name=) self.roles_mock.update.assert_called_with( - identity_fakes.role_id, - **kwargs + identity_fakes.role_id, **kwargs ) self.assertIsNone(result) @@ -1359,8 +1361,10 @@ class TestRoleSet(TestRole): loaded=True, ) arglist = [ - '--name', 'over', - '--domain', identity_fakes.domain_name, + '--name', + 'over', + '--domain', + identity_fakes.domain_name, identity_fakes.ROLE_2['name'], ] verifylist = [ @@ -1380,8 +1384,7 @@ class TestRoleSet(TestRole): } # RoleManager.update(role, name=) self.roles_mock.update.assert_called_with( - identity_fakes.ROLE_2['id'], - **kwargs + identity_fakes.ROLE_2['id'], **kwargs ) self.assertIsNone(result) @@ -1392,8 +1395,10 @@ class TestRoleSet(TestRole): loaded=True, ) arglist = [ - '--name', 'over', - '--description', identity_fakes.role_description, + '--name', + 'over', + '--description', + identity_fakes.role_description, identity_fakes.ROLE_2['name'], ] verifylist = [ @@ -1413,8 +1418,7 @@ class TestRoleSet(TestRole): } # RoleManager.update(role, name=) self.roles_mock.update.assert_called_with( - identity_fakes.ROLE_2['id'], - **kwargs + identity_fakes.ROLE_2['id'], **kwargs ) self.assertIsNone(result) @@ -1425,7 +1429,8 @@ class TestRoleSet(TestRole): loaded=True, ) arglist = [ - '--name', 'over', + '--name', + 'over', '--immutable', identity_fakes.ROLE_2['name'], ] @@ -1446,8 +1451,7 @@ class TestRoleSet(TestRole): } # RoleManager.update(role, name=) self.roles_mock.update.assert_called_with( - identity_fakes.ROLE_2['id'], - **kwargs + identity_fakes.ROLE_2['id'], **kwargs ) self.assertIsNone(result) @@ -1458,7 +1462,8 @@ class TestRoleSet(TestRole): loaded=True, ) arglist = [ - '--name', 'over', + '--name', + 'over', '--no-immutable', identity_fakes.ROLE_2['name'], ] @@ -1479,14 +1484,12 @@ class TestRoleSet(TestRole): } # RoleManager.update(role, name=) self.roles_mock.update.assert_called_with( - identity_fakes.ROLE_2['id'], - **kwargs + identity_fakes.ROLE_2['id'], **kwargs ) self.assertIsNone(result) class TestRoleShow(TestRole): - def setUp(self): super(TestRoleShow, self).setUp() @@ -1534,7 +1537,8 @@ class TestRoleShow(TestRole): loaded=True, ) arglist = [ - '--domain', identity_fakes.domain_name, + '--domain', + identity_fakes.domain_name, identity_fakes.ROLE_2['name'], ] verifylist = [ diff --git a/openstackclient/tests/unit/identity/v3/test_role_assignment.py b/openstackclient/tests/unit/identity/v3/test_role_assignment.py index 7d38d360..04cb68cb 100644 --- a/openstackclient/tests/unit/identity/v3/test_role_assignment.py +++ b/openstackclient/tests/unit/identity/v3/test_role_assignment.py @@ -20,13 +20,11 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestRoleAssignment(identity_fakes.TestIdentityv3): - def setUp(self): super(TestRoleAssignment, self).setUp() class TestRoleAssignmentList(TestRoleAssignment): - columns = ( 'Role', 'User', @@ -60,26 +58,28 @@ class TestRoleAssignmentList(TestRoleAssignment): self.roles_mock = self.app.client_manager.identity.roles self.roles_mock.reset_mock() - self.role_assignments_mock = self.app.client_manager.identity.\ - role_assignments + self.role_assignments_mock = ( + self.app.client_manager.identity.role_assignments + ) self.role_assignments_mock.reset_mock() # Get the command object to test self.cmd = role_assignment.ListRoleAssignment(self.app, None) def test_role_assignment_list_no_filters(self): - self.role_assignments_mock.list.return_value = [ fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID), + identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID + ), loaded=True, ), fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID), + identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID + ), loaded=True, ), ] @@ -102,47 +102,51 @@ class TestRoleAssignmentList(TestRoleAssignment): user=None, project=None, os_inherit_extension_inherited_to=None, - include_names=False) + include_names=False, + ) self.assertEqual(self.columns, columns) - datalist = (( - identity_fakes.role_id, - identity_fakes.user_id, - '', - identity_fakes.project_id, - '', - '', - False - ), (identity_fakes.role_id, - '', - identity_fakes.group_id, - identity_fakes.project_id, - '', - '', - False - ),) + datalist = ( + ( + identity_fakes.role_id, + identity_fakes.user_id, + '', + identity_fakes.project_id, + '', + '', + False, + ), + ( + identity_fakes.role_id, + '', + identity_fakes.group_id, + identity_fakes.project_id, + '', + '', + False, + ), + ) self.assertEqual(datalist, tuple(data)) def test_role_assignment_list_user(self): - self.role_assignments_mock.list.return_value = [ fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID), + identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID + ), loaded=True, ), fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID), + identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID + ), loaded=True, ), ] - arglist = [ - '--user', identity_fakes.user_name - ] + arglist = ['--user', identity_fakes.user_name] verifylist = [ ('user', identity_fakes.user_name), ('group', None), @@ -170,47 +174,51 @@ class TestRoleAssignmentList(TestRoleAssignment): role=None, effective=False, os_inherit_extension_inherited_to=None, - include_names=False) + include_names=False, + ) self.assertEqual(self.columns, columns) - datalist = (( - identity_fakes.role_id, - identity_fakes.user_id, - '', - '', - identity_fakes.domain_id, - '', - False - ), (identity_fakes.role_id, - identity_fakes.user_id, - '', - identity_fakes.project_id, - '', - '', - False - ),) + datalist = ( + ( + identity_fakes.role_id, + identity_fakes.user_id, + '', + '', + identity_fakes.domain_id, + '', + False, + ), + ( + identity_fakes.role_id, + identity_fakes.user_id, + '', + identity_fakes.project_id, + '', + '', + False, + ), + ) self.assertEqual(datalist, tuple(data)) def test_role_assignment_list_group(self): - self.role_assignments_mock.list.return_value = [ fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_GROUP_ID), + identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_GROUP_ID + ), loaded=True, ), fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID), + identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID + ), loaded=True, ), ] - arglist = [ - '--group', identity_fakes.group_name - ] + arglist = ['--group', identity_fakes.group_name] verifylist = [ ('user', None), ('group', identity_fakes.group_name), @@ -238,47 +246,51 @@ class TestRoleAssignmentList(TestRoleAssignment): role=None, user=None, os_inherit_extension_inherited_to=None, - include_names=False) + include_names=False, + ) self.assertEqual(self.columns, columns) - datalist = (( - identity_fakes.role_id, - '', - identity_fakes.group_id, - '', - identity_fakes.domain_id, - '', - False - ), (identity_fakes.role_id, - '', - identity_fakes.group_id, - identity_fakes.project_id, - '', - '', - False - ),) + datalist = ( + ( + identity_fakes.role_id, + '', + identity_fakes.group_id, + '', + identity_fakes.domain_id, + '', + False, + ), + ( + identity_fakes.role_id, + '', + identity_fakes.group_id, + identity_fakes.project_id, + '', + '', + False, + ), + ) self.assertEqual(datalist, tuple(data)) def test_role_assignment_list_domain(self): - self.role_assignments_mock.list.return_value = [ fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID), + identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID + ), loaded=True, ), fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_GROUP_ID), + identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_GROUP_ID + ), loaded=True, ), ] - arglist = [ - '--domain', identity_fakes.domain_name - ] + arglist = ['--domain', identity_fakes.domain_name] verifylist = [ ('user', None), ('group', None), @@ -306,47 +318,51 @@ class TestRoleAssignmentList(TestRoleAssignment): role=None, user=None, os_inherit_extension_inherited_to=None, - include_names=False) + include_names=False, + ) self.assertEqual(self.columns, columns) - datalist = (( - identity_fakes.role_id, - identity_fakes.user_id, - '', - '', - identity_fakes.domain_id, - '', - False - ), (identity_fakes.role_id, - '', - identity_fakes.group_id, - '', - identity_fakes.domain_id, - '', - False - ),) + datalist = ( + ( + identity_fakes.role_id, + identity_fakes.user_id, + '', + '', + identity_fakes.domain_id, + '', + False, + ), + ( + identity_fakes.role_id, + '', + identity_fakes.group_id, + '', + identity_fakes.domain_id, + '', + False, + ), + ) self.assertEqual(datalist, tuple(data)) def test_role_assignment_list_project(self): - self.role_assignments_mock.list.return_value = [ fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID), + identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID + ), loaded=True, ), fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID), + identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_GROUP_ID + ), loaded=True, ), ] - arglist = [ - '--project', identity_fakes.project_name - ] + arglist = ['--project', identity_fakes.project_name] verifylist = [ ('user', None), ('group', None), @@ -374,29 +390,33 @@ class TestRoleAssignmentList(TestRoleAssignment): role=None, user=None, os_inherit_extension_inherited_to=None, - include_names=False) + include_names=False, + ) self.assertEqual(self.columns, columns) - datalist = (( - identity_fakes.role_id, - identity_fakes.user_id, - '', - identity_fakes.project_id, - '', - '', - False - ), (identity_fakes.role_id, - '', - identity_fakes.group_id, - identity_fakes.project_id, - '', - '', - False - ),) + datalist = ( + ( + identity_fakes.role_id, + identity_fakes.user_id, + '', + identity_fakes.project_id, + '', + '', + False, + ), + ( + identity_fakes.role_id, + '', + identity_fakes.group_id, + identity_fakes.project_id, + '', + '', + False, + ), + ) self.assertEqual(datalist, tuple(data)) def test_role_assignment_list_def_creds(self): - auth_ref = self.app.client_manager.auth_ref = mock.Mock() auth_ref.project_id.return_value = identity_fakes.project_id auth_ref.user_id.return_value = identity_fakes.user_id @@ -405,7 +425,8 @@ class TestRoleAssignmentList(TestRoleAssignment): fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID), + identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID + ), loaded=True, ), ] @@ -443,33 +464,37 @@ class TestRoleAssignmentList(TestRoleAssignment): role=None, effective=False, os_inherit_extension_inherited_to=None, - include_names=False) + include_names=False, + ) self.assertEqual(self.columns, columns) - datalist = (( - identity_fakes.role_id, - identity_fakes.user_id, - '', - identity_fakes.project_id, - '', - '', - False - ),) + datalist = ( + ( + identity_fakes.role_id, + identity_fakes.user_id, + '', + identity_fakes.project_id, + '', + '', + False, + ), + ) self.assertEqual(datalist, tuple(data)) def test_role_assignment_list_effective(self): - self.role_assignments_mock.list.return_value = [ fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID), + identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID + ), loaded=True, ), fakes.FakeResource( None, copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID), + identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID + ), loaded=True, ), ] @@ -502,44 +527,42 @@ class TestRoleAssignmentList(TestRoleAssignment): role=None, user=None, os_inherit_extension_inherited_to=None, - include_names=False) + include_names=False, + ) self.assertEqual(self.columns, columns) - datalist = (( - identity_fakes.role_id, - identity_fakes.user_id, - '', - identity_fakes.project_id, - '', - '', - False - ), (identity_fakes.role_id, - identity_fakes.user_id, - '', - '', - identity_fakes.domain_id, - '', - False - ),) + datalist = ( + ( + identity_fakes.role_id, + identity_fakes.user_id, + '', + identity_fakes.project_id, + '', + '', + False, + ), + ( + identity_fakes.role_id, + identity_fakes.user_id, + '', + '', + identity_fakes.domain_id, + '', + False, + ), + ) self.assertEqual(tuple(data), datalist) def test_role_assignment_list_inherited(self): - + fake_assignment_a = copy.deepcopy( + identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INHERITED + ) + fake_assignment_b = copy.deepcopy( + identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INHERITED + ) self.role_assignments_mock.list.return_value = [ - fakes.FakeResource( - None, - copy.deepcopy( - (identity_fakes. - ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INHERITED)), - loaded=True, - ), - fakes.FakeResource( - None, - copy.deepcopy( - (identity_fakes. - ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INHERITED)), - loaded=True, - ), + fakes.FakeResource(None, fake_assignment_a, loaded=True), + fakes.FakeResource(None, fake_assignment_b, loaded=True), ] arglist = ['--inherited'] @@ -570,44 +593,42 @@ class TestRoleAssignmentList(TestRoleAssignment): role=None, user=None, os_inherit_extension_inherited_to='projects', - include_names=False) + include_names=False, + ) self.assertEqual(self.columns, columns) - datalist = (( - identity_fakes.role_id, - identity_fakes.user_id, - '', - identity_fakes.project_id, - '', - '', - True - ), (identity_fakes.role_id, - identity_fakes.user_id, - '', - '', - identity_fakes.domain_id, - '', - True - ),) + datalist = ( + ( + identity_fakes.role_id, + identity_fakes.user_id, + '', + identity_fakes.project_id, + '', + '', + True, + ), + ( + identity_fakes.role_id, + identity_fakes.user_id, + '', + '', + identity_fakes.domain_id, + '', + True, + ), + ) self.assertEqual(datalist, tuple(data)) def test_role_assignment_list_include_names(self): - + fake_role_assignment_a = copy.deepcopy( + identity_fakes.ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INCLUDE_NAMES + ) + fake_role_assignment_b = copy.deepcopy( + identity_fakes.ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INCLUDE_NAMES + ) self.role_assignments_mock.list.return_value = [ - fakes.FakeResource( - None, - copy.deepcopy( - identity_fakes - .ASSIGNMENT_WITH_PROJECT_ID_AND_USER_ID_INCLUDE_NAMES), - loaded=True, - ), - fakes.FakeResource( - None, - copy.deepcopy( - identity_fakes - .ASSIGNMENT_WITH_DOMAIN_ID_AND_USER_ID_INCLUDE_NAMES), - loaded=True, - ), + fakes.FakeResource(None, fake_role_assignment_a, loaded=True), + fakes.FakeResource(None, fake_role_assignment_b, loaded=True), ] arglist = ['--names'] @@ -640,46 +661,62 @@ class TestRoleAssignmentList(TestRoleAssignment): role=None, user=None, os_inherit_extension_inherited_to=None, - include_names=True) + include_names=True, + ) collist = ( - 'Role', 'User', 'Group', 'Project', 'Domain', 'System', 'Inherited' + 'Role', + 'User', + 'Group', + 'Project', + 'Domain', + 'System', + 'Inherited', ) self.assertEqual(columns, collist) - datalist1 = (( - identity_fakes.role_name, - '@'.join([identity_fakes.user_name, identity_fakes.domain_name]), - '', - '@'.join([identity_fakes.project_name, - identity_fakes.domain_name]), - '', - '', - False - ), (identity_fakes.role_name, - '@'.join([identity_fakes.user_name, identity_fakes.domain_name]), - '', - '', - identity_fakes.domain_name, - '', - False - ),) + datalist1 = ( + ( + identity_fakes.role_name, + '@'.join( + [identity_fakes.user_name, identity_fakes.domain_name] + ), + '', + '@'.join( + [identity_fakes.project_name, identity_fakes.domain_name] + ), + '', + '', + False, + ), + ( + identity_fakes.role_name, + '@'.join( + [identity_fakes.user_name, identity_fakes.domain_name] + ), + '', + '', + identity_fakes.domain_name, + '', + False, + ), + ) self.assertEqual(tuple(data), datalist1) def test_role_assignment_list_domain_role(self): - self.role_assignments_mock.list.return_value = [ fakes.FakeResource( None, - copy.deepcopy( - identity_fakes.ASSIGNMENT_WITH_DOMAIN_ROLE), + copy.deepcopy(identity_fakes.ASSIGNMENT_WITH_DOMAIN_ROLE), loaded=True, ), ] arglist = [ - '--role', identity_fakes.ROLE_2['name'], - '--role-domain', identity_fakes.domain_name + '--role', + identity_fakes.ROLE_2['name'], + '--role-domain', + identity_fakes.domain_name, ] verifylist = [ ('user', None), @@ -708,16 +745,19 @@ class TestRoleAssignmentList(TestRoleAssignment): role=self.roles_mock.get(), effective=False, os_inherit_extension_inherited_to=None, - include_names=False) + include_names=False, + ) self.assertEqual(self.columns, columns) - datalist = (( - identity_fakes.ROLE_2['id'], - identity_fakes.user_id, - '', - '', - identity_fakes.domain_id, - '', - False - ),) + datalist = ( + ( + identity_fakes.ROLE_2['id'], + identity_fakes.user_id, + '', + '', + identity_fakes.domain_id, + '', + False, + ), + ) self.assertEqual(datalist, tuple(data)) diff --git a/openstackclient/tests/unit/identity/v3/test_service.py b/openstackclient/tests/unit/identity/v3/test_service.py index 4cba445b..8143ddd5 100644 --- a/openstackclient/tests/unit/identity/v3/test_service.py +++ b/openstackclient/tests/unit/identity/v3/test_service.py @@ -21,7 +21,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestService(identity_fakes.TestIdentityv3): - def setUp(self): super(TestService, self).setUp() @@ -31,7 +30,6 @@ class TestService(identity_fakes.TestIdentityv3): class TestServiceCreate(TestService): - columns = ( 'description', 'enabled', @@ -58,7 +56,8 @@ class TestServiceCreate(TestService): def test_service_create_name(self): arglist = [ - '--name', self.service.name, + '--name', + self.service.name, self.service.type, ] verifylist = [ @@ -88,7 +87,8 @@ class TestServiceCreate(TestService): def test_service_create_description(self): arglist = [ - '--description', self.service.description, + '--description', + self.service.description, self.service.type, ] verifylist = [ @@ -178,7 +178,6 @@ class TestServiceCreate(TestService): class TestServiceDelete(TestService): - service = identity_fakes.FakeService.create_one_service() def setUp(self): @@ -209,7 +208,6 @@ class TestServiceDelete(TestService): class TestServiceList(TestService): - service = identity_fakes.FakeService.create_one_service() def setUp(self): @@ -234,11 +232,13 @@ class TestServiceList(TestService): collist = ('ID', 'Name', 'Type') self.assertEqual(collist, columns) - datalist = (( - self.service.id, - self.service.name, - self.service.type, - ), ) + datalist = ( + ( + self.service.id, + self.service.name, + self.service.type, + ), + ) self.assertEqual(datalist, tuple(data)) def test_service_list_long(self): @@ -259,18 +259,19 @@ class TestServiceList(TestService): collist = ('ID', 'Name', 'Type', 'Description', 'Enabled') self.assertEqual(collist, columns) - datalist = (( - self.service.id, - self.service.name, - self.service.type, - self.service.description, - True, - ), ) + datalist = ( + ( + self.service.id, + self.service.name, + self.service.type, + self.service.description, + True, + ), + ) self.assertEqual(datalist, tuple(data)) class TestServiceSet(TestService): - service = identity_fakes.FakeService.create_one_service() def setUp(self): @@ -303,7 +304,8 @@ class TestServiceSet(TestService): def test_service_set_type(self): arglist = [ - '--type', self.service.type, + '--type', + self.service.type, self.service.name, ] verifylist = [ @@ -323,15 +325,13 @@ class TestServiceSet(TestService): 'type': self.service.type, } # ServiceManager.update(service, name=, type=, enabled=, **kwargs) - self.services_mock.update.assert_called_with( - self.service.id, - **kwargs - ) + self.services_mock.update.assert_called_with(self.service.id, **kwargs) self.assertIsNone(result) def test_service_set_name(self): arglist = [ - '--name', self.service.name, + '--name', + self.service.name, self.service.name, ] verifylist = [ @@ -351,15 +351,13 @@ class TestServiceSet(TestService): 'name': self.service.name, } # ServiceManager.update(service, name=, type=, enabled=, **kwargs) - self.services_mock.update.assert_called_with( - self.service.id, - **kwargs - ) + self.services_mock.update.assert_called_with(self.service.id, **kwargs) self.assertIsNone(result) def test_service_set_description(self): arglist = [ - '--description', self.service.description, + '--description', + self.service.description, self.service.name, ] verifylist = [ @@ -379,10 +377,7 @@ class TestServiceSet(TestService): 'description': self.service.description, } # ServiceManager.update(service, name=, type=, enabled=, **kwargs) - self.services_mock.update.assert_called_with( - self.service.id, - **kwargs - ) + self.services_mock.update.assert_called_with(self.service.id, **kwargs) self.assertIsNone(result) def test_service_set_enable(self): @@ -407,10 +402,7 @@ class TestServiceSet(TestService): 'enabled': True, } # ServiceManager.update(service, name=, type=, enabled=, **kwargs) - self.services_mock.update.assert_called_with( - self.service.id, - **kwargs - ) + self.services_mock.update.assert_called_with(self.service.id, **kwargs) self.assertIsNone(result) def test_service_set_disable(self): @@ -435,15 +427,11 @@ class TestServiceSet(TestService): 'enabled': False, } # ServiceManager.update(service, name=, type=, enabled=, **kwargs) - self.services_mock.update.assert_called_with( - self.service.id, - **kwargs - ) + self.services_mock.update.assert_called_with(self.service.id, **kwargs) self.assertIsNone(result) class TestServiceShow(TestService): - service = identity_fakes.FakeService.create_one_service() def setUp(self): @@ -470,9 +458,7 @@ class TestServiceShow(TestService): columns, data = self.cmd.take_action(parsed_args) # ServiceManager.get(id) - self.services_mock.find.assert_called_with( - name=self.service.name - ) + self.services_mock.find.assert_called_with(name=self.service.name) collist = ('description', 'enabled', 'id', 'name', 'type') self.assertEqual(collist, columns) @@ -501,4 +487,6 @@ class TestServiceShow(TestService): except exceptions.CommandError as e: self.assertEqual( "Multiple service matches found for 'nounique_service'," - " use an ID to be more specific.", str(e)) + " use an ID to be more specific.", + str(e), + ) diff --git a/openstackclient/tests/unit/identity/v3/test_service_provider.py b/openstackclient/tests/unit/identity/v3/test_service_provider.py index 57473ef9..59117da9 100644 --- a/openstackclient/tests/unit/identity/v3/test_service_provider.py +++ b/openstackclient/tests/unit/identity/v3/test_service_provider.py @@ -20,7 +20,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as service_fakes class TestServiceProvider(service_fakes.TestFederatedIdentity): - def setUp(self): super(TestServiceProvider, self).setUp() @@ -30,7 +29,6 @@ class TestServiceProvider(service_fakes.TestFederatedIdentity): class TestServiceProviderCreate(TestServiceProvider): - columns = ( 'auth_url', 'description', @@ -43,7 +41,7 @@ class TestServiceProviderCreate(TestServiceProvider): service_fakes.sp_description, True, service_fakes.sp_id, - service_fakes.service_provider_url + service_fakes.service_provider_url, ) def setUp(self): @@ -56,15 +54,16 @@ class TestServiceProviderCreate(TestServiceProvider): def test_create_service_provider_required_options_only(self): arglist = [ - '--auth-url', service_fakes.sp_auth_url, - '--service-provider-url', service_fakes.service_provider_url, + '--auth-url', + service_fakes.sp_auth_url, + '--service-provider-url', + service_fakes.service_provider_url, service_fakes.sp_id, ] verifylist = [ ('auth_url', service_fakes.sp_auth_url), ('service_provider_url', service_fakes.service_provider_url), ('service_provider_id', service_fakes.sp_id), - ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) @@ -74,23 +73,24 @@ class TestServiceProviderCreate(TestServiceProvider): 'enabled': True, 'description': None, 'auth_url': service_fakes.sp_auth_url, - 'sp_url': service_fakes.service_provider_url + 'sp_url': service_fakes.service_provider_url, } self.service_providers_mock.create.assert_called_with( - id=service_fakes.sp_id, - **kwargs + id=service_fakes.sp_id, **kwargs ) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_create_service_provider_description(self): - arglist = [ - '--description', service_fakes.sp_description, - '--auth-url', service_fakes.sp_auth_url, - '--service-provider-url', service_fakes.service_provider_url, + '--description', + service_fakes.sp_description, + '--auth-url', + service_fakes.sp_auth_url, + '--service-provider-url', + service_fakes.service_provider_url, service_fakes.sp_id, ] verifylist = [ @@ -112,15 +112,13 @@ class TestServiceProviderCreate(TestServiceProvider): } self.service_providers_mock.create.assert_called_with( - id=service_fakes.sp_id, - **kwargs + id=service_fakes.sp_id, **kwargs ) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_create_service_provider_disabled(self): - # Prepare FakeResource object service_provider = copy.deepcopy(service_fakes.SERVICE_PROVIDER) service_provider['enabled'] = False @@ -130,8 +128,10 @@ class TestServiceProviderCreate(TestServiceProvider): self.service_providers_mock.create.return_value = resource arglist = [ - '--auth-url', service_fakes.sp_auth_url, - '--service-provider-url', service_fakes.service_provider_url, + '--auth-url', + service_fakes.sp_auth_url, + '--service-provider-url', + service_fakes.service_provider_url, '--disable', service_fakes.sp_id, ] @@ -151,8 +151,7 @@ class TestServiceProviderCreate(TestServiceProvider): } self.service_providers_mock.create.assert_called_with( - id=service_fakes.sp_id, - **kwargs + id=service_fakes.sp_id, **kwargs ) self.assertEqual(self.columns, columns) datalist = ( @@ -160,13 +159,12 @@ class TestServiceProviderCreate(TestServiceProvider): None, False, service_fakes.sp_id, - service_fakes.service_provider_url + service_fakes.service_provider_url, ) self.assertEqual(datalist, data) class TestServiceProviderDelete(TestServiceProvider): - def setUp(self): super(TestServiceProviderDelete, self).setUp() @@ -198,7 +196,6 @@ class TestServiceProviderDelete(TestServiceProvider): class TestServiceProviderList(TestServiceProvider): - def setUp(self): super(TestServiceProviderList, self).setUp() @@ -232,17 +229,18 @@ class TestServiceProviderList(TestServiceProvider): collist = ('ID', 'Enabled', 'Description', 'Auth URL') self.assertEqual(collist, columns) - datalist = (( - service_fakes.sp_id, - True, - service_fakes.sp_description, - service_fakes.sp_auth_url - ), ) + datalist = ( + ( + service_fakes.sp_id, + True, + service_fakes.sp_description, + service_fakes.sp_auth_url, + ), + ) self.assertEqual(tuple(data), datalist) class TestServiceProviderSet(TestServiceProvider): - columns = ( 'auth_url', 'description', @@ -272,16 +270,13 @@ class TestServiceProviderSet(TestServiceProvider): """Prepare fake return objects before the test is executed""" updated_sp = copy.deepcopy(service_fakes.SERVICE_PROVIDER) updated_sp['enabled'] = False - resources = fakes.FakeResource( - None, - updated_sp, - loaded=True - ) + resources = fakes.FakeResource(None, updated_sp, loaded=True) self.service_providers_mock.update.return_value = resources prepare(self) arglist = [ - '--disable', service_fakes.sp_id, + '--disable', + service_fakes.sp_id, ] verifylist = [ ('service_provider', service_fakes.sp_id), @@ -295,7 +290,7 @@ class TestServiceProviderSet(TestServiceProvider): enabled=False, description=None, auth_url=None, - sp_url=None + sp_url=None, ) def test_service_provider_enable(self): @@ -309,13 +304,14 @@ class TestServiceProviderSet(TestServiceProvider): resources = fakes.FakeResource( None, copy.deepcopy(service_fakes.SERVICE_PROVIDER), - loaded=True + loaded=True, ) self.service_providers_mock.update.return_value = resources prepare(self) arglist = [ - '--enable', service_fakes.sp_id, + '--enable', + service_fakes.sp_id, ] verifylist = [ ('service_provider', service_fakes.sp_id), @@ -326,8 +322,12 @@ class TestServiceProviderSet(TestServiceProvider): self.cmd.take_action(parsed_args) self.service_providers_mock.update.assert_called_with( - service_fakes.sp_id, enabled=True, description=None, - auth_url=None, sp_url=None) + service_fakes.sp_id, + enabled=True, + description=None, + auth_url=None, + sp_url=None, + ) def test_service_provider_no_options(self): def prepare(self): @@ -335,7 +335,7 @@ class TestServiceProviderSet(TestServiceProvider): resources = fakes.FakeResource( None, copy.deepcopy(service_fakes.SERVICE_PROVIDER), - loaded=True + loaded=True, ) self.service_providers_mock.get.return_value = resources @@ -364,7 +364,6 @@ class TestServiceProviderSet(TestServiceProvider): class TestServiceProviderShow(TestServiceProvider): - def setUp(self): super(TestServiceProviderShow, self).setUp() @@ -373,8 +372,10 @@ class TestServiceProviderShow(TestServiceProvider): copy.deepcopy(service_fakes.SERVICE_PROVIDER), loaded=True, ) - self.service_providers_mock.get.side_effect = [Exception("Not found"), - ret] + self.service_providers_mock.get.side_effect = [ + Exception("Not found"), + ret, + ] self.service_providers_mock.get.return_value = ret # Get the command object to test @@ -392,8 +393,7 @@ class TestServiceProviderShow(TestServiceProvider): columns, data = self.cmd.take_action(parsed_args) self.service_providers_mock.get.assert_called_with( - service_fakes.sp_id, - id='BETA' + service_fakes.sp_id, id='BETA' ) collist = ('auth_url', 'description', 'enabled', 'id', 'sp_url') @@ -403,6 +403,6 @@ class TestServiceProviderShow(TestServiceProvider): service_fakes.sp_description, True, service_fakes.sp_id, - service_fakes.service_provider_url + service_fakes.service_provider_url, ) self.assertEqual(data, datalist) diff --git a/openstackclient/tests/unit/identity/v3/test_token.py b/openstackclient/tests/unit/identity/v3/test_token.py index adb491b3..80d5dc19 100644 --- a/openstackclient/tests/unit/identity/v3/test_token.py +++ b/openstackclient/tests/unit/identity/v3/test_token.py @@ -20,7 +20,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestToken(identity_fakes.TestIdentityv3): - def setUp(self): super(TestToken, self).setUp() @@ -30,7 +29,6 @@ class TestToken(identity_fakes.TestIdentityv3): class TestTokenIssue(TestToken): - def setUp(self): super(TestTokenIssue, self).setUp() @@ -117,7 +115,6 @@ class TestTokenIssue(TestToken): class TestTokenRevoke(TestToken): - TOKEN = 'fob' def setUp(self): diff --git a/openstackclient/tests/unit/identity/v3/test_trust.py b/openstackclient/tests/unit/identity/v3/test_trust.py index d530adf5..67e64cea 100644 --- a/openstackclient/tests/unit/identity/v3/test_trust.py +++ b/openstackclient/tests/unit/identity/v3/test_trust.py @@ -23,7 +23,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestTrust(identity_fakes.TestIdentityv3): - def setUp(self): super(TestTrust, self).setUp() @@ -38,7 +37,6 @@ class TestTrust(identity_fakes.TestIdentityv3): class TestTrustCreate(TestTrust): - def setUp(self): super(TestTrustCreate, self).setUp() @@ -71,10 +69,12 @@ class TestTrustCreate(TestTrust): def test_trust_create_basic(self): arglist = [ - '--project', identity_fakes.project_id, - '--role', identity_fakes.role_id, + '--project', + identity_fakes.project_id, + '--role', + identity_fakes.role_id, + identity_fakes.user_id, identity_fakes.user_id, - identity_fakes.user_id ] verifylist = [ ('project', identity_fakes.project_id), @@ -100,13 +100,18 @@ class TestTrustCreate(TestTrust): # TrustManager.create(trustee_id, trustor_id, impersonation=, # project=, role_names=, expires_at=) self.trusts_mock.create.assert_called_with( - identity_fakes.user_id, - identity_fakes.user_id, - **kwargs + identity_fakes.user_id, identity_fakes.user_id, **kwargs ) - collist = ('expires_at', 'id', 'impersonation', 'project_id', - 'roles', 'trustee_user_id', 'trustor_user_id') + collist = ( + 'expires_at', + 'id', + 'impersonation', + 'project_id', + 'roles', + 'trustee_user_id', + 'trustor_user_id', + ) self.assertEqual(collist, columns) datalist = ( identity_fakes.trust_expires, @@ -115,13 +120,12 @@ class TestTrustCreate(TestTrust): identity_fakes.project_id, identity_fakes.role_name, identity_fakes.user_id, - identity_fakes.user_id + identity_fakes.user_id, ) self.assertEqual(datalist, data) class TestTrustDelete(TestTrust): - def setUp(self): super(TestTrustDelete, self).setUp() @@ -140,9 +144,7 @@ class TestTrustDelete(TestTrust): arglist = [ identity_fakes.trust_id, ] - verifylist = [ - ('trust', [identity_fakes.trust_id]) - ] + verifylist = [('trust', [identity_fakes.trust_id])] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) @@ -154,8 +156,10 @@ class TestTrustDelete(TestTrust): @mock.patch.object(utils, 'find_resource') def test_delete_multi_trusts_with_exception(self, find_mock): - find_mock.side_effect = [self.trusts_mock.get.return_value, - exceptions.CommandError] + find_mock.side_effect = [ + self.trusts_mock.get.return_value, + exceptions.CommandError, + ] arglist = [ identity_fakes.trust_id, 'unexist_trust', @@ -169,19 +173,18 @@ class TestTrustDelete(TestTrust): self.cmd.take_action(parsed_args) self.fail('CommandError should be raised.') except exceptions.CommandError as e: - self.assertEqual('1 of 2 trusts failed to delete.', - str(e)) + self.assertEqual('1 of 2 trusts failed to delete.', str(e)) find_mock.assert_any_call(self.trusts_mock, identity_fakes.trust_id) find_mock.assert_any_call(self.trusts_mock, 'unexist_trust') self.assertEqual(2, find_mock.call_count) self.trusts_mock.delete.assert_called_once_with( - identity_fakes.trust_id) + identity_fakes.trust_id + ) class TestTrustList(TestTrust): - def setUp(self): super(TestTrustList, self).setUp() @@ -211,17 +214,25 @@ class TestTrustList(TestTrust): trustee_user=None, ) - collist = ('ID', 'Expires At', 'Impersonation', 'Project ID', - 'Trustee User ID', 'Trustor User ID') + collist = ( + 'ID', + 'Expires At', + 'Impersonation', + 'Project ID', + 'Trustee User ID', + 'Trustor User ID', + ) self.assertEqual(collist, columns) - datalist = (( - identity_fakes.trust_id, - identity_fakes.trust_expires, - identity_fakes.trust_impersonation, - identity_fakes.project_id, - identity_fakes.user_id, - identity_fakes.user_id - ), ) + datalist = ( + ( + identity_fakes.trust_id, + identity_fakes.trust_expires, + identity_fakes.trust_impersonation, + identity_fakes.project_id, + identity_fakes.user_id, + identity_fakes.user_id, + ), + ) self.assertEqual(datalist, tuple(data)) def test_trust_list_auth_user(self): @@ -248,17 +259,25 @@ class TestTrustList(TestTrust): trustee_user=self.users_mock.get() ) - collist = ('ID', 'Expires At', 'Impersonation', 'Project ID', - 'Trustee User ID', 'Trustor User ID') + collist = ( + 'ID', + 'Expires At', + 'Impersonation', + 'Project ID', + 'Trustee User ID', + 'Trustor User ID', + ) self.assertEqual(collist, columns) - datalist = (( - identity_fakes.trust_id, - identity_fakes.trust_expires, - identity_fakes.trust_impersonation, - identity_fakes.project_id, - identity_fakes.user_id, - identity_fakes.user_id - ), ) + datalist = ( + ( + identity_fakes.trust_id, + identity_fakes.trust_expires, + identity_fakes.trust_impersonation, + identity_fakes.project_id, + identity_fakes.user_id, + identity_fakes.user_id, + ), + ) self.assertEqual(datalist, tuple(data)) def test_trust_list_trustee(self): @@ -281,17 +300,25 @@ class TestTrustList(TestTrust): trustor_user=None, ) - collist = ('ID', 'Expires At', 'Impersonation', 'Project ID', - 'Trustee User ID', 'Trustor User ID') + collist = ( + 'ID', + 'Expires At', + 'Impersonation', + 'Project ID', + 'Trustee User ID', + 'Trustor User ID', + ) self.assertEqual(collist, columns) - datalist = (( - identity_fakes.trust_id, - identity_fakes.trust_expires, - identity_fakes.trust_impersonation, - identity_fakes.project_id, - identity_fakes.user_id, - identity_fakes.user_id - ), ) + datalist = ( + ( + identity_fakes.trust_id, + identity_fakes.trust_expires, + identity_fakes.trust_impersonation, + identity_fakes.project_id, + identity_fakes.user_id, + identity_fakes.user_id, + ), + ) self.assertEqual(datalist, tuple(data)) def test_trust_list_trustor(self): @@ -314,22 +341,29 @@ class TestTrustList(TestTrust): trustee_user=None, ) - collist = ('ID', 'Expires At', 'Impersonation', 'Project ID', - 'Trustee User ID', 'Trustor User ID') + collist = ( + 'ID', + 'Expires At', + 'Impersonation', + 'Project ID', + 'Trustee User ID', + 'Trustor User ID', + ) self.assertEqual(collist, columns) - datalist = (( - identity_fakes.trust_id, - identity_fakes.trust_expires, - identity_fakes.trust_impersonation, - identity_fakes.project_id, - identity_fakes.user_id, - identity_fakes.user_id - ), ) + datalist = ( + ( + identity_fakes.trust_id, + identity_fakes.trust_expires, + identity_fakes.trust_impersonation, + identity_fakes.project_id, + identity_fakes.user_id, + identity_fakes.user_id, + ), + ) self.assertEqual(datalist, tuple(data)) class TestTrustShow(TestTrust): - def setUp(self): super(TestTrustShow, self).setUp() @@ -358,8 +392,15 @@ class TestTrustShow(TestTrust): self.trusts_mock.get.assert_called_with(identity_fakes.trust_id) - collist = ('expires_at', 'id', 'impersonation', 'project_id', - 'roles', 'trustee_user_id', 'trustor_user_id') + collist = ( + 'expires_at', + 'id', + 'impersonation', + 'project_id', + 'roles', + 'trustee_user_id', + 'trustor_user_id', + ) self.assertEqual(collist, columns) datalist = ( identity_fakes.trust_expires, @@ -368,6 +409,6 @@ class TestTrustShow(TestTrust): identity_fakes.project_id, identity_fakes.role_name, identity_fakes.user_id, - identity_fakes.user_id + identity_fakes.user_id, ) self.assertEqual(datalist, data) diff --git a/openstackclient/tests/unit/identity/v3/test_unscoped_saml.py b/openstackclient/tests/unit/identity/v3/test_unscoped_saml.py index 34655263..fcc72bd6 100644 --- a/openstackclient/tests/unit/identity/v3/test_unscoped_saml.py +++ b/openstackclient/tests/unit/identity/v3/test_unscoped_saml.py @@ -18,7 +18,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestUnscopedSAML(identity_fakes.TestFederatedIdentity): - def setUp(self): super(TestUnscopedSAML, self).setUp() @@ -30,7 +29,6 @@ class TestUnscopedSAML(identity_fakes.TestFederatedIdentity): class TestDomainList(TestUnscopedSAML): - def setUp(self): super(TestDomainList, self).setUp() @@ -59,17 +57,18 @@ class TestDomainList(TestUnscopedSAML): collist = ('ID', 'Enabled', 'Name', 'Description') self.assertEqual(collist, columns) - datalist = (( - identity_fakes.domain_id, - True, - identity_fakes.domain_name, - identity_fakes.domain_description, - ), ) + datalist = ( + ( + identity_fakes.domain_id, + True, + identity_fakes.domain_name, + identity_fakes.domain_description, + ), + ) self.assertEqual(datalist, tuple(data)) class TestProjectList(TestUnscopedSAML): - def setUp(self): super(TestProjectList, self).setUp() @@ -98,10 +97,12 @@ class TestProjectList(TestUnscopedSAML): collist = ('ID', 'Domain ID', 'Enabled', 'Name') self.assertEqual(collist, columns) - datalist = (( - identity_fakes.project_id, - identity_fakes.domain_id, - True, - identity_fakes.project_name, - ), ) + datalist = ( + ( + identity_fakes.project_id, + identity_fakes.domain_id, + True, + identity_fakes.project_name, + ), + ) self.assertEqual(datalist, tuple(data)) diff --git a/openstackclient/tests/unit/identity/v3/test_user.py b/openstackclient/tests/unit/identity/v3/test_user.py index c71435ba..15ebd67e 100644 --- a/openstackclient/tests/unit/identity/v3/test_user.py +++ b/openstackclient/tests/unit/identity/v3/test_user.py @@ -25,7 +25,6 @@ from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes class TestUser(identity_fakes.TestIdentityv3): - def setUp(self): super(TestUser, self).setUp() @@ -46,13 +45,13 @@ class TestUser(identity_fakes.TestIdentityv3): self.users_mock.reset_mock() # Shortcut for RoleAssignmentManager Mock - self.role_assignments_mock = self.app.client_manager.identity.\ - role_assignments + self.role_assignments_mock = ( + self.app.client_manager.identity.role_assignments + ) self.role_assignments_mock.reset_mock() class TestUserCreate(TestUser): - domain = identity_fakes.FakeDomain.create_one_domain() project = identity_fakes.FakeProject.create_one_project() @@ -69,8 +68,10 @@ class TestUserCreate(TestUser): super(TestUserCreate, self).setUp() self.user = identity_fakes.FakeUser.create_one_user( - attrs={'domain_id': self.domain.id, - 'default_project_id': self.project.id} + attrs={ + 'domain_id': self.domain.id, + 'default_project_id': self.project.id, + } ) self.datalist = ( self.project.id, @@ -118,16 +119,15 @@ class TestUserCreate(TestUser): # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_user_create_password(self): arglist = [ - '--password', 'secret', + '--password', + 'secret', self.user.name, ] verifylist = [ @@ -157,9 +157,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -198,16 +196,15 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_user_create_email(self): arglist = [ - '--email', 'barney@example.com', + '--email', + 'barney@example.com', self.user.name, ] verifylist = [ @@ -236,16 +233,15 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_user_create_project(self): arglist = [ - '--project', self.project.name, + '--project', + self.project.name, self.user.name, ] verifylist = [ @@ -274,9 +270,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) datalist = ( @@ -291,8 +285,10 @@ class TestUserCreate(TestUser): def test_user_create_project_domain(self): arglist = [ - '--project', self.project.name, - '--project-domain', self.project.domain_id, + '--project', + self.project.name, + '--project-domain', + self.project.domain_id, self.user.name, ] verifylist = [ @@ -322,9 +318,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) datalist = ( @@ -339,7 +333,8 @@ class TestUserCreate(TestUser): def test_user_create_domain(self): arglist = [ - '--domain', self.domain.name, + '--domain', + self.domain.name, self.user.name, ] verifylist = [ @@ -368,9 +363,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -405,9 +398,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -441,9 +432,7 @@ class TestUserCreate(TestUser): 'password': None, } # users.create(name=, password, email, tenant_id=None, enabled=True) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -478,9 +467,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -516,9 +503,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -554,9 +539,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -592,9 +575,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -630,9 +611,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -668,9 +647,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -706,9 +683,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -744,9 +719,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -782,9 +755,7 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -820,22 +791,24 @@ class TestUserCreate(TestUser): } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) def test_user_create_option_with_multi_factor_auth_rule(self): arglist = [ - '--multi-factor-auth-rule', identity_fakes.mfa_opt1, - '--multi-factor-auth-rule', identity_fakes.mfa_opt2, + '--multi-factor-auth-rule', + identity_fakes.mfa_opt1, + '--multi-factor-auth-rule', + identity_fakes.mfa_opt2, self.user.name, ] verifylist = [ - ('multi_factor_auth_rule', [identity_fakes.mfa_opt1, - identity_fakes.mfa_opt2]), + ( + 'multi_factor_auth_rule', + [identity_fakes.mfa_opt1, identity_fakes.mfa_opt2], + ), ('enable', False), ('disable', False), ('name', self.user.name), @@ -855,15 +828,14 @@ class TestUserCreate(TestUser): 'domain': None, 'email': None, 'enabled': True, - 'options': {'multi_factor_auth_rules': [["password", "totp"], - ["password"]]}, + 'options': { + 'multi_factor_auth_rules': [["password", "totp"], ["password"]] + }, 'password': None, } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) @@ -872,7 +844,8 @@ class TestUserCreate(TestUser): arglist = [ '--ignore-password-expiry', '--disable-multi-factor-auth', - '--multi-factor-auth-rule', identity_fakes.mfa_opt1, + '--multi-factor-auth-rule', + identity_fakes.mfa_opt1, self.user.name, ] verifylist = [ @@ -898,23 +871,22 @@ class TestUserCreate(TestUser): 'domain': None, 'email': None, 'enabled': True, - 'options': {'ignore_password_expiry': True, - 'multi_factor_auth_enabled': False, - 'multi_factor_auth_rules': [["password", "totp"]]}, + 'options': { + 'ignore_password_expiry': True, + 'multi_factor_auth_enabled': False, + 'multi_factor_auth_rules': [["password", "totp"]], + }, 'password': None, } # UserManager.create(name=, domain=, project=, password=, email=, # description=, enabled=, default_project=) - self.users_mock.create.assert_called_with( - **kwargs - ) + self.users_mock.create.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, data) class TestUserDelete(TestUser): - user = identity_fakes.FakeUser.create_one_user() def setUp(self): @@ -945,8 +917,7 @@ class TestUserDelete(TestUser): @mock.patch.object(utils, 'find_resource') def test_delete_multi_users_with_exception(self, find_mock): - find_mock.side_effect = [self.user, - exceptions.CommandError] + find_mock.side_effect = [self.user, exceptions.CommandError] arglist = [ self.user.id, 'unexist_user', @@ -960,8 +931,7 @@ class TestUserDelete(TestUser): self.cmd.take_action(parsed_args) self.fail('CommandError should be raised.') except exceptions.CommandError as e: - self.assertEqual('1 of 2 users failed to delete.', - str(e)) + self.assertEqual('1 of 2 users failed to delete.', str(e)) find_mock.assert_any_call(self.users_mock, self.user.id) find_mock.assert_any_call(self.users_mock, 'unexist_user') @@ -971,22 +941,19 @@ class TestUserDelete(TestUser): class TestUserList(TestUser): - domain = identity_fakes.FakeDomain.create_one_domain() project = identity_fakes.FakeProject.create_one_project() user = identity_fakes.FakeUser.create_one_user( - attrs={'domain_id': domain.id, - 'default_project_id': project.id} + attrs={'domain_id': domain.id, 'default_project_id': project.id} ) group = identity_fakes.FakeGroup.create_one_group() role_assignment = ( identity_fakes.FakeRoleAssignment.create_one_role_assignment( - attrs={'user': {'id': user.id}})) + attrs={'user': {'id': user.id}} + ) + ) - columns = [ - 'ID', - 'Name' - ] + columns = ['ID', 'Name'] datalist = ( ( user.id, @@ -1023,16 +990,15 @@ class TestUserList(TestUser): 'group': None, } - self.users_mock.list.assert_called_with( - **kwargs - ) + self.users_mock.list.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, tuple(data)) def test_user_list_domain(self): arglist = [ - '--domain', self.domain.id, + '--domain', + self.domain.id, ] verifylist = [ ('domain', self.domain.id), @@ -1050,16 +1016,15 @@ class TestUserList(TestUser): 'group': None, } - self.users_mock.list.assert_called_with( - **kwargs - ) + self.users_mock.list.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, tuple(data)) def test_user_list_group(self): arglist = [ - '--group', self.group.name, + '--group', + self.group.name, ] verifylist = [ ('group', self.group.name), @@ -1077,9 +1042,7 @@ class TestUserList(TestUser): 'group': self.group.id, } - self.users_mock.list.assert_called_with( - **kwargs - ) + self.users_mock.list.assert_called_with(**kwargs) self.assertEqual(self.columns, columns) self.assertEqual(self.datalist, tuple(data)) @@ -1104,9 +1067,7 @@ class TestUserList(TestUser): 'group': None, } - self.users_mock.list.assert_called_with( - **kwargs - ) + self.users_mock.list.assert_called_with(**kwargs) collist = [ 'ID', @@ -1133,7 +1094,8 @@ class TestUserList(TestUser): def test_user_list_project(self): arglist = [ - '--project', self.project.name, + '--project', + self.project.name, ] verifylist = [ ('project', self.project.name), @@ -1157,15 +1119,13 @@ class TestUserList(TestUser): class TestUserSet(TestUser): - project = identity_fakes.FakeProject.create_one_project() domain = identity_fakes.FakeDomain.create_one_domain() user = identity_fakes.FakeUser.create_one_user( attrs={'default_project_id': project.id} ) user2 = identity_fakes.FakeUser.create_one_user( - attrs={'default_project_id': project.id, - 'domain_id': domain.id} + attrs={'default_project_id': project.id, 'domain_id': domain.id} ) def setUp(self): @@ -1199,7 +1159,8 @@ class TestUserSet(TestUser): def test_user_set_name(self): arglist = [ - '--name', 'qwerty', + '--name', + 'qwerty', self.user.name, ] verifylist = [ @@ -1222,17 +1183,16 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_specify_domain(self): arglist = [ - '--name', 'qwerty', - '--domain', self.domain.id, - self.user2.name + '--name', + 'qwerty', + '--domain', + self.domain.id, + self.user2.name, ] verifylist = [ ('name', 'qwerty'), @@ -1248,20 +1208,15 @@ class TestUserSet(TestUser): result = self.cmd.take_action(parsed_args) - kwargs = { - 'enabled': True, - 'name': 'qwerty' - } + kwargs = {'enabled': True, 'name': 'qwerty'} - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_password(self): arglist = [ - '--password', 'secret', + '--password', + 'secret', self.user.name, ] verifylist = [ @@ -1285,10 +1240,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_password_prompt(self): @@ -1320,15 +1272,13 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_email(self): arglist = [ - '--email', 'barney@example.com', + '--email', + 'barney@example.com', self.user.name, ] verifylist = [ @@ -1351,15 +1301,13 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_project(self): arglist = [ - '--project', self.project.id, + '--project', + self.project.id, self.user.name, ] verifylist = [ @@ -1382,16 +1330,15 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_project_domain(self): arglist = [ - '--project', self.project.id, - '--project-domain', self.project.domain_id, + '--project', + self.project.id, + '--project-domain', + self.project.domain_id, self.user.name, ] verifylist = [ @@ -1415,10 +1362,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_enable(self): @@ -1445,10 +1389,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_disable(self): @@ -1475,10 +1416,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_ignore_lockout_failure_attempts(self): @@ -1506,10 +1444,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_no_ignore_lockout_failure_attempts(self): @@ -1537,10 +1472,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_ignore_password_expiry(self): @@ -1568,10 +1500,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_no_ignore_password_expiry(self): @@ -1599,10 +1528,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_ignore_change_password_upon_first_use(self): @@ -1630,10 +1556,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_no_ignore_change_password_upon_first_use(self): @@ -1661,10 +1584,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_enable_lock_password(self): @@ -1692,10 +1612,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_disable_lock_password(self): @@ -1723,10 +1640,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_enable_multi_factor_auth(self): @@ -1754,10 +1668,7 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_disable_multi_factor_auth(self): @@ -1785,15 +1696,13 @@ class TestUserSet(TestUser): } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_option_multi_factor_auth_rule(self): arglist = [ - '--multi-factor-auth-rule', identity_fakes.mfa_opt1, + '--multi-factor-auth-rule', + identity_fakes.mfa_opt1, self.user.name, ] verifylist = [ @@ -1812,21 +1721,20 @@ class TestUserSet(TestUser): # Set expected values kwargs = { 'enabled': True, - 'options': {'multi_factor_auth_rules': [["password", "totp"]]}} + 'options': {'multi_factor_auth_rules': [["password", "totp"]]}, + } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) def test_user_set_with_multiple_options(self): arglist = [ '--ignore-password-expiry', '--enable-multi-factor-auth', - '--multi-factor-auth-rule', identity_fakes.mfa_opt1, + '--multi-factor-auth-rule', + identity_fakes.mfa_opt1, self.user.name, ] verifylist = [ @@ -1847,21 +1755,20 @@ class TestUserSet(TestUser): # Set expected values kwargs = { 'enabled': True, - 'options': {'ignore_password_expiry': True, - 'multi_factor_auth_enabled': True, - 'multi_factor_auth_rules': [["password", "totp"]]}} + 'options': { + 'ignore_password_expiry': True, + 'multi_factor_auth_enabled': True, + 'multi_factor_auth_rules': [["password", "totp"]], + }, + } # UserManager.update(user, name=, domain=, project=, password=, # email=, description=, enabled=, default_project=) - self.users_mock.update.assert_called_with( - self.user.id, - **kwargs - ) + self.users_mock.update.assert_called_with(self.user.id, **kwargs) self.assertIsNone(result) class TestUserSetPassword(TestUser): - def setUp(self): super(TestUserSetPassword, self).setUp() self.cmd = user.SetPasswordUser(self.app, None) @@ -1877,7 +1784,8 @@ class TestUserSetPassword(TestUser): current_pass = 'old_pass' new_pass = 'new_pass' arglist = [ - '--password', new_pass, + '--password', + new_pass, ] verifylist = [ ('password', new_pass), @@ -1911,8 +1819,10 @@ class TestUserSetPassword(TestUser): current_pass = 'old_pass' new_pass = 'new_pass' arglist = [ - '--password', new_pass, - '--original-password', current_pass, + '--password', + new_pass, + '--original-password', + current_pass, ] verifylist = [ ('password', new_pass), @@ -1929,7 +1839,6 @@ class TestUserSetPassword(TestUser): class TestUserShow(TestUser): - user = identity_fakes.FakeUser.create_one_user() def setUp(self): @@ -1939,17 +1848,18 @@ class TestUserShow(TestUser): # Get the command object to test self.cmd = user.ShowUser(self.app, None) - self.app.client_manager.identity.auth.client.get_user_id.\ - return_value = self.user.id - self.app.client_manager.identity.tokens.get_token_data.return_value = \ - {'token': - {'user': - {'domain': {'id': self.user.domain_id}, - 'id': self.user.id, - 'name': self.user.name, - } - } - } + self.app.client_manager.identity.auth.client.get_user_id.return_value = ( # noqa: E501 + self.user.id + ) + self.app.client_manager.identity.tokens.get_token_data.return_value = { + 'token': { + 'user': { + 'domain': {'id': self.user.domain_id}, + 'id': self.user.id, + 'name': self.user.name, + } + } + } def test_user_show(self): arglist = [ @@ -1967,8 +1877,14 @@ class TestUserShow(TestUser): self.users_mock.get.assert_called_with(self.user.id) - collist = ('default_project_id', 'domain_id', 'email', - 'enabled', 'id', 'name') + collist = ( + 'default_project_id', + 'domain_id', + 'email', + 'enabled', + 'id', + 'name', + ) self.assertEqual(collist, columns) datalist = ( self.user.default_project_id, @@ -1982,11 +1898,13 @@ class TestUserShow(TestUser): def test_user_show_with_domain(self): user = identity_fakes.FakeUser.create_one_user( - {"name": self.user.name}) + {"name": self.user.name} + ) identity_client = self.app.client_manager.identity arglist = [ - "--domain", self.user.domain_id, + "--domain", + self.user.domain_id, user.name, ] verifylist = [ @@ -1995,13 +1913,14 @@ class TestUserShow(TestUser): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - user_str = common._get_token_resource(identity_client, 'user', - parsed_args.user, - parsed_args.domain) + user_str = common._get_token_resource( + identity_client, 'user', parsed_args.user, parsed_args.domain + ) self.assertEqual(self.user.id, user_str) arglist = [ - "--domain", user.domain_id, + "--domain", + user.domain_id, user.name, ] verifylist = [ @@ -2010,7 +1929,7 @@ class TestUserShow(TestUser): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - user_str = common._get_token_resource(identity_client, 'user', - parsed_args.user, - parsed_args.domain) + user_str = common._get_token_resource( + identity_client, 'user', parsed_args.user, parsed_args.domain + ) self.assertEqual(user.name, user_str) -- cgit v1.2.1