From cedaff450c5784649727b058908e02fe90e2c5f9 Mon Sep 17 00:00:00 2001 From: Brian Curtin Date: Fri, 17 Apr 2015 10:35:11 -0500 Subject: [PATCH] Apply delete changes to identity proxies Change-Id: I60e6e70d71720a2c5b82c33c6867597bc74863f8 --- openstack/identity/v2/_proxy.py | 48 ++++++- openstack/identity/v3/_proxy.py | 128 +++++++++++++++--- .../tests/unit/identity/v2/test_proxy.py | 21 ++- .../tests/unit/identity/v3/test_proxy.py | 61 ++++++--- 4 files changed, 213 insertions(+), 45 deletions(-) diff --git a/openstack/identity/v2/_proxy.py b/openstack/identity/v2/_proxy.py index ff107cfc..5c096cc6 100644 --- a/openstack/identity/v2/_proxy.py +++ b/openstack/identity/v2/_proxy.py @@ -21,8 +21,20 @@ class Proxy(proxy.BaseProxy): def create_role(self, **data): return role.Role(data).create(self.session) - def delete_role(self, **data): - role.Role(data).delete(self.session) + def delete_role(self, value, ignore_missing=True): + """Delete a role + + :param value: The value can be either the ID of a role or a + :class:`~openstack.identity.v2.role.Role` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the role does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(role.Role, value, ignore_missing) def find_role(self, name_or_id): return role.Role.find(self.session, name_or_id) @@ -39,8 +51,20 @@ class Proxy(proxy.BaseProxy): def create_tenant(self, **data): return tenant.Tenant(data).create(self.session) - def delete_tenant(self, **data): - tenant.Tenant(data).delete(self.session) + def delete_tenant(self, value, ignore_missing=True): + """Delete a tenant + + :param value: The value can be either the ID of a tenant or a + :class:`~openstack.identity.v2.tenant.Tenant` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the tenant does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(tenant.Tenant, value, ignore_missing) def find_tenant(self, name_or_id): return tenant.Tenant.find(self.session, name_or_id) @@ -57,8 +81,20 @@ class Proxy(proxy.BaseProxy): def create_user(self, **data): return user.User(data).create(self.session) - def delete_user(self, **data): - user.User(data).delete(self.session) + def delete_user(self, value, ignore_missing=True): + """Delete a user + + :param value: The value can be either the ID of a user or a + :class:`~openstack.identity.v2.user.User` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the user does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(user.User, value, ignore_missing) def find_user(self, name_or_id): return user.User.find(self.session, name_or_id) diff --git a/openstack/identity/v3/_proxy.py b/openstack/identity/v3/_proxy.py index c9f4da96..8a3a272e 100644 --- a/openstack/identity/v3/_proxy.py +++ b/openstack/identity/v3/_proxy.py @@ -26,8 +26,20 @@ class Proxy(proxy.BaseProxy): def create_credential(self, **data): return credential.Credential(data).create(self.session) - def delete_credential(self, **data): - credential.Credential(data).delete(self.session) + def delete_credential(self, value, ignore_missing=True): + """Delete a credential + + :param value: The value can be either the ID of a credential or a + :class:`~openstack.identity.v3.credential.Credential` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the credential does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(credential.Credential, value, ignore_missing) def find_credential(self, name_or_id): return credential.Credential.find(self.session, name_or_id) @@ -44,8 +56,20 @@ class Proxy(proxy.BaseProxy): def create_domain(self, **data): return domain.Domain(data).create(self.session) - def delete_domain(self, **data): - domain.Domain(data).delete(self.session) + def delete_domain(self, value, ignore_missing=True): + """Delete a domain + + :param value: The value can be either the ID of a domain or a + :class:`~openstack.identity.v3.domain.Domain` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the domain does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(domain.Domain, value, ignore_missing) def find_domain(self, name_or_id): return domain.Domain.find(self.session, name_or_id) @@ -62,8 +86,20 @@ class Proxy(proxy.BaseProxy): def create_endpoint(self, **data): return endpoint.Endpoint(data).create(self.session) - def delete_endpoint(self, **data): - endpoint.Endpoint(data).delete(self.session) + def delete_endpoint(self, value, ignore_missing=True): + """Delete an endpoint + + :param value: The value can be either the ID of an endpoint or a + :class:`~openstack.identity.v3.endpoint.Endpoint` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the endpoint does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(endpoint.Endpoint, value, ignore_missing) def find_endpoint(self, name_or_id): return endpoint.Endpoint.find(self.session, name_or_id) @@ -80,8 +116,20 @@ class Proxy(proxy.BaseProxy): def create_group(self, **data): return group.Group(data).create(self.session) - def delete_group(self, **data): - group.Group(data).delete(self.session) + def delete_group(self, value, ignore_missing=True): + """Delete a group + + :param value: The value can be either the ID of a group or a + :class:`~openstack.identity.v3.group.Group` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the group does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(group.Group, value, ignore_missing) def find_group(self, name_or_id): return group.Group.find(self.session, name_or_id) @@ -98,8 +146,20 @@ class Proxy(proxy.BaseProxy): def create_policy(self, **data): return policy.Policy(data).create(self.session) - def delete_policy(self, **data): - policy.Policy(data).delete(self.session) + def delete_policy(self, value, ignore_missing=True): + """Delete a policy + + :param value: The value can be either the ID of a policy or a + :class:`~openstack.identity.v3.policy.Policy` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the policy does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(policy.Policy, value, ignore_missing) def find_policy(self, name_or_id): return policy.Policy.find(self.session, name_or_id) @@ -116,8 +176,20 @@ class Proxy(proxy.BaseProxy): def create_project(self, **data): return project.Project(data).create(self.session) - def delete_project(self, **data): - project.Project(data).delete(self.session) + def delete_project(self, value, ignore_missing=True): + """Delete a project + + :param value: The value can be either the ID of a project or a + :class:`~openstack.identity.v3.project.Project` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the project does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(project.Project, value, ignore_missing) def find_project(self, name_or_id): return project.Project.find(self.session, name_or_id) @@ -134,8 +206,20 @@ class Proxy(proxy.BaseProxy): def create_service(self, **data): return service.Service(data).create(self.session) - def delete_service(self, **data): - service.Service(data).delete(self.session) + def delete_service(self, value, ignore_missing=True): + """Delete a service + + :param value: The value can be either the ID of a service or a + :class:`~openstack.identity.v3.service.Service` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the service does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(service.Service, value, ignore_missing) def find_service(self, name_or_id): return service.Service.find(self.session, name_or_id) @@ -152,8 +236,20 @@ class Proxy(proxy.BaseProxy): def create_user(self, **data): return user.User(data).create(self.session) - def delete_user(self, **data): - user.User(data).delete(self.session) + def delete_user(self, value, ignore_missing=True): + """Delete a user + + :param value: The value can be either the ID of a user or a + :class:`~openstack.identity.v3.user.User` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the user does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(user.User, value, ignore_missing) def find_user(self, name_or_id): return user.User.find(self.session, name_or_id) diff --git a/openstack/tests/unit/identity/v2/test_proxy.py b/openstack/tests/unit/identity/v2/test_proxy.py index 90413b0b..2c23d7fb 100644 --- a/openstack/tests/unit/identity/v2/test_proxy.py +++ b/openstack/tests/unit/identity/v2/test_proxy.py @@ -11,6 +11,9 @@ # under the License. from openstack.identity.v2 import _proxy +from openstack.identity.v2 import role +from openstack.identity.v2 import tenant +from openstack.identity.v2 import user from openstack.tests.unit import test_proxy_base @@ -24,8 +27,10 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_role) def test_role_delete(self): - self.verify_delete('openstack.identity.v2.role.Role.delete', - self.proxy.delete_role) + self.verify_delete2(role.Role, self.proxy.delete_role, False) + + def test_role_delete_ignore(self): + self.verify_delete2(role.Role, self.proxy.delete_role, True) def test_role_find(self): self.verify_find('openstack.identity.v2.role.Role.find', @@ -48,8 +53,10 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_tenant) def test_tenant_delete(self): - self.verify_delete('openstack.identity.v2.tenant.Tenant.delete', - self.proxy.delete_tenant) + self.verify_delete2(tenant.Tenant, self.proxy.delete_tenant, False) + + def test_tenant_delete_ignore(self): + self.verify_delete2(tenant.Tenant, self.proxy.delete_tenant, True) def test_tenant_find(self): self.verify_find('openstack.identity.v2.tenant.Tenant.find', @@ -72,8 +79,10 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_user) def test_user_delete(self): - self.verify_delete('openstack.identity.v2.user.User.delete', - self.proxy.delete_user) + self.verify_delete2(user.User, self.proxy.delete_user, False) + + def test_user_delete_ignore(self): + self.verify_delete2(user.User, self.proxy.delete_user, True) def test_user_find(self): self.verify_find('openstack.identity.v2.user.User.find', diff --git a/openstack/tests/unit/identity/v3/test_proxy.py b/openstack/tests/unit/identity/v3/test_proxy.py index 7917c2c2..b556f56f 100644 --- a/openstack/tests/unit/identity/v3/test_proxy.py +++ b/openstack/tests/unit/identity/v3/test_proxy.py @@ -11,6 +11,14 @@ # under the License. from openstack.identity.v3 import _proxy +from openstack.identity.v3 import credential +from openstack.identity.v3 import domain +from openstack.identity.v3 import endpoint +from openstack.identity.v3 import group +from openstack.identity.v3 import policy +from openstack.identity.v3 import project +from openstack.identity.v3 import service +from openstack.identity.v3 import user from openstack.tests.unit import test_proxy_base @@ -25,9 +33,12 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_credential) def test_credential_delete(self): - self.verify_delete( - 'openstack.identity.v3.credential.Credential.delete', - self.proxy.delete_credential) + self.verify_delete2(credential.Credential, + self.proxy.delete_credential, False) + + def test_credential_delete_ignore(self): + self.verify_delete2(credential.Credential, + self.proxy.delete_credential, True) def test_credential_find(self): self.verify_find('openstack.identity.v3.credential.Credential.find', @@ -51,8 +62,10 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_domain) def test_domain_delete(self): - self.verify_delete('openstack.identity.v3.domain.Domain.delete', - self.proxy.delete_domain) + self.verify_delete2(domain.Domain, self.proxy.delete_domain, False) + + def test_domain_delete_ignore(self): + self.verify_delete2(domain.Domain, self.proxy.delete_domain, True) def test_domain_find(self): self.verify_find('openstack.identity.v3.domain.Domain.find', @@ -75,8 +88,12 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_endpoint) def test_endpoint_delete(self): - self.verify_delete('openstack.identity.v3.endpoint.Endpoint.delete', - self.proxy.delete_endpoint) + self.verify_delete2(endpoint.Endpoint, self.proxy.delete_endpoint, + False) + + def test_endpoint_delete_ignore(self): + self.verify_delete2(endpoint.Endpoint, self.proxy.delete_endpoint, + True) def test_endpoint_find(self): self.verify_find('openstack.identity.v3.endpoint.Endpoint.find', @@ -99,8 +116,10 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_group) def test_group_delete(self): - self.verify_delete('openstack.identity.v3.group.Group.delete', - self.proxy.delete_group) + self.verify_delete2(group.Group, self.proxy.delete_group, False) + + def test_group_delete_ignore(self): + self.verify_delete2(group.Group, self.proxy.delete_group, True) def test_group_find(self): self.verify_find('openstack.identity.v3.group.Group.find', @@ -123,8 +142,10 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_policy) def test_policy_delete(self): - self.verify_delete('openstack.identity.v3.policy.Policy.delete', - self.proxy.delete_policy) + self.verify_delete2(policy.Policy, self.proxy.delete_policy, False) + + def test_policy_delete_ignore(self): + self.verify_delete2(policy.Policy, self.proxy.delete_policy, True) def test_policy_find(self): self.verify_find('openstack.identity.v3.policy.Policy.find', @@ -147,8 +168,10 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_project) def test_project_delete(self): - self.verify_delete('openstack.identity.v3.project.Project.delete', - self.proxy.delete_project) + self.verify_delete2(project.Project, self.proxy.delete_project, False) + + def test_project_delete_ignore(self): + self.verify_delete2(project.Project, self.proxy.delete_project, True) def test_project_find(self): self.verify_find('openstack.identity.v3.project.Project.find', @@ -171,8 +194,10 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_service) def test_service_delete(self): - self.verify_delete('openstack.identity.v3.service.Service.delete', - self.proxy.delete_service) + self.verify_delete2(service.Service, self.proxy.delete_service, False) + + def test_service_delete_ignore(self): + self.verify_delete2(service.Service, self.proxy.delete_service, True) def test_service_find(self): self.verify_find('openstack.identity.v3.service.Service.find', @@ -195,8 +220,10 @@ class TestIdentityProxy(test_proxy_base.TestProxyBase): self.proxy.create_user) def test_user_delete(self): - self.verify_delete('openstack.identity.v3.user.User.delete', - self.proxy.delete_user) + self.verify_delete2(user.User, self.proxy.delete_user, False) + + def test_user_delete_ignore(self): + self.verify_delete2(user.User, self.proxy.delete_user, True) def test_user_find(self): self.verify_find('openstack.identity.v3.user.User.find',