def test_get_user_ctx_for_validation_existing_users( self, mock_existing_users, mock_task_config): context = {"a": 10} users = [mock.MagicMock(), mock.MagicMock()] eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock(), users=users) result = eng._get_user_ctx_for_validation(context) self.assertEqual(context["config"]["existing_users"], users) mock_existing_users.assert_called_once_with(context) self.assertEqual(mock_existing_users.return_value, result)
def test_validate(self, mock_validate, mock_task_config): mock_task_config.return_value = config = mock.MagicMock() eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock(), mock.Mock()) mock_validate = mock.MagicMock() eng._validate_config_syntax = mock_validate.syntax eng._validate_config_platforms = mock_validate.platforms eng._validate_config_semantic = mock_validate.semantic eng.validate() mock_validate.syntax.assert_called_once_with(config) mock_validate.platforms.assert_called_once_with(config) mock_validate.semantic.assert_called_once_with(config)
def validate(cls, deployment, config, task_instance=None): """Validate a task config against specified deployment. :param deployment: UUID or name of the deployment :param config: a dict with a task configuration """ deployment = objects.Deployment.get(deployment) task = task_instance or objects.Task( deployment_uuid=deployment["uuid"], temporary=True) benchmark_engine = engine.TaskEngine(config, task, admin=deployment["admin"], users=deployment["users"]) benchmark_engine.validate()
def test_validate__wrong_semantic(self, mock_task_config): task = mock.MagicMock() eng = engine.TaskEngine(mock.MagicMock(), task, mock.Mock()) eng._validate_config_syntax = mock.MagicMock() eng._validate_config_platforms = mock.MagicMock() eng._validate_config_semantic = mock.MagicMock( side_effect=exceptions.InvalidTaskConfig) self.assertRaises(exceptions.InvalidTaskException, eng.validate) self.assertTrue(task.set_failed.called) # all steps of validation are called, which means that the last one is # failed self.assertTrue(eng._validate_config_syntax) self.assertTrue(eng._validate_config_platforms) self.assertTrue(eng._validate_config_semantic)
def test__validate_config_scenarios_name(self, mock_scenario_get_all, mock_task_config): mock_task_instance = mock.MagicMock() mock_subtask = mock.MagicMock() mock_subtask.scenarios = [{"name": "a"}, {"name": "b"}] mock_task_instance.subtasks = [mock_subtask] mock_scenario_get_all.return_value = [ mock.MagicMock(get_name=lambda: "e"), mock.MagicMock(get_name=lambda: "b"), mock.MagicMock(get_name=lambda: "a") ] eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock()) eng._validate_config_scenarios_name(mock_task_instance)
def test__validate_config_syntax__wrong_context( self, mock_context_manager, mock_scenario_runner_validate, mock_task_config): mock_task_instance = mock.MagicMock() mock_subtask = mock.MagicMock() mock_subtask.workloads = [ engine.Workload({"name": "sca", "context": "a"}), engine.Workload({"name": "sca", "runner": "b"}) ] mock_task_instance.subtasks = [mock_subtask] eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock()) mock_context_manager.validate = mock.MagicMock( side_effect=jsonschema.ValidationError("a")) self.assertRaises(exceptions.InvalidTaskConfig, eng._validate_config_syntax, mock_task_instance)
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__wrong_syntax(self): task = mock.MagicMock() eng = engine.TaskEngine(mock.MagicMock(), task, mock.Mock()) e = exceptions.InvalidTaskConfig(name="foo", pos=0, config="", reason="foo") eng._validate_config_syntax = mock.MagicMock(side_effect=e) eng._validate_config_platforms = mock.Mock() actual_e = self.assertRaises(exceptions.InvalidTaskException, eng.validate) self.assertEqual(e, actual_e) self.assertTrue(task.set_failed.called) # the next validation step should not be processed self.assertFalse(eng._validate_config_platforms.called)
def test__validate_config_semantic(self, 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): def run(self): pass mock_task_instance = mock.MagicMock() wconf1 = self._make_workload(name="SomeScen.scenario") 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, 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)
def test__validate_config_semantic_helper(self, mock_task_config, mock_scenario_get): deployment = mock.Mock() eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock(), deployment) mock_scenario = mock_scenario_get.return_value workloads = [engine.Workload( {"name": "name", "runner": "runner", "args": "args"}, 0)] user_context = mock.MagicMock() user_context.__enter__.return_value.context = { "users": [{"foo": "user1"}]} eng._validate_config_semantic_helper("admin", user_context, workloads, deployment) mock_scenario.validate.assert_called_once_with( "name", {"runner": "runner", "args": "args"}, admin="admin", users=[{"foo": "user1"}], deployment=deployment)
def test__validate_config_semantic_helper(self, mock_task_config): eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock(), mock.Mock()) eng._validate_workload = mock.Mock() workloads = [engine.Workload( {"name": "name", "runner": "runner", "args": "args"}, 0)] users = [{"foo": "user1"}] user_context = mock.MagicMock() user_context.__enter__.return_value.context = {"users": users} eng._validate_config_semantic_helper( "admin", user_context, workloads, "foo") eng._validate_workload.assert_called_once_with( workloads[0], credentials={"foo": {"admin": "admin", "users": users}}, vtype="semantic")
def test__validate_config_scenarios_name_non_exsisting( self, mock_scenario, mock_task_config): mock_task_instance = mock.MagicMock() mock_subtask = mock.MagicMock() mock_subtask.workloads = [ engine.Workload({"name": "exist"}), engine.Workload({"name": "nonexist1"}), engine.Workload({"name": "nonexist2"}) ] mock_task_instance.subtasks = [mock_subtask] mock_scenario.list_benchmark_scenarios.return_value = ["exist", "aaa"] eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock()) self.assertRaises(exceptions.NotFoundScenarios, eng._validate_config_scenarios_name, mock_task_instance)
def test_validate(self, mock_validate, mock_task_config): mock_task_config.return_value = config = mock.MagicMock() eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock()) mock_validate = mock.MagicMock() eng._validate_config_scenarios_name = mock_validate.names eng._validate_config_syntax = mock_validate.syntax eng._validate_config_semantic = mock_validate.semantic eng.validate() expected_calls = [ mock.call.names(config), mock.call.syntax(config), mock.call.semantic(config) ] mock_validate.assert_has_calls(expected_calls)
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___validate_workload__wrong_runner( self, mock_scenario_runner_validate, mock_task_config, mock_scenario_get, mock_dumps): mock_dumps.return_value = "<JSON>" result = validation.ValidationResult(False, "There is no such runner") mock_scenario_runner_validate.return_value = [result] scenario_cls = mock_scenario_get.return_value scenario_cls.get_default_context.return_value = {} workload = engine.Workload({"name": "sca", "runner": {"type": "b"}}, 0) eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock(), mock.Mock()) e = self.assertRaises(exceptions.InvalidTaskConfig, eng._validate_workload, workload) self.assertEqual("Input task is invalid!\n\nSubtask sca[0] has wrong " "configuration\nSubtask configuration:\n" "<JSON>\n\nReason(s):\n" " There is no such runner", e.format_message())
def test___validate_workload__wrong_runner( self, mock_scenario_runner_validate, mock_task_config, mock_scenario_get, mock_dumps): mock_dumps.return_value = "<JSON>" mock_scenario_runner_validate.return_value = [ "There is no such runner"] scenario_cls = mock_scenario_get.return_value scenario_cls.get_default_context.return_value = {} workload = self._make_workload(name="sca", runner=("b", {})) eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock(), mock.Mock()) e = self.assertRaises(exceptions.InvalidTaskConfig, eng._validate_workload, workload) self.assertEqual("Input task is invalid!\n\nSubtask sca[0] has wrong " "configuration\nSubtask configuration:\n" "<JSON>\n\nReason(s):\n" " There is no such runner", e.format_message())
def test__validate_config_semantic_helper(self, mock_scenario_validate, mock_task_config): deployment = mock.MagicMock() eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock()) workload = engine.Workload({ "name": "name", "runner": "runner", "args": "args" }) eng._validate_config_semantic_helper("admin", "user", workload, "pos", deployment) mock_scenario_validate.assert_called_once_with("name", { "runner": "runner", "args": "args" }, admin="admin", users=["user"], deployment=deployment)
def test__prepare_context(self): @context.configure("test1", 1, platform="testing") class TestContext1(context.Context): pass self.addCleanup(TestContext1.unregister) @context.configure("test2", 2, platform="testing") class TestContext2(context.Context): pass self.addCleanup(TestContext2.unregister) @scenario.configure("test_ctx.test", platform="testing", context={"test1@testing": { "a": 1 }}) class TestScenario(scenario.Scenario): pass self.addCleanup(TestScenario.unregister) task = mock.MagicMock() name = "test_ctx.test" context_config = {"test1": 1, "test2": 2} 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 }, "env": env.data } self.assertEqual(expected_result, result)
def test_run__task_aborted( self, mock_scenario_runner, mock_scenario, mock_context_manager_setup, mock_context_manager_cleanup, mock_result_consumer, mock_task_get_status): task = mock.MagicMock(spec=objects.Task) config = { "a.task": [{"runner": {"type": "a", "b": 1}}], "b.task": [{"runner": {"type": "a", "b": 1}}], "c.task": [{"runner": {"type": "a", "b": 1}}] } fake_runner_cls = mock.MagicMock() fake_runner = mock.MagicMock() fake_runner_cls.return_value = fake_runner mock_task_get_status.return_value = consts.TaskStatus.SOFT_ABORTING mock_scenario_runner.get.return_value = fake_runner_cls eng = engine.TaskEngine(config, task, mock.Mock()) eng.run() self.assertEqual(mock.call(consts.TaskStatus.ABORTED), task.update_status.mock_calls[-1])
def test__validate_config_syntax( self, mock_context_manager_validate, mock_scenario_runner_validate, mock_task_config ): mock_task_instance = mock.MagicMock() mock_subtask = mock.MagicMock() mock_subtask.workloads = [ engine.Workload({"name": "sca", "context": "a"}), engine.Workload({"name": "sca", "runner": "b"}) ] mock_task_instance.subtasks = [mock_subtask] eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock()) eng._validate_config_syntax(mock_task_instance) mock_scenario_runner_validate.assert_has_calls( [mock.call({}), mock.call("b")], any_order=True) mock_context_manager_validate.assert_has_calls( [mock.call("a", non_hidden=True), mock.call({}, non_hidden=True)], any_order=True)
def test_run_exception_is_logged(self, mock_context_manager_setup, mock_context_manager_cleanup, mock_scenario_runner, mock_scenario, mock_context, mock_result_consumer, mock_log, mock_task_get_status): scenario_cls = mock_scenario.get.return_value scenario_cls.get_default_context.return_value = {} context_cls = mock_context.get.return_value context_cls.get_fullname.return_value = "context_a" mock_context_manager_setup.side_effect = Exception mock_result_consumer.is_task_in_aborting_status.return_value = False mock_task_instance = mock.MagicMock() mock_task_instance.subtasks = [{ "title": "foo", "description": "Do not launch it!!", "contexts": {}, "workloads": [ self._make_workload(name="a.task", description="foo", contexts={"context_a": { "a": 1 }}), self._make_workload(name="a.task", description="foo", contexts={"context_a": { "b": 2 }}, position=2) ] }] eng = engine.TaskEngine(mock_task_instance, mock.MagicMock(), mock.MagicMock()) eng.run() self.assertEqual(2, mock_log.exception.call_count)
def test__validate_config_semantic( self, mock_deployment_get, mock__validate_config_semantic_helper, mock_users_ctx, mock_clients, mock_task_config): mock_users_ctx.UserGenerator = fakes.FakeUserContext mock_clients.return_value = mock.MagicMock() mock_task_instance = mock.MagicMock() mock_subtask1 = mock.MagicMock() wconf1 = engine.Workload({"name": "a", "runner": "ra"}) wconf2 = engine.Workload({"name": "a", "runner": "rb"}) mock_subtask1.workloads = [wconf1, wconf2] mock_subtask2 = mock.MagicMock() wconf3 = engine.Workload({"name": "b", "runner": "ra"}) mock_subtask2.workloads = [wconf3] mock_task_instance.subtasks = [mock_subtask1, mock_subtask2] fake_task = mock.MagicMock() eng = engine.TaskEngine(mock_task_instance, fake_task) eng.admin = "admin" eng._validate_config_semantic(mock_task_instance) expected_calls = [ mock.call("admin"), mock.call(fakes.FakeUserContext.user["credential"]) ] mock_clients.assert_has_calls(expected_calls) mock_deployment_get.assert_called_once_with(fake_task["uuid"]) admin = user = mock_clients.return_value fake_deployment = mock_deployment_get.return_value expected_calls = [ mock.call(admin, user, wconf1, 0, fake_deployment), mock.call(admin, user, wconf2, 1, fake_deployment), mock.call(admin, user, wconf3, 0, fake_deployment) ] mock__validate_config_semantic_helper.assert_has_calls( expected_calls, any_order=True)
def test_validate__wrong_semantic(self): task = mock.MagicMock() eng = engine.TaskEngine(mock.MagicMock(), task, mock.Mock()) e = exceptions.InvalidTaskConfig(name="foo", pos=0, config="", reason="foo") eng._validate_config_syntax = mock.MagicMock() eng._validate_config_platforms = mock.MagicMock() eng._validate_config_semantic = mock.MagicMock(side_effect=e) actual_e = self.assertRaises(exceptions.InvalidTaskException, eng.validate) self.assertEqual(e, actual_e) self.assertTrue(task.set_failed.called) # all steps of validation are called, which means that the last one is # failed self.assertTrue(eng._validate_config_syntax) self.assertTrue(eng._validate_config_platforms) self.assertTrue(eng._validate_config_semantic)
def test_schema_is_valid(self): discover.load_plugins(os.path.join(self.rally_jobs_path, "plugins")) files = { f for f in os.listdir(self.rally_jobs_path) if (os.path.isfile(os.path.join(self.rally_jobs_path, f)) and f.endswith(".yaml") and not f.endswith("_args.yaml")) } # TODO(andreykurilin): figure out why it fails files -= {"rally-mos.yaml", "sahara-clusters.yaml"} for filename in files: full_path = os.path.join(self.rally_jobs_path, filename) with open(full_path) as task_file: try: args_file = os.path.join( self.rally_jobs_path, filename.rsplit(".", 1)[0] + "_args.yaml") args = {} if os.path.exists(args_file): args = yaml.safe_load(open(args_file).read()) if not isinstance(args, dict): raise TypeError( "args file %s must be dict in yaml or json " "presentation" % args_file) task_inst = api._Task(api.API(skip_db_check=True)) task = task_inst.render_template( task_template=task_file.read(), **args) task = task_cfg.TaskConfig(yaml.safe_load(task)) task_obj = fakes.FakeTask({"uuid": full_path}) eng = engine.TaskEngine(task, task_obj, mock.Mock()) eng.validate(only_syntax=True) except Exception: print(traceback.format_exc()) self.fail("Wrong task input file: %s" % full_path)
def test_run__subtask_crashed(self, mock_scenario_runner, mock_scenario, mock_context_manager_setup, mock_context_manager_cleanup, mock_result_consumer, mock_task_get_status): task = mock.MagicMock(spec=objects.Task) subtask_obj = task.add_subtask.return_value subtask_obj.add_workload.side_effect = MyException() mock_result_consumer.is_task_in_aborting_status.return_value = False config = task_cfg.TaskConfig({ "a.task": [{ "runner": { "type": "a", "b": 1 } }], "b.task": [{ "runner": { "type": "a", "b": 1 } }], "c.task": [{ "runner": { "type": "a", "b": 1 } }] }) fake_runner_cls = mock.MagicMock() fake_runner = mock.MagicMock() fake_runner_cls.return_value = fake_runner mock_scenario_runner.get.return_value = fake_runner_cls eng = engine.TaskEngine(config, task, mock.Mock()) self.assertRaises(MyException, eng.run) task.update_status.assert_has_calls(( mock.call(consts.TaskStatus.RUNNING), mock.call(consts.TaskStatus.CRASHED), )) subtask_obj.update_status.assert_called_once_with( consts.SubtaskStatus.CRASHED)
def test__validate_config_syntax__wrong_sla( self, mock_task_config, mock_sla_validate, mock_scenario_get, mock_dumps): mock_dumps.return_value = "<JSON>" mock_sla_validate.return_value = ["sla_error"] scenario_cls = mock_scenario_get.return_value scenario_cls.get_default_context.return_value = {} mock_task_instance = mock.MagicMock() mock_task_instance.subtasks = [{"workloads": [ self._make_workload(name="sca"), self._make_workload(name="sca", position=1, sla={"foo_sla": "sla_conf"}) ]}] eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock(), mock.Mock()) e = self.assertRaises(exceptions.InvalidTaskConfig, eng._validate_config_syntax, mock_task_instance) self.assertEqual("Input task is invalid!\n\n" "Subtask sca[1] has wrong configuration\n" "Subtask configuration:\n<JSON>\n\n" "Reason(s):\n sla_error", e.format_message())
def test_run__task_soft_aborted(self, mock_scenario_runner, mock_scenario, mock_context_manager_setup, mock_context_manager_cleanup, mock_result_consumer): task = mock.MagicMock() mock_result_consumer.is_task_in_aborting_status.side_effect = [ False, False, True ] config = { "a.task": [{ "runner": { "type": "a", "b": 1 } }], "b.task": [{ "runner": { "type": "a", "b": 1 } }], "c.task": [{ "runner": { "type": "a", "b": 1 } }] } fake_runner_cls = mock.MagicMock() fake_runner = mock.MagicMock() fake_runner_cls.return_value = fake_runner mock_scenario_runner.get.return_value = fake_runner_cls eng = engine.TaskEngine(config, task) eng.run() self.assertEqual(2, fake_runner.run.call_count) self.assertEqual(mock.call(consts.TaskStatus.ABORTED), task.update_status.mock_calls[-1])
def test__validate_config_semantic( self, mock_deployment_get, mock__validate_config_semantic_helper, mock_task_config, mock_credential, mock_context, mock_scenario_get, mock_clients): deployment = fakes.FakeDeployment( uuid="deployment_uuid", admin={"foo": "admin"}, users=[{"bar": "user1"}]) scenario_cls = mock_scenario_get.return_value scenario_cls.get_namespace.return_value = "default" 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) admin = mock_credential.return_value user_context = mock_context.get.return_value.return_value mock_clients.assert_called_once_with(admin) mock_clients.return_value.verified_keystone.assert_called_once_with() mock__validate_config_semantic_helper.assert_has_calls([ mock.call(admin, user_context, [wconf1], deployment), mock.call(admin, user_context, [wconf2, wconf3], deployment), ], any_order=True)
def test__validate_config_scenarios_name_non_exsisting( self, mock_scenario, mock_task_config): mock_task_instance = mock.MagicMock() mock_subtask = mock.MagicMock() mock_subtask.workloads = [ engine.Workload({"name": "exist"}, 0), engine.Workload({"name": "nonexist1"}, 1), engine.Workload({"name": "nonexist2"}, 2) ] mock_task_instance.subtasks = [mock_subtask] mock_scenario.get_all.return_value = [ mock.Mock(get_name=lambda: "exist"), mock.Mock(get_name=lambda: "aaa")] eng = engine.TaskEngine(mock.MagicMock(), mock.MagicMock(), mock.Mock()) exc = self.assertRaises(exceptions.NotFoundScenarios, eng._validate_config_scenarios_name, mock_task_instance) self.assertEqual("There are no benchmark scenarios with names: " "`nonexist2, nonexist1`.", str(exc))
def test_consume_results_abort_manually(self, mock_sla_checker, mock_event, mock_thread, mock_task_get_status): runner = mock.MagicMock(result_queue=False) is_done = mock.MagicMock() is_done.isSet.side_effect = (False, True) task = mock.MagicMock() mock_task_get_status.return_value = consts.TaskStatus.ABORTED key = {"kw": {"fake": 2}, "name": "fake", "pos": 0} eng = engine.TaskEngine({}, task) eng.duration = 123 eng.full_duration = 456 with engine.ResultConsumer(key, task, runner, True): pass mock_sla_checker.assert_called_once_with(key["kw"]) mocked_set_aborted = mock_sla_checker.return_value.set_aborted_manually mocked_set_aborted.assert_called_once_with()