Add new functional CLI tests

Change-Id: Ia0d8f727e6875f6c39551dd84eab1ad9422ad820
Closes-Bug: #1398383

functionaltests/resources/v2/wf_v2.yaml

@@ -3,9 +3,24 @@ version: '2.0'
 
 wf:
   type: direct
-  
   tasks:
     hello:
       action: std.echo output="Hello"
+      policies:
+        wait-before: 5
       publish:
         result: $
+
+wf1:
+  type: reverse
+  tags:  [tag]
+  input:
+    - farewell
+  tasks:
+    addressee:
+      action: std.echo output="John"
+      publish:
+        name: $
+    goodbye:
+      action: std.echo output="{$.farewell}, {$.name}"
+      requires: [addressee]

mistralclient/tests/functional/cli/v2/base_v2.py

@@ -108,10 +108,16 @@ class MistralClientTestBase(base.MistralCLIAuth, base.MistralCLIAltAuth):
 
         return trigger
 
-    def execution_create(self, wf_name, admin=True):
-        ex = self.mistral_cli(admin, 'execution-create', params=wf_name)
+    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)
 
         return ex
+
+    def create_file(self, file_name, file_body=""):
+        f = open(file_name, 'w')
+        f.write(file_body)
+        f.close()
+        self.addCleanup(os.remove, file_name)

mistralclient/tests/functional/cli/v2/cli_tests_v2.py

@@ -98,6 +98,12 @@ class WorkbookCLITests(base_v2.MistralClientTestBase):
         wbs = self.mistral_admin('workbook-list')
         self.assertNotIn(wb_name, [workbook['Name'] for workbook in wbs])
 
+    def test_workbook_create_with_tags(self):
+        wb = self.workbook_create(self.wb_with_tags_def)
+
+        tags = self.get_value_of_field(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")
@@ -106,7 +112,7 @@ class WorkbookCLITests(base_v2.MistralClientTestBase):
         self.assertNotIn('tag', tags)
 
         wb = self.mistral_admin(
-            'workbook-update', params='{0}'.format(self.wb_with_tags_def))
+            'workbook-update', params=self.wb_with_tags_def)
         self.assertTableStruct(wb, ['Field', 'Value'])
 
         name = self.get_value_of_field(wb, 'Name')
@@ -148,29 +154,53 @@ class WorkflowCLITests(base_v2.MistralClientTestBase):
         super(WorkflowCLITests, cls).setUpClass()
 
     def test_workflow_create_delete(self):
-        init_wf = self.mistral_admin(
+        init_wfs = self.mistral_admin(
             'workflow-create', params=self.wf_def)
-        wf_name = init_wf[0]['Name']
-        self.assertTableStruct(init_wf, ['Name', 'Created at', 'Updated at'])
+        wf_name = [wf['Name'] for wf in init_wfs]
+        self.assertTableStruct(init_wfs, ['Name', 'Created at', 'Updated at'])
 
         wfs = self.mistral_admin('workflow-list')
-        self.assertIn(wf_name, [workflow['Name'] for workflow in wfs])
+        self.assertIn(wf_name[0], [workflow['Name'] for workflow in wfs])
 
-        self.mistral_admin('workflow-delete', params=wf_name)
+        for wf in wfs:
+            self.mistral_admin('workflow-delete', params=wf['Name'])
 
         wfs = self.mistral_admin('workflow-list')
-        self.assertNotIn(wf_name, [workflow['Name'] for workflow in wfs])
+        for wf in wf_name:
+            self.assertNotIn(wf, [workflow['Name'] for workflow in wfs])
+
+    def test_create_wf_with_tags(self):
+        init_wfs = self.workflow_create(self.wf_def)
+        wf_name = init_wfs[1]['Name']
+        self.assertTableStruct(init_wfs, ['Name', 'Created at',
+                                          'Updated at', 'Tags'])
+
+        created_wf_info = self.get_item_info(
+            get_from=init_wfs, get_by='Name', value=wf_name)
+
+        self.assertEqual('tag', created_wf_info['Tags'])
 
     def test_workflow_update(self):
         wf = self.workflow_create(self.wf_def)
         wf_name = wf[0]['Name']
 
+        created_wf_info = self.get_item_info(
+            get_from=wf, get_by='Name', value=wf_name)
+
         upd_wf = self.mistral_admin(
             'workflow-update', params='{0}'.format(self.wf_def))
         self.assertTableStruct(upd_wf, ['Name', 'Created at', 'Updated at'])
 
+        updated_wf_info = self.get_item_info(
+            get_from=upd_wf, get_by='Name', value=wf_name)
+
         self.assertEqual(wf_name, upd_wf[0]['Name'])
 
+        self.assertEqual(created_wf_info['Created at'].split(".")[0],
+                         updated_wf_info['Created at'])
+        self.assertNotEqual(created_wf_info['Updated at'],
+                            updated_wf_info['Updated at'])
+
     def test_workflow_get(self):
         created = self.workflow_create(self.wf_def)
         wf_name = created[0]['Name']
@@ -198,33 +228,43 @@ class ExecutionCLITests(base_v2.MistralClientTestBase):
     def setUp(self):
         super(ExecutionCLITests, self).setUp()
 
-        wf = self.workflow_create(self.wf_def)
-        self.wf_name = wf[0]['Name']
+        wfs = self.workflow_create(self.wf_def)
+        self.direct_wf = wfs[0]
+        self.reverse_wf = wfs[1]
 
-        wf_delay = self.workflow_create(self.wf_with_delay_def)
-        self.wf_delay = wf_delay[0]["Name"]
+        self.create_file('input', '{\n    "farewell": "Bye"\n}\n')
+        self.create_file('task_name', '{\n    "task_name": "goodbye"\n}\n')
 
     def test_execution_create_delete(self):
         execution = self.mistral_admin(
-            'execution-create', params=self.wf_name)
+            'execution-create', params=self.direct_wf['Name'])
         exec_id = self.get_value_of_field(execution, 'ID')
         self.assertTableStruct(execution, ['Field', 'Value'])
 
         wf = self.get_value_of_field(execution, 'Workflow')
         created_at = self.get_value_of_field(execution, 'Created at')
 
