def test_old_validator_users_error(self):
@plugin.from_func()
def scenario():
pass
scenario._meta_init()
validator_func = mock.Mock()
validator_func.return_value = common_validation.ValidationResult(False)
validator = validation.validator(validator_func)
self.assertEqual(scenario, validator("a", "b", "c", d=1)(scenario))
self.assertEqual(1, len(scenario._meta_get("validators")))
vname, args, kwargs = scenario._meta_get("validators")[0]
validator_cls = common_validation.Validator.get(vname)
validator_inst = validator_cls(*args, **kwargs)
fake_admin = fakes.fake_credential()
fake_users1 = fakes.fake_credential()
fake_users2 = fakes.fake_credential()
users = [{"credential": fake_users1}, {"credential": fake_users2}]
credentials = {"openstack": {"admin": fake_admin, "users": users}}
result = validator_inst.validate(credentials, {}, None, None)
self.assertIsInstance(result, common_validation.ValidationResult)
self.assertFalse(result.is_valid)
fake_users1.clients.assert_called_once_with()
fake_users2.clients.assert_called_once_with()
validator_func.assert_called_once_with(
{}, fake_users1.clients.return_value, mock.ANY,
"a", "b", "c", d=1)
deployment = validator_func.call_args[0][2]
self.assertEqual({"admin": fake_admin, "users": users},
deployment.get_credentials_for("openstack"))
def test__prepare_context_with_existing_users(self, mock_scenario_get,
mock_task_config):
mock_scenario = mock_scenario_get.return_value
mock_scenario.get_default_context.return_value = {}
mock_scenario.get_namespace.return_value = "openstack"
task = mock.MagicMock()
name = "a.task"
context = {"b": 3, "c": 4}
config = {
"a.task": [{"context": {"context_a": {"a": 1}}}],
}
admin = fakes.fake_credential(foo="admin")
users = [fakes.fake_credential(bar="user1")]
deployment = fakes.FakeDeployment(uuid="deployment_uuid",
admin=admin, users=users)
eng = engine.TaskEngine(config, task, deployment)
result = eng._prepare_context(context, name, "foo_uuid")
expected_result = {
"task": task,
"owner_id": "foo_uuid",
"admin": {"credential": admin},
"scenario_name": name,
"scenario_namespace": "openstack",
"config": {"b": 3, "c": 4, "existing_users": users}
}
self.assertEqual(result, expected_result)
mock_scenario_get.assert_called_once_with(name)
def test_old_validator_users_error(self):
validator_func = mock.Mock()
validator_func.return_value = validation.ValidationResult(False)
validator = validation.validator(validator_func)
self.assertEqual(self.Plugin,
validator("a", "b", "c", d=1)(self.Plugin))
self.assertEqual(1, len(self.Plugin._meta_get("validators")))
vname, args, kwargs = self.Plugin._meta_get("validators")[0]
validator_cls = common_validation.Validator.get(vname)
validator_inst = validator_cls(*args, **kwargs)
fake_admin = fakes.fake_credential()
fake_users1 = fakes.fake_credential()
fake_users2 = fakes.fake_credential()
users = [{"credential": fake_users1}, {"credential": fake_users2}]
ctx = {"admin": {"credential": fake_admin}, "users": users}
self.assertRaises(
common_validation.ValidationError,
validator_inst.validate, ctx, {}, None, None)
fake_users1.clients.assert_called_once_with()
fake_users2.clients.assert_called_once_with()
validator_func.assert_called_once_with(
{}, fake_users1.clients.return_value, mock.ANY,
"a", "b", "c", d=1)
deployment = validator_func.call_args[0][2]
self.assertEqual({"admin": fake_admin,
"users": [fake_users1, fake_users2]},
deployment.get_credentials_for("openstack"))
def test_old_validator_users(self):
validator_func = mock.Mock()
validator_func.return_value = None
validator = validation.validator(validator_func)
self.assertEqual(self.Plugin,
validator("a", "b", "c", d=1)(self.Plugin))
self.assertEqual(1, len(self.Plugin._meta_get("validators")))
vname, args, kwargs = self.Plugin._meta_get("validators")[0]
validator_cls = common_validation.Validator.get(vname)
validator_inst = validator_cls(*args, **kwargs)
fake_admin = fakes.fake_credential()
fake_users1 = fakes.fake_credential()
fake_users2 = fakes.fake_credential()
users = [{"credential": fake_users1}, {"credential": fake_users2}]
credentials = {"openstack": {"admin": fake_admin, "users": users}}
result = validator_inst.validate(credentials, {}, None, None)
self.assertIsInstance(result, common_validation.ValidationResult)
self.assertTrue(result.is_valid)
fake_users1.clients.assert_called_once_with()
fake_users2.clients.assert_called_once_with()
validator_func.assert_has_calls((
mock.call({}, fake_users1.clients.return_value, mock.ANY,
"a", "b", "c", d=1),
mock.call({}, fake_users2.clients.return_value, mock.ANY,
"a", "b", "c", d=1)
))
for args in validator_func.call_args:
deployment = validator_func.call_args[0][2]
self.assertEqual({"admin": fake_admin, "users": users},
deployment.get_credentials_for("openstack"))
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)
@scenario.configure("SomeScen.scenario")
class SomeScen(scenario.Scenario):
def run(self):
pass
mock_task_instance = mock.MagicMock()
wconf1 = self._make_workload(name="SomeScen.scenario",
contexts={"users": {}})
wconf2 = self._make_workload(name="SomeScen.scenario",
position=1)
subtask1 = {"workloads": [wconf1, wconf2]}
wconf3 = self._make_workload(name="SomeScen.scenario",
position=2)
subtask2 = {"workloads": [wconf3]}
mock_task_instance.subtasks = [subtask1, subtask2]
fake_task = mock.MagicMock()
eng = engine.TaskEngine(mock_task_instance, fake_task, deployment)
eng._validate_config_semantic(mock_task_instance)
def test_old_validator_users_error(self):
validator_func = mock.Mock()
validator_func.return_value = validation.ValidationResult(False)
validator = validation.validator(validator_func)
self.assertEqual(self.Plugin,
validator("a", "b", "c", d=1)(self.Plugin))
self.assertEqual(1, len(self.Plugin._meta_get("validators")))
vname, args, kwargs = self.Plugin._meta_get("validators")[0]
validator_cls = common_validation.Validator.get(vname)
validator_inst = validator_cls(*args, **kwargs)
fake_admin = fakes.fake_credential()
fake_users1 = fakes.fake_credential()
fake_users2 = fakes.fake_credential()
users = [{"credential": fake_users1}, {"credential": fake_users2}]
ctx = {"admin": {"credential": fake_admin}, "users": users}
self.assertRaises(common_validation.ValidationError,
validator_inst.validate, ctx, {}, None, None)
fake_users1.clients.assert_called_once_with()
fake_users2.clients.assert_called_once_with()
validator_func.assert_called_once_with(
{}, fake_users1.clients.return_value, mock.ANY, "a", "b", "c", d=1)
deployment = validator_func.call_args[0][2]
self.assertEqual(
{
"admin": fake_admin,
"users": [fake_users1, fake_users2]
}, deployment.get_credentials_for("openstack"))
def test_required_service(self):
validator = self._unwrap_validator(validation.required_services,
consts.Service.KEYSTONE,
consts.Service.NOVA,
consts.Service.NOVA_NET)
admin = fakes.fake_credential(foo="bar")
clients = mock.Mock()
clients.services().values.return_value = [consts.Service.KEYSTONE,
consts.Service.NOVA,
consts.Service.NOVA_NET]
fake_service = mock.Mock(binary="nova-network", status="enabled")
admin_clients = admin.clients.return_value
nova_client = admin_clients.nova.return_value
nova_client.services.list.return_value = [fake_service]
deployment = fakes.FakeDeployment(admin=admin)
result = validator({}, clients, deployment)
self.assertTrue(result.is_valid, result.msg)
validator = self._unwrap_validator(validation.required_services,
consts.Service.KEYSTONE,
consts.Service.NOVA)
clients.services().values.return_value = [consts.Service.KEYSTONE]
result = validator({}, clients, None)
self.assertFalse(result.is_valid, result.msg)
def test_old_validator_admin(self):
validator_func = mock.Mock()
validator_func.return_value = None
validator = validation.validator(validator_func)
self.assertEqual(self.Plugin,
validator("a", "b", "c", d=1)(self.Plugin))
self.assertEqual(1, len(self.Plugin._meta_get("validators")))
vname, args, kwargs = self.Plugin._meta_get("validators")[0]
validator_cls = common_validation.Validator.get(vname)
validator_inst = validator_cls(*args, **kwargs)
fake_admin = fakes.fake_credential()
ctx = {"admin": {"credential": fake_admin}, "users": []}
result = validator_inst.validate(ctx, {}, None, None)
self.assertIsNone(result)
validator_func.assert_called_once_with({},
None,
mock.ANY,
"a",
"b",
"c",
d=1)
deployment = validator_func.call_args[0][2]
self.assertEqual({
"admin": fake_admin,
"users": []
}, deployment.get_credentials_for("openstack"))
def test__validate_config_semantic(
self, mock_deployment_get,
mock__validate_config_semantic_helper,
mock_task_config, mock_context,
mock_scenario_get):
admin = fakes.fake_credential(foo="admin")
users = [fakes.fake_credential(bar="user1")]
deployment = fakes.FakeDeployment(
uuid="deployment_uuid", admin=admin, users=users)
class SomeScen(object):
is_classbased = True
@classmethod
def get_namespace(cls):
return "openstack"
@classmethod
def get_info(cls):
return {"title": "foo"}
mock_scenario_get.return_value = SomeScen
mock_task_instance = mock.MagicMock()
mock_subtask1 = mock.MagicMock()
wconf1 = engine.Workload({"name": "a", "runner": "ra",
"context": {"users": {}}}, 0)
wconf2 = engine.Workload({"name": "a", "runner": "rb"}, 1)
mock_subtask1.workloads = [wconf1, wconf2]
mock_subtask2 = mock.MagicMock()
wconf3 = engine.Workload({"name": "b", "runner": "ra"}, 0)
mock_subtask2.workloads = [wconf3]
mock_task_instance.subtasks = [mock_subtask1, mock_subtask2]
fake_task = mock.MagicMock()
eng = engine.TaskEngine(mock_task_instance, fake_task, deployment)
eng._validate_config_semantic(mock_task_instance)
user_context = mock_context.get.return_value.return_value
mock__validate_config_semantic_helper.assert_has_calls([
mock.call(admin, user_context, [wconf1], "openstack"),
mock.call(admin, user_context, [wconf2, wconf3], "openstack"),
], any_order=True)
def test__validate_config_semantic(
self, mock_deployment_get,
mock__validate_config_semantic_helper,
mock_task_config, mock_context,
mock_scenario_get):
admin = fakes.fake_credential(foo="admin")
users = [fakes.fake_credential(bar="user1")]
deployment = fakes.FakeDeployment(
uuid="deployment_uuid", admin=admin, users=users)
# TODO(boris-42): Refactor this test case to make it
# up to date with other code
class SomeScen(object):
is_classbased = True
@classmethod
def get_platform(cls):
return "openstack"
@classmethod
def get_info(cls):
return {"title": "foo"}
mock_scenario_get.return_value = SomeScen
mock_task_instance = mock.MagicMock()
wconf1 = self._make_workload(name="a", runner="ra",
context={"users": {}})
wconf2 = self._make_workload(name="a", runner="rb", position=1)
subtask1 = {"workloads": [wconf1, wconf2]}
wconf3 = self._make_workload(name="b", runner="ra", position=2)
subtask2 = {"workloads": [wconf3]}
mock_task_instance.subtasks = [subtask1, subtask2]
fake_task = mock.MagicMock()
eng = engine.TaskEngine(mock_task_instance, fake_task, deployment)
eng._validate_config_semantic(mock_task_instance)
user_context = mock_context.get.return_value.return_value
mock__validate_config_semantic_helper.assert_called_once_with(
admin, user_context, [wconf1, wconf2, wconf3], "openstack")
def test_required_cinder_services(self):
validator = self._unwrap_validator(
validation.required_cinder_services,
service_name=six.text_type("cinder-service"))
fake_service = mock.Mock(binary="cinder-service", state="up")
admin = fakes.fake_credential(foo="bar")
cinder = admin.clients.return_value.cinder.return_value
cinder.services.list.return_value = [fake_service]
deployment = fakes.FakeDeployment(admin=admin)
result = validator({}, None, deployment)
self.assertTrue(result.is_valid, result.msg)
fake_service.state = "down"
result = validator({}, None, deployment)
self.assertFalse(result.is_valid, result.msg)
def test_required_clients_with_admin(self):
validator = self._unwrap_validator(validation.required_clients,
"keystone", "nova", admin=True)
admin = fakes.fake_credential(foo="bar")
clients = admin.clients.return_value
clients.keystone.return_value = "keystone"
clients.nova.return_value = "nova"
deployment = fakes.FakeDeployment(admin=admin)
result = validator({}, clients, deployment)
self.assertTrue(result.is_valid, result.msg)
clients.nova.side_effect = ImportError
result = validator({}, clients, deployment)
self.assertFalse(result.is_valid, result.msg)
def setUp(self):
super(TempestContextTestCase, self).setUp()
self.mock_isfile = mock.patch("os.path.isfile",
return_value=True).start()
self.cred = fakes.fake_credential(**CRED)
self.deployment = fakes.FakeDeployment(
uuid="fake_deployment", admin=self.cred)
cfg = {"verifier": mock.Mock(deployment=self.deployment),
"verification": {"uuid": "uuid"}}
cfg["verifier"].manager.home_dir = "/p/a/t/h"
cfg["verifier"].manager.configfile = "/fake/path/to/config"
self.context = context.TempestContext(cfg)
self.context.conf.add_section("compute")
self.context.conf.add_section("orchestration")
self.context.conf.add_section("scenario")
def setUp(self):
super(TempestContextTestCase, self).setUp()
self.mock_isfile = mock.patch("os.path.isfile",
return_value=True).start()
self.cred = fakes.fake_credential(**CRED)
self.deployment = fakes.FakeDeployment(
uuid="fake_deployment", admin=self.cred)
cfg = {"verifier": mock.Mock(deployment=self.deployment),
"verification": {"uuid": "uuid"}}
cfg["verifier"].manager.home_dir = "/p/a/t/h"
cfg["verifier"].manager.configfile = "/fake/path/to/config"
self.context = context.TempestContext(cfg)
self.context.conf.add_section("compute")
self.context.conf.add_section("orchestration")
self.context.conf.add_section("scenario")
def test_old_validator_admin(self):
validator_func = mock.Mock()
validator_func.return_value = None
validator = validation.validator(validator_func)
self.assertEqual(self.Plugin,
validator("a", "b", "c", d=1)(self.Plugin))
self.assertEqual(1, len(self.Plugin._meta_get("validators")))
vname, args, kwargs = self.Plugin._meta_get("validators")[0]
validator_cls = common_validation.Validator.get(vname)
validator_inst = validator_cls(*args, **kwargs)
fake_admin = fakes.fake_credential()
ctx = {"admin": {"credential": fake_admin}, "users": []}
result = validator_inst.validate(ctx, {}, None, None)
self.assertIsNone(result)
validator_func.assert_called_once_with(
{}, None, mock.ANY, "a", "b", "c", d=1)
deployment = validator_func.call_args[0][2]
self.assertEqual({"admin": fake_admin, "users": []},
deployment.get_credentials_for("openstack"))
def setUp(self):
super(TempestConfigfileManagerTestCase, self).setUp()
deployment = fakes.FakeDeployment(uuid="fake_deployment",
admin=fakes.fake_credential(**CRED))
self.tempest = config.TempestConfigfileManager(deployment)
def setUp(self):
super(TempestConfigfileManagerTestCase, self).setUp()
deployment = fakes.FakeDeployment(uuid="fake_deployment",
admin=fakes.fake_credential(**CRED))
self.tempest = config.TempestConfigfileManager(deployment)
