openstack/rally
Code Issues Proposed changes

port more things to use envmanager

Browse Source 
* Port rally.task.engine to use EnvManager instead of Deployment
* Rename method `set_deployment` of `rally.common.objects.Verifier`
  to `set_env`. It can be done in backward incompatible way, since the
  original method should be called only from rally.api
* Extend `rally.common.objects.Verifier` with `env` property
* Move OpenStackCredential under dict parenthood. object like style
  makes things too complicated. The simple dict should give more
  transparency. As for backward compatibility old-behaviour is kept.
* Call `check_helth` method of EnvManager from TaskEngine instead of
  hardcoded for openstack `verify_connection` method.
* Remove methods `get_validation_context` and `verify_connection` from
  OpenStackCredential. It should not be called anywhere.

Change-Id: I76608deaefc68dbd5a99a3339584c9cf70e16ba0
This commit is contained in:
Andrey Kurilin 2018-02-08 16:41:55 +02:00
parent c7b08c1377
commit a9a9fe4b87
20 changed files with 415 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
rally/api.py
View File

@ -19,7 +19,6 @@ import os
import re
import sys
import time
import traceback
import jinja2
import jinja2.meta
@ -163,40 +162,55 @@ class _Deployment(APIGroup):
:param deployment: UUID of deployment
:returns: Service list
"""
env = self._get(deployment).env_obj
result = {}
all_credentials = self._get(deployment).get_all_credentials()
for platform in all_credentials:
result[platform] = []
for credential in all_credentials[platform]:
no_error = True
result[platform].append({"services": []})
active_user = None
if credential["admin"]:
active_user = credential["admin"]
try:
credential["admin"].verify_connection()
except Exception as e:
no_error = False
result[platform][-1]["admin_error"] = {
"etype": e.__class__.__name__,
"msg": str(e),
"trace": traceback.format_exc()}
for user in credential["users"]:
try:
user.verify_connection()
except Exception as e:
no_error = False
result[platform][-1]["user_error"] = {
"etype": e.__class__.__name__,
"msg": str(e),
"trace": traceback.format_exc()}
break
for p, res in env.check_health().items():
name = "openstack" if p == "existing@openstack" else p
if not res["available"]:
# NOTE(andreykurilin): the old behavior supports 2 keys
# for storing errors: admin_error and user_error.
# Since admin/users is not mandatory thing for new design
# of Platforms, let's put platform error to "admin_error"
key = "admin_error"
if name == "openstack":
if res["message"].startswith("Bad user creds"):
key = "user_error"
if no_error:
active_user = active_user or credential["users"][0]
services = active_user.list_services()
result[platform][-1]["services"] = services
# NOTE(andreykurilin): the last not null line in traceback
# includes Exception cls with a message. By parsing it, we
# can get etype.
trace = res["traceback"].split("\n")
last_line = [l for l in trace if l][-1]
etype, _msg = last_line.split(":", 1)
result[name] = [
{
key: {
"etype": etype,
"msg": res["message"],
"trace": res["traceback"]
},
"services": []
}
]
else:
if name == "openstack":
services = env.get_info()[p]["info"]["services"]
services = sorted(
{"type": stype, "name": sname}
for stype, sname in services.items())
result[name] = [{"services": services}]
else:
# NOTE(andreykurilin): the info method of platforms allows
# to return whatever single platform wants, i.e
# Platform X can return just a version and no services
# at all. Checking for 'services' key there is not a
# solution, since the value of it can have the format
# which differs from openstack-like (the old design of
# Deployment component)
result[name] = [{"services": []}]
return result
@ -352,7 +366,7 @@ class _Task(APIGroup):
LOG.exception("Invalid Task")
raise exceptions.InvalidTaskException(str(e))
engine.TaskEngine(config, task, deployment).validate()
engine.TaskEngine(config, task, deployment.env_obj).validate()
def start(self, deployment, config, task=None, abort_on_sla_failure=False):
"""Validate and start a task.
@ -402,7 +416,7 @@ class _Task(APIGroup):
description=config.description)
task_engine = engine.TaskEngine(
config, task, deployment,
config, task, deployment.env_obj,
abort_on_sla_failure=abort_on_sla_failure)
task_engine.validate()
@ -686,7 +700,7 @@ class _Verifier(APIGroup):
if deployment_id:
LOG.info("Deleting deployment-specific data for verifier %s."
% verifier)
verifier.set_deployment(deployment_id)
verifier.set_env(deployment_id)
verifier.manager.uninstall()
LOG.info("Deployment-specific data has been successfully deleted!")
else:
@ -795,7 +809,7 @@ class _Verifier(APIGroup):
"""
if not isinstance(verifier, objects.Verifier):
verifier = self._get(verifier)
verifier.set_deployment(deployment_id)
verifier.set_env(deployment_id)
LOG.info("Configuring verifier %s for deployment '%s' (UUID=%s)."
% (verifier,
verifier.deployment["name"],
@ -856,7 +870,7 @@ class _Verifier(APIGroup):
verifier, verifier.status, consts.VerifierStatus.INSTALLED)
)
verifier.set_deployment(deployment_id)
verifier.set_env(deployment_id)
LOG.info("Overriding configuration of verifier %s for deployment '%s' "
"(UUID=%s)."
% (verifier,
@ -985,7 +999,7 @@ class _Verification(APIGroup):
verifier, verifier.status, consts.VerifierStatus.INSTALLED)
)
verifier.set_deployment(deployment_id)
verifier.set_env(deployment_id)
if not verifier.manager.is_configured():
self.api.verifier.configure(verifier=verifier,
deployment_id=deployment_id)
@ -1136,7 +1150,7 @@ class _Verification(APIGroup):
# [1] https://blueprints.launchpad.net/rally/+spec/verification-import
verifier = self.api.verifier._get(verifier_id)
verifier.set_deployment(deployment_id)
verifier.set_env(deployment_id)
LOG.info("Importing test results into a new verification for "
"deployment '%s' (UUID=%s), using verifier %s."
% (verifier.deployment["name"],

9
rally/common/objects/credential.py
View File

@ -13,13 +13,20 @@
# License for the specific language governing permissions and limitations
# under the License.
from rally.common import logging
from rally.plugins.openstack import credential
# TODO(astudenov): remove this class in future releases
LOG = logging.getLogger(__name__)
class Credential(credential.OpenStackCredential):
"""Deprecated version of OpenStackCredential class"""
def __init__(self, *args, **kwargs):
super(Credential, self).__init__(*args, **kwargs)
LOG.warning("Class rally.common.objects.Credential is deprecated "
"since Rally 0.11.0. Use raw dict for OpenStack "
"credentials instead.")
def to_dict(self, include_permission=False):
dct = super(Credential, self).to_dict()

11
rally/common/objects/verifier.py
View File

@ -82,18 +82,23 @@ class Verifier(object):
def update_properties(self, **properties):
self._db_entry = db.verifier_update(self.uuid, **properties)
def set_deployment(self, deployment_id):
def set_env(self, env_id):
from rally.common import objects
self._deployment = objects.Deployment.get(deployment_id)
self._deployment = objects.Deployment.get(env_id)
@property
def deployment(self):
# TODO(andreykurilin): deprecate this property someday
if self._deployment is None:
raise exceptions.RallyException(
"Verifier is not linked to any deployment. Please, call "
"`set_deployment` method.")
"`set_env` method.")
return self._deployment
@property
def env(self):
return self.deployment.env_obj
@property
def manager(self):
# lazy load manager to be able to use non-plugin related stuff without

2
rally/common/plugin/discover.py
View File

@ -52,7 +52,7 @@ def itersubclasses(cls, seen=None):
def import_modules_from_package(package):
"""Import modules from package and append into sys.modules
:param package: Full package name. For example: rally.deployment.engines
:param package: Full package name. For example: rally.plugins.openstack
"""
path = [os.path.dirname(rally.__file__), ".."] + package.split(".")
path = os.path.join(*path)

2
rally/env/env_mgr.py vendored
View File

@ -614,7 +614,7 @@ class EnvManager(object):
from rally.common import objects
for verifier in objects.Verifier.list():
verifier.set_deployment(self.uuid)
verifier.set_env(self.uuid)
verifier.manager.uninstall()
db.env_set_status(self.uuid, STATUS.DESTROYING, new_env_status)

30
rally/plugins/openstack/context/keystone/users.py
View File

@ -20,7 +20,6 @@ from oslo_config import cfg
from rally.common import broker
from rally.common import logging
from rally.common import objects
from rally.common import utils as rutils
from rally.common import validation
from rally import consts
@ -105,19 +104,19 @@ class UserGenerator(context.Context):
def __init__(self, context):
super(UserGenerator, self).__init__(context)
deployment = objects.Deployment.get(context["task"]["deployment_uuid"])
creds = deployment.get_credentials_for("openstack")
creds = self.env["platforms"]["openstack"]
if creds.get("admin"):
context["admin"] = {"credential": creds["admin"]}
context["admin"] = {
"credential": credential.OpenStackCredential(**creds["admin"])}
if creds["users"] and not (set(self.config) - {"user_choice_method"}):
self.existing_users = creds["users"]
else:
self.existing_users = []
self.credential = context["admin"]["credential"]
project_domain = (self.credential.project_domain_name or
project_domain = (self.credential["project_domain_name"] or
cfg.CONF.openstack.project_domain)
user_domain = (self.credential.user_domain_name or
user_domain = (self.credential["user_domain_name"] or
cfg.CONF.openstack.user_domain)
self.DEFAULT_FOR_NEW_USERS["project_domain"] = project_domain
self.DEFAULT_FOR_NEW_USERS["user_domain"] = user_domain
@ -207,19 +206,19 @@ class UserGenerator(context.Context):
domain_name=user_dom,
default_role=default_role)
user_credential = credential.OpenStackCredential(
auth_url=self.credential.auth_url,
auth_url=self.credential["auth_url"],
username=user.name,
password=password,
tenant_name=self.context["tenants"][tenant_id]["name"],
permission=consts.EndpointPermission.USER,
project_domain_name=project_dom,
user_domain_name=user_dom,
endpoint_type=self.credential.endpoint_type,
https_insecure=self.credential.https_insecure,
https_cacert=self.credential.https_cacert,
region_name=self.credential.region_name,
profiler_hmac_key=self.credential.profiler_hmac_key,
profiler_conn_str=self.credential.profiler_conn_str)
endpoint_type=self.credential["endpoint_type"],
https_insecure=self.credential["https_insecure"],
https_cacert=self.credential["https_cacert"],
region_name=self.credential["region_name"],
profiler_hmac_key=self.credential["profiler_hmac_key"],
profiler_conn_str=self.credential["profiler_conn_str"])
users.append({"id": user.id,
"credential": user_credential,
"tenant_id": tenant_id})
@ -284,9 +283,10 @@ class UserGenerator(context.Context):
msg="Failed to create the requested number of users.")
def use_existing_users(self):
LOG.debug("Using existing users")
LOG.debug("Using existing users for OpenStack platform.")
for user_credential in self.existing_users:
user_clients = user_credential.clients()
user_credential = credential.OpenStackCredential(**user_credential)
user_clients = osclients.Clients(user_credential)
user_id = user_clients.keystone.auth_ref.user_id
tenant_id = user_clients.keystone.auth_ref.project_id

87
rally/plugins/openstack/credential.py
View File

@ -14,87 +14,82 @@
# under the License.
from rally.common import logging
from rally import consts
from rally.plugins.openstack import osclients
LOG = logging.getLogger(__file__)
class OpenStackCredential(object):
class OpenStackCredential(dict):
"""Credential for OpenStack."""
def __init__(self, auth_url, username, password, tenant_name=None,
project_name=None,
permission=consts.EndpointPermission.USER,
permission=None,
region_name=None, endpoint_type=None,
domain_name=None, endpoint=None, user_domain_name=None,
project_domain_name=None,
https_insecure=False, https_cacert=None,
profiler_hmac_key=None, profiler_conn_str=None):
self.auth_url = auth_url
self.username = username
self.password = password
self.tenant_name = tenant_name or project_name
self.permission = permission
self.region_name = region_name
self.endpoint_type = endpoint_type
self.domain_name = domain_name
self.user_domain_name = user_domain_name
self.project_domain_name = project_domain_name
self.endpoint = endpoint
self.https_insecure = https_insecure
self.https_cacert = https_cacert
self.profiler_hmac_key = profiler_hmac_key
self.profiler_conn_str = profiler_conn_str
profiler_hmac_key=None, profiler_conn_str=None, **kwargs):
if kwargs:
raise TypeError("%s" % kwargs)
# TODO(andreykurilin): deprecate permission and endpoint
super(OpenStackCredential, self).__init__([
("auth_url", auth_url),
("username", username),
("password", password),
("tenant_name", (tenant_name or project_name)),
("permission", permission),
("endpoint", endpoint),
("region_name", region_name),
("endpoint_type", endpoint_type),
("domain_name", domain_name),
("user_domain_name", user_domain_name),
("project_domain_name", project_domain_name),
("https_insecure", https_insecure),
("https_cacert", https_cacert),
("profiler_hmac_key", profiler_hmac_key),
("profiler_conn_str", profiler_conn_str)
])
self._clients_cache = {}
def __getattr__(self, attr, default=None):
# TODO(andreykurilin): print warning to force everyone to use this
# object as raw dict as soon as we clean over code.
return self.get(attr, default)
# backward compatibility
@property
def insecure(self):
LOG.warning("Property 'insecure' is deprecated since Rally 0.10.0. "
"Use 'https_insecure' instead.")
return self.https_insecure
return self["https_insecure"]
# backward compatibility
@property
def cacert(self):
LOG.warning("Property 'cacert' is deprecated since Rally 0.10.0. "
"Use 'https_cacert' instead.")
return self.https_cacert
return self["https_cacert"]
def to_dict(self):
return {"auth_url": self.auth_url,
"username": self.username,
"password": self.password,
"tenant_name": self.tenant_name,
"region_name": self.region_name,
"endpoint_type": self.endpoint_type,
"domain_name": self.domain_name,
"endpoint": self.endpoint,
"https_insecure": self.https_insecure,
"https_cacert": self.https_cacert,
"user_domain_name": self.user_domain_name,
"project_domain_name": self.project_domain_name,
"permission": self.permission,
"profiler_hmac_key": self.profiler_hmac_key,
"profiler_conn_str": self.profiler_conn_str}
def verify_connection(self):
if self.permission == consts.EndpointPermission.ADMIN:
self.clients().verified_keystone()
else:
self.clients().keystone()
return dict(self)
def list_services(self):
LOG.warning("Method `list_services` of OpenStackCredentials is "
"deprecated since Rally 0.11.0. Use osclients instead.")
return sorted([{"type": stype, "name": sname}
for stype, sname in self.clients().services().items()],
key=lambda s: s["name"])
@classmethod
def get_validation_context(cls):
return {"users@openstack": {}}
# this method is mostly used by validation step. let's refactor it and
# deprecated this
def clients(self, api_info=None):
return osclients.Clients(self, api_info=api_info,
cache=self._clients_cache)
def __deepcopy__(self, memodict=None):
import copy
return self.__class__(**copy.deepcopy(self.to_dict()))

3
rally/plugins/openstack/osclients.py
View File

@ -427,14 +427,11 @@ class Heat(OSClient):
# when heatclient no longer uses it.
kw_args = {}
if self.credential.endpoint_type:
kw_args["endpoint_type"] = self.credential.endpoint_type
kw_args["interface"] = self.credential.endpoint_type
client = heat.Client(
self.choose_version(version),
session=self.keystone.get_session()[0],
# Remove endpoint once requirement is python-heatclient>=1.6
endpoint=self._get_endpoint(service_type),
endpoint_override=self._get_endpoint(service_type),
**kw_args)
return client

1
rally/task/context.py
View File

@ -131,6 +131,7 @@ class BaseContext(plugin.Plugin, functional.FunctionalMixin,
# however we handle this
self.config = config
self.context = ctx
self.env = self.context.get("env", {})
@classmethod
def get_order(cls):

51
rally/task/engine.py
View File

@ -231,25 +231,24 @@ class TaskEngine(object):
Typical usage:
...
engine = TaskEngine(config, task, deployment)
engine = TaskEngine(config, task, env)
engine.validate() # to test config
engine.run() # to run config
"""
def __init__(self, config, task, deployment,
abort_on_sla_failure=False):
def __init__(self, config, task, env, abort_on_sla_failure=False):
"""TaskEngine constructor.
:param config: An instance of a TaskConfig
:param task: Instance of Task,
the current task which is being performed
:param deployment: Instance of Deployment,
:param env: Instance of Environment,
:param abort_on_sla_failure: True if the execution should be stopped
when some SLA check fails
"""
self.config = config
self.task = task
self.deployment = deployment
self.env = env
self.abort_on_sla_failure = abort_on_sla_failure
def _validate_workload(self, workload, vcontext=None, vtype=None):
@ -340,10 +339,11 @@ class TaskEngine(object):
"Task validation of required platforms.")
def _validate_config_platforms(self, config):
# FIXME(andreykurilin): prepare the similar context object to others
credentials = self.deployment.get_all_credentials()
platforms = dict(
(p["platform_name"], p["platform_data"])
for p in self.env.data["platforms"].values())
ctx = {"task": self.task,
"platforms": dict((p, creds[0])
for p, creds in credentials.items())}
"platforms": platforms}
for subtask in config.subtasks:
for workload in subtask["workloads"]:
self._validate_workload(
@ -351,9 +351,30 @@ class TaskEngine(object):
@logging.log_task_wrapper(LOG.info, "Task validation of semantic.")
def _validate_config_semantic(self, config):
self.deployment.verify_connections()
validation_ctx = self.deployment.get_validation_context()
ctx_obj = {"task": self.task, "config": validation_ctx}
LOG.info("Check health of the environment '%s'." % self.env.uuid)
failed = []
for p, res in self.env.check_health().items():
LOG.info("Platform %s (available: %s): %s" %
(p, res["available"], res["message"]))
if not res["available"]:
failed.append(p)
if logging.is_debug():
LOG.error(res["traceback"])
if failed:
raise exceptions.ValidationError(
"One or several platforms are not available: %s. Check logs "
"for more details." % ", ".join(failed))
validation_ctx = self.env.get_validation_context()
env_data = self.env.data
env_data["platforms"] = dict(
(p["platform_name"], p["platform_data"])
for p in env_data["platforms"].values())
ctx_obj = {"task": self.task,
"config": validation_ctx,
"env": env_data}
with context.ContextManager(ctx_obj):
for subtask in config.subtasks:
for workload in subtask["workloads"]:
@ -392,11 +413,17 @@ class TaskEngine(object):
for k, v in ctx.items():
context_config[context.Context.get(k).get_fullname()] = v
env_data = self.env.data
env_data["platforms"] = dict(
(p["platform_name"], p["platform_data"])
for p in env_data["platforms"].values())
context_obj = {
"task": self.task,
"owner_id": owner_id,
"scenario_name": scenario_name,
"config": context_config
"config": context_config,
"env": env_data
}
return context_obj

11
tests/check_samples/test_task_samples.py
View File

@ -63,9 +63,14 @@ class TestTaskSamples(unittest.TestCase):
deployment = rapi.deployment._get("MAIN")
admin_cred = deployment.get_credentials_for("openstack")["admin"]
ctx = {"admin": {"credential": admin_cred},
"task": {"uuid": self.__class__.__name__,
"deployment_uuid": deployment["uuid"]}}
ctx = {
"env": {
"platforms": {
"openstack": {
"admin": admin_cred.to_dict(),
"users": []}}},
"task": {"uuid": self.__class__.__name__,
"deployment_uuid": deployment["uuid"]}}
user_ctx = users.UserGenerator(ctx)
user_ctx.setup()
self.addCleanup(user_ctx.cleanup)

22
tests/unit/common/objects/test_credential.py
View File

@ -27,8 +27,7 @@ class CredentialTestCase(test.TestCase):
"foo_url", "foo_user", "foo_password",
tenant_name="foo_tenant",
permission=consts.EndpointPermission.ADMIN)
self.assertEqual(credential.to_dict(),
{"auth_url": "foo_url",
self.assertEqual({"auth_url": "foo_url",
"username": "foo_user",
"password": "foo_password",
"tenant_name": "foo_tenant",
@ -41,39 +40,39 @@ class CredentialTestCase(test.TestCase):
"project_domain_name": None,
"user_domain_name": None,
"profiler_hmac_key": None,
"profiler_conn_str": None})
"profiler_conn_str": None},
credential.to_dict())
def test_to_dict_with_include_permission(self):
credential = objects.Credential(
"foo_url", "foo_user", "foo_password",
tenant_name="foo_tenant",
permission=consts.EndpointPermission.ADMIN)
self.assertEqual(credential.to_dict(include_permission=True),
{"auth_url": "foo_url",
self.assertEqual({"auth_url": "foo_url",
"username": "foo_user",
"password": "foo_password",
"tenant_name": "foo_tenant",
"region_name": None,
"domain_name": None,
"endpoint": None,
"permission": consts.EndpointPermission.ADMIN,
"endpoint": None,
"endpoint_type": None,
"https_insecure": False,
"https_cacert": None,
"project_domain_name": None,
"user_domain_name": None,
"profiler_hmac_key": None,
"profiler_conn_str": None})
"profiler_conn_str": None},
credential.to_dict(include_permission=True))
def test_to_dict_with_kwarg_credential(self):
credential = objects.Credential(
"foo_url", "foo_user", "foo_password",
tenant_name="foo_tenant",
permission=consts.EndpointPermission.ADMIN,
endpoint="foo_endpoint",
permission=consts.EndpointPermission.ADMIN,
endpoint_type=consts.EndpointType.PUBLIC)
self.assertEqual(credential.to_dict(),
{"auth_url": "foo_url",
self.assertEqual({"auth_url": "foo_url",
"username": "foo_user",
"password": "foo_password",
"tenant_name": "foo_tenant",
@ -86,4 +85,5 @@ class CredentialTestCase(test.TestCase):
"project_domain_name": None,
"user_domain_name": None,
"profiler_hmac_key": None,
"profiler_conn_str": None})
"profiler_conn_str": None},
credential.to_dict())

