Merge "Changes Delete Plan to Call Workflow"

tripleoclient/tests/v1/test_overcloud_plan.py

@@ -58,37 +58,50 @@ class TestOvercloudDeletePlan(utils.TestCommand):
 
         self.cmd = overcloud_plan.DeletePlan(self.app, None)
         self.app.client_manager.workflow_engine = mock.Mock()
+        self.tripleoclient = mock.Mock()
+
+        self.websocket = mock.Mock()
+        self.websocket.__enter__ = lambda s: self.websocket
+        self.websocket.__exit__ = lambda s, *exc: None
+        self.tripleoclient = mock.Mock()
+        self.tripleoclient.messaging_websocket.return_value = self.websocket
+        self.app.client_manager.tripleoclient = self.tripleoclient
+
         self.workflow = self.app.client_manager.workflow_engine
 
-    @mock.patch(
+    def test_delete_plan(self):
-        'tripleoclient.workflows.plan_management.delete_deployment_plan',
-        autospec=True)
-    def test_delete_plan(self, delete_deployment_plan_mock):
         parsed_args = self.check_parser(self.cmd, ['test-plan'],
                                         [('plans', ['test-plan'])])
 
+        self.websocket.wait_for_messages.return_value = iter([{
+            "execution": {"id": "IDID"},
+            "status": "SUCCESS"
+        }])
+
         self.cmd.take_action(parsed_args)
 
-        delete_deployment_plan_mock.assert_called_once_with(
+        self.workflow.executions.create.assert_called_once_with(
-            self.workflow,
+            'tripleo.plan_management.v1.delete_deployment_plan',
-            container='test-plan')
+            workflow_input={'container': 'test-plan'})
 
-    @mock.patch(
+    def test_delete_multiple_plans(self):
-        'tripleoclient.workflows.plan_management.delete_deployment_plan',
-        autospec=True)
-    def test_delete_multiple_plans(self, delete_deployment_plan_mock):
         argslist = ['test-plan1', 'test-plan2']
         verifylist = [('plans', ['test-plan1', 'test-plan2'])]
         parsed_args = self.check_parser(self.cmd, argslist, verifylist)
 
+        self.websocket.wait_for_messages.return_value = iter([{
+            "execution": {"id": "IDID"},
+            "status": "SUCCESS"
+        }])
+
         self.cmd.take_action(parsed_args)
 
-        expected = [
+        self.workflow.executions.create.assert_has_calls([
-            mock.call(self.workflow, container='test-plan1'),
+            mock.call('tripleo.plan_management.v1.delete_deployment_plan',
-            mock.call(self.workflow, container='test-plan2'),
+                      workflow_input={'container': 'test-plan1'}),
-        ]
+            mock.call('tripleo.plan_management.v1.delete_deployment_plan',
-        self.assertEqual(delete_deployment_plan_mock.call_args_list,
+                      workflow_input={'container': 'test-plan2'}),
-                         expected)
+        ], any_order=True)
 
 
 class TestOvercloudCreatePlan(utils.TestCommand):

tripleoclient/tests/workflows/test_plan_management.py

@@ -175,17 +175,17 @@ class TestPlanCreationWorkflows(utils.TestCommand):
             'test-overcloud', 'network_data.yaml', mock_open_context())
 
     def test_delete_plan(self):
-        self.workflow.action_executions.create.return_value = (
+        output = mock.Mock(output='{"result": ""}')
-            mock.Mock(output='{"result": null}'))
+        self.workflow.action_executions.create.return_value = output
+        self.websocket.wait_for_messages.return_value = self.message_success
 
         plan_management.delete_deployment_plan(
-            self.workflow,
+            self.app.client_manager,
-            container='overcloud')
+            container='test-overcloud')
 
-        self.workflow.action_executions.create.assert_called_once_with(
+        self.workflow.executions.create.assert_called_once_with(
-            'tripleo.plan.delete',
+            'tripleo.plan_management.v1.delete_deployment_plan',
-            {'container': 'overcloud'},
+            workflow_input={'container': 'test-overcloud'})
-            run_sync=True, save_result=True)
 
     @mock.patch('tripleoclient.workflows.plan_management.tarball',
                 autospec=True)

tripleoclient/v1/overcloud_plan.py

@@ -60,11 +60,11 @@ class DeletePlan(command.Command):
     def take_action(self, parsed_args):
         self.log.debug("take_action(%s)" % parsed_args)
 
-        workflow_client = self.app.client_manager.workflow_engine
+        clients = self.app.client_manager
 
         for plan in parsed_args.plans:
             print("Deleting plan %s..." % plan)
-            plan_management.delete_deployment_plan(workflow_client,
+            plan_management.delete_deployment_plan(clients,
                                                    container=plan)
 
 

tripleoclient/workflows/plan_management.py

@@ -86,16 +86,25 @@ def create_deployment_plan(clients, **workflow_input):
             'Exception creating plan: {}'.format(payload['message']))
 
 
-def delete_deployment_plan(workflow_client, **input_):
+def delete_deployment_plan(clients, **workflow_input):
-    try:
+    workflow_client = clients.workflow_engine
-        results = base.call_action(workflow_client,
+    tripleoclients = clients.tripleoclient
-                                   'tripleo.plan.delete',
+
-                                   **input_)
+    execution = base.start_workflow(
-        if results is not None:
+        workflow_client,
-            print(results)
+        'tripleo.plan_management.v1.delete_deployment_plan',
-    except Exception as err:
+        workflow_input=workflow_input
-        raise exceptions.WorkflowServiceError(
+    )
-            'Exception deleting plan: {}'.format(err))
+
+    with tripleoclients.messaging_websocket() as ws:
+        for payload in base.wait_for_messages(workflow_client, ws, execution,
+                                              _WORKFLOW_TIMEOUT):
+            if 'message' in payload:
+                print(payload['message'])
+
+            if payload['status'] != 'SUCCESS':
+                raise exceptions.WorkflowServiceError(
+                    'Exception deleting plan: {}'.format(payload['message']))
 
 
 def update_deployment_plan(clients, **workflow_input):