Merge "Add "Task ID" field for "action-execution-get" command output"

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
+        state_info = (
-                      else base.cut(action_ex.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(
+        parser.add_argument('action_execution', help='Action execution ID.')
-            '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
         )

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):
+    def get_field_value(self, obj, field):
-        return [o['Value'] for o in obj
+        return [
-                if o['Field'] == "{0}".format(field)][0]
+            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))
+            params='{0}'.format(wb_def)
-        wb_name = self.get_value_of_field(wb, "Name")
+        )
-        self.addCleanup(self.mistral_cli,
+
-                        admin,
+        wb_name = self.get_field_value(wb, "Name")
-                        'workbook-delete',
+
-                        params=wb_name)
+        self.addCleanup(
-        self.addCleanup(self.mistral_cli,
+            self.mistral_cli,
-                        admin,
+            admin,
-                        'workflow-delete',
+            'workbook-delete',
-                        params='wb.wf1')
+            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')
+        exec_id = self.get_field_value(ex, 'ID')
-        self.addCleanup(self.mistral_cli,
+
-                        admin,
+        self.addCleanup(
-                        'execution-delete',
+            self.mistral_cli,
-                        params=exec_id)
+            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')
+        env_name = self.get_field_value(env, 'Name')
-        self.addCleanup(self.mistral_cli,
+
-                        admin,
+        self.addCleanup(
-                        'environment-delete',
+            self.mistral_cli,
-                        params=env_name)
+            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)

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,

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',
+            ['ID', 'Name', 'Workflow name', 'State', 'State info', 'Accepted']
-             'State info', 'Is 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")
+        init_update_at = self.get_field_value(wb, "Updated at")
-        tags = self.get_value_of_field(wb, 'Tags')
+        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")
+        update_at = self.get_field_value(wb, "Updated at")
-        name = self.get_value_of_field(wb, 'Name')
+        name = self.get_field_value(wb, 'Name')
-        tags = self.get_value_of_field(wb, 'Tags')
+        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")
+        update_at = self.get_field_value(wb, "Updated at")
-        name = self.get_value_of_field(wb, 'Name')
+        name = self.get_field_value(wb, 'Name')
-        tags = self.get_value_of_field(wb, 'Tags')
+        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')
+        created_wb_name = self.get_field_value(created, 'Name')
-        fetched_wb_name = self.get_value_of_field(fetched, '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')
+        created_wb_tag = self.get_field_value(created, 'Tags')
-        fetched_wb_tag = self.get_value_of_field(fetched, '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_valid = self.get_field_value(wb, 'Valid')
-        wb_error = self.get_value_of_field(wb, 'Error')
+        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_valid = self.get_field_value(wb, 'Valid')
-        wb_error = self.get_value_of_field(wb, 'Error')
+        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_valid = self.get_field_value(wf, 'Valid')
-        wf_error = self.get_value_of_field(wf, 'Error')
+        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_valid = self.get_field_value(wf, 'Valid')
-        wf_error = self.get_value_of_field(wf, 'Error')
+        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_name = self.get_field_value(execution, 'Workflow name')
-        wf_id = self.get_value_of_field(execution, 'Workflow ID')
+        wf_id = self.get_field_value(execution, 'Workflow ID')
-        created_at = self.get_value_of_field(execution, 'Created at')
+        created_at = self.get_field_value(execution, 'Created at')
-        description = self.get_value_of_field(execution, 'Description')
+        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')
+        exec_id = self.get_field_value(execution, 'ID')
-        status = self.get_value_of_field(execution, 'State')
+        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')
+        updated_exec_id = self.get_field_value(execution, 'ID')
-        status = self.get_value_of_field(execution, 'State')
+        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')
+        gotten_id = self.get_field_value(execution, 'ID')
-        wf_name = self.get_value_of_field(execution, 'Workflow name')
+        wf_name = self.get_field_value(execution, 'Workflow name')
-        wf_id = self.get_value_of_field(execution, 'Workflow ID')
+        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):
-
+        wf_ex1 = self.mistral_admin(
-        execution1 = 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')
+        wf_ex1_id = self.get_field_value(wf_ex1, 'ID')
-        exec_id_2 = self.get_value_of_field(execution2, 'ID')
+        wf_ex2_id = self.get_field_value(wf_ex2, 'ID')
-        executions = self.mistral_cli(
+
+        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(wf_ex1_id, [ex['ID'] for ex in wf_execs])
-        self.assertIn(exec_id_2, [ex['ID'] for ex in executions])
+        self.assertIn(wf_ex2_id, [ex['ID'] for ex in wf_execs])
 
-        ex1_index = -1
+        wf_ex1_index = -1
-        ex2_index = -1
+        wf_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
 
-        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(wf_ex1_id, [ex['ID'] for ex in wf_execs])
-        self.assertIn(exec_id_2, [ex['ID'] for ex in executions])
+        self.assertIn(wf_ex2_id, [ex['ID'] for ex in wf_execs])
 
-        ex1_index = -1
+        wf_ex1_index = -1
-        ex2_index = -1
+        wf_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
 
-        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')
+        tr_name = self.get_field_value(trigger, 'Name')
-        wf_name = self.get_value_of_field(trigger, 'Workflow')
+        wf_name = self.get_field_value(trigger, 'Workflow')
-        created_at = self.get_value_of_field(trigger, 'Created at')
+        created_at = self.get_field_value(trigger, 'Created at')
-        remain = self.get_value_of_field(trigger, 'Remaining executions')
+        remain = self.get_field_value(trigger, 'Remaining executions')
-        next_time = self.get_value_of_field(trigger, 'Next execution time')
+        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')
+        tr_name = self.get_field_value(fetched_tr, 'Name')
-        wf_name = self.get_value_of_field(fetched_tr, 'Workflow')
+        wf_name = self.get_field_value(fetched_tr, 'Workflow')
-        created_at = self.get_value_of_field(fetched_tr, 'Created at')
+        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'])
+        wf_ex = self.execution_create(self.direct_wf['Name'])
-        exec_id = self.get_value_of_field(execution, 'ID')
+        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')
+        fetched_task_id = self.get_field_value(fetched_task, 'ID')
-        task_execution_id = self.get_value_of_field(fetched_task,
+        task_execution_id = self.get_field_value(fetched_task, 'Execution ID')
-                                                    '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_name = self.get_field_value(env, 'Name')
-        env_desc = self.get_value_of_field(env, 'Description')
+        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_name = self.get_field_value(env, 'Name')
-        env_desc = self.get_value_of_field(env, 'Description')
+        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_name = self.get_field_value(env, 'Name')
-        env_desc = self.get_value_of_field(env, 'Description')
+        env_desc = self.get_field_value(env, 'Description')
-        env_created_at = self.get_value_of_field(env, 'Created at')
+        env_created_at = self.get_field_value(env, 'Created at')
-        env_updated_at = self.get_value_of_field(env, 'Updated 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_name = self.get_field_value(env, 'Name')
-        updated_env_desc = self.get_value_of_field(env, 'Description')
+        updated_env_desc = self.get_field_value(env, 'Description')
-        updated_env_created_at = self.get_value_of_field(env, 'Created at')
+        updated_env_created_at = self.get_field_value(env, 'Created at')
-        updated_env_updated_at = self.get_value_of_field(env, 'Updated 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_name = self.get_field_value(env, 'Name')
-        env_desc = self.get_value_of_field(env, 'Description')
+        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_name = self.get_field_value(env, 'Name')
-        fetched_env_desc = self.get_value_of_field(env, 'Description')
+        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 = self.mistral_admin('task-list', params=self.direct_ex_id)[0]
-            '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')
+        wf_name = self.get_field_value(act_ex, 'Workflow name')
-        status = self.get_value_of_field(act_ex, 'State')
+        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')
+        name = self.get_field_value(action_ex, 'Name')
-        wf_name = self.get_value_of_field(action_ex, 'Workflow name')
+        wf_name = self.get_field_value(action_ex, 'Workflow name')
-        task_name = self.get_value_of_field(action_ex, 'Task 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,

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(
+        mock.assert_called_once_with(URL_TEMPLATE, json.dumps(body))
-            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
+        expected = action_executions.ActionExecution(
-        ).to_dict(), action_execution.to_dict())
+            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(
+        expected = action_executions.ActionExecution(
-            self.action_executions, ACTION_EXEC
+            self.action_executions,
-        ).to_dict(), action_execution.to_dict())
+            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(
+        expected = action_executions.ActionExecution(
-            self.action_executions, ACTION_EXEC
+            self.action_executions,
-        ).to_dict(), action_execution.to_dict())
+            ACTION_EXEC
+        ).to_dict()
 
-        mock.assert_called_once_with(
+        self.assertEqual(expected, action_execution.to_dict())
-            URL_TEMPLATE_ID % ACTION_EXEC['id'])
+
+        mock.assert_called_once_with(URL_TEMPLATE_ID % ACTION_EXEC['id'])
 
     def test_delete(self):
         mock = self.mock_http_delete(status_code=204)

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,
+        result = self.call(
-                           app_args=['id', '--state', 'ERROR'])
+            action_ex_cmd.Update,
+            app_args=['id', '--state', 'ERROR']
+        )
 
         self.assertEqual(
-            ('123', 'some', 'thing', 'task1', 'RUNNING',
+            ('123', 'some', 'thing', 'task1', '1-2-3-4', 'RUNNING',
-             'RUNNING somehow.', True), result[1]
+             '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]
         )