11
tests/unit/common/objects/test_verifier.py
View File

@ -78,11 +78,14 @@ class VerifierTestCase(test.TestCase):
status="some-status")
@mock.patch("rally.env.env_mgr.EnvManager.get")
def test_deployment_property(self, mock_env_manager_get):
def test_env_and_deployment_properties(self, mock_env_manager_get):
v = objects.Verifier(self.db_obj)
v.set_deployment("some-deployment")
self.assertEqual(mock_env_manager_get.return_value, v.deployment._env)
mock_env_manager_get.assert_called_once_with("some-deployment")
v.set_env("some-env")
self.assertEqual(mock_env_manager_get.return_value,
v.deployment.env_obj)
self.assertEqual(mock_env_manager_get.return_value,
v.env)
mock_env_manager_get.assert_called_once_with("some-env")
def test_deployment_property_raise_exc(self):
v = objects.Verifier(self.db_obj)

2
tests/unit/env/test_env_mgr.py vendored
View File

@ -716,7 +716,7 @@ class EnvManagerTestCase(test.TestCase):
platform.STATUS.FAILED_TO_DESTROY)
])
verifier.set_deployment.assert_called_once_with(666)
verifier.set_env.assert_called_once_with(666)
verifier.manager.uninstall.assert_called_once_with()
@mock.patch("rally.common.db.env_get_status")

