From 7631da24252646c8f6165dceee9e3c2989ceeb6c Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Mon, 17 Sep 2018 13:32:38 -0400 Subject: [PATCH] Add barbican scenarios Added code to test barbican scenarios. These scenarios include the following: - create and delete secret - create and get secret - create and list secret - create secret - list secrets Also add the assoicated zuul and rally-jobs for openstack CI test infrastructure. Change-Id: I378666e026200c020cd8d25ebb5b669644c4a364 Signed-off-by: Chuck Short --- .zuul.d/rally-task-barbican.yaml | 27 +++++ .zuul.d/zuul.yaml | 2 + CHANGELOG.rst | 1 + rally-jobs/barbican.yaml | 75 +++++++++++++ rally_openstack/cleanup/resources.py | 20 ++++ rally_openstack/consts.py | 3 + rally_openstack/scenarios/barbican/secrets.py | 105 ++++++++++++++++++ .../services/key_manager/__init__.py | 0 .../services/key_manager/barbican.py | 49 ++++++++ requirements.txt | 1 + .../barbican/create-and-delete-secret.json | 22 ++++ .../barbican/create-and-delete-secret.yaml | 15 +++ .../barbican/create-and-get-secret.json | 22 ++++ .../barbican/create-and-get-secret.yaml | 15 +++ .../barbican/create-and-list-secret.json | 22 ++++ .../barbican/create-and-list-secret.yaml | 15 +++ .../scenarios/barbican/create-secret.json | 22 ++++ .../scenarios/barbican/create-secret.yaml | 15 +++ .../tasks/scenarios/barbican/get-secret.json | 22 ++++ .../tasks/scenarios/barbican/get-secret.yaml | 15 +++ .../scenarios/barbican/list-secrets.json | 22 ++++ .../scenarios/barbican/list-secrets.yaml | 15 +++ tests/unit/cleanup/test_resources.py | 29 +++++ tests/unit/fakes.py | 8 ++ tests/unit/scenarios/barbican/test_secrets.py | 99 +++++++++++++++++ tests/unit/scenarios/barbican/test_utils.py | 47 ++++++++ tests/unit/services/barbican/__init__.py | 0 tests/unit/services/barbican/test_secrets.py | 62 +++++++++++ upper-constraints.txt | 1 + 29 files changed, 751 insertions(+) create mode 100644 .zuul.d/rally-task-barbican.yaml create mode 100644 rally-jobs/barbican.yaml create mode 100644 rally_openstack/scenarios/barbican/secrets.py create mode 100644 rally_openstack/services/key_manager/__init__.py create mode 100644 rally_openstack/services/key_manager/barbican.py create mode 100644 samples/tasks/scenarios/barbican/create-and-delete-secret.json create mode 100644 samples/tasks/scenarios/barbican/create-and-delete-secret.yaml create mode 100644 samples/tasks/scenarios/barbican/create-and-get-secret.json create mode 100644 samples/tasks/scenarios/barbican/create-and-get-secret.yaml create mode 100644 samples/tasks/scenarios/barbican/create-and-list-secret.json create mode 100644 samples/tasks/scenarios/barbican/create-and-list-secret.yaml create mode 100644 samples/tasks/scenarios/barbican/create-secret.json create mode 100644 samples/tasks/scenarios/barbican/create-secret.yaml create mode 100644 samples/tasks/scenarios/barbican/get-secret.json create mode 100644 samples/tasks/scenarios/barbican/get-secret.yaml create mode 100644 samples/tasks/scenarios/barbican/list-secrets.json create mode 100644 samples/tasks/scenarios/barbican/list-secrets.yaml create mode 100644 tests/unit/scenarios/barbican/test_secrets.py create mode 100644 tests/unit/scenarios/barbican/test_utils.py create mode 100644 tests/unit/services/barbican/__init__.py create mode 100644 tests/unit/services/barbican/test_secrets.py diff --git a/.zuul.d/rally-task-barbican.yaml b/.zuul.d/rally-task-barbican.yaml new file mode 100644 index 00000000..45a75816 --- /dev/null +++ b/.zuul.d/rally-task-barbican.yaml @@ -0,0 +1,27 @@ +- job: + name: rally-task-barbican + parent: rally-task-at-devstack + required-projects: + - name: openstack-dev/devstack + - name: openstack-infra/devstack-gate + - name: openstack/rally + - name: openstack/rally-openstack + - name: openstack/barbican + - name: openstack/python-barbicanclient + vars: + devstack_plugins: + rally-openstack: https://git.openstack.org/openstack/rally-openstack + barbican: https://git.openstack.org/openstack/barbican + devstack_services: + barbican: true + # disable redundant services for the job + ceilometer-acentral: false + ceilometer-acompute: false + ceilometer-alarm-evaluator: false + ceilometer-alarm-notifier: false + ceilometer-anotification: false + ceilometer-api: false + ceilometer-collector: false + horizon: false + tempest: false + rally_task: rally-jobs/barbican.yaml diff --git a/.zuul.d/zuul.yaml b/.zuul.d/zuul.yaml index 11ae5c6a..b586b5a8 100644 --- a/.zuul.d/zuul.yaml +++ b/.zuul.d/zuul.yaml @@ -54,6 +54,8 @@ - rally-task-basic-with-existing-users: # use_existing_users key did not trigger proper ansible tasks voting: false + - rally-task-barbican: + voting: false - rally-task-cinder # NOTE(andreykurilin): this requires more thing to configure before # launching. diff --git a/CHANGELOG.rst b/CHANGELOG.rst index e2d42348..ad97477c 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -23,6 +23,7 @@ Added ~~~~~ * Added neutron trunk scenarios +* Added barbican scenarios. [1.3.0] - 2018-10-08 -------------------- diff --git a/rally-jobs/barbican.yaml b/rally-jobs/barbican.yaml new file mode 100644 index 00000000..0e68ef71 --- /dev/null +++ b/rally-jobs/barbican.yaml @@ -0,0 +1,75 @@ +--- + version: 2 + title: Task for rally-task-barbican-job + description: Testing just one cinder scenario to verify that rally-task-barbican works + subtasks: + - + title: BarbicanSecrets.create_and_delete + workloads: + - + scenario: + BarbicanSecrets.create_and_delete: {} + runner: + constant: + times: 2 + concurrency: 1 + contexts: + users: + tenants: 1 + users_per_tenant: 1 + - + title: BarbicanSecrets.get + workloads: + - + scenario: + BarbicanSecrets.get: {} + runner: + constant: + times: 2 + concurrency: 1 + contexts: + users: + tenants: 1 + users_per_tenant: 1 + - + title: BarbicanSecrets.create_and_list + workloads: + - + scenario: + BarbicanSecrets.create_and_list: {} + runner: + constant: + times: 2 + concurrency: 1 + contexts: + users: + tenants: 1 + users_per_tenant: 1 + - + title: BarbicanSecrets.create + workloads: + - + scenario: + BarbicanSecrets.create: {} + runner: + constant: + times: 2 + concurrency: 1 + contexts: + users: + tenants: 1 + users_per_tenant: 1 + - + title: BarbicanSecrets.list + workloads: + - + scenario: + BarbicanSecrets.list: {} + runner: + constant: + times: 2 + concurrency: 1 + contexts: + users: + tenants: 1 + users_per_tenant: 1 diff --git a/rally_openstack/cleanup/resources.py b/rally_openstack/cleanup/resources.py index 68d5da48..f8f56924 100644 --- a/rally_openstack/cleanup/resources.py +++ b/rally_openstack/cleanup/resources.py @@ -524,6 +524,7 @@ class CinderQos(base.ResourceManager): # MANILA + _manila_order = get_order(450) @@ -814,6 +815,7 @@ class MistralExecutions(SynchronizedDeletion, base.ResourceManager): # MURANO + _murano_order = get_order(1200) @@ -1041,3 +1043,21 @@ class KeystoneEc2(SynchronizedDeletion, base.ResourceManager): def delete(self): self._manager().delete_ec2credential( self.user_id, access=self.raw_resource.access) + +# BARBICAN + + +@base.resource("barbican", "secrets", order=1500, admin_required=True, + perform_for_admin_only=True) +class BarbicanSecrets(base.ResourceManager): + + def id(self): + return self.raw_resource.secret_ref + + def is_deleted(self): + try: + self._manager().get(self.id()) + except Exception: + return True + + return False diff --git a/rally_openstack/consts.py b/rally_openstack/consts.py index efb3ebfd..ca657593 100644 --- a/rally_openstack/consts.py +++ b/rally_openstack/consts.py @@ -67,6 +67,7 @@ class _Service(utils.ImmutableMixin, utils.EnumMixin): GNOCCHI = "gnocchi" MAGNUM = "magnum" WATCHER = "watcher" + BARBICAN = "barbican" class _ServiceType(utils.ImmutableMixin, utils.EnumMixin): @@ -98,6 +99,7 @@ class _ServiceType(utils.ImmutableMixin, utils.EnumMixin): METRIC = "metric" CONTAINER_INFRA = "container-infra" INFRA_OPTIM = "infra-optim" + KEY_MANAGER = "key-manager" def __init__(self): self.__names = { @@ -127,6 +129,7 @@ class _ServiceType(utils.ImmutableMixin, utils.EnumMixin): self.METRIC: _Service.GNOCCHI, self.CONTAINER_INFRA: _Service.MAGNUM, self.INFRA_OPTIM: _Service.WATCHER, + self.KEY_MANAGER: _Service.BARBICAN } def __getitem__(self, service_type): diff --git a/rally_openstack/scenarios/barbican/secrets.py b/rally_openstack/scenarios/barbican/secrets.py new file mode 100644 index 00000000..34661977 --- /dev/null +++ b/rally_openstack/scenarios/barbican/secrets.py @@ -0,0 +1,105 @@ +# Copyright 2018 Red Hat, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from rally.task import validation + +from rally_openstack import consts +from rally_openstack import scenario +from rally_openstack.services.key_manager import barbican + +"""Scenarios for Barbican secrets.""" + + +class BarbicanBase(scenario.OpenStackScenario): + """Base class for Barbican scenarios with basic atomic actions.""" + + def __init__(self, context=None, admin_context=None, clients=None): + super(BarbicanBase, self).__init__(context, admin_context, clients) + if hasattr(self, "_admin_clients"): + self.admin_barbican = barbican.BarbicanService( + self._admin_clients, name_generator=self.generate_random_name, + atomic_inst=self.atomic_actions()) + + +@validation.add("required_services", services=[consts.Service.BARBICAN]) +@validation.add("required_platform", platform="openstack", admin=True) +@scenario.configure(name="BarbicanSecrets.list") +class BarbicanSecretsList(BarbicanBase): + def run(self): + """List secrets.""" + self.admin_barbican.list_secrets() + + +@validation.add("required_services", services=[consts.Service.BARBICAN]) +@validation.add("required_platform", platform="openstack", admin=True) +@scenario.configure(context={"admin_cleanup@openstack": ["barbican"]}, + name="BarbicanSecrets.create") +class BarbicanSecretsCreate(BarbicanBase): + def run(self): + """Create secret.""" + self.admin_barbican.create_secret() + + +@validation.add("required_services", services=[consts.Service.BARBICAN]) +@validation.add("required_platform", platform="openstack", admin=True) +@scenario.configure(context={"admin_cleanup@openstack": ["barbican"]}, + name="BarbicanSecrets.create_and_delete") +class BarbicanSecretsCreateAndDelete(BarbicanBase): + def run(self): + """Create and Delete secret.""" + secret = self.admin_barbican.create_secret() + self.admin_barbican.delete_secret(secret.secret_ref) + + +@validation.add("required_services", services=[consts.Service.BARBICAN]) +@validation.add("required_platform", platform="openstack", admin=True) +@scenario.configure(context={"admin_cleanup@openstack": ["barbican"]}, + name="BarbicanSecrets.create_and_get") +class BarbicanSecretsCreateAndGet(BarbicanBase): + def run(self): + """Create and Get Secret. + + """ + secret = self.admin_barbican.create_secret() + self.assertTrue(secret) + secret_info = self.admin_barbican.get_secret(secret.secret_ref) + self.assertEqual(secret.secret_ref, secret_info.secret_ref) + + +@validation.add("required_services", services=[consts.Service.BARBICAN]) +@validation.add("required_platform", platform="openstack", admin=True) +@scenario.configure(context={"admin_cleanup@openstack": ["barbican"]}, + name="BarbicanSecrets.get") +class BarbicanSecretsGet(BarbicanBase): + def run(self, secret_ref=None): + """Create and Get Secret. + + :param secret_ref: Name of the secret to get + """ + if secret_ref is None: + secret = self.admin_barbican.create_secret() + self.admin_barbican.get_secret(secret.secret_ref) + else: + self.admin_barbican.get_secret(secret_ref) + + +@validation.add("required_services", services=[consts.Service.BARBICAN]) +@validation.add("required_platform", platform="openstack", admin=True) +@scenario.configure(context={"admin_cleanup@openstack": ["barbican"]}, + name="BarbicanSecrets.create_and_list") +class BarbicanSecretsCreateAndList(BarbicanBase): + def run(self): + """Create and then list all secrets.""" + self.admin_barbican.create_secret() + self.admin_barbican.list_secrets() diff --git a/rally_openstack/services/key_manager/__init__.py b/rally_openstack/services/key_manager/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/rally_openstack/services/key_manager/barbican.py b/rally_openstack/services/key_manager/barbican.py new file mode 100644 index 00000000..4fe94acb --- /dev/null +++ b/rally_openstack/services/key_manager/barbican.py @@ -0,0 +1,49 @@ +# Copyright 2018 Red Hat, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from rally.task import atomic +from rally.task import service + + +class BarbicanService(service.Service): + + @atomic.action_timer("barbican.list_secrets") + def list_secrets(self): + """List Secret""" + return self._clients.barbican().secrets.list() + + @atomic.action_timer("barbican.create_secret") + def create_secret(self): + """Create Secret""" + secret_name = self.generate_random_name() + val = self._clients.barbican().secrets.create(name=secret_name, + payload="rally_data") + val.store() + return val + + @atomic.action_timer("barbican.get_secret") + def get_secret(self, secret_ref): + """Get the secret. + + :param secret_name: The name of the secret. + """ + return self._clients.barbican().secrets.get(secret_ref) + + @atomic.action_timer("barbican.delete_secret") + def delete_secret(self, secret_name): + """Delete the secret + + :param secret_name: The name of the secret to delete + """ + return self._clients.barbican().secrets.delete(secret_name) diff --git a/requirements.txt b/requirements.txt index 4d563513..be4607bd 100644 --- a/requirements.txt +++ b/requirements.txt @@ -13,6 +13,7 @@ keystoneauth1>=3.3.0 # Apache Software License kubernetes>1.0.0 # Apache License Version 2.0 os-faults>=0.1.15 # Apache Software License osprofiler>=1.4.0 # Apache Software License +python-barbicanclient>=4.5.2 # Apache Software License python-ceilometerclient>=2.5.0 # Apache Software License python-cinderclient>=3.3.0 # Apache Software License python-designateclient>=2.7.0 # Apache License, Version 2.0 diff --git a/samples/tasks/scenarios/barbican/create-and-delete-secret.json b/samples/tasks/scenarios/barbican/create-and-delete-secret.json new file mode 100644 index 00000000..13836eb2 --- /dev/null +++ b/samples/tasks/scenarios/barbican/create-and-delete-secret.json @@ -0,0 +1,22 @@ +{ + "BarbicanSecrets.create_and_delete": [ + { + "runner": { + "type": "constant", + "times": 2, + "concurrency": 1 + }, + "context": { + "users": { + "tenants": 1, + "users_per_tenant": 1 + } + }, + "sla": { + "failure_rate": { + "max": 0 + } + } + } + ] +} diff --git a/samples/tasks/scenarios/barbican/create-and-delete-secret.yaml b/samples/tasks/scenarios/barbican/create-and-delete-secret.yaml new file mode 100644 index 00000000..c4bb8dee --- /dev/null +++ b/samples/tasks/scenarios/barbican/create-and-delete-secret.yaml @@ -0,0 +1,15 @@ +--- + BarbicanSecrets.create_and_delete: + - + runner: + type: "constant" + times: 2 + concurrency: 1 + context: + users: + tenants: 1 + users_per_tenant: 1 + sla: + failure_rate: + max: 0 + diff --git a/samples/tasks/scenarios/barbican/create-and-get-secret.json b/samples/tasks/scenarios/barbican/create-and-get-secret.json new file mode 100644 index 00000000..acea6320 --- /dev/null +++ b/samples/tasks/scenarios/barbican/create-and-get-secret.json @@ -0,0 +1,22 @@ +{ + "BarbicanSecrets.create_and_get": [ + { + "runner": { + "type": "constant", + "times": 2, + "concurrency": 1 + }, + "context": { + "users": { + "tenants": 1, + "users_per_tenant": 1 + } + }, + "sla": { + "failure_rate": { + "max": 0 + } + } + } + ] +} diff --git a/samples/tasks/scenarios/barbican/create-and-get-secret.yaml b/samples/tasks/scenarios/barbican/create-and-get-secret.yaml new file mode 100644 index 00000000..c3229222 --- /dev/null +++ b/samples/tasks/scenarios/barbican/create-and-get-secret.yaml @@ -0,0 +1,15 @@ +--- + BarbicanSecrets.create_and_get: + - + runner: + type: "constant" + times: 2 + concurrency: 1 + context: + users: + tenants: 1 + users_per_tenant: 1 + sla: + failure_rate: + max: 0 + diff --git a/samples/tasks/scenarios/barbican/create-and-list-secret.json b/samples/tasks/scenarios/barbican/create-and-list-secret.json new file mode 100644 index 00000000..a6ab2abf --- /dev/null +++ b/samples/tasks/scenarios/barbican/create-and-list-secret.json @@ -0,0 +1,22 @@ +{ + "BarbicanSecrets.create_and_list": [ + { + "runner": { + "type": "constant", + "times": 2, + "concurrency": 1 + }, + "context": { + "users": { + "tenants": 1, + "users_per_tenant": 1 + } + }, + "sla": { + "failure_rate": { + "max": 0 + } + } + } + ] +} diff --git a/samples/tasks/scenarios/barbican/create-and-list-secret.yaml b/samples/tasks/scenarios/barbican/create-and-list-secret.yaml new file mode 100644 index 00000000..2c4eb0a2 --- /dev/null +++ b/samples/tasks/scenarios/barbican/create-and-list-secret.yaml @@ -0,0 +1,15 @@ +--- + BarbicanSecrets.create_and_list: + - + runner: + type: "constant" + times: 2 + concurrency: 1 + context: + users: + tenants: 1 + users_per_tenant: 1 + sla: + failure_rate: + max: 0 + diff --git a/samples/tasks/scenarios/barbican/create-secret.json b/samples/tasks/scenarios/barbican/create-secret.json new file mode 100644 index 00000000..bbcc58a5 --- /dev/null +++ b/samples/tasks/scenarios/barbican/create-secret.json @@ -0,0 +1,22 @@ +{ + "BarbicanSecrets.create": [ + { + "runner": { + "type": "constant", + "times": 2, + "concurrency": 1 + }, + "context": { + "users": { + "tenants": 1, + "users_per_tenant": 1 + } + }, + "sla": { + "failure_rate": { + "max": 0 + } + } + } + ] +} diff --git a/samples/tasks/scenarios/barbican/create-secret.yaml b/samples/tasks/scenarios/barbican/create-secret.yaml new file mode 100644 index 00000000..70f4e120 --- /dev/null +++ b/samples/tasks/scenarios/barbican/create-secret.yaml @@ -0,0 +1,15 @@ +--- + BarbicanSecrets.create: + - + runner: + type: "constant" + times: 2 + concurrency: 1 + context: + users: + tenants: 1 + users_per_tenant: 1 + sla: + failure_rate: + max: 0 + diff --git a/samples/tasks/scenarios/barbican/get-secret.json b/samples/tasks/scenarios/barbican/get-secret.json new file mode 100644 index 00000000..f3969ccc --- /dev/null +++ b/samples/tasks/scenarios/barbican/get-secret.json @@ -0,0 +1,22 @@ +{ + "BarbicanSecrets.get": [ + { + "runner": { + "type": "constant", + "times": 2, + "concurrency": 1 + }, + "context": { + "users": { + "tenants": 1, + "users_per_tenant": 1 + } + }, + "sla": { + "failure_rate": { + "max": 0 + } + } + } + ] +} diff --git a/samples/tasks/scenarios/barbican/get-secret.yaml b/samples/tasks/scenarios/barbican/get-secret.yaml new file mode 100644 index 00000000..11986684 --- /dev/null +++ b/samples/tasks/scenarios/barbican/get-secret.yaml @@ -0,0 +1,15 @@ +--- + BarbicanSecrets.get: + - + runner: + type: "constant" + times: 2 + concurrency: 1 + context: + users: + tenants: 1 + users_per_tenant: 1 + sla: + failure_rate: + max: 0 + diff --git a/samples/tasks/scenarios/barbican/list-secrets.json b/samples/tasks/scenarios/barbican/list-secrets.json new file mode 100644 index 00000000..b5e790ad --- /dev/null +++ b/samples/tasks/scenarios/barbican/list-secrets.json @@ -0,0 +1,22 @@ +{ + "BarbicanSecrets.list": [ + { + "runner": { + "type": "constant", + "times": 2, + "concurrency": 1 + }, + "context": { + "users": { + "tenants": 1, + "users_per_tenant": 1 + } + }, + "sla": { + "failure_rate": { + "max": 0 + } + } + } + ] +} diff --git a/samples/tasks/scenarios/barbican/list-secrets.yaml b/samples/tasks/scenarios/barbican/list-secrets.yaml new file mode 100644 index 00000000..56304a17 --- /dev/null +++ b/samples/tasks/scenarios/barbican/list-secrets.yaml @@ -0,0 +1,15 @@ +--- + BarbicanSecrets.list: + - + runner: + type: "constant" + times: 2 + concurrency: 1 + context: + users: + tenants: 1 + users_per_tenant: 1 + sla: + failure_rate: + max: 0 + diff --git a/tests/unit/cleanup/test_resources.py b/tests/unit/cleanup/test_resources.py index 0d10b5c8..1acece3e 100644 --- a/tests/unit/cleanup/test_resources.py +++ b/tests/unit/cleanup/test_resources.py @@ -1170,3 +1170,32 @@ class GnocchiResourceTestCase(test.TestCase): [mock.call(marker=None), mock.call(marker=res[1]["id"]), mock.call(marker=res[3]["id"])], gnocchi._manager.return_value.list.call_args_list) + + +class BarbicanSecretsTestCase(test.TestCase): + + def test_id(self): + barbican = resources.BarbicanSecrets() + barbican.raw_resource = mock.MagicMock(secret_ref="fake_uuid") + self.assertEqual("fake_uuid", barbican.id()) + + def test_list(self): + barbican = resources.BarbicanSecrets() + barbican._manager = mock.MagicMock() + + barbican.list() + barbican._manager.assert_called_once_with() + + def test_delete(self): + barbican = resources.BarbicanSecrets() + barbican._manager = mock.MagicMock() + barbican.raw_resource = mock.MagicMock(uuid="fake_uuid") + + barbican.delete() + barbican._manager.assert_called_once_with() + + def test_is_deleted(self): + barbican = resources.BarbicanSecrets() + barbican._manager = mock.MagicMock() + barbican.raw_resource = mock.MagicMock(uuid="fake_uuid") + self.assertFalse(barbican.is_deleted()) diff --git a/tests/unit/fakes.py b/tests/unit/fakes.py index e2e3cd39..c5532b7d 100644 --- a/tests/unit/fakes.py +++ b/tests/unit/fakes.py @@ -187,6 +187,14 @@ class FakeFlavor(FakeResource): self.name = name +class FakeSecret(FakeResource): + + def __init__(self, id="secret-id-0", manager=None, secret_ref="secret_ref", + name="secret-name-0"): + super(FakeSecret, self).__init__(manager, id=id) + self.secret_ref = secret_ref + + class FakeKeypair(FakeResource): pass diff --git a/tests/unit/scenarios/barbican/test_secrets.py b/tests/unit/scenarios/barbican/test_secrets.py new file mode 100644 index 00000000..753441b2 --- /dev/null +++ b/tests/unit/scenarios/barbican/test_secrets.py @@ -0,0 +1,99 @@ +# Copyright 2018 Red Hat Inc +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import mock + +from rally_openstack.scenarios.barbican import secrets +from tests.unit import fakes +from tests.unit import test + + +class BarbicanSecretsTestCase(test.ScenarioTestCase): + + def get_test_context(self): + context = super(BarbicanSecretsTestCase, self).get_test_context() + context.update({ + "admin": { + "user_id": "fake", + "credential": mock.MagicMock() + }, + "user": { + "user_id": "fake", + "credential": mock.MagicMock() + }, + "tenant": {"id": "fake"} + }) + return context + + def setUp(self): + super(BarbicanSecretsTestCase, self).setUp() + patch = mock.patch( + "rally_openstack.services.key_manager.barbican.BarbicanService") + self.addCleanup(patch.stop) + self.mock_secrets = patch.start() + + def test_list_secrets(self): + secrets_service = self.mock_secrets.return_value + scenario = secrets.BarbicanSecretsList(self.context) + scenario.run() + secrets_service.list_secrets.assert_called_once_with() + + def test_create_secret(self): + secrets_service = self.mock_secrets.return_value + scenario = secrets.BarbicanSecretsCreate(self.context) + scenario.run() + secrets_service.create_secret.assert_called_once_with() + + def test_create_and_delete_secret(self): + secrets_service = self.mock_secrets.return_value + scenario = secrets.BarbicanSecretsCreateAndDelete(self.context) + scenario.run() + + secrets_service.create_secret.assert_called_once_with() + self.assertEqual(1, secrets_service.delete_secret.call_count) + + def test_create_and_get_secret(self): + secrets_service = self.mock_secrets.return_value + fake_secret = fakes.FakeSecret(id=1, name="secretxxx") + secrets_service.create_secret.return_value = fake_secret + fake_secret_info = fakes.FakeSecret(id=1, name="secret1xxx") + secrets_service.get_secret.return_value = fake_secret_info + scenario = secrets.BarbicanSecretsCreateAndGet(self.context) + scenario.run() + + secrets_service.create_secret.assert_called_once_with() + + def test_get_secret(self): + secrets_service = self.mock_secrets.return_value + scenario = secrets.BarbicanSecretsGet(self.context) + scenario.run() + + secrets_service.create_secret.assert_called_once_with() + + def test_get_secret_with_secret(self): + secret = mock.Mock() + secret.secret_ref = mock.Mock() + secrets_service = self.mock_secrets.return_value + scenario = secrets.BarbicanSecretsGet(self.context) + scenario.run() + + self.assertEqual(1, secrets_service.get_secret.call_count) + + def test_create_and_list_secret(self): + secrets_service = self.mock_secrets.return_value + scenario = secrets.BarbicanSecretsCreateAndList(self.context) + scenario.run() + secrets_service.create_secret.assert_called_once_with() + secrets_service.list_secrets.assert_called_once_with() diff --git a/tests/unit/scenarios/barbican/test_utils.py b/tests/unit/scenarios/barbican/test_utils.py new file mode 100644 index 00000000..5aa1e6ee --- /dev/null +++ b/tests/unit/scenarios/barbican/test_utils.py @@ -0,0 +1,47 @@ +# Copyright 2018 Red Hat Inc +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import mock + +from rally_openstack.scenarios.barbican import secrets +from tests.unit import test + + +class BarbicanBaseTestCase(test.ScenarioTestCase): + + def setUp(self): + super(BarbicanBaseTestCase, self).setUp() + self.context = super(BarbicanBaseTestCase, self).get_test_context() + self.context.update({ + "admin": { + "id": "fake_user_id", + "credential": mock.MagicMock() + }, + "user": { + "id": "fake_user_id", + "credential": mock.MagicMock() + }, + "tenant": {"id": "fake_tenant_id", + "name": "fake_tenant_name"} + }) + patch = mock.patch( + "rally_openstack.services.key_manager.barbican.BarbicanService") + self.addCleanup(patch.stop) + self.mock_service = patch.start() + + def test_barbican_base(self): + base = secrets.BarbicanBase(self.context) + self.assertEqual(base.admin_barbican, + self.mock_service.return_value) diff --git a/tests/unit/services/barbican/__init__.py b/tests/unit/services/barbican/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/unit/services/barbican/test_secrets.py b/tests/unit/services/barbican/test_secrets.py new file mode 100644 index 00000000..ec66df28 --- /dev/null +++ b/tests/unit/services/barbican/test_secrets.py @@ -0,0 +1,62 @@ +# Copyright 2018 Red Hat, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import mock + +from rally_openstack.services.key_manager import barbican +from tests.unit import test + + +class BarbicanServiceTestCase(test.TestCase): + def setUp(self): + super(BarbicanServiceTestCase, self).setUp() + self.clients = mock.MagicMock() + self.name_generator = mock.MagicMock() + self.service = barbican.BarbicanService( + self.clients, + name_generator=self.name_generator) + + def atomic_actions(self): + return self.service._atomic_actions + + def test__list_secrets(self): + self.assertEqual( + self.service.list_secrets(), + self.service._clients.barbican().secrets.list.return_value + ) + self._test_atomic_action_timer(self.atomic_actions(), + "barbican.list_secrets") + + def test__create_secret(self): + self.assertEqual( + self.service.create_secret(), + self.service._clients.barbican().secrets.create( + name="fake_secret", payload="rally_data") + ) + self._test_atomic_action_timer(self.atomic_actions(), + "barbican.create_secret") + + def test__get_secret(self): + self.service.get_secret("fake_secret") + self.service._clients.barbican().secrets.get \ + .assert_called_once_with("fake_secret") + self._test_atomic_action_timer(self.atomic_actions(), + "barbican.get_secret") + + def test__delete_secret(self): + self.service.delete_secret("fake_secret") + self.service._clients.barbican().secrets.delete \ + .assert_called_once_with("fake_secret") + self._test_atomic_action_timer(self.atomic_actions(), + "barbican.delete_secret") diff --git a/upper-constraints.txt b/upper-constraints.txt index 1ae6785d..8eca494f 100644 --- a/upper-constraints.txt +++ b/upper-constraints.txt @@ -87,6 +87,7 @@ pyOpenSSL===18.0.0 pyparsing===2.2.2 pyperclip===1.7.0 Python===2.7.15rc1 +python-barbicanclient===4.5.2 python-ceilometerclient===2.9.0 python-cinderclient===4.0.1 python-dateutil===2.7.3