From 7a0b5000aedca2d56ad4b9d37725d1d0a2c6a35c Mon Sep 17 00:00:00 2001 From: Renat Akhmerov Date: Sat, 23 Jul 2016 09:20:08 +0700 Subject: [PATCH] Add "Task ID" field for "action-execution-get" command output * A series of small cosmetic changes Change-Id: Ie984f3843a7b2e9ceb05df4519cc61e7d8fd5794 --- .../commands/v2/action_executions.py | 20 +- .../tests/functional/cli/v2/base_v2.py | 107 ++++--- .../cli/v2/cli_multi_tenancy_tests.py | 32 +-- .../tests/functional/cli/v2/cli_tests_v2.py | 271 ++++++++++-------- .../tests/unit/v2/test_action_executions.py | 41 ++- .../tests/unit/v2/test_cli_action_execs.py | 25 +- 6 files changed, 286 insertions(+), 210 deletions(-) diff --git a/mistralclient/commands/v2/action_executions.py b/mistralclient/commands/v2/action_executions.py index 6c0e6d37..7dea2cd8 100644 --- a/mistralclient/commands/v2/action_executions.py +++ b/mistralclient/commands/v2/action_executions.py @@ -35,20 +35,24 @@ def format(action_ex=None, lister=False): 'Name', 'Workflow name', 'Task name', + 'Task ID', 'State', 'State info', - 'Is accepted', + 'Accepted', ) if action_ex: - state_info = (action_ex.state_info if not lister - else base.cut(action_ex.state_info)) + state_info = ( + action_ex.state_info if not lister + else base.cut(action_ex.state_info) + ) data = ( action_ex.id, action_ex.name, action_ex.workflow_name, action_ex.task_name if hasattr(action_ex, 'task_name') else None, + action_ex.task_execution_id, action_ex.state, state_info, action_ex.accepted, @@ -144,12 +148,14 @@ class List(base.MistralLister): parser.add_argument( 'task_execution_id', nargs='?', - help='Task execution ID.') + help='Task execution ID.' + ) return parser def _get_resources(self, parsed_args): mistral_client = self.app.client_manager.workflow_engine + return mistral_client.action_executions.list( parsed_args.task_execution_id ) @@ -161,13 +167,13 @@ class Get(command.ShowOne): def get_parser(self, prog_name): parser = super(Get, self).get_parser(prog_name) - parser.add_argument( - 'action_execution', - help='Action execution ID.') + parser.add_argument('action_execution', help='Action execution ID.') + return parser def take_action(self, parsed_args): mistral_client = self.app.client_manager.workflow_engine + execution = mistral_client.action_executions.get( parsed_args.action_execution ) diff --git a/mistralclient/tests/functional/cli/v2/base_v2.py b/mistralclient/tests/functional/cli/v2/base_v2.py index ce8a985f..d039af59 100644 --- a/mistralclient/tests/functional/cli/v2/base_v2.py +++ b/mistralclient/tests/functional/cli/v2/base_v2.py @@ -32,47 +32,60 @@ class MistralClientTestBase(base.MistralCLIAuth, base.MistralCLIAltAuth): super(MistralClientTestBase, cls).setUpClass() cls.wb_def = os.path.relpath( - 'functionaltests/resources/v2/wb_v2.yaml', os.getcwd()) + 'functionaltests/resources/v2/wb_v2.yaml', os.getcwd() + ) cls.wb_with_tags_def = os.path.relpath( - 'functionaltests/resources/v2/wb_with_tags_v2.yaml', os.getcwd()) + 'functionaltests/resources/v2/wb_with_tags_v2.yaml', os.getcwd() + ) cls.wf_def = os.path.relpath( - 'functionaltests/resources/v2/wf_v2.yaml', os.getcwd()) + 'functionaltests/resources/v2/wf_v2.yaml', os.getcwd() + ) cls.wf_single_def = os.path.relpath( - 'functionaltests/resources/v2/wf_single_v2.yaml', os.getcwd()) + 'functionaltests/resources/v2/wf_single_v2.yaml', os.getcwd() + ) cls.wf_with_delay_def = os.path.relpath( - 'functionaltests/resources/v2/wf_delay_v2.yaml', os.getcwd()) + 'functionaltests/resources/v2/wf_delay_v2.yaml', os.getcwd() + ) cls.act_def = os.path.relpath( - 'functionaltests/resources/v2/action_v2.yaml', os.getcwd()) + 'functionaltests/resources/v2/action_v2.yaml', os.getcwd() + ) cls.act_tag_def = os.path.relpath( - 'functionaltests/resources/v2/action_v2_tags.yaml', os.getcwd()) + 'functionaltests/resources/v2/action_v2_tags.yaml', os.getcwd() + ) def setUp(self): super(MistralClientTestBase, self).setUp() - def get_value_of_field(self, obj, field): - return [o['Value'] for o in obj - if o['Field'] == "{0}".format(field)][0] + def get_field_value(self, obj, field): + return [ + o['Value'] for o in obj + if o['Field'] == "{0}".format(field) + ][0] def get_item_info(self, get_from, get_by, value): return [i for i in get_from if i[get_by] == value][0] def mistral_admin(self, cmd, params=""): self.clients = self._get_admin_clients() - return self.parser.listing(self.mistral( - '{0}'.format(cmd), params='{0}'.format(params))) + + return self.parser.listing( + self.mistral('{0}'.format(cmd), params='{0}'.format(params)) + ) def mistral_alt_user(self, cmd, params=""): self.clients = self._get_alt_clients() - return self.parser.listing(self.mistral_alt( - '{0}'.format(cmd), params='{0}'.format(params))) - def mistral_cli(self, admin, cmd, params): + return self.parser.listing( + self.mistral_alt('{0}'.format(cmd), params='{0}'.format(params)) + ) + + def mistral_cli(self, admin, cmd, params=''): if admin: return self.mistral_admin(cmd, params) else: @@ -82,16 +95,24 @@ class MistralClientTestBase(base.MistralCLIAuth, base.MistralCLIAltAuth): wb = self.mistral_cli( admin, 'workbook-create', - params='{0}'.format(wb_def)) - wb_name = self.get_value_of_field(wb, "Name") - self.addCleanup(self.mistral_cli, - admin, - 'workbook-delete', - params=wb_name) - self.addCleanup(self.mistral_cli, - admin, - 'workflow-delete', - params='wb.wf1') + params='{0}'.format(wb_def) + ) + + wb_name = self.get_field_value(wb, "Name") + + self.addCleanup( + self.mistral_cli, + admin, + 'workbook-delete', + params=wb_name + ) + + self.addCleanup( + self.mistral_cli, + admin, + 'workflow-delete', + params='wb.wf1' + ) return wb @@ -156,17 +177,20 @@ class MistralClientTestBase(base.MistralCLIAuth, base.MistralCLIAltAuth): def cron_trigger_create(self, name, wf_name, wf_input, pattern=None, count=None, first_time=None, admin=True): optional_params = "" + if pattern: optional_params += ' --pattern "{}"'.format(pattern) if count: optional_params += ' --count {}'.format(count) if first_time: optional_params += ' --first-time "{}"'.format(first_time) + trigger = self.mistral_cli( admin, 'cron-trigger-create', params='{} {} {} {}'.format(name, wf_name, wf_input, optional_params)) + self.addCleanup(self.mistral_cli, admin, 'cron-trigger-delete', @@ -176,21 +200,27 @@ class MistralClientTestBase(base.MistralCLIAuth, base.MistralCLIAltAuth): def execution_create(self, params, admin=True): ex = self.mistral_cli(admin, 'execution-create', params=params) - exec_id = self.get_value_of_field(ex, 'ID') - self.addCleanup(self.mistral_cli, - admin, - 'execution-delete', - params=exec_id) + exec_id = self.get_field_value(ex, 'ID') + + self.addCleanup( + self.mistral_cli, + admin, + 'execution-delete', + params=exec_id + ) return ex def environment_create(self, params, admin=True): env = self.mistral_cli(admin, 'environment-create', params=params) - env_name = self.get_value_of_field(env, 'Name') - self.addCleanup(self.mistral_cli, - admin, - 'environment-delete', - params=env_name) + env_name = self.get_field_value(env, 'Name') + + self.addCleanup( + self.mistral_cli, + admin, + 'environment-delete', + params=env_name + ) return env @@ -198,13 +228,14 @@ class MistralClientTestBase(base.MistralCLIAuth, base.MistralCLIAltAuth): f = open(file_name, 'w') f.write(file_body) f.close() + self.addCleanup(os.remove, file_name) def wait_execution_success(self, exec_id, timeout=180): start_time = time.time() ex = self.mistral_admin('execution-get', params=exec_id) - exec_state = self.get_value_of_field(ex, 'State') + exec_state = self.get_field_value(ex, 'State') expected_states = ['SUCCESS', 'RUNNING'] @@ -212,14 +243,16 @@ class MistralClientTestBase(base.MistralCLIAuth, base.MistralCLIAltAuth): if time.time() - start_time > timeout: msg = ("Execution exceeds timeout {0} to change state " "to SUCCESS. Execution: {1}".format(timeout, ex)) + raise exceptions.TimeoutException(msg) ex = self.mistral_admin('execution-get', params=exec_id) - exec_state = self.get_value_of_field(ex, 'State') + exec_state = self.get_field_value(ex, 'State') if exec_state not in expected_states: msg = ("Execution state %s is not in expected " "states: %s" % (exec_state, expected_states)) + raise exceptions.TempestException(msg) time.sleep(2) diff --git a/mistralclient/tests/functional/cli/v2/cli_multi_tenancy_tests.py b/mistralclient/tests/functional/cli/v2/cli_multi_tenancy_tests.py index 2c411c56..70971e74 100644 --- a/mistralclient/tests/functional/cli/v2/cli_multi_tenancy_tests.py +++ b/mistralclient/tests/functional/cli/v2/cli_multi_tenancy_tests.py @@ -83,7 +83,7 @@ class WorkbookIsolationCLITests(base_v2.MistralClientTestBase): def test_wb_isolation(self): wb = self.workbook_create(self.wb_def) - wb_name = self.get_value_of_field(wb, "Name") + wb_name = self.get_field_value(wb, "Name") wbs = self.mistral_admin("workbook-list") self.assertIn(wb_name, [w["Name"] for w in wbs]) @@ -94,7 +94,7 @@ class WorkbookIsolationCLITests(base_v2.MistralClientTestBase): def test_get_wb_from_another_tenant(self): wb = self.workbook_create(self.wb_def) - name = self.get_value_of_field(wb, "Name") + name = self.get_field_value(wb, "Name") self.assertRaises( exceptions.CommandFailed, @@ -105,7 +105,7 @@ class WorkbookIsolationCLITests(base_v2.MistralClientTestBase): def test_delete_wb_from_another_tenant(self): wb = self.workbook_create(self.wb_def) - name = self.get_value_of_field(wb, "Name") + name = self.get_field_value(wb, "Name") self.assertRaises( exceptions.CommandFailed, @@ -166,7 +166,7 @@ class WorkflowIsolationCLITests(base_v2.MistralClientTestBase): self.assertEqual( wf[0]["Name"], - self.get_value_of_field(same_wf, "Name") + self.get_field_value(same_wf, "Name") ) def test_delete_wf_from_another_tenant(self): @@ -188,13 +188,13 @@ class WorkflowSharingCLITests(base_v2.MistralClientTestBase): def _update_shared_workflow(self, new_status='accepted'): member = self.workflow_member_create(self.wf[0]["ID"]) - status = self.get_value_of_field(member, 'Status') + status = self.get_field_value(member, 'Status') self.assertEqual('pending', status) cmd_param = '%s workflow --status %s' % (self.wf[0]["ID"], new_status) member = self.mistral_alt_user("member-update", params=cmd_param) - status = self.get_value_of_field(member, 'Status') + status = self.get_field_value(member, 'Status') self.assertEqual(new_status, status) @@ -222,7 +222,7 @@ class WorkflowSharingCLITests(base_v2.MistralClientTestBase): self._update_shared_workflow(new_status='accepted') execution = self.execution_create(self.wf[0]["ID"], admin=False) - wf_name = self.get_value_of_field(execution, 'Workflow name') + wf_name = self.get_field_value(execution, 'Workflow name') self.assertEqual(self.wf[0]["Name"], wf_name) @@ -236,7 +236,7 @@ class WorkflowSharingCLITests(base_v2.MistralClientTestBase): "5 * * * *", admin=False ) - wf_name = self.get_value_of_field(trigger, 'Workflow') + wf_name = self.get_field_value(trigger, 'Workflow') self.assertEqual(self.wf[0]["Name"], wf_name) @@ -311,7 +311,7 @@ class ActionIsolationCLITests(base_v2.MistralClientTestBase): self.assertEqual( act[0]["Name"], - self.get_value_of_field(same_act, "Name") + self.get_field_value(same_act, "Name") ) @@ -372,7 +372,7 @@ class ExecutionIsolationCLITests(base_v2.MistralClientTestBase): def test_execution_isolation(self): wf = self.workflow_create(self.wf_def) ex = self.execution_create(wf[0]["Name"]) - exec_id = self.get_value_of_field(ex, "ID") + exec_id = self.get_field_value(ex, "ID") execs = self.mistral_admin("execution-list") self.assertIn(exec_id, [e["ID"] for e in execs]) @@ -383,7 +383,7 @@ class ExecutionIsolationCLITests(base_v2.MistralClientTestBase): def test_get_execution_from_another_tenant(self): wf = self.workflow_create(self.wf_def) ex = self.execution_create(wf[0]["Name"]) - exec_id = self.get_value_of_field(ex, "ID") + exec_id = self.get_field_value(ex, "ID") self.assertRaises( exceptions.CommandFailed, @@ -426,7 +426,7 @@ class EnvironmentIsolationCLITests(base_v2.MistralClientTestBase): def test_environment_isolation(self): env = self.environment_create(self.env_file) - env_name = self.get_value_of_field(env, "Name") + env_name = self.get_field_value(env, "Name") envs = self.mistral_admin("environment-list") self.assertIn(env_name, [en["Name"] for en in envs]) @@ -437,7 +437,7 @@ class EnvironmentIsolationCLITests(base_v2.MistralClientTestBase): def test_get_env_from_another_tenant(self): env = self.environment_create(self.env_file) - env_name = self.get_value_of_field(env, "Name") + env_name = self.get_field_value(env, "Name") self.assertRaises( exceptions.CommandFailed, @@ -448,7 +448,7 @@ class EnvironmentIsolationCLITests(base_v2.MistralClientTestBase): def test_delete_env_from_another_tenant(self): env = self.environment_create(self.env_file) - env_name = self.get_value_of_field(env, "Name") + env_name = self.get_field_value(env, "Name") self.assertRaises( exceptions.CommandFailed, @@ -463,7 +463,7 @@ class ActionExecutionIsolationCLITests(base_v2.MistralClientTestBase): def test_action_execution_isolation(self): wf = self.workflow_create(self.wf_def) wf_exec = self.execution_create(wf[0]["Name"]) - direct_ex_id = self.get_value_of_field(wf_exec, 'ID') + direct_ex_id = self.get_field_value(wf_exec, 'ID') self.wait_execution_success(direct_ex_id) @@ -478,7 +478,7 @@ class ActionExecutionIsolationCLITests(base_v2.MistralClientTestBase): def test_get_action_execution_from_another_tenant(self): wf = self.workflow_create(self.wf_def) ex = self.execution_create(wf[0]["Name"]) - exec_id = self.get_value_of_field(ex, "ID") + exec_id = self.get_field_value(ex, "ID") self.assertRaises( exceptions.CommandFailed, diff --git a/mistralclient/tests/functional/cli/v2/cli_tests_v2.py b/mistralclient/tests/functional/cli/v2/cli_tests_v2.py index ae3b148b..e8076a21 100644 --- a/mistralclient/tests/functional/cli/v2/cli_tests_v2.py +++ b/mistralclient/tests/functional/cli/v2/cli_tests_v2.py @@ -93,8 +93,7 @@ class SimpleMistralCLITests(base.MistralCLIAuth): self.mistral('action-execution-list')) self.assertTableStruct( act_execs, - ['ID', 'Name', 'Workflow name', 'State', - 'State info', 'Is accepted'] + ['ID', 'Name', 'Workflow name', 'State', 'State info', 'Accepted'] ) @@ -108,7 +107,7 @@ class WorkbookCLITests(base_v2.MistralClientTestBase): def test_workbook_create_delete(self): wb = self.mistral_admin( 'workbook-create', params=self.wb_def) - wb_name = self.get_value_of_field(wb, "Name") + wb_name = self.get_field_value(wb, "Name") self.assertTableStruct(wb, ['Field', 'Value']) @@ -126,22 +125,22 @@ class WorkbookCLITests(base_v2.MistralClientTestBase): def test_workbook_create_with_tags(self): wb = self.workbook_create(self.wb_with_tags_def) - tags = self.get_value_of_field(wb, 'Tags') + tags = self.get_field_value(wb, 'Tags') self.assertIn('tag', tags) def test_workbook_update(self): wb = self.workbook_create(self.wb_def) - wb_name = self.get_value_of_field(wb, "Name") + wb_name = self.get_field_value(wb, "Name") - init_update_at = self.get_value_of_field(wb, "Updated at") - tags = self.get_value_of_field(wb, 'Tags') + init_update_at = self.get_field_value(wb, "Updated at") + tags = self.get_field_value(wb, 'Tags') self.assertNotIn('tag', tags) wb = self.mistral_admin( 'workbook-update', params=self.wb_def) - update_at = self.get_value_of_field(wb, "Updated at") - name = self.get_value_of_field(wb, 'Name') - tags = self.get_value_of_field(wb, 'Tags') + update_at = self.get_field_value(wb, "Updated at") + name = self.get_field_value(wb, 'Name') + tags = self.get_field_value(wb, 'Tags') self.assertEqual(wb_name, name) self.assertNotIn('tag', tags) @@ -151,9 +150,9 @@ class WorkbookCLITests(base_v2.MistralClientTestBase): 'workbook-update', params=self.wb_with_tags_def) self.assertTableStruct(wb, ['Field', 'Value']) - update_at = self.get_value_of_field(wb, "Updated at") - name = self.get_value_of_field(wb, 'Name') - tags = self.get_value_of_field(wb, 'Tags') + update_at = self.get_field_value(wb, "Updated at") + name = self.get_field_value(wb, 'Name') + tags = self.get_field_value(wb, 'Tags') self.assertEqual(wb_name, name) self.assertIn('tag', tags) @@ -161,23 +160,23 @@ class WorkbookCLITests(base_v2.MistralClientTestBase): def test_workbook_get(self): created = self.workbook_create(self.wb_with_tags_def) - wb_name = self.get_value_of_field(created, "Name") + wb_name = self.get_field_value(created, "Name") fetched = self.mistral_admin('workbook-get', params=wb_name) - created_wb_name = self.get_value_of_field(created, 'Name') - fetched_wb_name = self.get_value_of_field(fetched, 'Name') + created_wb_name = self.get_field_value(created, 'Name') + fetched_wb_name = self.get_field_value(fetched, 'Name') self.assertEqual(created_wb_name, fetched_wb_name) - created_wb_tag = self.get_value_of_field(created, 'Tags') - fetched_wb_tag = self.get_value_of_field(fetched, 'Tags') + created_wb_tag = self.get_field_value(created, 'Tags') + fetched_wb_tag = self.get_field_value(fetched, 'Tags') self.assertEqual(created_wb_tag, fetched_wb_tag) def test_workbook_get_definition(self): wb = self.workbook_create(self.wb_def) - wb_name = self.get_value_of_field(wb, "Name") + wb_name = self.get_field_value(wb, "Name") definition = self.mistral_admin( 'workbook-get-definition', params=wb_name) @@ -186,8 +185,8 @@ class WorkbookCLITests(base_v2.MistralClientTestBase): def test_workbook_validate_with_valid_def(self): wb = self.mistral_admin( 'workbook-validate', params=self.wb_def) - wb_valid = self.get_value_of_field(wb, 'Valid') - wb_error = self.get_value_of_field(wb, 'Error') + wb_valid = self.get_field_value(wb, 'Valid') + wb_error = self.get_field_value(wb, 'Error') self.assertEqual('True', wb_valid) self.assertEqual('None', wb_error) @@ -198,8 +197,8 @@ class WorkbookCLITests(base_v2.MistralClientTestBase): wb = self.mistral_admin( 'workbook-validate', params='wb.yaml') - wb_valid = self.get_value_of_field(wb, 'Valid') - wb_error = self.get_value_of_field(wb, 'Error') + wb_valid = self.get_field_value(wb, 'Valid') + wb_error = self.get_field_value(wb, 'Error') self.assertEqual('False', wb_valid) self.assertNotEqual('None', wb_error) @@ -347,7 +346,7 @@ class WorkflowCLITests(base_v2.MistralClientTestBase): wf_name = created[0]['Name'] fetched = self.mistral_admin('workflow-get', params=wf_name) - fetched_wf_name = self.get_value_of_field(fetched, 'Name') + fetched_wf_name = self.get_field_value(fetched, 'Name') self.assertEqual(wf_name, fetched_wf_name) def test_workflow_get_with_id(self): @@ -356,7 +355,7 @@ class WorkflowCLITests(base_v2.MistralClientTestBase): wf_id = created[0]['ID'] fetched = self.mistral_admin('workflow-get', params=wf_id) - fetched_wf_name = self.get_value_of_field(fetched, 'Name') + fetched_wf_name = self.get_field_value(fetched, 'Name') self.assertEqual(wf_name, fetched_wf_name) def test_workflow_get_definition(self): @@ -370,8 +369,8 @@ class WorkflowCLITests(base_v2.MistralClientTestBase): def test_workflow_validate_with_valid_def(self): wf = self.mistral_admin( 'workflow-validate', params=self.wf_def) - wf_valid = self.get_value_of_field(wf, 'Valid') - wf_error = self.get_value_of_field(wf, 'Error') + wf_valid = self.get_field_value(wf, 'Valid') + wf_error = self.get_field_value(wf, 'Error') self.assertEqual('True', wf_valid) self.assertEqual('None', wf_error) @@ -382,8 +381,8 @@ class WorkflowCLITests(base_v2.MistralClientTestBase): wf = self.mistral_admin( 'workflow-validate', params='wf.yaml') - wf_valid = self.get_value_of_field(wf, 'Valid') - wf_error = self.get_value_of_field(wf, 'Error') + wf_valid = self.get_field_value(wf, 'Valid') + wf_error = self.get_field_value(wf, 'Error') self.assertEqual('False', wf_valid) self.assertNotEqual('None', wf_error) @@ -400,6 +399,7 @@ class ExecutionCLITests(base_v2.MistralClientTestBase): super(ExecutionCLITests, self).setUp() wfs = self.workflow_create(self.wf_def) + self.direct_wf = wfs[0] self.reverse_wf = wfs[1] @@ -411,13 +411,13 @@ class ExecutionCLITests(base_v2.MistralClientTestBase): 'execution-create', params='{0} -d "execution test"'.format(self.direct_wf['Name']) ) - exec_id = self.get_value_of_field(execution, 'ID') + exec_id = self.get_field_value(execution, 'ID') self.assertTableStruct(execution, ['Field', 'Value']) - wf_name = self.get_value_of_field(execution, 'Workflow name') - wf_id = self.get_value_of_field(execution, 'Workflow ID') - created_at = self.get_value_of_field(execution, 'Created at') - description = self.get_value_of_field(execution, 'Description') + wf_name = self.get_field_value(execution, 'Workflow name') + wf_id = self.get_field_value(execution, 'Workflow ID') + created_at = self.get_field_value(execution, 'Created at') + description = self.get_field_value(execution, 'Description') self.assertEqual(self.direct_wf['Name'], wf_name) self.assertIsNotNone(wf_id) @@ -433,7 +433,7 @@ class ExecutionCLITests(base_v2.MistralClientTestBase): def test_execution_create_with_input_and_start_task(self): execution = self.execution_create( "%s input task_name" % self.reverse_wf['Name']) - exec_id = self.get_value_of_field(execution, 'ID') + exec_id = self.get_field_value(execution, 'ID') result = self.wait_execution_success(exec_id) self.assertTrue(result) @@ -441,8 +441,8 @@ class ExecutionCLITests(base_v2.MistralClientTestBase): def test_execution_update(self): execution = self.execution_create(self.direct_wf['Name']) - exec_id = self.get_value_of_field(execution, 'ID') - status = self.get_value_of_field(execution, 'State') + exec_id = self.get_field_value(execution, 'ID') + status = self.get_field_value(execution, 'State') self.assertEqual('RUNNING', status) @@ -450,8 +450,8 @@ class ExecutionCLITests(base_v2.MistralClientTestBase): execution = self.mistral_admin( 'execution-update', params='{0} -s PAUSED'.format(exec_id)) - updated_exec_id = self.get_value_of_field(execution, 'ID') - status = self.get_value_of_field(execution, 'State') + updated_exec_id = self.get_field_value(execution, 'ID') + status = self.get_field_value(execution, 'State') self.assertEqual(exec_id, updated_exec_id) self.assertEqual('PAUSED', status) @@ -462,20 +462,22 @@ class ExecutionCLITests(base_v2.MistralClientTestBase): params='{0} -d "execution update test"'.format(exec_id) ) - description = self.get_value_of_field(execution, 'Description') + description = self.get_field_value(execution, 'Description') self.assertEqual("execution update test", description) def test_execution_get(self): execution = self.execution_create(self.direct_wf['Name']) - exec_id = self.get_value_of_field(execution, 'ID') + exec_id = self.get_field_value(execution, 'ID') execution = self.mistral_admin( - 'execution-get', params='{0}'.format(exec_id)) + 'execution-get', + params='{0}'.format(exec_id) + ) - gotten_id = self.get_value_of_field(execution, 'ID') - wf_name = self.get_value_of_field(execution, 'Workflow name') - wf_id = self.get_value_of_field(execution, 'Workflow ID') + gotten_id = self.get_field_value(execution, 'ID') + wf_name = self.get_field_value(execution, 'Workflow name') + wf_id = self.get_field_value(execution, 'Workflow ID') self.assertIsNotNone(wf_id) self.assertEqual(exec_id, gotten_id) @@ -483,87 +485,96 @@ class ExecutionCLITests(base_v2.MistralClientTestBase): def test_execution_get_input(self): execution = self.execution_create(self.direct_wf['Name']) - exec_id = self.get_value_of_field(execution, 'ID') + exec_id = self.get_field_value(execution, 'ID') ex_input = self.mistral_admin('execution-get-input', params=exec_id) self.assertEqual([], ex_input) def test_execution_get_output(self): execution = self.execution_create(self.direct_wf['Name']) - exec_id = self.get_value_of_field(execution, 'ID') + exec_id = self.get_field_value(execution, 'ID') ex_output = self.mistral_admin( - 'execution-get-output', params=exec_id) + 'execution-get-output', + params=exec_id + ) self.assertEqual([], ex_output) def test_executions_list_with_pagination(self): - - execution1 = self.mistral_admin( + wf_ex1 = self.mistral_admin( 'execution-create', params='{0} -d "a"'.format(self.direct_wf['Name']) ) - execution2 = self.mistral_admin( + wf_ex2 = self.mistral_admin( 'execution-create', params='{0} -d "b"'.format(self.direct_wf['Name']) ) - executions = self.mistral_cli( + wf_execs = self.mistral_cli(True, 'execution-list') + + self.assertEqual(2, len(wf_execs)) + + wf_execs = self.mistral_cli( True, 'execution-list', params="--limit 1" ) - self.assertEqual(1, len(executions)) + self.assertEqual(1, len(wf_execs)) - exec_id_1 = self.get_value_of_field(execution1, 'ID') - exec_id_2 = self.get_value_of_field(execution2, 'ID') - executions = self.mistral_cli( + wf_ex1_id = self.get_field_value(wf_ex1, 'ID') + wf_ex2_id = self.get_field_value(wf_ex2, 'ID') + + wf_execs = self.mistral_cli( True, 'execution-list', - params="--marker %s" % exec_id_1 + params="--marker %s" % wf_ex1_id ) - self.assertNotIn(exec_id_1, [ex['ID'] for ex in executions]) - self.assertIn(exec_id_2, [ex['ID'] for ex in executions]) - executions = self.mistral_cli( + self.assertNotIn(wf_ex1_id, [ex['ID'] for ex in wf_execs]) + self.assertIn(wf_ex2_id, [ex['ID'] for ex in wf_execs]) + + wf_execs = self.mistral_cli( True, 'execution-list', params="--sort_keys Description" ) - self.assertIn(exec_id_1, [ex['ID'] for ex in executions]) - self.assertIn(exec_id_2, [ex['ID'] for ex in executions]) + self.assertIn(wf_ex1_id, [ex['ID'] for ex in wf_execs]) + self.assertIn(wf_ex2_id, [ex['ID'] for ex in wf_execs]) - ex1_index = -1 - ex2_index = -1 - for idx, ex in enumerate(executions): - if ex['ID'] == exec_id_1: - ex1_index = idx - elif ex['ID'] == exec_id_2: - ex2_index = idx + wf_ex1_index = -1 + wf_ex2_index = -1 - self.assertTrue(ex1_index < ex2_index) + for idx, ex in enumerate(wf_execs): + if ex['ID'] == wf_ex1_id: + wf_ex1_index = idx + elif ex['ID'] == wf_ex2_id: + wf_ex2_index = idx - executions = self.mistral_cli( + self.assertTrue(wf_ex1_index < wf_ex2_index) + + wf_execs = self.mistral_cli( True, 'execution-list', params="--sort_keys Description --sort_dirs=desc" ) - self.assertIn(exec_id_1, [ex['ID'] for ex in executions]) - self.assertIn(exec_id_2, [ex['ID'] for ex in executions]) + self.assertIn(wf_ex1_id, [ex['ID'] for ex in wf_execs]) + self.assertIn(wf_ex2_id, [ex['ID'] for ex in wf_execs]) - ex1_index = -1 - ex2_index = -1 - for idx, ex in enumerate(executions): - if ex['ID'] == exec_id_1: - ex1_index = idx - elif ex['ID'] == exec_id_2: - ex2_index = idx + wf_ex1_index = -1 + wf_ex2_index = -1 - self.assertTrue(ex1_index > ex2_index) + for idx, ex in enumerate(wf_execs): + if ex['ID'] == wf_ex1_id: + wf_ex1_index = idx + elif ex['ID'] == wf_ex2_id: + wf_ex2_index = idx + + self.assertTrue(wf_ex1_index > wf_ex2_index) class CronTriggerCLITests(base_v2.MistralClientTestBase): @@ -586,11 +597,11 @@ class CronTriggerCLITests(base_v2.MistralClientTestBase): ' --first-time "4242-12-25 13:37"' % self.wf_name)) self.assertTableStruct(trigger, ['Field', 'Value']) - tr_name = self.get_value_of_field(trigger, 'Name') - wf_name = self.get_value_of_field(trigger, 'Workflow') - created_at = self.get_value_of_field(trigger, 'Created at') - remain = self.get_value_of_field(trigger, 'Remaining executions') - next_time = self.get_value_of_field(trigger, 'Next execution time') + tr_name = self.get_field_value(trigger, 'Name') + wf_name = self.get_field_value(trigger, 'Workflow') + created_at = self.get_field_value(trigger, 'Created at') + remain = self.get_field_value(trigger, 'Remaining executions') + next_time = self.get_field_value(trigger, 'Next execution time') self.assertEqual('trigger', tr_name) self.assertEqual(self.wf_name, wf_name) @@ -622,16 +633,16 @@ class CronTriggerCLITests(base_v2.MistralClientTestBase): 'trigger', self.wf_name, '{}', "5 * * * *") self.assertTableStruct(trigger, ['Field', 'Value']) - tr_name = self.get_value_of_field(trigger, 'Name') + tr_name = self.get_field_value(trigger, 'Name') fetched_tr = self.mistral_admin( 'cron-trigger-get', params='trigger') self.assertTableStruct(trigger, ['Field', 'Value']) - tr_name = self.get_value_of_field(fetched_tr, 'Name') - wf_name = self.get_value_of_field(fetched_tr, 'Workflow') - created_at = self.get_value_of_field(fetched_tr, 'Created at') + tr_name = self.get_field_value(fetched_tr, 'Name') + wf_name = self.get_field_value(fetched_tr, 'Workflow') + created_at = self.get_field_value(fetched_tr, 'Created at') self.assertEqual('trigger', tr_name) self.assertEqual(self.wf_name, wf_name) @@ -645,6 +656,7 @@ class TaskCLITests(base_v2.MistralClientTestBase): super(TaskCLITests, self).setUp() wfs = self.workflow_create(self.wf_def) + self.direct_wf = wfs[0] self.reverse_wf = wfs[1] @@ -652,19 +664,19 @@ class TaskCLITests(base_v2.MistralClientTestBase): self.create_file('task_name', '{\n "task_name": "goodbye"\n}\n') def test_task_get(self): - execution = self.execution_create(self.direct_wf['Name']) - exec_id = self.get_value_of_field(execution, 'ID') + wf_ex = self.execution_create(self.direct_wf['Name']) + wf_ex_id = self.get_field_value(wf_ex, 'ID') + + tasks = self.mistral_admin('task-list', params=wf_ex_id) - tasks = self.mistral_admin('task-list') created_task_id = tasks[-1]['ID'] fetched_task = self.mistral_admin('task-get', params=created_task_id) - fetched_task_id = self.get_value_of_field(fetched_task, 'ID') - task_execution_id = self.get_value_of_field(fetched_task, - 'Execution ID') + fetched_task_id = self.get_field_value(fetched_task, 'ID') + task_execution_id = self.get_field_value(fetched_task, 'Execution ID') self.assertEqual(created_task_id, fetched_task_id) - self.assertEqual(exec_id, task_execution_id) + self.assertEqual(wf_ex_id, task_execution_id) class ActionCLITests(base_v2.MistralClientTestBase): @@ -780,8 +792,8 @@ class EnvironmentCLITests(base_v2.MistralClientTestBase): def test_environment_create(self): env = self.mistral_admin('environment-create', params='env.yaml') - env_name = self.get_value_of_field(env, 'Name') - env_desc = self.get_value_of_field(env, 'Description') + env_name = self.get_field_value(env, 'Name') + env_desc = self.get_field_value(env, 'Description') self.assertTableStruct(env, ['Field', 'Value']) @@ -803,8 +815,8 @@ class EnvironmentCLITests(base_v2.MistralClientTestBase): env = self.mistral_admin('environment-create', params='env_without_des.yaml') - env_name = self.get_value_of_field(env, 'Name') - env_desc = self.get_value_of_field(env, 'Description') + env_name = self.get_field_value(env, 'Name') + env_desc = self.get_field_value(env, 'Description') self.assertTableStruct(env, ['Field', 'Value']) @@ -819,10 +831,10 @@ class EnvironmentCLITests(base_v2.MistralClientTestBase): def test_environment_update(self): env = self.environment_create('env.yaml') - env_name = self.get_value_of_field(env, 'Name') - env_desc = self.get_value_of_field(env, 'Description') - env_created_at = self.get_value_of_field(env, 'Created at') - env_updated_at = self.get_value_of_field(env, 'Updated at') + env_name = self.get_field_value(env, 'Name') + env_desc = self.get_field_value(env, 'Description') + env_created_at = self.get_field_value(env, 'Created at') + env_updated_at = self.get_field_value(env, 'Updated at') self.assertIsNotNone(env_created_at) self.assertEqual('None', env_updated_at) @@ -836,10 +848,10 @@ class EnvironmentCLITests(base_v2.MistralClientTestBase): env = self.mistral_admin('environment-update', params='env_upd.yaml') self.assertTableStruct(env, ['Field', 'Value']) - updated_env_name = self.get_value_of_field(env, 'Name') - updated_env_desc = self.get_value_of_field(env, 'Description') - updated_env_created_at = self.get_value_of_field(env, 'Created at') - updated_env_updated_at = self.get_value_of_field(env, 'Updated at') + updated_env_name = self.get_field_value(env, 'Name') + updated_env_desc = self.get_field_value(env, 'Description') + updated_env_created_at = self.get_field_value(env, 'Created at') + updated_env_updated_at = self.get_field_value(env, 'Updated at') self.assertEqual(env_name, updated_env_name) self.assertNotEqual(env_desc, updated_env_desc) @@ -849,12 +861,12 @@ class EnvironmentCLITests(base_v2.MistralClientTestBase): def test_environment_get(self): env = self.environment_create('env.yaml') - env_name = self.get_value_of_field(env, 'Name') - env_desc = self.get_value_of_field(env, 'Description') + env_name = self.get_field_value(env, 'Name') + env_desc = self.get_field_value(env, 'Description') env = self.mistral_admin('environment-get', params=env_name) - fetched_env_name = self.get_value_of_field(env, 'Name') - fetched_env_desc = self.get_value_of_field(env, 'Description') + fetched_env_name = self.get_field_value(env, 'Name') + fetched_env_desc = self.get_field_value(env, 'Description') self.assertTableStruct(env, ['Field', 'Value']) self.assertEqual(env_name, fetched_env_name) @@ -868,29 +880,34 @@ class ActionExecutionCLITests(base_v2.MistralClientTestBase): super(ActionExecutionCLITests, self).setUp() wfs = self.workflow_create(self.wf_def) + self.direct_wf = wfs[0] direct_wf_exec = self.execution_create(self.direct_wf['Name']) - self.direct_ex_id = self.get_value_of_field(direct_wf_exec, 'ID') + + self.direct_ex_id = self.get_field_value(direct_wf_exec, 'ID') def test_act_execution_get(self): self.wait_execution_success(self.direct_ex_id) - task = self.mistral_admin( - 'task-list', params=self.direct_ex_id)[0] + task = self.mistral_admin('task-list', params=self.direct_ex_id)[0] act_ex_from_list = self.mistral_admin( - 'action-execution-list', params=task['ID'])[0] + 'action-execution-list', + params=task['ID'] + )[0] act_ex = self.mistral_admin( - 'action-execution-get', params=act_ex_from_list['ID']) + 'action-execution-get', + params=act_ex_from_list['ID'] + ) - wf_name = self.get_value_of_field(act_ex, 'Workflow name') - status = self.get_value_of_field(act_ex, 'State') + wf_name = self.get_field_value(act_ex, 'Workflow name') + status = self.get_field_value(act_ex, 'State') self.assertEqual( act_ex_from_list['ID'], - self.get_value_of_field(act_ex, 'ID') + self.get_field_value(act_ex, 'ID') ) self.assertEqual(self.direct_wf['Name'], wf_name) self.assertEqual('SUCCESS', status) @@ -901,13 +918,13 @@ class ActionExecutionCLITests(base_v2.MistralClientTestBase): params="std.echo '{0}' --save-result".format( '{"output": "Hello!"}') ) - action_ex_id = self.get_value_of_field(action_ex, 'ID') + action_ex_id = self.get_field_value(action_ex, 'ID') self.assertTableStruct(action_ex, ['Field', 'Value']) - name = self.get_value_of_field(action_ex, 'Name') - wf_name = self.get_value_of_field(action_ex, 'Workflow name') - task_name = self.get_value_of_field(action_ex, 'Task name') + name = self.get_field_value(action_ex, 'Name') + wf_name = self.get_field_value(action_ex, 'Workflow name') + task_name = self.get_field_value(action_ex, 'Task name') self.assertEqual('std.echo', name) self.assertEqual('None', wf_name) @@ -1146,7 +1163,7 @@ class NegativeCLITests(base_v2.MistralClientTestBase): def test_ex_update_both_state_and_description(self): wf = self.workflow_create(self.wf_def) execution = self.execution_create(params=wf[0]['Name']) - exec_id = self.get_value_of_field(execution, 'ID') + exec_id = self.get_field_value(execution, 'ID') self.assertRaises(exceptions.CommandFailed, self.mistral_admin, 'execution-update', @@ -1374,7 +1391,7 @@ class NegativeCLITests(base_v2.MistralClientTestBase): def test_action_execution_update(self): wfs = self.workflow_create(self.wf_def) direct_wf_exec = self.execution_create(wfs[0]['Name']) - direct_ex_id = self.get_value_of_field(direct_wf_exec, 'ID') + direct_ex_id = self.get_field_value(direct_wf_exec, 'ID') self.assertRaises(exceptions.CommandFailed, self.mistral_admin, diff --git a/mistralclient/tests/unit/v2/test_action_executions.py b/mistralclient/tests/unit/v2/test_action_executions.py index f7c75095..985dcb14 100644 --- a/mistralclient/tests/unit/v2/test_action_executions.py +++ b/mistralclient/tests/unit/v2/test_action_executions.py @@ -48,8 +48,7 @@ class TestActionExecutions(base.BaseClientV2Test): self.action_executions, ACTION_EXEC ).to_dict(), action_execution.to_dict()) - mock.assert_called_once_with( - URL_TEMPLATE, json.dumps(body)) + mock.assert_called_once_with(URL_TEMPLATE, json.dumps(body)) def test_update(self): mock = self.mock_http_put(content=ACTION_EXEC) @@ -63,12 +62,21 @@ class TestActionExecutions(base.BaseClientV2Test): ) self.assertIsNotNone(action_execution) - self.assertEqual(action_executions.ActionExecution( - self.action_executions, ACTION_EXEC - ).to_dict(), action_execution.to_dict()) + + expected = action_executions.ActionExecution( + self.action_executions, + ACTION_EXEC + ).to_dict() + + self.assertEqual( + expected, + action_execution.to_dict() + ) mock.assert_called_once_with( - URL_TEMPLATE_ID % ACTION_EXEC['id'], json.dumps(body)) + URL_TEMPLATE_ID % ACTION_EXEC['id'], + json.dumps(body) + ) def test_list(self): mock = self.mock_http_get( @@ -80,9 +88,12 @@ class TestActionExecutions(base.BaseClientV2Test): self.assertEqual(1, len(action_execution_list)) action_execution = action_execution_list[0] - self.assertEqual(action_executions.ActionExecution( - self.action_executions, ACTION_EXEC - ).to_dict(), action_execution.to_dict()) + expected = action_executions.ActionExecution( + self.action_executions, + ACTION_EXEC + ).to_dict() + + self.assertEqual(expected, action_execution.to_dict()) mock.assert_called_once_with(URL_TEMPLATE) @@ -91,12 +102,14 @@ class TestActionExecutions(base.BaseClientV2Test): action_execution = self.action_executions.get(ACTION_EXEC['id']) - self.assertEqual(action_executions.ActionExecution( - self.action_executions, ACTION_EXEC - ).to_dict(), action_execution.to_dict()) + expected = action_executions.ActionExecution( + self.action_executions, + ACTION_EXEC + ).to_dict() - mock.assert_called_once_with( - URL_TEMPLATE_ID % ACTION_EXEC['id']) + self.assertEqual(expected, action_execution.to_dict()) + + mock.assert_called_once_with(URL_TEMPLATE_ID % ACTION_EXEC['id']) def test_delete(self): mock = self.mock_http_delete(status_code=204) diff --git a/mistralclient/tests/unit/v2/test_cli_action_execs.py b/mistralclient/tests/unit/v2/test_cli_action_execs.py index dfb051aa..a1304623 100644 --- a/mistralclient/tests/unit/v2/test_cli_action_execs.py +++ b/mistralclient/tests/unit/v2/test_cli_action_execs.py @@ -27,6 +27,7 @@ ACTION_EX_DICT = { 'name': 'some', 'workflow_name': 'thing', 'task_name': 'task1', + 'task_execution_id': "1-2-3-4", 'state': 'RUNNING', 'state_info': 'RUNNING somehow.', 'accepted': True @@ -37,15 +38,18 @@ ACTION_EX_INPUT = {"param1": "val1", "param2": 2} ACTION_EX_WITH_OUTPUT_DICT = ACTION_EX_DICT.copy() ACTION_EX_WITH_OUTPUT_DICT.update({'output': json.dumps(ACTION_EX_RESULT)}) + ACTION_EX_WITH_INPUT_DICT = ACTION_EX_DICT.copy() ACTION_EX_WITH_INPUT_DICT.update({'input': json.dumps(ACTION_EX_INPUT)}) ACTION_EX = action_ex.ActionExecution(mock, ACTION_EX_DICT) ACTION_EX_WITH_OUTPUT = action_ex.ActionExecution( - mock, ACTION_EX_WITH_OUTPUT_DICT + mock, + ACTION_EX_WITH_OUTPUT_DICT ) ACTION_EX_WITH_INPUT = action_ex.ActionExecution( - mock, ACTION_EX_WITH_INPUT_DICT + mock, + ACTION_EX_WITH_INPUT_DICT ) @@ -76,7 +80,7 @@ class TestCLIActionExecutions(base.BaseCommandTest): ) self.assertEqual( - ('123', 'some', 'thing', 'task1', 'RUNNING', + ('123', 'some', 'thing', 'task1', '1-2-3-4', 'RUNNING', 'RUNNING somehow.', True), result[1] ) @@ -84,12 +88,15 @@ class TestCLIActionExecutions(base.BaseCommandTest): def test_update(self): self.client.action_executions.update.return_value = ACTION_EX - result = self.call(action_ex_cmd.Update, - app_args=['id', '--state', 'ERROR']) + result = self.call( + action_ex_cmd.Update, + app_args=['id', '--state', 'ERROR'] + ) self.assertEqual( - ('123', 'some', 'thing', 'task1', 'RUNNING', - 'RUNNING somehow.', True), result[1] + ('123', 'some', 'thing', 'task1', '1-2-3-4', 'RUNNING', + 'RUNNING somehow.', True), + result[1] ) def test_list(self): @@ -98,7 +105,7 @@ class TestCLIActionExecutions(base.BaseCommandTest): result = self.call(action_ex_cmd.List) self.assertEqual( - [('123', 'some', 'thing', 'task1', 'RUNNING', + [('123', 'some', 'thing', 'task1', '1-2-3-4', 'RUNNING', 'RUNNING somehow.', True)], result[1] ) @@ -109,7 +116,7 @@ class TestCLIActionExecutions(base.BaseCommandTest): result = self.call(action_ex_cmd.Get, app_args=['id']) self.assertEqual( - ('123', 'some', 'thing', 'task1', 'RUNNING', + ('123', 'some', 'thing', 'task1', '1-2-3-4', 'RUNNING', 'RUNNING somehow.', True), result[1] )