1
tests/unit/fakes.py
View File

@ -1851,6 +1851,7 @@ class FakeDeployment(dict):
"default": [{"admin": None, "users": []}]}
dict.__init__(self, **kwargs)
self.update_status = mock.Mock()
self.env_obj = mock.Mock()
def get_platforms(self):
return [platform for platform in self["credentials"]]

141
tests/unit/plugins/openstack/context/keystone/test_users.py
View File

@ -31,24 +31,29 @@ class UserGeneratorBaseTestCase(test.ScenarioTestCase):
self.osclients = self.osclients_patcher.start()
self.addCleanup(self.osclients_patcher.stop)
self.deployment_patcher = mock.patch("%s.objects.Deployment.get" % CTX)
self.deployment_get = self.deployment_patcher.start()
self.addCleanup(self.deployment_patcher.stop)
self.deployment_uuid = "deployment_id"
self.admin_cred = mock.MagicMock()
self.admin_cred = {
"username": "root", "password": "qwerty",
"auth_url": "https://example.com",
"project_domain_name": "foo",
"user_domain_name": "bar"}
self.platforms = {
"openstack": {
"admin": self.admin_cred,
"users": []
}
}
self.context.update({
"config": {"users": {}},
"admin": {"credential": self.admin_cred},
"users": [],
"env": {"platforms": self.platforms},
"task": {"uuid": "task_id",
"deployment_uuid": self.deployment_uuid}
})
def test___init__for_new_users(self):
deployment = self.deployment_get.return_value
deployment.get_credentials_for.return_value = {"users": []}
self.context["config"]["users"] = {
"tenants": 1, "users_per_tenant": 1,
"resource_management_workers": 1}
@ -56,36 +61,27 @@ class UserGeneratorBaseTestCase(test.ScenarioTestCase):
user_generator = users.UserGenerator(self.context)
self.assertEqual([], user_generator.existing_users)
self.assertEqual(self.admin_cred.project_domain_name,
self.assertEqual(self.admin_cred["project_domain_name"],
user_generator.config["project_domain"])
self.assertEqual(self.admin_cred.user_domain_name,
self.assertEqual(self.admin_cred["user_domain_name"],
user_generator.config["user_domain"])
self.deployment_get.assert_called_once_with(self.deployment_uuid)
deployment.get_credentials_for.assert_called_once_with("openstack")
self.deployment_get.reset_mock()
deployment.get_credentials_for.reset_mock()
# the case #2 - existing users are presented in deployment but
# the user forces to create new ones
deployment.get_credentials_for.return_value = {"users": [mock.Mock()]}
self.platforms["openstack"]["users"] = [mock.Mock()]
user_generator = users.UserGenerator(self.context)
self.assertEqual([], user_generator.existing_users)
self.assertEqual(self.admin_cred.project_domain_name,
self.assertEqual(self.admin_cred["project_domain_name"],
user_generator.config["project_domain"])
self.assertEqual(self.admin_cred.user_domain_name,
self.assertEqual(self.admin_cred["user_domain_name"],
user_generator.config["user_domain"])
self.deployment_get.assert_called_once_with(self.deployment_uuid)
deployment.get_credentials_for.assert_called_once_with("openstack")
def test___init__for_existing_users(self):
deployment = self.deployment_get.return_value
foo_user = mock.Mock()
deployment.get_credentials_for.return_value = {"users": [foo_user]}
self.platforms["openstack"]["users"] = [foo_user]
user_generator = users.UserGenerator(self.context)
@ -93,12 +89,6 @@ class UserGeneratorBaseTestCase(test.ScenarioTestCase):
self.assertEqual({"user_choice_method": "random"},
user_generator.config)
self.deployment_get.assert_called_once_with(self.deployment_uuid)
deployment.get_credentials_for.assert_called_once_with("openstack")
self.deployment_get.reset_mock()
deployment.get_credentials_for.reset_mock()
# the case #2: the config with `user_choice_method` option
self.context["config"]["users"] = {"user_choice_method": "foo"}
@ -107,9 +97,6 @@ class UserGeneratorBaseTestCase(test.ScenarioTestCase):
self.assertEqual([foo_user], user_generator.existing_users)
self.assertEqual({"user_choice_method": "foo"}, user_generator.config)
self.deployment_get.assert_called_once_with(self.deployment_uuid)
deployment.get_credentials_for.assert_called_once_with("openstack")
def test_setup(self):
user_generator = users.UserGenerator(self.context)
user_generator.use_existing_users = mock.Mock()
@ -167,26 +154,34 @@ class UserGeneratorForExistingUsersTestCase(test.ScenarioTestCase):
self.osclients = self.osclients_patcher.start()
self.addCleanup(self.osclients_patcher.stop)
self.deployment_patcher = mock.patch("%s.objects.Deployment.get" % CTX)
self.deployment_get = self.deployment_patcher.start()
self.addCleanup(self.deployment_patcher.stop)
self.deployment_uuid = "deployment_id"
self.platforms = {
"openstack": {
"admin": {"username": "root",
"password": "qwerty",
"auth_url": "https://example.com"},
"users": []
}
}
self.context.update({
"config": {"users": {}},
"users": [],
"env": {"platforms": self.platforms},
"task": {"uuid": "task_id",
"deployment_uuid": self.deployment_uuid}
})
def test_use_existing_users(self):
user1 = mock.MagicMock(tenant_id="1", user_id="1",
tenant_name="proj", username="usr")
user2 = mock.MagicMock(tenant_id="1", user_id="2",
tenant_name="proj", username="usr")
user3 = mock.MagicMock(tenant_id="2", user_id="3",
tenant_name="proj", username="usr")
@mock.patch("%s.credential.OpenStackCredential" % CTX)
@mock.patch("%s.osclients.Clients" % CTX)
def test_use_existing_users(self, mock_clients,
mock_open_stack_credential):
user1 = {"tenant_name": "proj", "username": "usr",
"password": "pswd", "auth_url": "https://example.com"}
user2 = {"tenant_name": "proj", "username": "usr",
"password": "pswd", "auth_url": "https://example.com"}
user3 = {"tenant_name": "proj", "username": "usr",
"password": "pswd", "auth_url": "https://example.com"}
user_list = [user1, user2, user3]
@ -197,21 +192,18 @@ class UserGeneratorForExistingUsersTestCase(test.ScenarioTestCase):
@property
def user_id(self):
self.USER_ID_COUNT += 1
return user_list[self.USER_ID_COUNT - 1].user_id
return "u%s" % self.USER_ID_COUNT
@property
def project_id(self):
self.PROJECT_ID_COUNT += 1
return user_list[self.PROJECT_ID_COUNT - 1].tenant_id
return "p%s" % (self.PROJECT_ID_COUNT % 2)
auth_ref = AuthRef()
user1.clients.return_value.keystone.auth_ref = auth_ref
user2.clients.return_value.keystone.auth_ref = auth_ref
user3.clients.return_value.keystone.auth_ref = auth_ref
mock_clients.return_value.keystone.auth_ref = auth_ref
deployment = self.deployment_get.return_value
deployment.get_credentials_for.return_value = {"users": user_list}
self.platforms["openstack"]["users"] = user_list
user_generator = users.UserGenerator(self.context)
user_generator.setup()
@ -220,16 +212,16 @@ class UserGeneratorForExistingUsersTestCase(test.ScenarioTestCase):
self.assertIn("tenants", self.context)
self.assertIn("user_choice_method", self.context)
self.assertEqual("random", self.context["user_choice_method"])
creds = mock_open_stack_credential.return_value
self.assertEqual(
[{"id": user1.user_id, "credential": user1,
"tenant_id": user1.tenant_id},
{"id": user2.user_id, "credential": user2,
"tenant_id": user2.tenant_id},
{"id": user3.user_id, "credential": user3,
"tenant_id": user3.tenant_id}], self.context["users"]
[{"id": "u1", "credential": creds, "tenant_id": "p1"},
{"id": "u2", "credential": creds, "tenant_id": "p0"},
{"id": "u3", "credential": creds, "tenant_id": "p1"}],
self.context["users"]
)
self.assertEqual({"1": {"id": "1", "name": user1.tenant_name},
"2": {"id": "2", "name": user3.tenant_name}},
self.assertEqual({"p0": {"id": "p0", "name": creds.tenant_name},
"p1": {"id": "p1", "name": creds.tenant_name}},
self.context["tenants"])
@ -246,13 +238,15 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
self.osclients = self.osclients_patcher.start()
self.addCleanup(self.osclients_patcher.stop)
self.deployment_patcher = mock.patch("%s.objects.Deployment.get" % CTX)
self.deployment_get = self.deployment_patcher.start()
self.addCleanup(self.deployment_patcher.stop)
# Force the case of creating new users
deployment = self.deployment_get.return_value
deployment.get_credentials_for.return_value = {"users": []}
self.platforms = {
"openstack": {
"admin": {"username": "root",
"password": "qwerty",
"auth_url": "https://example.com"},
"users": []
}
}
self.context.update({
"config": {
@ -262,7 +256,7 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
"resource_management_workers": self.threads,
}
},
"admin": {"credential": mock.MagicMock()},
"env": {"platforms": self.platforms},
"users": [],
"task": {"uuid": "task_id", "deployment_uuid": "dep_uuid"}
})
@ -451,7 +445,7 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
tmp_context["config"]["users"] = {"tenants": 1,
"users_per_tenant": 2,
"resource_management_workers": 1}
tmp_context["admin"]["credential"] = credential
tmp_context["env"]["platforms"]["openstack"]["admin"] = credential
credential_dict = credential.to_dict()
user_list = [mock.MagicMock(id="id_%d" % i)
@ -477,10 +471,11 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
excluded_keys = ["auth_url", "username", "password",
"tenant_name", "region_name",
"project_domain_name",
"user_domain_name"]
"user_domain_name", "permission"]
for key in (set(credential_dict.keys()) - set(excluded_keys)):
self.assertEqual(credential_dict[key],
user_credential_dict[key])
user_credential_dict[key],
"The key '%s' differs." % key)
tenants_ids = []
for t in ctx.context["tenants"].keys():
@ -504,7 +499,8 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
"resource_management_workers": 1
}
},
"admin": {"credential": credential},
"env": {"platforms": {"openstack": {"admin": credential,
"users": []}}},
"task": {"uuid": "task_id", "deployment_uuid": "deployment_id"}
}
@ -526,7 +522,8 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
"resource_management_workers": 1
}
},
"admin": {"credential": credential},
"env": {"platforms": {"openstack": {"admin": credential,
"users": []}}},
"task": {"uuid": "task_id", "deployment_uuid": "deployment_id"}
}

