From e491d0dc847e4f90ccfd74b0e0f5f4801314176e Mon Sep 17 00:00:00 2001 From: Steve Martinelli Date: Wed, 25 Feb 2015 01:58:58 -0500 Subject: [PATCH] Federation Service Providers CRUD operations Implement CRUD operations for Service Providers used in K2K. Implements: bp k2k-service-providers Change-Id: I514c64d2a412d12cff922a02c575f1764a1a23ae --- .../tests/unit/v3/test_federation.py | 70 ++++++++++++ keystoneclient/v3/contrib/federation/core.py | 2 + .../contrib/federation/service_providers.py | 104 ++++++++++++++++++ 3 files changed, 176 insertions(+) create mode 100644 keystoneclient/v3/contrib/federation/service_providers.py diff --git a/keystoneclient/tests/unit/v3/test_federation.py b/keystoneclient/tests/unit/v3/test_federation.py index 19ec44f55..2a4abc4ef 100644 --- a/keystoneclient/tests/unit/v3/test_federation.py +++ b/keystoneclient/tests/unit/v3/test_federation.py @@ -21,6 +21,7 @@ from keystoneclient.v3.contrib.federation import base from keystoneclient.v3.contrib.federation import identity_providers from keystoneclient.v3.contrib.federation import mappings from keystoneclient.v3.contrib.federation import protocols +from keystoneclient.v3.contrib.federation import service_providers from keystoneclient.v3 import domains from keystoneclient.v3 import projects @@ -407,3 +408,72 @@ class FederatedTokenTests(utils.TestCase): def test_get_user_domain_id(self): """Ensure a federated user's domain ID does not exist.""" self.assertIsNone(self.federated_token.user_domain_id) + + +class ServiceProviderTests(utils.TestCase, utils.CrudTests): + def setUp(self): + super(ServiceProviderTests, self).setUp() + self.key = 'service_provider' + self.collection_key = 'service_providers' + self.model = service_providers.ServiceProvider + self.manager = self.client.federation.service_providers + self.path_prefix = 'OS-FEDERATION' + + def new_ref(self, **kwargs): + kwargs.setdefault('auth_url', uuid.uuid4().hex) + kwargs.setdefault('description', uuid.uuid4().hex) + kwargs.setdefault('enabled', True) + kwargs.setdefault('id', uuid.uuid4().hex) + kwargs.setdefault('sp_url', uuid.uuid4().hex) + return kwargs + + def test_positional_parameters_expect_fail(self): + """Ensure CrudManager raises TypeError exceptions. + + After passing wrong number of positional arguments + an exception should be raised. + + Operations to be tested: + * create() + * get() + * list() + * delete() + * update() + + """ + POS_PARAM_1 = uuid.uuid4().hex + POS_PARAM_2 = uuid.uuid4().hex + POS_PARAM_3 = uuid.uuid4().hex + + PARAMETERS = { + 'create': (POS_PARAM_1, POS_PARAM_2), + 'get': (POS_PARAM_1, POS_PARAM_2), + 'list': (POS_PARAM_1, POS_PARAM_2), + 'update': (POS_PARAM_1, POS_PARAM_2, POS_PARAM_3), + 'delete': (POS_PARAM_1, POS_PARAM_2) + } + + for f_name, args in PARAMETERS.items(): + self.assertRaises(TypeError, getattr(self.manager, f_name), + *args) + + def test_create(self): + ref = self.new_ref() + + # req_ref argument allows you to specify a different + # signature for the request when the manager does some + # conversion before doing the request (e.g. converting + # from datetime object to timestamp string) + req_ref = ref.copy() + req_ref.pop('id') + + self.stub_entity('PUT', entity=ref, id=ref['id'], status_code=201) + + returned = self.manager.create(**ref) + self.assertIsInstance(returned, self.model) + for attr in req_ref: + self.assertEqual( + getattr(returned, attr), + req_ref[attr], + 'Expected different %s' % attr) + self.assertEntityRequestBodyIs(req_ref) diff --git a/keystoneclient/v3/contrib/federation/core.py b/keystoneclient/v3/contrib/federation/core.py index 76c5dc75d..b8074606b 100644 --- a/keystoneclient/v3/contrib/federation/core.py +++ b/keystoneclient/v3/contrib/federation/core.py @@ -15,6 +15,7 @@ from keystoneclient.v3.contrib.federation import identity_providers from keystoneclient.v3.contrib.federation import mappings from keystoneclient.v3.contrib.federation import projects from keystoneclient.v3.contrib.federation import protocols +from keystoneclient.v3.contrib.federation import service_providers class FederationManager(object): @@ -25,3 +26,4 @@ class FederationManager(object): self.protocols = protocols.ProtocolManager(api) self.projects = projects.ProjectManager(api) self.domains = domains.DomainManager(api) + self.service_providers = service_providers.ServiceProviderManager(api) diff --git a/keystoneclient/v3/contrib/federation/service_providers.py b/keystoneclient/v3/contrib/federation/service_providers.py new file mode 100644 index 000000000..a4192956b --- /dev/null +++ b/keystoneclient/v3/contrib/federation/service_providers.py @@ -0,0 +1,104 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from keystoneclient import base +from keystoneclient import utils + + +class ServiceProvider(base.Resource): + """Object representing Service Provider container + + Attributes: + * id: user-defined unique string identifying Service Provider. + * sp_url: the shibboleth endpoint of a Service Provider. + * auth_url: the authentication url of Service Provider. + + """ + pass + + +class ServiceProviderManager(base.CrudManager): + """Manager class for manipulating Service Providers.""" + + resource_class = ServiceProvider + collection_key = 'service_providers' + key = 'service_provider' + base_url = 'OS-FEDERATION' + + def _build_url_and_put(self, **kwargs): + url = self.build_url(dict_args_in_out=kwargs) + body = {self.key: kwargs} + return self._update(url, body=body, response_key=self.key, + method='PUT') + + @utils.positional.method(0) + def create(self, id, **kwargs): + """Create Service Provider object. + + Utilize Keystone URI: + ``PUT /OS-FEDERATION/service_providers/{id}`` + + :param id: unique id of the service provider. + + """ + return self._build_url_and_put(service_provider_id=id, + **kwargs) + + def get(self, service_provider): + """Fetch Service Provider object + + Utilize Keystone URI: + ``GET /OS-FEDERATION/service_providers/{id}`` + + :param service_provider: an object with service_provider_id + stored inside. + + """ + return super(ServiceProviderManager, self).get( + service_provider_id=base.getid(service_provider)) + + def list(self, **kwargs): + """List all Service Providers. + + Utilize Keystone URI: + ``GET /OS-FEDERATION/service_providers`` + + """ + return super(ServiceProviderManager, self).list(**kwargs) + + def update(self, service_provider, **kwargs): + """Update the existing Service Provider object on the server. + + Only properties provided to the function are being updated. + + Utilize Keystone URI: + ``PATCH /OS-FEDERATION/service_providers/{id}`` + + :param service_provider: an object with service_provider_id + stored inside. + + """ + return super(ServiceProviderManager, self).update( + service_provider_id=base.getid(service_provider), **kwargs) + + def delete(self, service_provider): + """Delete Service Provider object. + + Utilize Keystone URI: + ``DELETE /OS-FEDERATION/service_providers/{id}`` + + :param service_provider: an object with service_provider_id + stored inside. + + """ + return super(ServiceProviderManager, self).delete( + service_provider_id=base.getid(service_provider))