-        self.assertEqual(self.wf_name, wf)
+        self.assertEqual(self.direct_wf['Name'], wf)
         self.assertIsNotNone(created_at)
 
         execs = self.mistral_admin('execution-list')
         self.assertIn(exec_id, [ex['ID'] for ex in execs])
         self.assertIn(wf, [ex['Workflow'] for ex in execs])
-        self.assertIn('SUCCESS', [ex['State'] for ex in execs])
 
         self.mistral_admin('execution-delete', params=exec_id)
 
+    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')
+
+        execution = self.mistral_admin(
+            'execution-get', params=exec_id)
+        exec_state = self.get_value_of_field(execution, 'State')
+        self.assertEqual('SUCCESS', exec_state)
+
     def test_execution_update(self):
-        execution = self.execution_create(self.wf_delay)
+        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')
@@ -241,7 +281,7 @@ class ExecutionCLITests(base_v2.MistralClientTestBase):
         self.assertEqual('PAUSED', status)
 
     def test_execution_get(self):
-        execution = self.execution_create(self.wf_name)
+        execution = self.execution_create(self.direct_wf['Name'])
         exec_id = self.get_value_of_field(execution, 'ID')
 
         execution = self.mistral_admin(
@@ -251,21 +291,22 @@ class ExecutionCLITests(base_v2.MistralClientTestBase):
         wf = self.get_value_of_field(execution, 'Workflow')
 
         self.assertEqual(exec_id, gotten_id)
-        self.assertEqual(self.wf_name, wf)
+        self.assertEqual(self.direct_wf['Name'], wf)
 
     def test_execution_get_input(self):
-        execution = self.execution_create(self.wf_name)
+        execution = self.execution_create(self.direct_wf['Name'])
         exec_id = self.get_value_of_field(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.wf_name)
+        execution = self.execution_create(self.direct_wf['Name'])
         exec_id = self.get_value_of_field(execution, 'ID')
 
         ex_output = self.mistral_admin(
             'execution-get-output', params=exec_id)
+
         self.assertEqual([], ex_output)
 
 
@@ -300,7 +341,7 @@ class CronTriggerCLITests(base_v2.MistralClientTestBase):
         self.assertIn(tr_name, [tr['Name'] for tr in trgs])
         self.assertIn(wf_name, [tr['Workflow'] for tr in trgs])
 
-        self.mistral('cron-trigger-delete', params='{0}'.format(tr_name))
+        self.mistral('cron-trigger-delete', params=tr_name)
 
         trgs = self.mistral_admin('cron-trigger-list')
         self.assertNotIn(tr_name, [tr['Name'] for tr in trgs])
@@ -336,6 +377,35 @@ class CronTriggerCLITests(base_v2.MistralClientTestBase):
         self.assertIsNotNone(created_at)
 
 
+class TaskCLITests(base_v2.MistralClientTestBase):
+    """Test suite checks commands to work with tasks."""
+
+    def setUp(self):
+        super(TaskCLITests, self).setUp()
+
+        wfs = self.workflow_create(self.wf_def)
+        self.direct_wf = wfs[0]
+        self.reverse_wf = wfs[1]
+
+        self.create_file('input', '{\n    "farewell": "Bye"\n}\n')
+        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')
+
+        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')
+
+        self.assertEqual(created_task_id, fetched_task_id)
+        self.assertEqual(exec_id, task_execution_id)
+
+
 class ActionCLITests(base_v2.MistralClientTestBase):
     """Test suite checks commands to work with actions."""
 
@@ -386,8 +456,7 @@ class ActionCLITests(base_v2.MistralClientTestBase):
         created_action = self.get_item_info(
             get_from=acts, get_by='Name', value='greeting')
 
-        acts = self.mistral_admin(
-            'action-update', params='{0}'.format(self.act_def))
+        acts = self.mistral_admin('action-update', params=self.act_def)
 
         updated_action = self.get_item_info(
             get_from=acts, get_by='Name', value='greeting')
@@ -439,16 +508,49 @@ class NegativeCLITests(base_v2.MistralClientTestBase):
                           self.mistral_admin,
                           'workbook-delete', params='wb')
 
