def test_start_with_task_args(self, mock__load_and_validate_task, mock_detailed): fake_task = fakes.FakeTask(uuid="new_uuid", tag="some_tag") self.fake_api.task.create.return_value = fakes.FakeTask( uuid="new_uuid", tag="some_tag") self.fake_api.task.validate.return_value = fakes.FakeTask( uuid="some_id") task_path = "path_to_config.json" task_args = "task_args" task_args_file = "task_args_file" self.task.start(self.fake_api, task_path, deployment="any", task_args=task_args, task_args_file=task_args_file, tag="some_tag") mock__load_and_validate_task.assert_called_once_with( self.fake_api, task_path, raw_args=task_args, args_file=task_args_file) self.fake_api.task.start.assert_called_once_with( "any", mock__load_and_validate_task.return_value, task=fake_task["uuid"], abort_on_sla_failure=False) mock_detailed.assert_called_once_with( self.fake_api, task_id=fake_task["uuid"]) self.fake_api.task.create.assert_called_once_with("any", "some_tag")
def test_results(self, mock_task_get, mock_json_dumps): task_id = "foo_task_id" data = [{ "key": "foo_key", "data": { "raw": "foo_raw", "sla": [], "hooks": [], "load_duration": 1.0, "full_duration": 2.0 } }] result = map( lambda x: { "key": x["key"], "result": x["data"]["raw"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"], "hooks": x["data"]["hooks"], "sla": x["data"]["sla"] }, data) fake_task = fakes.FakeTask({"status": consts.TaskStatus.FINISHED}) fake_task.get_results = mock.MagicMock(return_value=data) mock_task_get.return_value = fake_task self.task.results(task_id) self.assertEqual(1, mock_json_dumps.call_count) self.assertEqual(1, len(mock_json_dumps.call_args[0])) self.assertSequenceEqual(result, mock_json_dumps.call_args[0][0]) self.assertEqual({ "sort_keys": True, "indent": 4 }, mock_json_dumps.call_args[1]) mock_task_get.assert_called_once_with(task_id)
def test_results(self, mock_json_dumps): task_id = "foo_task_id" created_at = dt.datetime(2017, 2, 6, 1, 1, 1) data = [ {"key": "foo_key", "data": {"raw": "foo_raw", "sla": [], "hooks": [], "load_duration": 1.0, "full_duration": 2.0}, "created_at": created_at.strftime("%Y-%d-%mT%H:%M:%S")} ] result = map(lambda x: {"key": x["key"], "result": x["data"]["raw"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"], "created_at": x.get("created_at"), "hooks": x["data"]["hooks"], "sla": x["data"]["sla"]}, data) fake_task = fakes.FakeTask({"status": consts.TaskStatus.FINISHED, "results": data}) self.fake_api.task.get.return_value = fake_task self.task.results(self.fake_api, task_id) self.assertEqual(1, mock_json_dumps.call_count) self.assertEqual(1, len(mock_json_dumps.call_args[0])) self.assertSequenceEqual(result, mock_json_dumps.call_args[0][0]) self.assertEqual({"sort_keys": False, "indent": 4}, mock_json_dumps.call_args[1]) self.fake_api.task.get.assert_called_once_with(task_id)
def test_start_invalid_task(self, mock__load_and_validate_task, mock_detailed): task_obj = fakes.FakeTask(temporary=False, tag="tag", uuid="uuid") self.fake_api.task.create.return_value = task_obj exc = exceptions.InvalidTaskException("foo") mock__load_and_validate_task.side_effect = exc self.assertRaises(exceptions.InvalidTaskException, self.task.start, self.fake_api, "task_path", "deployment", tag="tag") self.assertFalse(self.fake_api.task.create.called) self.assertFalse(self.fake_api.task.start.called) # the case 2 task_cfg = {"some": "json"} mock__load_and_validate_task.side_effect = (task_cfg, ) self.fake_api.task.start.side_effect = KeyError() self.assertRaises(KeyError, self.task.start, self.fake_api, "task_path", "deployment", tag="tag") self.fake_api.task.create.assert_called_once_with("deployment", "tag") self.fake_api.task.start.assert_called_once_with( "deployment", task_cfg, task=task_obj["uuid"], abort_on_sla_failure=False) self.assertFalse(mock_detailed.called)
def test__send_result(self): task = fakes.FakeTask(uuid="foo_uuid") task.result_has_valid_schema = mock.MagicMock(return_value=True) runner_ = self._get_runner(task=task) result = {"timestamp": 42} self.assertIsNone(runner_._send_result(result)) self.assertEqual([], runner_.result_batch) self.assertEqual(collections.deque([[result]]), runner_.result_queue)
def test__send_result_with_invalid_schema(self, mock_log): task = fakes.FakeTask(uuid="foo_uuid") task.result_has_valid_schema = mock.MagicMock(return_value=False) runner_ = self._get_runner(task=task) result = {"timestamp": 42} self.assertIsNone(runner_._send_result(result)) runner_.task.result_has_valid_schema.assert_called_once_with(result) self.assertTrue(mock_log.warning.called) self.assertEqual([], runner_.result_batch) self.assertEqual(collections.deque([]), runner_.result_queue)
def test_start(self, mock__load_and_validate_task, mock_detailed, mock_use, mock_version): deployment_id = "e0617de9-77d1-4875-9b49-9d5789e29f20" task_path = "path_to_config.json" fake_task = fakes.FakeTask(uuid="some_new_uuid", tag="tag") self.fake_api.task.create.return_value = fake_task self.fake_api.task.validate.return_value = fakes.FakeTask( some="json", uuid="some_uuid", temporary=True) self.task.start(self.fake_api, task_path, deployment_id, do_use=True) mock_version.version_string.assert_called_once_with() self.fake_api.task.create.assert_called_once_with( deployment_id, None) self.fake_api.task.start.assert_called_once_with( deployment_id, mock__load_and_validate_task.return_value, task=fake_task["uuid"], abort_on_sla_failure=False) mock__load_and_validate_task.assert_called_once_with( self.fake_api, task_path, args_file=None, raw_args=None) mock_use.assert_called_once_with(self.fake_api, "some_new_uuid") mock_detailed.assert_called_once_with(self.fake_api, task_id=fake_task["uuid"])
def test_results_no_data(self, mock_task_get, mock_stdout): task_id = "foo_task_id" fake_task = fakes.FakeTask({"status": consts.TaskStatus.FAILED}) mock_task_get.return_value = fake_task self.assertEqual(1, self.task.results(task_id)) mock_task_get.assert_called_once_with(task_id) expected_out = ("Task status is %s. Results " "available when it is one of %s.") % ( consts.TaskStatus.FAILED, ", ".join( (consts.TaskStatus.FINISHED, consts.TaskStatus.ABORTED))) mock_stdout.write.assert_has_calls([mock.call(expected_out)])
def test_list_uuids_only(self, mock_get_global, mock_print_list): self.fake_api.task.list.return_value = [ fakes.FakeTask(uuid="a", created_at=dt.datetime.now(), updated_at=dt.datetime.now(), status="c", tag="d", deployment_name="some_name")] self.task.list(self.fake_api, status="running", uuids_only=True) self.fake_api.task.list.assert_called_once_with( deployment=mock_get_global.return_value, status=consts.TaskStatus.RUNNING) mock_print_list.assert_called_once_with( self.fake_api.task.list.return_value, ["uuid"], print_header=False, print_border=False)
def test_start_on_unfinished_deployment(self, mock__load_and_validate_task, mock_detailed): deployment_id = "e0617de9-77d1-4875-9b49-9d5789e29f20" deployment_name = "xxx_name" task_path = "path_to_config.json" fake_task = fakes.FakeTask(uuid="some_new_uuid", tag="tag") self.fake_api.task.create.return_value = fake_task exc = exceptions.DeploymentNotFinishedStatus( name=deployment_name, uuid=deployment_id, status=consts.DeployStatus.DEPLOY_INIT) self.fake_api.task.create.side_effect = exc self.assertEqual(1, self.task.start(self.fake_api, task_path, deployment="any", tag="some_tag")) self.assertFalse(mock_detailed.called)
def test_list(self, mock_get_global, mock_print_list): self.fake_api.task.list.return_value = [ fakes.FakeTask(uuid="a", created_at=dt.datetime.now(), updated_at=dt.datetime.now(), status="c", tag="d", deployment_name="some_name")] self.task.list(self.fake_api, status="running") self.fake_api.task.list.assert_called_once_with( deployment=mock_get_global.return_value, status=consts.TaskStatus.RUNNING) headers = ["uuid", "deployment_name", "created_at", "duration", "status", "tag"] mock_print_list.assert_called_once_with( self.fake_api.task.list.return_value, headers, sortby_index=headers.index("created_at"))
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)
class TaskAPITestCase(test.TestCase): def setUp(self): super(TaskAPITestCase, self).setUp() self.task_uuid = "b0d9cd6c-2c94-4417-a238-35c7019d0257" self.task = { "uuid": self.task_uuid, } @mock.patch("rally.api.objects.Task") @mock.patch("rally.api.objects.Deployment.get", return_value=fakes.FakeDeployment(uuid="deployment_uuid", admin=mock.MagicMock(), users=[])) @mock.patch("rally.api.engine.BenchmarkEngine") def test_validate(self, mock_benchmark_engine, mock_deployment_get, mock_task): api.Task.validate(mock_deployment_get.return_value["uuid"], "config") mock_benchmark_engine.assert_has_calls([ mock.call("config", mock_task.return_value, admin=mock_deployment_get.return_value["admin"], users=[]), mock.call().validate() ]) mock_task.assert_called_once_with( temporary=True, deployment_uuid=mock_deployment_get.return_value["uuid"]) mock_deployment_get.assert_called_once_with( mock_deployment_get.return_value["uuid"]) @mock.patch("rally.api.objects.Task") @mock.patch("rally.api.objects.Deployment", return_value=fakes.FakeDeployment(uuid="deployment_uuid", admin=mock.MagicMock(), users=[])) @mock.patch("rally.api.engine.BenchmarkEngine") def test_validate_engine_exception(self, mock_benchmark_engine, mock_deployment, mock_task): excpt = exceptions.InvalidTaskException() mock_benchmark_engine.return_value.validate.side_effect = excpt self.assertRaises(exceptions.InvalidTaskException, api.Task.validate, mock_deployment.return_value["uuid"], "config") def test_render_template(self): self.assertEqual( "3 = 3", api.Task.render_template("{{a + b}} = {{c}}", a=1, b=2, c=3)) def test_render_template_default_values(self): template = "{% set a = a or 1 %}{{a + b}} = {{c}}" self.assertEqual("3 = 3", api.Task.render_template(template, b=2, c=3)) self.assertEqual("5 = 5", api.Task.render_template(template, a=2, b=3, c=5)) def test_render_template_default_filter(self): template = "{{ c | default(3) }}" self.assertEqual("3", api.Task.render_template(template)) self.assertEqual("5", api.Task.render_template(template, c=5)) def test_render_template_builtin(self): template = "{% for i in range(4) %}{{i}}{% endfor %}" self.assertEqual("0123", api.Task.render_template(template)) def test_render_template_missing_args(self): self.assertRaises(TypeError, api.Task.render_template, "{{a}}") def test_render_template_include_other_template(self): other_template_path = os.path.join( os.path.dirname(__file__), "..", "..", "samples/tasks/scenarios/nova/boot.json") template = "{%% include \"%s\" %%}" % os.path.basename( other_template_path) with open(other_template_path) as f: other_template = f.read() expect = api.Task.render_template(other_template) actual = api.Task.render_template(template, os.path.dirname(other_template_path)) self.assertEqual(expect, actual) @mock.patch("rally.common.objects.Deployment.get", return_value={"uuid": "b0d9cd6c-2c94-4417-a238-35c7019d0257"}) @mock.patch("rally.common.objects.Task") def test_create(self, mock_task, mock_deployment_get): tag = "a" api.Task.create(mock_deployment_get.return_value["uuid"], tag) mock_task.assert_called_once_with( deployment_uuid=mock_deployment_get.return_value["uuid"], tag=tag) @mock.patch("rally.api.objects.Task", return_value=fakes.FakeTask(uuid="some_uuid")) @mock.patch("rally.api.objects.Deployment.get", return_value=fakes.FakeDeployment(uuid="deployment_uuid", admin=mock.MagicMock(), users=[])) @mock.patch("rally.api.engine.BenchmarkEngine") def test_start(self, mock_benchmark_engine, mock_deployment_get, mock_task): api.Task.start(mock_deployment_get.return_value["uuid"], "config") mock_benchmark_engine.assert_has_calls([ mock.call("config", mock_task.return_value, admin=mock_deployment_get.return_value["admin"], users=[], abort_on_sla_failure=False), mock.call().run(), ]) mock_task.assert_called_once_with( deployment_uuid=mock_deployment_get.return_value["uuid"]) mock_deployment_get.assert_called_once_with( mock_deployment_get.return_value["uuid"]) @mock.patch("rally.api.objects.Task", return_value=fakes.FakeTask(uuid="some_uuid", task={}, temporary=True)) @mock.patch("rally.api.objects.Deployment.get", return_value=fakes.FakeDeployment(uuid="deployment_uuid", admin=mock.MagicMock(), users=[])) def test_start_temporary_task(self, mock_deployment_get, mock_task): self.assertRaises(ValueError, api.Task.start, mock_deployment_get.return_value["uuid"], "config") @mock.patch("rally.api.objects.Task") @mock.patch("rally.api.objects.Deployment.get") @mock.patch("rally.api.engine.BenchmarkEngine") def test_start_exception(self, mock_benchmark_engine, mock_deployment_get, mock_task): mock_task.return_value.is_temporary = False mock_benchmark_engine.return_value.run.side_effect = TypeError self.assertRaises(TypeError, api.Task.start, "deployment_uuid", "config") mock_deployment_get().update_status.assert_called_once_with( consts.DeployStatus.DEPLOY_INCONSISTENT) @ddt.data(True, False) @mock.patch("rally.api.time") @mock.patch("rally.api.objects.Task") def test_abort_sync(self, soft, mock_task, mock_time): mock_task.get_status.side_effect = (consts.TaskStatus.INIT, consts.TaskStatus.VERIFYING, consts.TaskStatus.RUNNING, consts.TaskStatus.ABORTING, consts.TaskStatus.SOFT_ABORTING, consts.TaskStatus.ABORTED) some_uuid = "ca441749-0eb9-4fcc-b2f6-76d314c55404" api.Task.abort(some_uuid, soft=soft, async=False) mock_task.get.assert_called_once_with(some_uuid) mock_task.get.return_value.abort.assert_called_once_with(soft=soft) self.assertEqual([mock.call(some_uuid)] * 6, mock_task.get_status.call_args_list) self.assertTrue(mock_time.sleep.called) @ddt.data(True, False) @mock.patch("rally.api.time") @mock.patch("rally.api.objects.Task") def test_abort_async(self, soft, mock_task, mock_time): some_uuid = "133695fb-400d-4988-859c-30bfaa0488ce" api.Task.abort(some_uuid, soft=soft, async=True) mock_task.get.assert_called_once_with(some_uuid) mock_task.get.return_value.abort.assert_called_once_with(soft=soft) self.assertFalse(mock_task.get_status.called) self.assertFalse(mock_time.sleep.called) @mock.patch("rally.common.objects.task.db.task_delete") def test_delete(self, mock_task_delete): api.Task.delete(self.task_uuid) mock_task_delete.assert_called_once_with( self.task_uuid, status=consts.TaskStatus.FINISHED) @mock.patch("rally.common.objects.task.db.task_delete") def test_delete_force(self, mock_task_delete): api.Task.delete(self.task_uuid, force=True) mock_task_delete.assert_called_once_with(self.task_uuid, status=None)
class TaskCommandsTestCase(test.TestCase): def setUp(self): super(TaskCommandsTestCase, self).setUp() self.task = task.TaskCommands() @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task(self, mock_open): input_task = "{'ab': {{test}}}" input_args = "{'test': 2}" # NOTE(boris-42): Such order of files is because we are reading # file with args before file with template. mock_open.side_effect = [ mock.mock_open(read_data="{'test': 1}").return_value, mock.mock_open(read_data=input_task).return_value ] task_conf = self.task._load_task("in_task", task_args_file="in_args_path") self.assertEqual({"ab": 1}, task_conf) mock_open.side_effect = [ mock.mock_open(read_data=input_task).return_value ] task_conf = self.task._load_task("in_task", task_args=input_args) self.assertEqual(task_conf, {"ab": 2}) mock_open.side_effect = [ mock.mock_open(read_data="{'test': 1}").return_value, mock.mock_open(read_data=input_task).return_value ] task_conf = self.task._load_task("in_task", task_args=input_args, task_args_file="any_file") self.assertEqual(task_conf, {"ab": 2}) @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task_wrong_task_args_file(self, mock_open): mock_open.side_effect = [ mock.mock_open(read_data="{'test': {}").return_value ] self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task", task_args_file="in_args_path") @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task_wrong_task_args_file_exception(self, mock_open): mock_open.side_effect = IOError self.assertRaises(IOError, self.task._load_task, "in_task", task_args_file="in_args_path") def test__load_task_wrong_input_task_args(self): self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task", "{'test': {}") self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task", "[]") @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task_task_render_raise_exc(self, mock_open): mock_open.side_effect = [ mock.mock_open(read_data="{'test': {{t}}}").return_value ] self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task") @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task_task_not_in_yaml(self, mock_open): mock_open.side_effect = [ mock.mock_open(read_data="{'test': {}").return_value ] self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task") def test_load_task_including_other_template(self): other_template_path = os.path.join( os.path.dirname(__file__), "..", "..", "..", "..", "samples/tasks/scenarios/nova/boot.json") input_task = "{%% include \"%s\" %%}" % os.path.basename( other_template_path) expect = self.task._load_task(other_template_path) with mock.patch("rally.cli.commands.task.open", create=True) as mock_open: mock_open.side_effect = [ mock.mock_open(read_data=input_task).return_value ] input_task_file = os.path.join( os.path.dirname(other_template_path), "input_task.json") actual = self.task._load_task(input_task_file) self.assertEqual(expect, actual) @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.api.Task.validate", return_value=fakes.FakeTask()) @mock.patch("rally.cli.commands.task.TaskCommands._load_task", return_value={"uuid": "some_uuid"}) def test__load_and_validate_task(self, mock__load_task, mock_task_validate, mock_os_path_exists): deployment = "some_deployment_uuid" self.task._load_and_validate_task("some_task", "task_args", "task_args_file", deployment) mock__load_task.assert_called_once_with("some_task", "task_args", "task_args_file") mock_task_validate.assert_called_once_with( deployment, mock__load_task.return_value, None) @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.os.path.isdir", return_value=True) @mock.patch("rally.cli.commands.task.TaskCommands._load_task") @mock.patch("rally.api.Task.validate") def test__load_and_validate_directory(self, mock_task_validate, mock__load_task, mock_os_path_isdir, mock_os_path_exists): deployment = "some_deployment_uuid" self.assertRaises(IOError, self.task._load_and_validate_task, "some_task", "task_args", "task_args_file", deployment) @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.os.path.isdir", return_value=False) @mock.patch("rally.cli.commands.task.api.Task.create", return_value=fakes.FakeTask(uuid="some_new_uuid", tag="tag")) @mock.patch("rally.cli.commands.task.TaskCommands.use") @mock.patch("rally.cli.commands.task.TaskCommands.detailed") @mock.patch("rally.cli.commands.task.TaskCommands._load_task", return_value={"some": "json"}) @mock.patch("rally.cli.commands.task.api.Task.validate", return_value=fakes.FakeTask(some="json", uuid="some_uuid", temporary=True)) @mock.patch("rally.cli.commands.task.api.Task.start") def test_start(self, mock_task_start, mock_task_validate, mock__load_task, mock_detailed, mock_use, mock_task_create, mock_os_path_isdir, mock_os_path_exists): deployment_id = "e0617de9-77d1-4875-9b49-9d5789e29f20" task_path = "path_to_config.json" self.task.start(task_path, deployment_id, do_use=True) mock_task_create.assert_called_once_with(deployment_id, None) mock_task_start.assert_called_once_with( deployment_id, mock__load_task.return_value, task=mock_task_validate.return_value, abort_on_sla_failure=False) mock__load_task.assert_called_once_with(task_path, None, None) mock_use.assert_called_once_with("some_new_uuid") mock_detailed.assert_called_once_with(task_id="some_new_uuid") @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.os.path.isdir", return_value=False) @mock.patch("rally.cli.commands.task.api.Task.create", return_value=fakes.FakeTask(uuid="new_uuid", tag="some_tag")) @mock.patch("rally.cli.commands.task.TaskCommands.detailed") @mock.patch("rally.cli.commands.task.api.Task.start") @mock.patch("rally.cli.commands.task.TaskCommands._load_task", return_value="some_config") @mock.patch("rally.cli.commands.task.api.Task.validate", return_value=fakes.FakeTask(uuid="some_id")) def test_start_with_task_args(self, mock_task_validate, mock__load_task, mock_task_start, mock_detailed, mock_task_create, mock_os_path_isdir, mock_os_path_exists): task_path = mock.MagicMock() task_args = mock.MagicMock() task_args_file = mock.MagicMock() self.task.start(task_path, deployment="any", task_args=task_args, task_args_file=task_args_file, tag="some_tag") mock__load_task.assert_called_once_with(task_path, task_args, task_args_file) mock_task_validate.assert_called_once_with( "any", mock__load_task.return_value, {}) mock_task_start.assert_called_once_with( "any", mock__load_task.return_value, task=mock_task_create.return_value, abort_on_sla_failure=False) mock_detailed.assert_called_once_with( task_id=mock_task_create.return_value["uuid"]) mock_task_create.assert_called_once_with("any", "some_tag") @mock.patch("rally.cli.commands.task.envutils.get_global") def test_start_no_deployment_id(self, mock_get_global): mock_get_global.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.start, "path_to_config.json", None) @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.os.path.isdir", return_value=False) @mock.patch("rally.cli.commands.task.api.Task.create", return_value=fakes.FakeTask(temporary=False, tag="tag", uuid="uuid")) @mock.patch("rally.cli.commands.task.TaskCommands._load_task", return_value={"some": "json"}) @mock.patch("rally.cli.commands.task.api.Task.validate") @mock.patch("rally.cli.commands.task.api.Task.start", side_effect=exceptions.InvalidTaskException) def test_start_invalid_task(self, mock_task_start, mock_task_validate, mock__load_task, mock_task_create, mock_os_path_isdir, mock_os_path_exists): result = self.task.start("task_path", "deployment", tag="tag") self.assertEqual(1, result) mock_task_create.assert_called_once_with("deployment", "tag") mock_task_start.assert_called_once_with( "deployment", mock__load_task.return_value, task=mock_task_create.return_value, abort_on_sla_failure=False) @mock.patch("rally.cli.commands.task.api") def test_abort(self, mock_api): test_uuid = "17860c43-2274-498d-8669-448eff7b073f" mock_api.Task.abort = mock.MagicMock() self.task.abort(test_uuid) mock_api.Task.abort.assert_called_once_with(test_uuid, False, async=False) @mock.patch("rally.cli.commands.task.envutils.get_global") def test_abort_no_task_id(self, mock_get_global): mock_get_global.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.abort, None) def test_status(self): test_uuid = "a3e7cefb-bec2-4802-89f6-410cc31f71af" value = {"task_id": "task", "status": "status"} with mock.patch("rally.cli.commands.task.db") as mock_db: mock_db.task_get = mock.MagicMock(return_value=value) self.task.status(test_uuid) mock_db.task_get.assert_called_once_with(test_uuid) @mock.patch("rally.cli.commands.task.envutils.get_global") def test_status_no_task_id(self, mock_get_global): mock_get_global.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.status, None) @mock.patch("rally.cli.commands.task.db") def test_detailed(self, mock_db): test_uuid = "c0d874d4-7195-4fd5-8688-abe82bfad36f" value = { "id": "task", "uuid": test_uuid, "status": "status", "results": [{ "key": { "name": "fake_name", "pos": "fake_pos", "kw": "fake_kw" }, "data": { "load_duration": 1.0, "full_duration": 2.0, "raw": [{ "duration": 0.9, "idle_duration": 0.5, "scenario_output": { "data": { "a": 3 }, "errors": "some" }, "atomic_actions": { "a": 0.6, "b": 0.7 }, "error": ["type", "message", "traceback"] }, { "duration": 0.5, "idle_duration": 0.2, "scenario_output": { "data": { "a": 1 }, "errors": "some" }, "atomic_actions": { "a": 0.2, "b": 0.4 }, "error": None }, { "duration": 0.6, "idle_duration": 0.4, "scenario_output": { "data": { "a": 2 }, "errors": None }, "atomic_actions": { "a": 0.3, "b": 0.5 }, "error": None }] } }] } mock_db.task_get_detailed = mock.MagicMock(return_value=value) self.task.detailed(test_uuid) mock_db.task_get_detailed.assert_called_once_with(test_uuid) self.task.detailed(test_uuid, iterations_data=True) @mock.patch("rally.cli.commands.task.db") @mock.patch("rally.cli.commands.task.logging") def test_detailed_task_failed(self, mock_logging, mock_db): value = { "id": "task", "uuid": "task_uuid", "status": consts.TaskStatus.FAILED, "results": [], "verification_log": "['1', '2', '3']" } mock_db.task_get_detailed = mock.MagicMock(return_value=value) mock_logging.is_debug.return_value = False self.task.detailed("task_uuid") mock_logging.is_debug.return_value = True self.task.detailed("task_uuid") @mock.patch("rally.cli.commands.task.envutils.get_global") def test_detailed_no_task_id(self, mock_get_global): mock_get_global.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.detailed, None) @mock.patch("rally.cli.commands.task.db") def test_detailed_wrong_id(self, mock_db): test_uuid = "eb290c30-38d8-4c8f-bbcc-fc8f74b004ae" mock_db.task_get_detailed = mock.MagicMock(return_value=None) self.task.detailed(test_uuid) mock_db.task_get_detailed.assert_called_once_with(test_uuid) @mock.patch("json.dumps") @mock.patch("rally.cli.commands.task.objects.Task.get") def test_results(self, mock_task_get, mock_json_dumps): task_id = "foo_task_id" data = [{ "key": "foo_key", "data": { "raw": "foo_raw", "sla": [], "load_duration": "lo_duration", "full_duration": "fu_duration" } }] result = map( lambda x: { "key": x["key"], "result": x["data"]["raw"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"], "sla": x["data"]["sla"] }, data) mock_results = mock.Mock(return_value=data) mock_task_get.return_value = mock.Mock(get_results=mock_results) self.task.results(task_id) self.assertEqual(1, mock_json_dumps.call_count) self.assertEqual(1, len(mock_json_dumps.call_args[0])) self.assertSequenceEqual(result, mock_json_dumps.call_args[0][0]) self.assertEqual({ "sort_keys": True, "indent": 4 }, mock_json_dumps.call_args[1]) mock_task_get.assert_called_once_with(task_id) @mock.patch("rally.cli.commands.task.sys.stdout") @mock.patch("rally.cli.commands.task.objects.Task.get") def test_results_no_data(self, mock_task_get, mock_stdout): task_id = "foo_task_id" mock_results = mock.Mock(return_value=[]) mock_task_get.return_value = mock.Mock(get_results=mock_results) result = self.task.results(task_id) mock_task_get.assert_called_once_with(task_id) self.assertEqual(1, result) expected_out = ("The task %s marked as '%s'. Results " "available when it is '%s' .") % ( task_id, consts.TaskStatus.FAILED, consts.TaskStatus.FINISHED) mock_stdout.write.assert_has_calls([mock.call(expected_out)]) @mock.patch("rally.cli.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cli.commands.task.os.path.realpath", side_effect=lambda p: "realpath_%s" % p) @mock.patch("rally.cli.commands.task.open", side_effect=mock.mock_open(), create=True) @mock.patch("rally.cli.commands.task.plot") @mock.patch("rally.cli.commands.task.webbrowser") @mock.patch("rally.cli.commands.task.objects.Task.get") def test_report_one_uuid(self, mock_task_get, mock_webbrowser, mock_plot, mock_open, mock_realpath, mock_validate): task_id = "eb290c30-38d8-4c8f-bbcc-fc8f74b004ae" data = [{ "key": { "name": "class.test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "load_duration": 0.1, "full_duration": 1.2 } }, { "key": { "name": "class.test", "pos": 0 }, "data": { "raw": "bar_raw", "sla": "bar_sla", "load_duration": 2.1, "full_duration": 2.2 } }] results = [{ "key": x["key"], "result": x["data"]["raw"], "sla": x["data"]["sla"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"] } for x in data] mock_results = mock.Mock(return_value=data) mock_task_get.return_value = mock.Mock(get_results=mock_results) mock_plot.plot.return_value = "html_report" def reset_mocks(): for m in mock_task_get, mock_webbrowser, mock_plot, mock_open: m.reset_mock() self.task.report(tasks=task_id, out="/tmp/%s.html" % task_id) mock_open.assert_called_once_with("/tmp/%s.html" % task_id, "w+") mock_plot.plot.assert_called_once_with(results, include_libs=False) mock_open.side_effect().write.assert_called_once_with("html_report") mock_task_get.assert_called_once_with(task_id) # JUnit reset_mocks() self.task.report(tasks=task_id, out="/tmp/%s.html" % task_id, out_format="junit") mock_open.assert_called_once_with("/tmp/%s.html" % task_id, "w+") self.assertFalse(mock_plot.plot.called) # HTML reset_mocks() self.task.report(task_id, out="output.html", open_it=True, out_format="html") mock_webbrowser.open_new_tab.assert_called_once_with( "file://realpath_output.html") mock_plot.plot.assert_called_once_with(results, include_libs=False) # HTML with embedded JS/CSS reset_mocks() self.task.report(task_id, open_it=False, out="output.html", out_format="html_static") self.assertFalse(mock_webbrowser.open_new_tab.called) mock_plot.plot.assert_called_once_with(results, include_libs=True) @mock.patch("rally.cli.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cli.commands.task.os.path.realpath", side_effect=lambda p: "realpath_%s" % p) @mock.patch("rally.cli.commands.task.open", side_effect=mock.mock_open(), create=True) @mock.patch("rally.cli.commands.task.plot") @mock.patch("rally.cli.commands.task.webbrowser") @mock.patch("rally.cli.commands.task.objects.Task.get") def test_report_bunch_uuids(self, mock_task_get, mock_webbrowser, mock_plot, mock_open, mock_realpath, mock_validate): tasks = [ "eb290c30-38d8-4c8f-bbcc-fc8f74b004ae", "eb290c30-38d8-4c8f-bbcc-fc8f74b004af" ] data = [{ "key": { "name": "test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "load_duration": 0.1, "full_duration": 1.2 } }, { "key": { "name": "test", "pos": 0 }, "data": { "raw": "bar_raw", "sla": "bar_sla", "load_duration": 2.1, "full_duration": 2.2 } }] results = [] for task_uuid in tasks: results.extend( map( lambda x: { "key": x["key"], "result": x["data"]["raw"], "sla": x["data"]["sla"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"] }, data)) mock_results = mock.Mock(return_value=data) mock_task_get.return_value = mock.Mock(get_results=mock_results) mock_plot.plot.return_value = "html_report" def reset_mocks(): for m in mock_task_get, mock_webbrowser, mock_plot, mock_open: m.reset_mock() self.task.report(tasks=tasks, out="/tmp/1_test.html") mock_open.assert_called_once_with("/tmp/1_test.html", "w+") mock_plot.plot.assert_called_once_with(results, include_libs=False) mock_open.side_effect().write.assert_called_once_with("html_report") expected_get_calls = [mock.call(task) for task in tasks] mock_task_get.assert_has_calls(expected_get_calls, any_order=True) @mock.patch("rally.cli.commands.task.json.load") @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cli.commands.task.os.path.realpath", side_effect=lambda p: "realpath_%s" % p) @mock.patch("rally.cli.commands.task.open", create=True) @mock.patch("rally.cli.commands.task.plot") def test_report_one_file(self, mock_plot, mock_open, mock_realpath, mock_validate, mock_path_exists, mock_json_load): task_file = "/tmp/some_file.json" data = [{ "key": { "name": "test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "load_duration": 0.1, "full_duration": 1.2 } }, { "key": { "name": "test", "pos": 1 }, "data": { "raw": "bar_raw", "sla": "bar_sla", "load_duration": 2.1, "full_duration": 2.2 } }] results = [{ "key": x["key"], "result": x["data"]["raw"], "sla": x["data"]["sla"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"] } for x in data] mock_plot.plot.return_value = "html_report" mock_open.side_effect = mock.mock_open(read_data=results) mock_json_load.return_value = results def reset_mocks(): for m in mock_plot, mock_open, mock_json_load, mock_validate: m.reset_mock() self.task.report(tasks=task_file, out="/tmp/1_test.html") expected_open_calls = [ mock.call(task_file, "r"), mock.call("/tmp/1_test.html", "w+") ] mock_open.assert_has_calls(expected_open_calls, any_order=True) mock_plot.plot.assert_called_once_with(results, include_libs=False) mock_open.side_effect().write.assert_called_once_with("html_report") @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.json.load") @mock.patch("rally.cli.commands.task.open", create=True) def test_report_exceptions(self, mock_open, mock_json_load, mock_path_exists): results = [{ "key": { "name": "test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "load_duration": 0.1, "full_duration": 1.2 } }] mock_open.side_effect = mock.mock_open(read_data=results) mock_json_load.return_value = results ret = self.task.report(tasks="/tmp/task.json", out="/tmp/tmp.hsml") self.assertEqual(ret, 1) for m in mock_open, mock_json_load: m.reset_mock() mock_path_exists.return_value = False ret = self.task.report(tasks="/tmp/task.json", out="/tmp/tmp.hsml") self.assertEqual(ret, 1) @mock.patch("rally.cli.commands.task.sys.stderr") @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.json.load") @mock.patch("rally.cli.commands.task.open", create=True) def test_report_invalid_format(self, mock_open, mock_json_load, mock_path_exists, mock_stderr): result = self.task.report(tasks="/tmp/task.json", out="/tmp/tmp.html", out_format="invalid") self.assertEqual(1, result) expected_out = "Invalid output format: invalid" mock_stderr.write.assert_has_calls([mock.call(expected_out)]) @mock.patch("rally.cli.commands.task.cliutils.print_list") @mock.patch("rally.cli.commands.task.envutils.get_global", return_value="123456789") @mock.patch("rally.cli.commands.task.objects.Task.list", return_value=[ fakes.FakeTask(uuid="a", created_at=date.datetime.now(), updated_at=date.datetime.now(), status="c", tag="d", deployment_name="some_name") ]) def test_list(self, mock_task_list, mock_get_global, mock_print_list): self.task.list(status="running") mock_task_list.assert_called_once_with( deployment=mock_get_global.return_value, status=consts.TaskStatus.RUNNING) headers = [ "uuid", "deployment_name", "created_at", "duration", "status", "tag" ] mock_print_list.assert_called_once_with( mock_task_list.return_value, headers, sortby_index=headers.index("created_at")) @mock.patch("rally.cli.commands.task.cliutils.print_list") @mock.patch("rally.cli.commands.task.envutils.get_global", return_value="123456789") @mock.patch("rally.cli.commands.task.objects.Task.list", return_value=[ fakes.FakeTask(uuid="a", created_at=date.datetime.now(), updated_at=date.datetime.now(), status="c", tag="d", deployment_name="some_name") ]) def test_list_uuids_only(self, mock_task_list, mock_get_global, mock_print_list): self.task.list(status="running", uuids_only=True) mock_task_list.assert_called_once_with( deployment=mock_get_global.return_value, status=consts.TaskStatus.RUNNING) mock_print_list.assert_called_once_with(mock_task_list.return_value, ["uuid"], print_header=False, print_border=False) def test_list_wrong_status(self): self.assertEqual( 1, self.task.list(deployment="fake", status="wrong non existing status")) @mock.patch("rally.cli.commands.task.objects.Task.list", return_value=[]) def test_list_no_results(self, mock_task_list): self.assertIsNone( self.task.list(deployment="fake", all_deployments=True)) mock_task_list.assert_called_once_with() mock_task_list.reset_mock() self.assertIsNone( self.task.list(deployment="d", status=consts.TaskStatus.RUNNING)) mock_task_list.assert_called_once_with( deployment="d", status=consts.TaskStatus.RUNNING) def test_delete(self): task_uuid = "8dcb9c5e-d60b-4022-8975-b5987c7833f7" force = False with mock.patch("rally.cli.commands.task.api") as mock_api: mock_api.Task.delete = mock.Mock() self.task.delete(task_uuid, force=force) mock_api.Task.delete.assert_called_once_with(task_uuid, force=force) @mock.patch("rally.cli.commands.task.api") def test_delete_multiple_uuid(self, mock_api): task_uuids = [ "4bf35b06-5916-484f-9547-12dce94902b7", "52cad69d-d3e4-47e1-b445-dec9c5858fe8", "6a3cb11c-ac75-41e7-8ae7-935732bfb48f", "018af931-0e5a-40d5-9d6f-b13f4a3a09fc" ] force = False self.task.delete(task_uuids, force=force) self.assertTrue(mock_api.Task.delete.call_count == len(task_uuids)) expected_calls = [ mock.call(task_uuid, force=force) for task_uuid in task_uuids ] self.assertTrue(mock_api.Task.delete.mock_calls == expected_calls) @mock.patch("rally.cli.commands.task.cliutils.print_list") @mock.patch("rally.cli.commands.task.objects.Task.get") def test_sla_check(self, mock_task_get, mock_print_list): data = [{ "key": { "name": "fake_name", "pos": "fake_pos", "kw": "fake_kw" }, "data": { "scenario_duration": 42.0, "raw": [], "sla": [{ "benchmark": "KeystoneBasic.create_user", "criterion": "max_seconds_per_iteration", "pos": 0, "success": False, "detail": "Max foo, actually bar" }] } }] mock_task_get().get_results.return_value = copy.deepcopy(data) result = self.task.sla_check(task_id="fake_task_id") self.assertEqual(1, result) mock_task_get.assert_called_with("fake_task_id") data[0]["data"]["sla"][0]["success"] = True mock_task_get().get_results.return_value = data result = self.task.sla_check(task_id="fake_task_id", tojson=True) self.assertEqual(0, result) @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.api.Task.validate") @mock.patch("rally.cli.commands.task.open", side_effect=mock.mock_open(read_data="{\"some\": \"json\"}"), create=True) def test_validate(self, mock_open, mock_task_validate, mock_os_path_exists): self.task.validate("path_to_config.json", "fake_id") mock_task_validate.assert_called_once_with("fake_id", {"some": "json"}, None) @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.TaskCommands._load_task", side_effect=task.FailedToLoadTask) def test_validate_failed_to_load_task(self, mock__load_task, mock_os_path_exists): args = mock.MagicMock() args_file = mock.MagicMock() result = self.task.validate("path_to_task", "fake_deployment_id", task_args=args, task_args_file=args_file) self.assertEqual(1, result) mock__load_task.assert_called_once_with("path_to_task", args, args_file) @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.TaskCommands._load_task") @mock.patch("rally.api.Task.validate") def test_validate_invalid(self, mock_task_validate, mock__load_task, mock_os_path_exists): mock_task_validate.side_effect = exceptions.InvalidTaskException result = self.task.validate("path_to_task", "deployment") self.assertEqual(1, result) mock_task_validate.assert_called_once_with( "deployment", mock__load_task.return_value, None) @mock.patch("rally.common.fileutils._rewrite_env_file") @mock.patch("rally.cli.commands.task.db.task_get", return_value=True) def test_use(self, mock_task_get, mock__rewrite_env_file): task_id = "80422553-5774-44bd-98ac-38bd8c7a0feb" self.task.use(task_id) mock__rewrite_env_file.assert_called_once_with( os.path.expanduser("~/.rally/globals"), ["RALLY_TASK=%s\n" % task_id]) @mock.patch("rally.cli.commands.task.db.task_get") def test_use_not_found(self, mock_task_get): task_id = "ddc3f8ba-082a-496d-b18f-72cdf5c10a14" mock_task_get.side_effect = exceptions.TaskNotFound(uuid=task_id) self.assertRaises(exceptions.TaskNotFound, self.task.use, task_id)
class TaskCommandsTestCase(test.TestCase): def setUp(self): super(TaskCommandsTestCase, self).setUp() self.task = task.TaskCommands() @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task(self, mock_open): input_task = "{'ab': {{test}}}" input_args = "{'test': 2}" # NOTE(boris-42): Such order of files is because we are reading # file with args before file with template. mock_open.side_effect = [ mock.mock_open(read_data="{'test': 1}").return_value, mock.mock_open(read_data=input_task).return_value ] task_conf = self.task._load_task("in_task", task_args_file="in_args_path") self.assertEqual({"ab": 1}, task_conf) mock_open.side_effect = [ mock.mock_open(read_data=input_task).return_value ] task_conf = self.task._load_task("in_task", task_args=input_args) self.assertEqual(task_conf, {"ab": 2}) mock_open.side_effect = [ mock.mock_open(read_data="{'test': 1}").return_value, mock.mock_open(read_data=input_task).return_value ] task_conf = self.task._load_task("in_task", task_args=input_args, task_args_file="any_file") self.assertEqual(task_conf, {"ab": 2}) @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task_wrong_task_args_file(self, mock_open): mock_open.side_effect = [ mock.mock_open(read_data="{'test': {}").return_value ] self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task", task_args_file="in_args_path") @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task_wrong_task_args_file_exception(self, mock_open): mock_open.side_effect = IOError self.assertRaises(IOError, self.task._load_task, "in_task", task_args_file="in_args_path") def test__load_task_wrong_input_task_args(self): self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task", "{'test': {}") self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task", "[]") @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task_task_render_raise_exc(self, mock_open): mock_open.side_effect = [ mock.mock_open(read_data="{'test': {{t}}}").return_value ] self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task") @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task_task_not_in_yaml(self, mock_open): mock_open.side_effect = [ mock.mock_open(read_data="{'test': {}").return_value ] self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task") def test_load_task_including_other_template(self): other_template_path = os.path.join( os.path.dirname(__file__), "..", "..", "..", "..", "samples/tasks/scenarios/nova/boot.json") input_task = "{%% include \"%s\" %%}" % os.path.basename( other_template_path) expect = self.task._load_task(other_template_path) with mock.patch("rally.cli.commands.task.open", create=True) as mock_open: mock_open.side_effect = [ mock.mock_open(read_data=input_task).return_value ] input_task_file = os.path.join( os.path.dirname(other_template_path), "input_task.json") actual = self.task._load_task(input_task_file) self.assertEqual(expect, actual) @mock.patch("rally.cli.commands.task.os.path.isfile", return_value=True) @mock.patch("rally.cli.commands.task.api.Task.validate", return_value=fakes.FakeTask()) @mock.patch("rally.cli.commands.task.TaskCommands._load_task", return_value={"uuid": "some_uuid"}) def test__load_and_validate_task(self, mock__load_task, mock_task_validate, mock_os_path_isfile): deployment = "some_deployment_uuid" self.task._load_and_validate_task("some_task", "task_args", "task_args_file", deployment) mock__load_task.assert_called_once_with("some_task", "task_args", "task_args_file") mock_task_validate.assert_called_once_with( deployment, mock__load_task.return_value, None) @mock.patch("rally.api.Task.validate") def test__load_and_validate_file(self, mock_task_validate): deployment = "some_deployment_uuid" self.assertRaises(IOError, self.task._load_and_validate_task, "some_task", "task_args", "task_args_file", deployment) @mock.patch("rally.cli.commands.task.version") @mock.patch("rally.cli.commands.task.os.path.isfile", return_value=True) @mock.patch("rally.cli.commands.task.api.Task.create", return_value=fakes.FakeTask(uuid="some_new_uuid", tag="tag")) @mock.patch("rally.cli.commands.task.TaskCommands.use") @mock.patch("rally.cli.commands.task.TaskCommands.detailed") @mock.patch("rally.cli.commands.task.TaskCommands._load_task", return_value={"some": "json"}) @mock.patch("rally.cli.commands.task.api.Task.validate", return_value=fakes.FakeTask(some="json", uuid="some_uuid", temporary=True)) @mock.patch("rally.cli.commands.task.api.Task.start") def test_start(self, mock_task_start, mock_task_validate, mock__load_task, mock_detailed, mock_use, mock_task_create, mock_os_path_isfile, mock_version): deployment_id = "e0617de9-77d1-4875-9b49-9d5789e29f20" task_path = "path_to_config.json" self.task.start(task_path, deployment_id, do_use=True) mock_version.version_string.assert_called_once_with() mock_task_create.assert_called_once_with(deployment_id, None) mock_task_start.assert_called_once_with( deployment_id, mock__load_task.return_value, task=mock_task_validate.return_value, abort_on_sla_failure=False) mock__load_task.assert_called_once_with(task_path, None, None) mock_use.assert_called_once_with("some_new_uuid") mock_detailed.assert_called_once_with(task_id="some_new_uuid") @mock.patch("rally.cli.commands.task.os.path.isfile", return_value=True) @mock.patch("rally.cli.commands.task.api.Task.create", return_value=fakes.FakeTask(uuid="new_uuid", tag="some_tag")) @mock.patch("rally.cli.commands.task.TaskCommands.detailed") @mock.patch("rally.cli.commands.task.api.Task.start") @mock.patch("rally.cli.commands.task.TaskCommands._load_task", return_value="some_config") @mock.patch("rally.cli.commands.task.api.Task.validate", return_value=fakes.FakeTask(uuid="some_id")) def test_start_with_task_args(self, mock_task_validate, mock__load_task, mock_task_start, mock_detailed, mock_task_create, mock_os_path_isfile): task_path = mock.MagicMock() task_args = mock.MagicMock() task_args_file = mock.MagicMock() self.task.start(task_path, deployment="any", task_args=task_args, task_args_file=task_args_file, tag="some_tag") mock__load_task.assert_called_once_with(task_path, task_args, task_args_file) mock_task_validate.assert_called_once_with( "any", mock__load_task.return_value, {}) mock_task_start.assert_called_once_with( "any", mock__load_task.return_value, task=mock_task_create.return_value, abort_on_sla_failure=False) mock_detailed.assert_called_once_with( task_id=mock_task_create.return_value["uuid"]) mock_task_create.assert_called_once_with("any", "some_tag") @mock.patch("rally.cli.commands.task.envutils.get_global") def test_start_no_deployment_id(self, mock_get_global): mock_get_global.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.start, "path_to_config.json", None) @mock.patch("rally.cli.commands.task.os.path.isfile", return_value=True) @mock.patch("rally.cli.commands.task.api.Task.create", return_value=fakes.FakeTask(temporary=False, tag="tag", uuid="uuid")) @mock.patch("rally.cli.commands.task.TaskCommands._load_task", return_value={"some": "json"}) @mock.patch("rally.cli.commands.task.api.Task.validate") @mock.patch("rally.cli.commands.task.api.Task.start", side_effect=exceptions.InvalidTaskException) def test_start_invalid_task(self, mock_task_start, mock_task_validate, mock__load_task, mock_task_create, mock_os_path_isfile): result = self.task.start("task_path", "deployment", tag="tag") self.assertEqual(1, result) mock_task_create.assert_called_once_with("deployment", "tag") mock_task_start.assert_called_once_with( "deployment", mock__load_task.return_value, task=mock_task_create.return_value, abort_on_sla_failure=False) @mock.patch("rally.cli.commands.task.api") def test_abort(self, mock_api): test_uuid = "17860c43-2274-498d-8669-448eff7b073f" mock_api.Task.abort = mock.MagicMock() self.task.abort(test_uuid) mock_api.Task.abort.assert_called_once_with(test_uuid, False, async=False) @mock.patch("rally.cli.commands.task.envutils.get_global") def test_abort_no_task_id(self, mock_get_global): mock_get_global.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.abort, None) def test_status(self): test_uuid = "a3e7cefb-bec2-4802-89f6-410cc31f71af" value = {"task_id": "task", "status": "status"} with mock.patch("rally.cli.commands.task.api.Task") as mock_task: mock_task.get = mock.MagicMock(return_value=value) self.task.status(test_uuid) mock_task.get.assert_called_once_with(test_uuid) @mock.patch("rally.cli.commands.task.envutils.get_global") def test_status_no_task_id(self, mock_get_global): mock_get_global.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.status, None) @mock.patch("rally.cli.commands.task.api.Task") def test_detailed(self, mock_task): test_uuid = "c0d874d4-7195-4fd5-8688-abe82bfad36f" mock_task.get_detailed.return_value = { "id": "task", "uuid": test_uuid, "status": "status", "results": [{ "key": { "name": "fake_name", "pos": "fake_pos", "kw": "fake_kw" }, "info": { "load_duration": 3.2, "full_duration": 3.5, "iterations_count": 4, "atomic": { "foo": {}, "bar": {} } }, "iterations": [{ "duration": 0.9, "idle_duration": 0.1, "output": { "additive": [], "complete": [] }, "atomic_actions": { "foo": 0.6, "bar": 0.7 }, "error": ["type", "message", "traceback"] }, { "duration": 1.2, "idle_duration": 0.3, "output": { "additive": [], "complete": [] }, "atomic_actions": { "foo": 0.6, "bar": 0.7 }, "error": ["type", "message", "traceback"] }, { "duration": 0.7, "idle_duration": 0.5, "scenario_output": { "data": { "foo": 0.6, "bar": 0.7 }, "errors": "some" }, "atomic_actions": { "foo": 0.6, "bar": 0.7 }, "error": ["type", "message", "traceback"] }, { "duration": 0.5, "idle_duration": 0.5, "output": { "additive": [], "complete": [] }, "atomic_actions": { "foo": 0.6, "bar": 0.7 }, "error": ["type", "message", "traceback"] }] }] } self.task.detailed(test_uuid) mock_task.get_detailed.assert_called_once_with(test_uuid, extended_results=True) self.task.detailed(test_uuid, iterations_data=True) @mock.patch("rally.cli.commands.task.sys.stdout") @mock.patch("rally.cli.commands.task.api.Task") @mock.patch("rally.cli.commands.task.logging") @ddt.data({"debug": True}, {"debug": False}) @ddt.unpack def test_detailed_task_failed(self, mock_logging, mock_task, mock_stdout, debug): test_uuid = "test_task_id" value = { "id": "task", "uuid": test_uuid, "status": consts.TaskStatus.FAILED, "results": [], "verification_log": json.dumps({ "etype": "error_type", "msg": "error_message", "trace": "error_traceback" }) } mock_task.get_detailed = mock.MagicMock(return_value=value) mock_logging.is_debug.return_value = debug self.task.detailed(test_uuid) verification = yaml.safe_load(value["verification_log"]) if debug: expected_calls = [ mock.call("Task test_task_id: failed"), mock.call("%s" % verification["trace"]) ] mock_stdout.write.assert_has_calls(expected_calls, any_order=True) else: expected_calls = [ mock.call("Task test_task_id: failed"), mock.call("%s" % verification["etype"]), mock.call("%s" % verification["msg"]), mock.call("\nFor more details run:\nrally " "-d task detailed %s" % test_uuid) ] mock_stdout.write.assert_has_calls(expected_calls, any_order=True) @mock.patch("rally.cli.commands.task.api.Task") @mock.patch("rally.cli.commands.task.sys.stdout") def test_detailed_task_status_not_in_finished_abort( self, mock_stdout, mock_task): test_uuid = "test_task_id" value = { "id": "task", "uuid": test_uuid, "status": consts.TaskStatus.INIT, "results": [] } mock_task.get_detailed = mock.MagicMock(return_value=value) self.task.detailed(test_uuid) expected_calls = [ mock.call("Task test_task_id: init"), mock.call("\nThe task test_task_id marked as " "'init'. Results available when it " "is 'finished'.") ] mock_stdout.write.assert_has_calls(expected_calls, any_order=True) @mock.patch("rally.cli.commands.task.envutils.get_global") def test_detailed_no_task_id(self, mock_get_global): mock_get_global.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.detailed, None) @mock.patch("rally.cli.commands.task.api.Task") def test_detailed_wrong_id(self, mock_task): test_uuid = "eb290c30-38d8-4c8f-bbcc-fc8f74b004ae" mock_task.get_detailed = mock.MagicMock(return_value=None) self.task.detailed(test_uuid) mock_task.get_detailed.assert_called_once_with(test_uuid, extended_results=True) @mock.patch("json.dumps") @mock.patch("rally.cli.commands.task.api.Task.get") def test_results(self, mock_task_get, mock_json_dumps): task_id = "foo_task_id" data = [{ "key": "foo_key", "data": { "raw": "foo_raw", "sla": [], "hooks": [], "load_duration": 1.0, "full_duration": 2.0 } }] result = map( lambda x: { "key": x["key"], "result": x["data"]["raw"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"], "hooks": x["data"]["hooks"], "sla": x["data"]["sla"] }, data) fake_task = fakes.FakeTask({"status": consts.TaskStatus.FINISHED}) fake_task.get_results = mock.MagicMock(return_value=data) mock_task_get.return_value = fake_task self.task.results(task_id) self.assertEqual(1, mock_json_dumps.call_count) self.assertEqual(1, len(mock_json_dumps.call_args[0])) self.assertSequenceEqual(result, mock_json_dumps.call_args[0][0]) self.assertEqual({ "sort_keys": True, "indent": 4 }, mock_json_dumps.call_args[1]) mock_task_get.assert_called_once_with(task_id) @mock.patch("rally.cli.commands.task.sys.stdout") @mock.patch("rally.cli.commands.task.api.Task.get") def test_results_no_data(self, mock_task_get, mock_stdout): task_id = "foo_task_id" fake_task = fakes.FakeTask({"status": consts.TaskStatus.FAILED}) mock_task_get.return_value = fake_task self.assertEqual(1, self.task.results(task_id)) mock_task_get.assert_called_once_with(task_id) expected_out = ("Task status is %s. Results " "available when it is one of %s.") % ( consts.TaskStatus.FAILED, ", ".join( (consts.TaskStatus.FINISHED, consts.TaskStatus.ABORTED))) mock_stdout.write.assert_has_calls([mock.call(expected_out)]) def _make_result(self, keys): return [{ "key": { "name": key, "pos": 0 }, "data": { "raw": key + "_raw", "sla": key + "_sla", "hooks": key + "_hooks", "load_duration": 1.2, "full_duration": 2.3 } } for key in keys] @mock.patch("rally.cli.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cli.commands.task.os.path") @mock.patch("rally.cli.commands.task.open", create=True) @mock.patch("rally.cli.commands.task.plot") @mock.patch("rally.cli.commands.task.api.Task.get") @mock.patch("rally.cli.commands.task.webbrowser") def test_trends(self, mock_webbrowser, mock_task_get, mock_plot, mock_open, mock_os_path, mock_validate): mock_os_path.exists = lambda p: p.startswith("path_to_") mock_os_path.expanduser = lambda p: p + "_expanded" mock_os_path.realpath.side_effect = lambda p: "realpath_" + p results_iter = iter( [self._make_result(["bar"]), self._make_result(["spam"])]) mock_task_get.return_value.get_results.side_effect = results_iter mock_plot.trends.return_value = "rendered_trends_report" mock_fd = mock.mock_open( read_data="[\"result_1_from_file\", \"result_2_from_file\"]") mock_open.side_effect = mock_fd ret = self.task.trends(tasks=[ "ab123456-38d8-4c8f-bbcc-fc8f74b004ae", "cd654321-38d8-4c8f-bbcc-fc8f74b004ae", "path_to_file" ], out="output.html", out_format="html") expected = [{ "load_duration": 1.2, "full_duration": 2.3, "sla": "bar_sla", "hooks": "bar_hooks", "key": { "name": "bar", "pos": 0 }, "result": "bar_raw" }, { "load_duration": 1.2, "full_duration": 2.3, "sla": "spam_sla", "hooks": "spam_hooks", "key": { "name": "spam", "pos": 0 }, "result": "spam_raw" }, "result_1_from_file", "result_2_from_file"] mock_plot.trends.assert_called_once_with(expected) self.assertEqual([ mock.call("path_to_file_expanded", "r"), mock.call("output.html_expanded", "w+") ], mock_open.mock_calls) self.assertIsNone(ret) self.assertEqual([ mock.call("result_1_from_file", task.api.Task.TASK_RESULT_SCHEMA), mock.call("result_2_from_file", task.api.Task.TASK_RESULT_SCHEMA) ], mock_validate.mock_calls) self.assertEqual([ mock.call("ab123456-38d8-4c8f-bbcc-fc8f74b004ae"), mock.call().get_results(), mock.call("cd654321-38d8-4c8f-bbcc-fc8f74b004ae"), mock.call().get_results() ], mock_task_get.mock_calls) self.assertFalse(mock_webbrowser.open_new_tab.called) mock_fd.return_value.write.assert_called_once_with( "rendered_trends_report") @mock.patch("rally.cli.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cli.commands.task.os.path") @mock.patch("rally.cli.commands.task.open", create=True) @mock.patch("rally.cli.commands.task.plot") @mock.patch("rally.cli.commands.task.webbrowser") def test_trends_single_file_and_open_webbrowser(self, mock_webbrowser, mock_plot, mock_open, mock_os_path, mock_validate): mock_os_path.exists.return_value = True mock_os_path.expanduser = lambda path: path mock_os_path.realpath.side_effect = lambda p: "realpath_" + p mock_open.side_effect = mock.mock_open(read_data="[\"result\"]") ret = self.task.trends(tasks=["path_to_file"], open_it=True, out="output.html", out_format="html") self.assertIsNone(ret) mock_webbrowser.open_new_tab.assert_called_once_with( "file://realpath_output.html") @mock.patch("rally.cli.commands.task.os.path") @mock.patch("rally.cli.commands.task.open", create=True) @mock.patch("rally.cli.commands.task.plot") @mock.patch("rally.cli.commands.task.api.Task.get") def test_trends_task_id_is_not_uuid_like(self, mock_task_get, mock_plot, mock_open, mock_os_path): mock_os_path.exists.return_value = False mock_task_get.return_value.get_results.return_value = ( self._make_result(["foo"])) ret = self.task.trends(tasks=["ab123456-38d8-4c8f-bbcc-fc8f74b004ae"], out="output.html", out_format="html") self.assertIsNone(ret) ret = self.task.trends(tasks=["this-is-not-uuid"], out="output.html", out_format="html") self.assertEqual(1, ret) @mock.patch("rally.cli.commands.task.os.path") @mock.patch("rally.cli.commands.task.open", create=True) @mock.patch("rally.cli.commands.task.plot") def test_trends_wrong_results_format(self, mock_plot, mock_open, mock_os_path): mock_os_path.exists.return_value = True mock_open.side_effect = mock.mock_open(read_data="[42]") ret = self.task.trends(tasks=["path_to_file"], out="output.html", out_format="html") self.assertEqual(1, ret) with mock.patch("rally.cli.commands.task.api.Task.TASK_RESULT_SCHEMA", {"type": "number"}): ret = self.task.trends(tasks=["path_to_file"], out="output.html", out_format="html") self.assertIsNone(ret) def test_trends_no_tasks_given(self): ret = self.task.trends(tasks=[], out="output.html", out_format="html") self.assertEqual(1, ret) @mock.patch("rally.cli.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cli.commands.task.os.path.realpath", side_effect=lambda p: "realpath_%s" % p) @mock.patch("rally.cli.commands.task.open", side_effect=mock.mock_open(), create=True) @mock.patch("rally.cli.commands.task.plot") @mock.patch("rally.cli.commands.task.webbrowser") @mock.patch("rally.cli.commands.task.api.Task.get") def test_report_one_uuid(self, mock_task_get, mock_webbrowser, mock_plot, mock_open, mock_realpath, mock_validate): task_id = "eb290c30-38d8-4c8f-bbcc-fc8f74b004ae" data = [{ "key": { "name": "class.test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "hooks": "foo_hooks", "load_duration": 0.1, "full_duration": 1.2 } }, { "key": { "name": "class.test", "pos": 0 }, "data": { "raw": "bar_raw", "sla": "bar_sla", "hooks": "bar_hooks", "load_duration": 2.1, "full_duration": 2.2 } }] results = [{ "key": x["key"], "result": x["data"]["raw"], "sla": x["data"]["sla"], "hooks": x["data"]["hooks"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"] } for x in data] mock_results = mock.Mock(return_value=data) mock_task_get.return_value = mock.Mock(get_results=mock_results) mock_plot.plot.return_value = "html_report" def reset_mocks(): for m in mock_task_get, mock_webbrowser, mock_plot, mock_open: m.reset_mock() self.task.report(tasks=task_id, out="/tmp/%s.html" % task_id) mock_open.assert_called_once_with("/tmp/%s.html" % task_id, "w+") mock_plot.plot.assert_called_once_with(results, include_libs=False) mock_open.side_effect().write.assert_called_once_with("html_report") mock_task_get.assert_called_once_with(task_id) # JUnit reset_mocks() self.task.report(tasks=task_id, out="/tmp/%s.html" % task_id, out_format="junit") mock_open.assert_called_once_with("/tmp/%s.html" % task_id, "w+") self.assertFalse(mock_plot.plot.called) # HTML reset_mocks() self.task.report(task_id, out="output.html", open_it=True, out_format="html") mock_webbrowser.open_new_tab.assert_called_once_with( "file://realpath_output.html") mock_plot.plot.assert_called_once_with(results, include_libs=False) # HTML with embedded JS/CSS reset_mocks() self.task.report(task_id, open_it=False, out="output.html", out_format="html_static") self.assertFalse(mock_webbrowser.open_new_tab.called) mock_plot.plot.assert_called_once_with(results, include_libs=True) @mock.patch("rally.cli.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cli.commands.task.os.path.realpath", side_effect=lambda p: "realpath_%s" % p) @mock.patch("rally.cli.commands.task.open", side_effect=mock.mock_open(), create=True) @mock.patch("rally.cli.commands.task.plot") @mock.patch("rally.cli.commands.task.webbrowser") @mock.patch("rally.cli.commands.task.api.Task.get") def test_report_bunch_uuids(self, mock_task_get, mock_webbrowser, mock_plot, mock_open, mock_realpath, mock_validate): tasks = [ "eb290c30-38d8-4c8f-bbcc-fc8f74b004ae", "eb290c30-38d8-4c8f-bbcc-fc8f74b004af" ] data = [{ "key": { "name": "test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "hooks": "foo_hooks", "load_duration": 0.1, "full_duration": 1.2 } }, { "key": { "name": "test", "pos": 0 }, "data": { "raw": "bar_raw", "sla": "bar_sla", "hooks": "bar_hooks", "load_duration": 2.1, "full_duration": 2.2 } }] results = [] for task_uuid in tasks: results.extend( map( lambda x: { "key": x["key"], "result": x["data"]["raw"], "sla": x["data"]["sla"], "hooks": x["data"]["hooks"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"] }, data)) mock_results = mock.Mock(return_value=data) mock_task_get.return_value = mock.Mock(get_results=mock_results) mock_plot.plot.return_value = "html_report" def reset_mocks(): for m in mock_task_get, mock_webbrowser, mock_plot, mock_open: m.reset_mock() self.task.report(tasks=tasks, out="/tmp/1_test.html") mock_open.assert_called_once_with("/tmp/1_test.html", "w+") mock_plot.plot.assert_called_once_with(results, include_libs=False) mock_open.side_effect().write.assert_called_once_with("html_report") expected_get_calls = [mock.call(task) for task in tasks] mock_task_get.assert_has_calls(expected_get_calls, any_order=True) @mock.patch("rally.cli.commands.task.json.load") @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cli.commands.task.os.path.realpath", side_effect=lambda p: "realpath_%s" % p) @mock.patch("rally.cli.commands.task.open", create=True) @mock.patch("rally.cli.commands.task.plot") def test_report_one_file(self, mock_plot, mock_open, mock_realpath, mock_validate, mock_path_exists, mock_json_load): task_file = "/tmp/some_file.json" data = [{ "key": { "name": "test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "load_duration": 0.1, "full_duration": 1.2 } }, { "key": { "name": "test", "pos": 1 }, "data": { "raw": "bar_raw", "sla": "bar_sla", "load_duration": 2.1, "full_duration": 2.2 } }] results = [{ "key": x["key"], "result": x["data"]["raw"], "sla": x["data"]["sla"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"] } for x in data] mock_plot.plot.return_value = "html_report" mock_open.side_effect = mock.mock_open(read_data=results) mock_json_load.return_value = results def reset_mocks(): for m in mock_plot, mock_open, mock_json_load, mock_validate: m.reset_mock() self.task.report(tasks=task_file, out="/tmp/1_test.html") expected_open_calls = [ mock.call(task_file, "r"), mock.call("/tmp/1_test.html", "w+") ] mock_open.assert_has_calls(expected_open_calls, any_order=True) mock_plot.plot.assert_called_once_with(results, include_libs=False) mock_open.side_effect().write.assert_called_once_with("html_report") @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.json.load") @mock.patch("rally.cli.commands.task.open", create=True) def test_report_exceptions(self, mock_open, mock_json_load, mock_path_exists): results = [{ "key": { "name": "test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "load_duration": 0.1, "full_duration": 1.2 } }] mock_open.side_effect = mock.mock_open(read_data=results) mock_json_load.return_value = results ret = self.task.report(tasks="/tmp/task.json", out="/tmp/tmp.hsml") self.assertEqual(ret, 1) for m in mock_open, mock_json_load: m.reset_mock() mock_path_exists.return_value = False ret = self.task.report(tasks="/tmp/task.json", out="/tmp/tmp.hsml") self.assertEqual(ret, 1) @mock.patch("rally.cli.commands.task.sys.stderr") @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.json.load") @mock.patch("rally.cli.commands.task.open", create=True) def test_report_invalid_format(self, mock_open, mock_json_load, mock_path_exists, mock_stderr): result = self.task.report(tasks="/tmp/task.json", out="/tmp/tmp.html", out_format="invalid") self.assertEqual(1, result) expected_out = "Invalid output format: invalid" mock_stderr.write.assert_has_calls([mock.call(expected_out)]) @mock.patch("rally.cli.commands.task.cliutils.print_list") @mock.patch("rally.cli.commands.task.envutils.get_global", return_value="123456789") @mock.patch("rally.cli.commands.task.api.Task.list", return_value=[ fakes.FakeTask(uuid="a", created_at=dt.datetime.now(), updated_at=dt.datetime.now(), status="c", tag="d", deployment_name="some_name") ]) def test_list(self, mock_task_list, mock_get_global, mock_print_list): self.task.list(status="running") mock_task_list.assert_called_once_with( deployment=mock_get_global.return_value, status=consts.TaskStatus.RUNNING) headers = [ "uuid", "deployment_name", "created_at", "duration", "status", "tag" ] mock_print_list.assert_called_once_with( mock_task_list.return_value, headers, sortby_index=headers.index("created_at")) @mock.patch("rally.cli.commands.task.cliutils.print_list") @mock.patch("rally.cli.commands.task.envutils.get_global", return_value="123456789") @mock.patch("rally.cli.commands.task.api.Task.list", return_value=[ fakes.FakeTask(uuid="a", created_at=dt.datetime.now(), updated_at=dt.datetime.now(), status="c", tag="d", deployment_name="some_name") ]) def test_list_uuids_only(self, mock_task_list, mock_get_global, mock_print_list): self.task.list(status="running", uuids_only=True) mock_task_list.assert_called_once_with( deployment=mock_get_global.return_value, status=consts.TaskStatus.RUNNING) mock_print_list.assert_called_once_with(mock_task_list.return_value, ["uuid"], print_header=False, print_border=False) def test_list_wrong_status(self): self.assertEqual( 1, self.task.list(deployment="fake", status="wrong non existing status")) @mock.patch("rally.cli.commands.task.api.Task.list", return_value=[]) def test_list_no_results(self, mock_task_list): self.assertIsNone( self.task.list(deployment="fake", all_deployments=True)) mock_task_list.assert_called_once_with() mock_task_list.reset_mock() self.assertIsNone( self.task.list(deployment="d", status=consts.TaskStatus.RUNNING)) mock_task_list.assert_called_once_with( deployment="d", status=consts.TaskStatus.RUNNING) def test_delete(self): task_uuid = "8dcb9c5e-d60b-4022-8975-b5987c7833f7" force = False with mock.patch("rally.cli.commands.task.api") as mock_api: mock_api.Task.delete = mock.Mock() self.task.delete(task_uuid, force=force) mock_api.Task.delete.assert_called_once_with(task_uuid, force=force) @mock.patch("rally.cli.commands.task.api") def test_delete_multiple_uuid(self, mock_api): task_uuids = [ "4bf35b06-5916-484f-9547-12dce94902b7", "52cad69d-d3e4-47e1-b445-dec9c5858fe8", "6a3cb11c-ac75-41e7-8ae7-935732bfb48f", "018af931-0e5a-40d5-9d6f-b13f4a3a09fc" ] force = False self.task.delete(task_uuids, force=force) self.assertTrue(mock_api.Task.delete.call_count == len(task_uuids)) expected_calls = [ mock.call(task_uuid, force=force) for task_uuid in task_uuids ] self.assertTrue(mock_api.Task.delete.mock_calls == expected_calls) @mock.patch("rally.cli.commands.task.cliutils.print_list") @mock.patch("rally.cli.commands.task.api.Task.get") def test_sla_check(self, mock_task_get, mock_print_list): data = [{ "key": { "name": "fake_name", "pos": "fake_pos", "kw": "fake_kw" }, "data": { "scenario_duration": 42.0, "raw": [], "sla": [{ "benchmark": "KeystoneBasic.create_user", "criterion": "max_seconds_per_iteration", "pos": 0, "success": False, "detail": "Max foo, actually bar" }] } }] mock_task_get().get_results.return_value = copy.deepcopy(data) result = self.task.sla_check(task_id="fake_task_id") self.assertEqual(1, result) mock_task_get.assert_called_with("fake_task_id") data[0]["data"]["sla"][0]["success"] = True mock_task_get().get_results.return_value = data result = self.task.sla_check(task_id="fake_task_id", tojson=True) self.assertEqual(0, result) @mock.patch("rally.cli.commands.task.os.path.isfile", return_value=True) @mock.patch("rally.api.Task.validate") @mock.patch("rally.cli.commands.task.open", side_effect=mock.mock_open(read_data="{\"some\": \"json\"}"), create=True) def test_validate(self, mock_open, mock_task_validate, mock_os_path_isfile): self.task.validate("path_to_config.json", "fake_id") mock_task_validate.assert_called_once_with("fake_id", {"some": "json"}, None) @mock.patch("rally.cli.commands.task.os.path.isfile", return_value=True) @mock.patch("rally.cli.commands.task.TaskCommands._load_task", side_effect=task.FailedToLoadTask) def test_validate_failed_to_load_task(self, mock__load_task, mock_os_path_isfile): args = mock.MagicMock() args_file = mock.MagicMock() result = self.task.validate("path_to_task", "fake_deployment_id", task_args=args, task_args_file=args_file) self.assertEqual(1, result) mock__load_task.assert_called_once_with("path_to_task", args, args_file) @mock.patch("rally.cli.commands.task.os.path.isfile", return_value=True) @mock.patch("rally.cli.commands.task.TaskCommands._load_task") @mock.patch("rally.api.Task.validate") def test_validate_invalid(self, mock_task_validate, mock__load_task, mock_os_path_isfile): mock_task_validate.side_effect = exceptions.InvalidTaskException result = self.task.validate("path_to_task", "deployment") self.assertEqual(1, result) mock_task_validate.assert_called_once_with( "deployment", mock__load_task.return_value, None) @mock.patch("rally.common.fileutils._rewrite_env_file") @mock.patch("rally.cli.commands.task.api.Task.get", return_value=True) def test_use(self, mock_task_get, mock__rewrite_env_file): task_id = "80422553-5774-44bd-98ac-38bd8c7a0feb" self.task.use(task_id) mock__rewrite_env_file.assert_called_once_with( os.path.expanduser("~/.rally/globals"), ["RALLY_TASK=%s\n" % task_id]) @mock.patch("rally.cli.commands.task.api.Task.get") def test_use_not_found(self, mock_task_get): task_id = "ddc3f8ba-082a-496d-b18f-72cdf5c10a14" mock_task_get.side_effect = exceptions.TaskNotFound(uuid=task_id) self.assertRaises(exceptions.TaskNotFound, self.task.use, task_id) @mock.patch("rally.task.exporter.Exporter.get") def test_export(self, mock_exporter_get): mock_client = mock.Mock() mock_exporter_class = mock.Mock(return_value=mock_client) mock_exporter_get.return_value = mock_exporter_class self.task.export("fake_uuid", "file:///fake_path.json") mock_exporter_get.assert_called_once_with("file") mock_client.export.assert_called_once_with("fake_uuid") @mock.patch("rally.task.exporter.Exporter.get") def test_export_exception(self, mock_exporter_get): mock_client = mock.Mock() mock_exporter_class = mock.Mock(return_value=mock_client) mock_exporter_get.return_value = mock_exporter_class mock_client.export.side_effect = IOError self.task.export("fake_uuid", "file:///fake_path.json") mock_exporter_get.assert_called_once_with("file") mock_client.export.assert_called_once_with("fake_uuid") @mock.patch("rally.cli.commands.task.sys.stdout") @mock.patch("rally.task.exporter.Exporter.get") def test_export_InvalidConnectionString(self, mock_exporter_get, mock_stdout): mock_exporter_class = mock.Mock( side_effect=exceptions.InvalidConnectionString) mock_exporter_get.return_value = mock_exporter_class self.task.export("fake_uuid", "file:///fake_path.json") mock_stdout.write.assert_has_calls([ mock.call("The connection string is not valid: None. " "Please check your connection string."), mock.call("\n") ]) mock_exporter_get.assert_called_once_with("file") @mock.patch("rally.cli.commands.task.plot.charts") @mock.patch("rally.cli.commands.task.sys.stdout") @mock.patch("rally.cli.commands.task.api.Task") @ddt.data( { "error_type": "test_no_trace_type", "error_message": "no_trace_error_message", "error_traceback": None, }, { "error_type": "test_error_type", "error_message": "test_error_message", "error_traceback": "test\nerror\ntraceback", }) @ddt.unpack def test_show_task_errors_no_trace(self, mock_task, mock_stdout, mock_charts, error_type, error_message, error_traceback=None): mock_charts.MainStatsTable.columns = ["Column 1", "Column 2"] test_uuid = "test_task_id" error_data = [error_type, error_message] if error_traceback: error_data.append(error_traceback) mock_task.get_detailed.return_value = { "id": "task", "uuid": test_uuid, "status": "finished", "results": [ { "key": { "name": "fake_name", "pos": "fake_pos", "kw": "fake_kw" }, "info": { "stat": { "cols": ["Column 1", "Column 2"], "rows": [[11, 22], [33, 44]] }, "load_duration": 3.2, "full_duration": 3.5, "iterations_count": 1, "iterations_failed": 1, "atomic": { "foo": {}, "bar": {} } }, "iterations": [ { "duration": 0.9, "idle_duration": 0.1, "output": { "additive": [], "complete": [] }, "atomic_actions": { "foo": 0.6, "bar": 0.7 }, "error": error_data }, ] }, ], "verification_log": json.dumps([error_type, error_message, error_traceback]) } self.task.detailed(test_uuid) mock_task.get_detailed.assert_called_once_with(test_uuid, extended_results=True) mock_stdout.write.assert_has_calls( [mock.call(error_traceback or "No traceback available.")], any_order=False)
class TaskCommandsTestCase(test.TestCase): def setUp(self): super(TaskCommandsTestCase, self).setUp() self.task = task.TaskCommands() @mock.patch("rally.cmd.commands.task.open", create=True) def test_load_task(self, mock_open): input_task = "{'ab': {{test}}}" input_args = "{'test': 2}" # NOTE(boris-42): Such order of files is because we are reading # file with args before file with template. mock_open.side_effect = [ mock.mock_open(read_data="{'test': 1}").return_value, mock.mock_open(read_data=input_task).return_value ] result = self.task._load_task("in_task", task_args_file="in_args_path") self.assertEqual(result, {"ab": 1}) mock_open.side_effect = [ mock.mock_open(read_data=input_task).return_value ] result = self.task._load_task("in_task", task_args=input_args) self.assertEqual(result, {"ab": 2}) mock_open.side_effect = [ mock.mock_open(read_data="{'test': 1}").return_value, mock.mock_open(read_data=input_task).return_value ] result = self.task._load_task("in_task", task_args=input_args, task_args_file="any_file") self.assertEqual(result, {"ab": 2}) @mock.patch("rally.cmd.commands.task.open", create=True) def test_load_task_wrong_task_args_file(self, mock_open): mock_open.side_effect = [ mock.mock_open(read_data="{'test': {}").return_value ] self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task", task_args_file="in_args_path") @mock.patch("rally.cmd.commands.task.open", create=True) def test_load_task_wrong_task_args_file_exception(self, mock_open): mock_open.side_effect = IOError self.assertRaises(IOError, self.task._load_task, "in_task", task_args_file="in_args_path") def test_load_task_wrong_input_task_args(self): self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task", "{'test': {}") self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task", "[]") @mock.patch("rally.cmd.commands.task.open", create=True) def test_load_task_task_render_raise_exc(self, mock_open): mock_open.side_effect = [ mock.mock_open(read_data="{'test': {{t}}}").return_value ] self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task") @mock.patch("rally.cmd.commands.task.open", create=True) def test_load_task_task_not_in_yaml(self, mock_open): mock_open.side_effect = [ mock.mock_open(read_data="{'test': {}").return_value ] self.assertRaises(task.FailedToLoadTask, self.task._load_task, "in_task") @mock.patch("rally.cmd.commands.task.TaskCommands.detailed") @mock.patch("rally.cmd.commands.task.TaskCommands._load_task", return_value={"some": "json"}) @mock.patch("rally.api.Task.create") @mock.patch("rally.cmd.commands.task.api.Task.start") def test_start(self, mock_api, mock_create_task, mock_load, mock_task_detailed): mock_create_task.return_value = (dict( uuid="c1a9bbe-1ead-4740-92b5-0feecf421634", created_at="2014-01-14 09:14:45.395822", status="init", tag=None)) deployment_id = "e0617de9-77d1-4875-9b49-9d5789e29f20" task_path = "path_to_config.json" self.task.start(task_path, deployment_id) mock_api.assert_called_once_with(deployment_id, {"some": "json"}, task=mock_create_task.return_value, abort_on_sla_failure=False) mock_load.assert_called_once_with(task_path, None, None) @mock.patch("rally.cmd.commands.task.TaskCommands._load_task", side_effect=task.FailedToLoadTask) def test_start_with_task_args(self, mock_load): task_path = mock.MagicMock() task_args = mock.MagicMock() task_args_file = mock.MagicMock() self.task.start(task_path, deployment="any", task_args=task_args, task_args_file=task_args_file) mock_load.assert_called_once_with(task_path, task_args, task_args_file) @mock.patch("rally.cmd.commands.task.envutils.get_global") def test_start_no_deployment_id(self, mock_default): mock_default.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.start, "path_to_config.json", None) @mock.patch("rally.cmd.commands.task.TaskCommands._load_task") @mock.patch("rally.cmd.commands.task.api") def test_start_invalid_task(self, mock_api, mock_load): mock_api.Task.start.side_effect = exceptions.InvalidConfigException result = self.task.start("task_path", "deployment", tag="tag") self.assertEqual(1, result) mock_api.Task.create.assert_called_once_with("deployment", "tag") mock_api.Task.start.assert_called_once_with( "deployment", mock_load.return_value, task=mock_api.Task.create.return_value, abort_on_sla_failure=False) @mock.patch("rally.cmd.commands.task.api") def test_abort(self, mock_api): test_uuid = "17860c43-2274-498d-8669-448eff7b073f" mock_api.Task.abort = mock.MagicMock() self.task.abort(test_uuid) task.api.Task.abort.assert_called_once_with(test_uuid) @mock.patch("rally.cmd.commands.task.envutils.get_global") def test_abort_no_task_id(self, mock_default): mock_default.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.abort, None) def test_status(self): test_uuid = "a3e7cefb-bec2-4802-89f6-410cc31f71af" value = {"task_id": "task", "status": "status"} with mock.patch("rally.cmd.commands.task.db") as mock_db: mock_db.task_get = mock.MagicMock(return_value=value) self.task.status(test_uuid) mock_db.task_get.assert_called_once_with(test_uuid) @mock.patch("rally.cmd.commands.task.envutils.get_global") def test_status_no_task_id(self, mock_default): mock_default.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.status, None) @mock.patch("rally.cmd.commands.task.db") def test_detailed(self, mock_db): test_uuid = "c0d874d4-7195-4fd5-8688-abe82bfad36f" value = { "id": "task", "uuid": test_uuid, "status": "status", "results": [{ "key": { "name": "fake_name", "pos": "fake_pos", "kw": "fake_kw" }, "data": { "load_duration": 1.0, "full_duration": 2.0, "raw": [{ "duration": 0.9, "idle_duration": 0.5, "scenario_output": { "data": { "a": 3 }, "errors": "some" }, "atomic_actions": { "a": 0.6, "b": 0.7 }, "error": ["type", "message", "traceback"] }, { "duration": 0.5, "idle_duration": 0.2, "scenario_output": { "data": { "a": 1 }, "errors": "some" }, "atomic_actions": { "a": 0.2, "b": 0.4 }, "error": None }, { "duration": 0.6, "idle_duration": 0.4, "scenario_output": { "data": { "a": 2 }, "errors": None }, "atomic_actions": { "a": 0.3, "b": 0.5 }, "error": None }] } }] } mock_db.task_get_detailed = mock.MagicMock(return_value=value) self.task.detailed(test_uuid) mock_db.task_get_detailed.assert_called_once_with(test_uuid) self.task.detailed(test_uuid, iterations_data=True) @mock.patch("rally.cmd.commands.task.db") @mock.patch("rally.cmd.commands.task.logging") def test_detailed_task_failed(self, mock_logging, mock_db): value = { "id": "task", "uuid": "task_uuid", "status": consts.TaskStatus.FAILED, "results": [], "verification_log": "['1', '2', '3']" } mock_db.task_get_detailed = mock.MagicMock(return_value=value) mock_logging.is_debug.return_value = False self.task.detailed("task_uuid") mock_logging.is_debug.return_value = True self.task.detailed("task_uuid") @mock.patch("rally.cmd.commands.task.envutils.get_global") def test_detailed_no_task_id(self, mock_default): mock_default.side_effect = exceptions.InvalidArgumentsException self.assertRaises(exceptions.InvalidArgumentsException, self.task.detailed, None) @mock.patch("rally.cmd.commands.task.db") def test_detailed_wrong_id(self, mock_db): test_uuid = "eb290c30-38d8-4c8f-bbcc-fc8f74b004ae" mock_db.task_get_detailed = mock.MagicMock(return_value=None) self.task.detailed(test_uuid) mock_db.task_get_detailed.assert_called_once_with(test_uuid) @mock.patch("json.dumps") @mock.patch("rally.cmd.commands.task.objects.Task.get") def test_results(self, mock_get, mock_json): task_id = "foo_task_id" data = [{ "key": "foo_key", "data": { "raw": "foo_raw", "sla": [], "load_duration": "lo_duration", "full_duration": "fu_duration" } }] result = map( lambda x: { "key": x["key"], "result": x["data"]["raw"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"], "sla": x["data"]["sla"] }, data) mock_results = mock.Mock(return_value=data) mock_get.return_value = mock.Mock(get_results=mock_results) self.task.results(task_id) self.assertEqual(1, mock_json.call_count) self.assertEqual(1, len(mock_json.call_args[0])) self.assertSequenceEqual(result, mock_json.call_args[0][0]) self.assertEqual({ "sort_keys": True, "indent": 4 }, mock_json.call_args[1]) mock_get.assert_called_once_with(task_id) @mock.patch("rally.cmd.commands.task.objects.Task.get") def test_invalid_results(self, mock_get): task_id = "foo_task_id" data = [] mock_results = mock.Mock(return_value=data) mock_get.return_value = mock.Mock(get_results=mock_results) result = self.task.results(task_id) mock_get.assert_called_once_with(task_id) self.assertEqual(1, result) @mock.patch("rally.cmd.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cmd.commands.task.os.path.realpath", side_effect=lambda p: "realpath_%s" % p) @mock.patch("rally.cmd.commands.task.open", side_effect=mock.mock_open(), create=True) @mock.patch("rally.cmd.commands.task.plot") @mock.patch("rally.cmd.commands.task.webbrowser") @mock.patch("rally.cmd.commands.task.objects.Task.get") def test_report_one_uuid(self, mock_get, mock_web, mock_plot, mock_open, mock_os, mock_validate): task_id = "eb290c30-38d8-4c8f-bbcc-fc8f74b004ae" data = [{ "key": { "name": "test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "load_duration": 0.1, "full_duration": 1.2 } }, { "key": { "name": "test", "pos": 0 }, "data": { "raw": "bar_raw", "sla": "bar_sla", "load_duration": 2.1, "full_duration": 2.2 } }] results = [{ "key": x["key"], "result": x["data"]["raw"], "sla": x["data"]["sla"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"] } for x in data] mock_results = mock.Mock(return_value=data) mock_get.return_value = mock.Mock(get_results=mock_results) mock_plot.plot.return_value = "html_report" def reset_mocks(): for m in mock_get, mock_web, mock_plot, mock_open: m.reset_mock() self.task.report(tasks=task_id, out="/tmp/%s.html" % task_id) mock_open.assert_called_once_with("/tmp/%s.html" % task_id, "w+") mock_plot.plot.assert_called_once_with(results) mock_open.side_effect().write.assert_called_once_with("html_report") mock_get.assert_called_once_with(task_id) reset_mocks() self.task.report(task_id, out="spam.html", open_it=True) mock_web.open_new_tab.assert_called_once_with( "file://realpath_spam.html") @mock.patch("rally.cmd.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cmd.commands.task.os.path.realpath", side_effect=lambda p: "realpath_%s" % p) @mock.patch("rally.cmd.commands.task.open", side_effect=mock.mock_open(), create=True) @mock.patch("rally.cmd.commands.task.plot") @mock.patch("rally.cmd.commands.task.webbrowser") @mock.patch("rally.cmd.commands.task.objects.Task.get") def test_report_bunch_uuids(self, mock_get, mock_web, mock_plot, mock_open, mock_os, mock_validate): tasks = [ "eb290c30-38d8-4c8f-bbcc-fc8f74b004ae", "eb290c30-38d8-4c8f-bbcc-fc8f74b004af" ] data = [{ "key": { "name": "test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "load_duration": 0.1, "full_duration": 1.2 } }, { "key": { "name": "test", "pos": 0 }, "data": { "raw": "bar_raw", "sla": "bar_sla", "load_duration": 2.1, "full_duration": 2.2 } }] results = list() for task_uuid in tasks: results.extend( map( lambda x: { "key": x["key"], "result": x["data"]["raw"], "sla": x["data"]["sla"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"] }, data)) mock_results = mock.Mock(return_value=data) mock_get.return_value = mock.Mock(get_results=mock_results) mock_plot.plot.return_value = "html_report" def reset_mocks(): for m in mock_get, mock_web, mock_plot, mock_open: m.reset_mock() self.task.report(tasks=tasks, out="/tmp/1_test.html") mock_open.assert_called_once_with("/tmp/1_test.html", "w+") mock_plot.plot.assert_called_once_with(results) mock_open.side_effect().write.assert_called_once_with("html_report") expected_get_calls = [mock.call(task) for task in tasks] mock_get.assert_has_calls(expected_get_calls, any_order=True) @mock.patch("rally.cmd.commands.task.json.load") @mock.patch("rally.cmd.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cmd.commands.task.jsonschema.validate", return_value=None) @mock.patch("rally.cmd.commands.task.os.path.realpath", side_effect=lambda p: "realpath_%s" % p) @mock.patch("rally.cmd.commands.task.open", create=True) @mock.patch("rally.cmd.commands.task.plot") def test_report_one_file(self, mock_plot, mock_open, mock_os, mock_validate, mock_path_exists, mock_json_load): task_file = "/tmp/some_file.json" data = [{ "key": { "name": "test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "load_duration": 0.1, "full_duration": 1.2 } }, { "key": { "name": "test", "pos": 1 }, "data": { "raw": "bar_raw", "sla": "bar_sla", "load_duration": 2.1, "full_duration": 2.2 } }] results = [{ "key": x["key"], "result": x["data"]["raw"], "sla": x["data"]["sla"], "load_duration": x["data"]["load_duration"], "full_duration": x["data"]["full_duration"] } for x in data] mock_plot.plot.return_value = "html_report" mock_open.side_effect = mock.mock_open(read_data=results) mock_json_load.return_value = results def reset_mocks(): for m in mock_plot, mock_open, mock_json_load, mock_validate: m.reset_mock() self.task.report(tasks=task_file, out="/tmp/1_test.html") expected_open_calls = [ mock.call(task_file, "r"), mock.call("/tmp/1_test.html", "w+") ] mock_open.assert_has_calls(expected_open_calls, any_order=True) mock_plot.plot.assert_called_once_with(results) mock_open.side_effect().write.assert_called_once_with("html_report") @mock.patch("rally.cmd.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cmd.commands.task.json.load") @mock.patch("rally.cmd.commands.task.open", create=True) def test_report_exceptions(self, mock_open, mock_json_load, mock_path_exists): results = [{ "key": { "name": "test", "pos": 0 }, "data": { "raw": "foo_raw", "sla": "foo_sla", "load_duration": 0.1, "full_duration": 1.2 } }] mock_open.side_effect = mock.mock_open(read_data=results) mock_json_load.return_value = results ret = self.task.report(tasks="/tmp/task.json", out="/tmp/tmp.hsml") self.assertEqual(ret, 1) for m in mock_open, mock_json_load: m.reset_mock() mock_path_exists.return_value = False ret = self.task.report(tasks="/tmp/task.json", out="/tmp/tmp.hsml") self.assertEqual(ret, 1) @mock.patch("rally.cmd.commands.task.cliutils.print_list") @mock.patch("rally.cmd.commands.task.envutils.get_global", return_value="123456789") @mock.patch("rally.cmd.commands.task.objects.Task.list", return_value=[ fakes.FakeTask(uuid="a", created_at=date.datetime.now(), updated_at=date.datetime.now(), status="c", tag="d", deployment_name="some_name") ]) def test_list(self, mock_objects_list, mock_default, mock_print_list): self.task.list(status="running") mock_objects_list.assert_called_once_with( deployment=mock_default.return_value, status=consts.TaskStatus.RUNNING) headers = [ "uuid", "deployment_name", "created_at", "duration", "status", "tag" ] mock_print_list.assert_called_once_with( mock_objects_list.return_value, headers, sortby_index=headers.index("created_at")) def test_list_wrong_status(self): self.assertEqual( 1, self.task.list(deployment="fake", status="wrong non existing status")) @mock.patch("rally.cmd.commands.task.objects.Task.list", return_value=[]) def test_list_no_results(self, mock_list): self.assertIsNone( self.task.list(deployment="fake", all_deployments=True)) mock_list.assert_called_once_with() mock_list.reset_mock() self.assertIsNone( self.task.list(deployment="d", status=consts.TaskStatus.RUNNING)) mock_list.assert_called_once_with(deployment="d", status=consts.TaskStatus.RUNNING) def test_delete(self): task_uuid = "8dcb9c5e-d60b-4022-8975-b5987c7833f7" force = False with mock.patch("rally.cmd.commands.task.api") as mock_api: mock_api.Task.delete = mock.Mock() self.task.delete(task_uuid, force=force) mock_api.Task.delete.assert_called_once_with(task_uuid, force=force) @mock.patch("rally.cmd.commands.task.api") def test_delete_multiple_uuid(self, mock_api): task_uuids = [ "4bf35b06-5916-484f-9547-12dce94902b7", "52cad69d-d3e4-47e1-b445-dec9c5858fe8", "6a3cb11c-ac75-41e7-8ae7-935732bfb48f", "018af931-0e5a-40d5-9d6f-b13f4a3a09fc" ] force = False self.task.delete(task_uuids, force=force) self.assertTrue(mock_api.Task.delete.call_count == len(task_uuids)) expected_calls = [ mock.call(task_uuid, force=force) for task_uuid in task_uuids ] self.assertTrue(mock_api.Task.delete.mock_calls == expected_calls) @mock.patch("rally.cmd.commands.task.cliutils.print_list") @mock.patch("rally.cmd.commands.task.objects.Task.get") def test_sla_check(self, mock_task_get, mock_print_list): data = [{ "key": { "name": "fake_name", "pos": "fake_pos", "kw": "fake_kw" }, "data": { "scenario_duration": 42.0, "raw": [], "sla": [{ "benchmark": "KeystoneBasic.create_user", "criterion": "max_seconds_per_iteration", "pos": 0, "success": False, "detail": "Max foo, actually bar" }] } }] mock_task_get().get_results.return_value = copy.deepcopy(data) result = self.task.sla_check(task_id="fake_task_id") self.assertEqual(1, result) mock_task_get.assert_called_with("fake_task_id") data[0]["data"]["sla"][0]["success"] = True mock_task_get().get_results.return_value = data result = self.task.sla_check(task_id="fake_task_id", tojson=True) self.assertEqual(0, result) @mock.patch("rally.cmd.commands.task.open", mock.mock_open(read_data="{\"some\": \"json\"}"), create=True) @mock.patch("rally.api.Task.validate") def test_validate(self, mock_validate): self.task.validate("path_to_config.json", "fake_id") mock_validate.assert_called_once_with("fake_id", {"some": "json"}) @mock.patch("rally.cmd.commands.task.TaskCommands._load_task", side_effect=task.FailedToLoadTask) def test_validate_failed_to_load_task(self, mock_load): args = mock.MagicMock() args_file = mock.MagicMock() result = self.task.validate("path_to_task", "fake_id", task_args=args, task_args_file=args_file) self.assertEqual(1, result) mock_load.assert_called_once_with("path_to_task", args, args_file) @mock.patch("rally.cmd.commands.task.TaskCommands._load_task") @mock.patch("rally.api.Task.validate") def test_validate_invalid(self, mock_task_validate, mock_load): mock_task_validate.side_effect = exceptions.InvalidTaskException result = self.task.validate("path_to_task", "deployment") self.assertEqual(1, result) mock_task_validate.assert_called_once_with("deployment", mock_load.return_value) @mock.patch("rally.cmd.commands.use.UseCommands.task") def test_use(self, mock_use_task): self.task.use("fake_id") mock_use_task.assert_called_once_with("fake_id")