21
tests/unit/plugins/openstack/test_credential.py
View File

@ -15,7 +15,6 @@
import mock
from rally import consts
from rally.plugins.openstack import credential
from tests.unit import test
@ -26,8 +25,7 @@ class OpenStackCredentialTestCase(test.TestCase):
super(OpenStackCredentialTestCase, self).setUp()
self.credential = credential.OpenStackCredential(
"foo_url", "foo_user", "foo_password",
tenant_name="foo_tenant",
permission=consts.EndpointPermission.ADMIN)
tenant_name="foo_tenant")
def test_to_dict(self):
self.assertEqual({"auth_url": "foo_url",
@ -36,8 +34,8 @@ class OpenStackCredentialTestCase(test.TestCase):
"tenant_name": "foo_tenant",
"region_name": None,
"domain_name": None,
"permission": None,
"endpoint": None,
"permission": consts.EndpointPermission.ADMIN,
"endpoint_type": None,
"https_insecure": False,
"https_cacert": None,
@ -47,21 +45,6 @@ class OpenStackCredentialTestCase(test.TestCase):
"profiler_conn_str": None},
self.credential.to_dict())
@mock.patch("rally.plugins.openstack.osclients.Clients")
def test_verify_connection_admin(self, mock_clients):
self.credential.verify_connection()
mock_clients.assert_called_once_with(
self.credential, api_info=None, cache={})
mock_clients.return_value.verified_keystone.assert_called_once_with()
@mock.patch("rally.plugins.openstack.osclients.Clients")
def test_verify_connection_user(self, mock_clients):
self.credential.permission = consts.EndpointPermission.USER
self.credential.verify_connection()
mock_clients.assert_called_once_with(
self.credential, api_info=None, cache={})
mock_clients.return_value.keystone.assert_called_once_with()
@mock.patch("rally.plugins.openstack.osclients.Clients")
def test_list_services(self, mock_clients):
mock_clients.return_value.services.return_value = {"compute": "nova",

62
tests/unit/plugins/openstack/test_osclients.py
View File

@ -19,12 +19,16 @@ from oslo_config import cfg
from rally import consts
from rally import exceptions
from rally import osclients as deprecated_osclients # noqa
from rally.plugins.openstack import credential as oscredential
from rally.plugins.openstack import osclients
from tests.unit import fakes
from tests.unit import test
PATH = "rally.plugins.openstack.osclients"
@osclients.configure("dummy", supported_versions=("0.1", "1"),
default_service_type="bar")
class DummyClient(osclients.OSClient):
@ -93,7 +97,7 @@ class OSClientTestCase(test.TestCase, OSClientTestCaseUtils):
self.assertEqual("foo",
fake_client.choose_service_type("foo"))
@mock.patch("rally.osclients.Keystone.service_catalog")
@mock.patch("%s.Keystone.service_catalog" % PATH)
@ddt.data(
{"endpoint_type": None, "service_type": None, "region_name": None},
{"endpoint_type": "et", "service_type": "st", "region_name": "rn"}
@ -119,7 +123,7 @@ class OSClientTestCase(test.TestCase, OSClientTestCaseUtils):
mock_url_for.assert_called_once_with(**call_args)
mock_choose_service_type.assert_called_once_with(service_type)
@mock.patch("rally.osclients.Keystone.get_session")
@mock.patch("%s.Keystone.get_session" % PATH)
def test__get_session(self, mock_keystone_get_session):
osclient = osclients.OSClient(None, None, None)
auth_url = "auth_url"
@ -263,7 +267,7 @@ class TestCreateKeystoneClient(test.TestCase, OSClientTestCaseUtils):
keystone = osclients.Keystone(None, None, None)
self.assertRaises(exceptions.RallyException, lambda: keystone.keystone)
@mock.patch("rally.osclients.Keystone.get_session")
@mock.patch("%s.Keystone.get_session" % PATH)
def test_auth_ref(self, mock_keystone_get_session):
session = mock.MagicMock()
auth_plugin = mock.MagicMock()
@ -293,8 +297,8 @@ class TestCreateKeystoneClient(test.TestCase, OSClientTestCaseUtils):
self.fail("keystone.auth_ref didn't raise"
" exceptions.AuthenticationFailed")
@mock.patch("rally.osclients.LOG.exception")
@mock.patch("rally.osclients.logging.is_debug")
@mock.patch("%s.LOG.exception" % PATH)
@mock.patch("%s.logging.is_debug" % PATH)
@mock.patch("keystoneauth1.identity.base.BaseIdentityPlugin.get_access")
def test_auth_ref_debug(self, mock_get_access,
mock_is_debug, mock_log_exception):
@ -326,11 +330,11 @@ class OSClientsTestCase(test.TestCase):
self.fake_keystone = fakes.FakeKeystoneClient()
keystone_patcher = mock.patch(
"rally.osclients.Keystone.create_client",
"%s.Keystone.create_client" % PATH,
return_value=self.fake_keystone)
self.mock_create_keystone_client = keystone_patcher.start()
self.auth_ref_patcher = mock.patch("rally.osclients.Keystone.auth_ref")
self.auth_ref_patcher = mock.patch("%s.Keystone.auth_ref" % PATH)
self.auth_ref = self.auth_ref_patcher.start()
self.service_catalog = self.auth_ref.service_catalog
@ -380,7 +384,7 @@ class OSClientsTestCase(test.TestCase):
self.assertRaises(exceptions.InvalidAdminException,
self.clients.verified_keystone)
@mock.patch("rally.osclients.Keystone.get_session")
@mock.patch("%s.Keystone.get_session" % PATH)
def test_verified_keystone_authentication_fails(self,
mock_keystone_get_session):
self.auth_ref_patcher.stop()
@ -395,7 +399,7 @@ class OSClientsTestCase(test.TestCase):
self.assertRaises(exceptions.AuthenticationFailed,
self.clients.verified_keystone)
@mock.patch("rally.osclients.Nova._get_endpoint")
@mock.patch("%s.Nova._get_endpoint" % PATH)
def test_nova(self, mock_nova__get_endpoint):
fake_nova = fakes.FakeNovaClient()
mock_nova__get_endpoint.return_value = "http://fake.to:2/fake"
@ -427,7 +431,7 @@ class OSClientsTestCase(test.TestCase):
def test_nova_service_type(self):
self.clients.nova.is_service_type_configurable()
@mock.patch("rally.osclients.Neutron._get_endpoint")
@mock.patch("%s.Neutron._get_endpoint" % PATH)
def test_neutron(self, mock_neutron__get_endpoint):
fake_neutron = fakes.FakeNeutronClient()
mock_neutron__get_endpoint.return_value = "http://fake.to:2/fake"
@ -446,7 +450,7 @@ class OSClientsTestCase(test.TestCase):
mock_neutron.client.Client.assert_called_once_with("2.0", **kw)
self.assertEqual(fake_neutron, self.clients.cache["neutron"])
@mock.patch("rally.osclients.Neutron._get_endpoint")
@mock.patch("%s.Neutron._get_endpoint" % PATH)
def test_neutron_endpoint_type(self, mock_neutron__get_endpoint):
fake_neutron = fakes.FakeNeutronClient()
mock_neutron__get_endpoint.return_value = "http://fake.to:2/fake"
@ -454,7 +458,7 @@ class OSClientsTestCase(test.TestCase):
mock_keystoneauth1 = mock.MagicMock()
mock_neutron.client.Client.return_value = fake_neutron
self.assertNotIn("neutron", self.clients.cache)
self.credential.endpoint_type = "internal"
self.credential["endpoint_type"] = "internal"
with mock.patch.dict("sys.modules",
{"neutronclient.neutron": mock_neutron,
"keystoneauth1": mock_keystoneauth1}):
@ -467,7 +471,7 @@ class OSClientsTestCase(test.TestCase):
mock_neutron.client.Client.assert_called_once_with("2.0", **kw)
self.assertEqual(fake_neutron, self.clients.cache["neutron"])
@mock.patch("rally.osclients.Heat._get_endpoint")
@mock.patch("%s.Heat._get_endpoint" % PATH)
def test_heat(self, mock_heat__get_endpoint):
fake_heat = fakes.FakeHeatClient()
mock_heat__get_endpoint.return_value = "http://fake.to:2/fake"
@ -482,12 +486,11 @@ class OSClientsTestCase(test.TestCase):
self.assertEqual(fake_heat, client)
kw = {
"session": mock_keystoneauth1.session.Session(),
"endpoint": mock_heat__get_endpoint.return_value,
"endpoint_override": mock_heat__get_endpoint.return_value}
mock_heat.client.Client.assert_called_once_with("1", **kw)
self.assertEqual(fake_heat, self.clients.cache["heat"])
@mock.patch("rally.osclients.Heat._get_endpoint")
@mock.patch("%s.Heat._get_endpoint" % PATH)
def test_heat_endpoint_type_interface(self, mock_heat__get_endpoint):
fake_heat = fakes.FakeHeatClient()
mock_heat__get_endpoint.return_value = "http://fake.to:2/fake"
@ -495,8 +498,7 @@ class OSClientsTestCase(test.TestCase):
mock_keystoneauth1 = mock.MagicMock()
mock_heat.client.Client.return_value = fake_heat
self.assertNotIn("heat", self.clients.cache)
self.credential.endpoint_type = "internal"
self.credential.interface = "internal"
self.credential["endpoint_type"] = "internal"
with mock.patch.dict("sys.modules",
{"heatclient": mock_heat,
"keystoneauth1": mock_keystoneauth1}):
@ -504,14 +506,12 @@ class OSClientsTestCase(test.TestCase):
self.assertEqual(fake_heat, client)
kw = {
"session": mock_keystoneauth1.session.Session(),
"endpoint": mock_heat__get_endpoint.return_value,
"endpoint_override": mock_heat__get_endpoint.return_value,
"endpoint_type": "internal",
"interface": "internal"}
mock_heat.client.Client.assert_called_once_with("1", **kw)
self.assertEqual(fake_heat, self.clients.cache["heat"])
@mock.patch("rally.osclients.Glance._get_endpoint")
@mock.patch("%s.Glance._get_endpoint" % PATH)
def test_glance(self, mock_glance__get_endpoint):
fake_glance = fakes.FakeGlanceClient()
mock_glance = mock.MagicMock()
@ -531,7 +531,7 @@ class OSClientsTestCase(test.TestCase):
mock_glance.Client.assert_called_once_with(**kw)
self.assertEqual(fake_glance, self.clients.cache["glance"])
@mock.patch("rally.osclients.Cinder._get_endpoint")
@mock.patch("%s.Cinder._get_endpoint" % PATH)
def test_cinder(self, mock_cinder__get_endpoint):
fake_cinder = mock.MagicMock(client=fakes.FakeCinderClient())
mock_cinder = mock.MagicMock()
@ -551,7 +551,7 @@ class OSClientsTestCase(test.TestCase):
"2", **kw)
self.assertEqual(fake_cinder, self.clients.cache["cinder"])
@mock.patch("rally.osclients.Manila._get_endpoint")
@mock.patch("%s.Manila._get_endpoint" % PATH)
def test_manila(self, mock_manila__get_endpoint):
mock_manila = mock.MagicMock()
mock_manila__get_endpoint.return_value = "http://fake.to:2/fake"
@ -577,7 +577,7 @@ class OSClientsTestCase(test.TestCase):
self.assertRaises(exceptions.RallyException,
osclients.Manila.validate_version, "foo")
@mock.patch("rally.osclients.Ceilometer._get_endpoint")
@mock.patch("%s.Ceilometer._get_endpoint" % PATH)
def test_ceilometer(self, mock_ceilometer__get_endpoint):
fake_ceilometer = fakes.FakeCeilometerClient()
mock_ceilometer = mock.MagicMock()
@ -649,7 +649,7 @@ class OSClientsTestCase(test.TestCase):
self.assertEqual(mock_monasca.client.Client.return_value,
self.clients.cache["monasca"])
@mock.patch("rally.osclients.Ironic._get_endpoint")
@mock.patch("%s.Ironic._get_endpoint" % PATH)
def test_ironic(self, mock_ironic__get_endpoint):
fake_ironic = fakes.FakeIronicClient()
mock_ironic = mock.MagicMock()
@ -669,7 +669,7 @@ class OSClientsTestCase(test.TestCase):
mock_ironic.client.get_client.assert_called_once_with("1", **kw)
self.assertEqual(fake_ironic, self.clients.cache["ironic"])
@mock.patch("rally.osclients.Sahara._get_endpoint")
@mock.patch("%s.Sahara._get_endpoint" % PATH)
def test_sahara(self, mock_sahara__get_endpoint):
fake_sahara = fakes.FakeSaharaClient()
mock_sahara = mock.MagicMock()
@ -710,7 +710,7 @@ class OSClientsTestCase(test.TestCase):
self.assertEqual(fake_zaqar, self.clients.cache["zaqar"],
mock_keystoneauth1.session.Session())
@mock.patch("rally.osclients.Trove._get_endpoint")
@mock.patch("%s.Trove._get_endpoint" % PATH)
def test_trove(self, mock_trove__get_endpoint):
fake_trove = fakes.FakeTroveClient()
mock_trove = mock.MagicMock()
@ -774,7 +774,7 @@ class OSClientsTestCase(test.TestCase):
mock_swift.client.Connection.assert_called_once_with(**kw)
self.assertEqual(fake_swift, self.clients.cache["swift"])
@mock.patch("rally.osclients.EC2._get_endpoint")
@mock.patch("%s.EC2._get_endpoint" % PATH)
def test_ec2(self, mock_ec2__get_endpoint):
mock_boto = mock.Mock()
self.fake_keystone.ec2 = mock.Mock()
@ -798,7 +798,7 @@ class OSClientsTestCase(test.TestCase):
mock_boto.connect_ec2_endpoint.assert_called_once_with(**kw)
self.assertEqual(fake_ec2, self.clients.cache["ec2"])
@mock.patch("rally.osclients.Keystone.service_catalog")
@mock.patch("%s.Keystone.service_catalog" % PATH)
def test_services(self, mock_keystone_service_catalog):
available_services = {consts.ServiceType.IDENTITY: {},
consts.ServiceType.COMPUTE: {},
@ -830,7 +830,7 @@ class OSClientsTestCase(test.TestCase):
mock_murano.client.Client.assert_called_once_with("1", **kw)
self.assertEqual(fake_murano, self.clients.cache["murano"])
@mock.patch("rally.osclients.Keystone.get_session")
@mock.patch("%s.Keystone.get_session" % PATH)
@ddt.data(
{},
{"version": "2"},
@ -900,7 +900,7 @@ class OSClientsTestCase(test.TestCase):
mock_senlin.client.Client.return_value,
self.clients.cache["senlin"])
@mock.patch("rally.osclients.Magnum._get_endpoint")
@mock.patch("%s.Magnum._get_endpoint" % PATH)
def test_magnum(self, mock_magnum__get_endpoint):
fake_magnum = fakes.FakeMagnumClient()
mock_magnum = mock.MagicMock()
@ -924,7 +924,7 @@ class OSClientsTestCase(test.TestCase):
mock_magnum.client.Client.assert_called_once_with(**kw)
self.assertEqual(fake_magnum, self.clients.cache["magnum"])
@mock.patch("rally.osclients.Watcher._get_endpoint")
@mock.patch("%s.Watcher._get_endpoint" % PATH)
def test_watcher(self, mock_watcher__get_endpoint):
fake_watcher = fakes.FakeWatcherClient()
mock_watcher = mock.MagicMock()

71
tests/unit/task/test_engine.py
View File

@ -26,7 +26,6 @@ from rally import exceptions
from rally.task import context
from rally.task import engine
from rally.task import scenario
from tests.unit import fakes
from tests.unit import test
@ -313,17 +312,17 @@ class TaskEngineTestCase(test.TestCase):
"Subtask configuration:\n<JSON>\n\n"
"Reason(s):\n trigger_error", e.format_message())
@mock.patch("rally.task.engine.context.Context")
@mock.patch("rally.task.engine.context.ContextManager.cleanup")
@mock.patch("rally.task.engine.context.ContextManager.setup")
@mock.patch("rally.task.engine.TaskConfig")
@mock.patch("rally.task.engine.objects.Deployment.get",
return_value="FakeDeployment")
def test__validate_config_semantic(
self, mock_deployment_get,
mock_task_config, mock_context):
admin = fakes.fake_credential(foo="admin")
users = [fakes.fake_credential(bar="user1")]
deployment = fakes.FakeDeployment(
uuid="deployment_uuid", admin=admin, users=users)
def test__validate_config_semantic(self, mock_task_config,
mock_context_manager_setup,
mock_context_manager_cleanup):
env = mock.MagicMock(uuid="env_uuid")
env.check_health.return_value = {
"foo": {"available": True, "message": ""},
"bar": {"available": True, "message": ""}
}
@scenario.configure("SomeScen.scenario")
class SomeScen(scenario.Scenario):
@ -344,41 +343,47 @@ class TaskEngineTestCase(test.TestCase):
mock_task_instance.subtasks = [subtask1, subtask2]
fake_task = mock.MagicMock()
eng = engine.TaskEngine(mock_task_instance, fake_task, deployment)
eng = engine.TaskEngine(mock_task_instance, fake_task, env)
eng._validate_config_semantic(mock_task_instance)
env.check_health.return_value = {
"foo": {"available": True, "message": ""},
"bar": {"available": False, "message": "", "traceback": "AAAA"}
}
self.assertRaises(exceptions.ValidationError,
eng._validate_config_semantic,
mock_task_instance)
@mock.patch("rally.task.engine.TaskConfig")
@mock.patch("rally.task.engine.TaskEngine._validate_workload")
def test__validate_config_platforms(
self, mock__validate_workload, mock_task_config):
class FakeDeployment(object):
def __init__(self, credentials):
self._creds = credentials
self.get_all_credentials = mock.Mock()
self.get_all_credentials.return_value = self._creds
foo_cred1 = {"admin": "admin", "users": ["user1"]}
foo_cred2 = {"admin": "admin", "users": ["user1"]}
deployment = FakeDeployment({"foo": [foo_cred1, foo_cred2]})
foo_cred = {"admin": "admin", "users": ["user1"]}
env = mock.MagicMock(data={
"platforms": {
"foo": {
"platform_name": "foo", "platform_data": foo_cred
}
}
})
workload1 = "workload1"
workload2 = "workload2"
subtasks = [{"workloads": [workload1]},
{"workloads": [workload2]}]
config = mock.Mock(subtasks=subtasks)
eng = engine.TaskEngine({}, mock.MagicMock(), deployment)
eng = engine.TaskEngine({}, mock.MagicMock(), env)
eng._validate_config_platforms(config)
self.assertEqual(
[mock.call(w, vtype="platform",
vcontext={"platforms": {"foo": foo_cred1},
vcontext={"platforms": {"foo": foo_cred},
"task": eng.task})
for w in (workload1, workload2)],
mock__validate_workload.call_args_list)
deployment.get_all_credentials.assert_called_once_with()
@mock.patch("rally.common.objects.Task.get_status")
@mock.patch("rally.task.engine.TaskConfig")
@ -434,11 +439,9 @@ class TaskEngineTestCase(test.TestCase):
self._make_workload(name="a.task", description="foo",
contexts={"context_a": {"b": 2}},
position=2)]}]
deployment = fakes.FakeDeployment(
uuid="deployment_uuid", admin={"foo": "admin"})
eng = engine.TaskEngine(mock_task_instance, mock.MagicMock(),
deployment)
mock.MagicMock())
eng.run()
self.assertEqual(2, mock_log.exception.call_count)
@ -471,9 +474,7 @@ class TaskEngineTestCase(test.TestCase):
fake_runner = mock.MagicMock()
fake_runner_cls.return_value = fake_runner
mock_scenario_runner.get.return_value = fake_runner_cls
deployment = fakes.FakeDeployment(
uuid="deployment_uuid", admin={"foo": "admin"})
eng = engine.TaskEngine(config, task, deployment)
eng = engine.TaskEngine(config, task, mock.MagicMock())
eng.run()
@ -575,13 +576,17 @@ class TaskEngineTestCase(test.TestCase):
name = "test_ctx.test"
context_config = {"test1": 1, "test2": 2}
eng = engine.TaskEngine({}, task, mock.MagicMock())
env = mock.MagicMock()
eng = engine.TaskEngine({}, task, env)
result = eng._prepare_context(context_config, name, "foo_uuid")
expected_result = {
"task": task,
"owner_id": "foo_uuid",
"scenario_name": name,
"config": {"test1@testing": 1, "test2@testing": 2}
"config": {"test1@testing": 1, "test2@testing": 2},
"env": env.data
}
self.assertEqual(expected_result, result)