-    def test_wb_update_unexist_wb(self):
+    def test_wb_update_wrong_path_to_def(self):
         self.assertRaises(exceptions.CommandFailed,
                           self.mistral_admin,
                           'workbook-update', params='wb')
 
+    def test_wb_update_nonexistant_wb(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workbook-update',
+                          params=self.wb_with_tags_def)
+
+    def test_wb_create_empty_def(self):
+        self.create_file('empty')
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workbook-create', params='empty')
+
+    def test_wb_update_empty_def(self):
+        self.create_file('empty')
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workbook-update', params='empty')
+
     def test_wb_get_definition_unexist_wb(self):
         self.assertRaises(exceptions.CommandFailed,
                           self.mistral_admin,
                           'workbook-get-definition', params='wb')
 
+    def test_wb_create_invalid_def(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workbook-create', params=self.wf_def)
+
+    def test_wb_update_invalid_def(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workbook-update', params=self.wf_def)
+
+    def test_wb_update_without_def(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workbook-update')
+
     def test_wf_list_extra_param(self):
         self.assertRaises(exceptions.CommandFailed,
                           self.mistral_admin,
@@ -488,6 +590,35 @@ class NegativeCLITests(base_v2.MistralClientTestBase):
                           self.mistral_admin,
                           'workflow-get-definition', params='wf')
 
+    def test_wf_get_definition_missed_param(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workflow-get-definition')
+
+    def test_wf_create_invalid_def(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workflow-create',
+                          params=self.wb_def)
+
+    def test_wf_update_invalid_def(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workflow-update',
+                          params=self.wb_def)
+
+    def test_wf_create_empty_def(self):
+        self.create_file('empty')
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workflow-create', params='empty')
+
+    def test_wf_update_empty_def(self):
+        self.create_file('empty')
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'workflow-update', params='empty')
+
     def test_ex_list_extra_param(self):
         self.assertRaises(exceptions.CommandFailed,
                           self.mistral_admin,
@@ -516,6 +647,38 @@ class NegativeCLITests(base_v2.MistralClientTestBase):
                           self.mistral_admin, 'execution-get',
                           params='%s id' % wf[0]['Name'])
 
+    def test_ex_create_without_wf_name(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'execution-create')
+
+    def test_ex_create_reverse_wf_without_start_task(self):
+        wf = self.workflow_create(self.wf_def)
+        self.create_file('input', '{\n    "farewell": "Bye"\n}\n')
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'execution-create ', params=wf[1]['Name'])
+
+    def test_ex_create_missed_input(self):
+        self.create_file('empty')
+        wf = self.workflow_create(self.wf_def)
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'execution-create empty', params=wf[1]['Name'])
+
+    def test_ex_invalid_status_changing(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')
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin, 'execution-update',
+                          params='%s ERROR' % exec_id)
+
+    def test_ex_delete_nonexistent_execution(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin,
+                          'execution-delete', params='1a2b3c')
+
     def test_tr_create_without_pattern(self):
         wf = self.workflow_create(self.wf_def)
         self.assertRaises(exceptions.CommandFailed,
@@ -584,3 +747,8 @@ class NegativeCLITests(base_v2.MistralClientTestBase):
         self.assertRaises(exceptions.CommandFailed,
                           self.mistral_admin, 'action-get-definition',
                           params='nonexist')
+
+    def test_task_get_nonexistent_task(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.mistral_admin, 'task-get',
+                          params='nonexist')