170
tests/unit/test_api.py
View File

@ -73,24 +73,24 @@ class TaskAPITestCase(test.TestCase):
@mock.patch("rally.api.engine.TaskEngine")
def test_validate(self, mock_task_engine, mock_deployment_get, mock_task,
mock_task_config):
fake_deployment = fakes.FakeDeployment(
uuid="deployment_uuid_1", admin="fake_admin", users=["fake_user"])
fake_deployment = mock.Mock()
fake_env = fake_deployment.env_obj
mock_deployment_get.return_value = fake_deployment
#######################################################################
# The case #1 -- create temporary task
#######################################################################
self.task_inst.validate(deployment=fake_deployment["uuid"],
self.task_inst.validate(deployment=fake_deployment.uuid,
config="config")
mock_task_engine.assert_called_once_with(
mock_task_config.return_value, mock_task.return_value,
fake_deployment),
fake_env),
mock_task_engine.return_value.validate.assert_called_once_with()
mock_task.assert_called_once_with(
temporary=True, env_uuid=fake_deployment["uuid"])
mock_deployment_get.assert_called_once_with(fake_deployment["uuid"])
temporary=True, env_uuid=fake_deployment.uuid)
mock_deployment_get.assert_called_once_with(fake_deployment.uuid)
self.assertFalse(mock_task.get.called)
#######################################################################
@ -105,12 +105,12 @@ class TaskAPITestCase(test.TestCase):
task_uuid = "task-id"
self.task_inst.validate(deployment=fake_deployment["uuid"],
self.task_inst.validate(deployment=fake_deployment.uuid,
config="config",
task=task_uuid)
mock_task_engine.assert_called_once_with(
mock_task_config.return_value, fake_task, fake_deployment)
mock_task_config.return_value, fake_task, fake_env)
mock_task_engine.return_value.validate.assert_called_once_with()
self.assertFalse(mock_task.called)
@ -129,12 +129,12 @@ class TaskAPITestCase(test.TestCase):
task_instance = fakes.FakeTask(uuid="task-id")
self.task_inst.validate(deployment=fake_deployment["uuid"],
self.task_inst.validate(deployment=fake_deployment.uuid,
config="config",
task_instance=task_instance)
mock_task_engine.assert_called_once_with(
mock_task_config.return_value, fake_task, fake_deployment)
mock_task_config.return_value, fake_task, fake_env)
mock_task_engine.return_value.validate.assert_called_once_with()
self.assertFalse(mock_task.called)
@ -151,7 +151,7 @@ class TaskAPITestCase(test.TestCase):
e = self.assertRaises(exceptions.InvalidTaskException,
self.task_inst.validate,
deployment=fake_deployment["uuid"],
deployment=fake_deployment.uuid,
config="config",
task_instance=task_instance)
self.assertIn("Who is a good boy?! Woof.", "%s" % e)
@ -270,9 +270,10 @@ class TaskAPITestCase(test.TestCase):
fake_task = fakes.FakeTask(uuid="some_uuid")
fake_task.get_status = mock.Mock()
mock_task.return_value = fake_task
mock_deployment_get.return_value = fakes.FakeDeployment(
fake_deployment = fakes.FakeDeployment(
uuid="deployment_uuid", admin="fake_admin", users=["fake_user"],
status=consts.DeployStatus.DEPLOY_FINISHED)
mock_deployment_get.return_value = fake_deployment
task_config_instance = mock_task_config.return_value
self.assertEqual(
@ -285,7 +286,7 @@ class TaskAPITestCase(test.TestCase):
mock_task_engine.assert_called_once_with(
task_config_instance,
mock_task.return_value,
mock_deployment_get.return_value,
fake_deployment.env_obj,
abort_on_sla_failure=False
)
task_engine = mock_task_engine.return_value
@ -805,90 +806,79 @@ class DeploymentAPITestCase(BaseDeploymentTestCase):
@mock.patch("rally.common.objects.Deployment.get")
def test_deployment_check(self, mock_deployment_get):
fake_credential1 = fakes.fake_credential()
fake_credential2 = fakes.fake_credential()
mock_deployment_get.return_value.get_all_credentials.return_value = {
"openstack": [{"admin": fake_credential1,
"users": [fake_credential2]}]}
env = mock_deployment_get.return_value.env_obj
env.check_health.return_value = {
"foo": {"available": True}
}
self.assertEqual(
{"openstack": [
{"services": fake_credential1.list_services.return_value}]},
{"foo": [{"services": []}]},
self.deployment_inst.check(deployment="uuid"))
fake_credential1.verify_connection.assert_called_once_with()
fake_credential2.verify_connection.assert_called_once_with()
env.check_health.assert_called_once_with()
self.assertFalse(env.get_info.called)
@mock.patch("rally.common.objects.Deployment.get")
def test_deployment_check_list_services_via_admin(self,
mock_deployment_get):
fake_credential1 = fakes.fake_credential()
fake_credential2 = fakes.fake_credential()
mock_deployment_get.return_value.get_all_credentials.return_value = {
"openstack": [{"admin": fake_credential1,
"users": [fake_credential2]}]}
def test_deployment_check_list_services(self, mock_deployment_get):
env = mock_deployment_get.return_value.env_obj
env.get_info.return_value = {
"existing@openstack": {"info": {"services": {"foo": "bar"}}}
}
env.check_health.return_value = {
"existing@openstack": {"available": True}
}
self.assertEqual(
{"openstack": [
{"services": fake_credential1.list_services.return_value}]},
{"openstack": [{"services": [{"type": "foo", "name": "bar"}]}]},
self.deployment_inst.check(deployment="uuid"))
fake_credential1.verify_connection.assert_called_once_with()
fake_credential1.list_services.assert_called_once_with()
fake_credential2.verify_connection.assert_called_once_with()
self.assertFalse(fake_credential2.list_services.called)
env.check_health.assert_called_once_with()
env.get_info.assert_called_once_with()
@mock.patch("rally.common.objects.Deployment.get")
def test_deployment_check_list_services_via_user(self,
mock_deployment_get):
fake_credential1 = fakes.fake_credential()
fake_credential2 = fakes.fake_credential()
def test_deployment_check_fails(self, mock_deployment_get):
env = mock_deployment_get.return_value.env_obj
env.get_info.return_value = {
"existing@openstack": {"info": {"services": [{"foo": "bar"}]}}
}
mock_deployment_get.return_value.get_all_credentials.return_value = {
"openstack": [{"admin": None,
"users": [fake_credential2, fake_credential1]}]}
trace1 = ("Traceback (most recent call last):\n"
" File '<ipython-input-3-e551aac575a4>', line 2, in "
"<module>\n"
" raise Exception('asd: asd :asd asd ')\n"
"Exception: asd: asd :asd asd \n")
msg1 = "Bad user creds: oops"
trace2 = ("Traceback (most recent call last):\n"
" File '<ipython-input-3-e551aac575a4>', line 2, in "
"<module>\n"
" raise KeyError('asd: asd :asd asd2 ')\n"
"KeyError: asd: asd :asd asd2 \n")
msg2 = "Ooops"
env.check_health.return_value = {
"existing@openstack": {
"available": False,
"message": msg1,
"traceback": trace1},
"foo@bar": {
"available": False,
"message": msg2,
"traceback": trace2
}
}
self.assertEqual(
{"openstack": [
{"services": fake_credential2.list_services.return_value}]},
{
"openstack": [{
"services": [],
"user_error": {"etype": "Exception",
"msg": msg1,
"trace": trace1}}],
"foo@bar": [{
"services": [],
"admin_error": {"etype": "KeyError",
"msg": msg2,
"trace": trace2}}]},
self.deployment_inst.check(deployment="uuid"))
fake_credential2.verify_connection.assert_called_once_with()
fake_credential2.list_services.assert_called_once_with()
fake_credential1.verify_connection.assert_called_once_with()
self.assertFalse(fake_credential1.list_services.called)
@mock.patch("rally.api.traceback")
@mock.patch("rally.common.objects.Deployment.get")
def test_deployment_check_fails(self, mock_deployment_get, mock_traceback):
mock_traceback.format_exc.side_effect = ("Trace1", "Trace2")
fake_credential1 = fakes.fake_credential()
fake_credential2 = fakes.fake_credential()
fake_credential1.verify_connection.side_effect = KeyError("oops")
fake_credential2.verify_connection.side_effect = TypeError("ooooops")
mock_deployment_get.return_value.get_all_credentials.return_value = {
"openstack": [{"admin": fake_credential1,
"users": [fake_credential2]}]}
self.assertEqual(
{"openstack": [
{"services": [],
"admin_error": {
"etype": "KeyError", "msg": "'oops'",
"trace": "Trace1"},
"user_error": {
"etype": "TypeError", "msg": "ooooops",
"trace": "Trace2"}}]},
self.deployment_inst.check(deployment="uuid"))
fake_credential1.verify_connection.assert_called_once_with()
fake_credential2.verify_connection.assert_called_once_with()
self.assertFalse(fake_credential1.list_services.called)
self.assertFalse(fake_credential2.list_services.called)
env.check_health.assert_called_once_with()
self.assertFalse(env.get_info.called)
def test_service_list(self):
fake_credential = fakes.fake_credential()
@ -1223,10 +1213,10 @@ class VerifierAPITestCase(test.TestCase):
self.assertFalse(mock_verifier_delete.called)
self.verifier_inst.api.verification.list.assert_called_once_with(
verifier_id=verifier_id, deployment_id=deployment_id)
verifier_obj.set_deployment.assert_called_once_with(deployment_id)
verifier_obj.set_env.assert_called_once_with(deployment_id)
verifier_obj.manager.uninstall.assert_called_once_with()
verifier_obj.set_deployment.reset_mock()
verifier_obj.set_env.reset_mock()
verifier_obj.manager.uninstall.reset_mock()
self.verifier_inst.api.verification.list.reset_mock()
@ -1236,7 +1226,7 @@ class VerifierAPITestCase(test.TestCase):
self.verifier_inst.api.verification.list.assert_called_once_with(
verifier_id=verifier_id, deployment_id=None)
self.assertFalse(verifier_obj.set_deployment.called)
self.assertFalse(verifier_obj.set_env.called)
verifier_obj.manager.uninstall.assert_called_once_with(full=True)
mock_verifier_delete.assert_called_once_with(verifier_id)
@ -1763,7 +1753,7 @@ class VerificationAPITestCase(test.TestCase):
results["totals"])
self.verification_inst.api.verifier._get.assert_called_once_with(
verifier_id)
verifier_obj.set_deployment.assert_called_once_with(deployment_id)
verifier_obj.set_env.assert_called_once_with(deployment_id)
verifier_obj.manager.validate_args.assert_called_once_with(run_args)
mock_verification_create.assert_called_once_with(
verifier_id, deployment_id=deployment_id, run_args=run_args)
@ -1831,7 +1821,7 @@ class VerificationAPITestCase(test.TestCase):
self.verification_inst.start(verifier_id=verifier_id,
deployment_id=deployment_id)
mock_deployment_get.assert_called_once_with(deployment_id)
verifier_obj.set_deployment.assert_called_once_with(deployment_id)
verifier_obj.set_env.assert_called_once_with(deployment_id)
@mock.patch("rally.api.objects.Verification.create")
@mock.patch("rally.api._Verifier.configure")
@ -1858,7 +1848,7 @@ class VerificationAPITestCase(test.TestCase):
**run_args)
mock_deployment_get.assert_called_once_with(deployment_id)
verifier_obj.set_deployment.assert_called_once_with(deployment_id)
verifier_obj.set_env.assert_called_once_with(deployment_id)
verifier_obj.manager.validate.assert_called_once_with(run_args)
mock_verification_create.assert_called_once_with(
@ -1922,7 +1912,7 @@ class VerificationAPITestCase(test.TestCase):
deployment_id=deployment_id,
tags=tags, **run_args)
verifier_obj.set_deployment.assert_called_once_with(deployment_id)
verifier_obj.set_env.assert_called_once_with(deployment_id)
verifier_obj.manager.validate.assert_called_once_with(run_args)
mock_verification_create.assert_called_once_with(
verifier_id=verifier_id, deployment_id=deployment_id, tags=tags,