Do not remove folder from workspace when delete application

This PR fixes #2022.

Signed-off-by: Denis Golovin [email protected]

Author: dgolovin

src/odo.ts

@@ -460,6 +460,7 @@ class OdoModel {
 
     public delete(item: OpenShiftObject): void {
         this.pathToObject.delete(item.path);
+        this.parentToChildren.delete(item);
         if (item.contextPath) {
             this.contextToObject.delete(item.contextPath.fsPath);
             this.deleteContext(item.contextPath.fsPath);
@@ -835,49 +836,50 @@ export class OdoImpl implements Odo {
         return this.insertAndReveal(new OpenShiftProject(clusters[0], projectName, true));
     }
 
-    public async deleteApplication(app: OpenShiftObject): Promise<OpenShiftObject> {
-        const allComps = await OdoImpl.instance.getComponents(app);
-        const allContexts = [];
-        let callDelete = false;
-        allComps.forEach((component) => {
-            OdoImpl.data.delete(component); // delete component from model
-            if (!callDelete && component.contextValue === ContextType.COMPONENT_PUSHED || component.contextValue === ContextType.COMPONENT_NO_CONTEXT) {
-                callDelete = true; // if there is at least one component deployed in application `odo app delete` command should be called
-            }
-            if (component.contextPath) { // if component has context folder save it to remove from settings cache
-                allContexts.push(workspace.getWorkspaceFolder(component.contextPath));
-            }
+    public async deleteComponentsWithoutRefresh(components: OpenShiftObject[]): Promise<void> {
+        let result = Promise.resolve();
+        components
+            .forEach((component) => {
+                result = result.then(async ()=> {
+                    if (component.contextPath) { // call odo only for local components in workspace
+                        await this.execute(
+                            Command.deleteComponent(
+                                component.getParent().getParent().getName(),
+                                component.getParent().getName(), component.getName(),
+                                !!component.contextPath,
+                                component.kind === ComponentKind.S2I
+                            ),
+                            component.contextPath ? component.contextPath.fsPath : Platform.getUserHomePath()
+                        );
+                    }
+                    await component.getParent().removeChild(component);
+                    OdoImpl.data.delete(component);
+                }
+            );
         });
+        await result;
+    }
 
-        if (callDelete) {
-            await this.execute(Command.deleteApplication(app.getParent().getName(), app.getName()));
-        }
-        // Chain workspace folder deletions, because when updateWorkspaceFoder called next call is possible only after
-        // listener registered with onDidChangeWorkspaceFolders called.
-        let result = Promise.resolve();
-        // To avoid workspace restart during deletion first have to check if there is wsFolder with index 0
-        const rootFolder = allContexts.find(folder => folder.index === 0);
-        allContexts.forEach((wsFolder) => {
-            if (rootFolder !== wsFolder) {
-                result = result.then(() => {
-                    workspace.updateWorkspaceFolders(wsFolder.index, 1);
-                    return new Promise<void>((resolve) => {
-                        const disposable = workspace.onDidChangeWorkspaceFolders(() => {
-                            disposable.dispose();
-                            resolve();
-                        });
-                    });
-                });
+    public async deleteApplication(app: OpenShiftObject): Promise<OpenShiftObject> {
+        const allComps = await OdoImpl.instance.getApplicationChildren(app);
+
+        // find out if there is at least one deployed component/service and `odo app delete` should be called
+        const callAppDelete = !!allComps.find(
+            (item) => [ContextType.COMPONENT_PUSHED, ContextType.COMPONENT_NO_CONTEXT, ContextType.SERVICE].includes(item.contextValue)
+        );
+
+        try { // first delete all application related resources in cluster
+            if (callAppDelete) {
+                await this.execute(Command.deleteApplication(app.getParent().getName(), app.getName()));
             }
-        });
-        if (rootFolder) {
-            result = result.then(() => {
-                workspace.updateWorkspaceFolders(rootFolder.index, 1)
-            });
-        }
-        return result.then(() => {
+            await this.deleteComponentsWithoutRefresh(allComps);
             return this.deleteAndRefresh(app);
-        });
+        } catch (error) {
+            // if error occurs during application deletion, app object has to be refreshed to new state
+            this.subject.next(new OdoEventImpl('changed', app));
+            throw error;
+        }
+
     }
 
     public async createApplication(application: OpenShiftObject): Promise<OpenShiftObject> {

src/openshift/application.ts

@@ -42,9 +42,9 @@ export class Application extends OpenShiftItem {
                     await Progress.execFunctionWithProgress(`Deleting the Application '${appName}'`, () => Application.odo.deleteApplication(application));
                     return `Application '${appName}' successfully deleted`
                 } catch (err) {
-                    const telemetryMessage = err instanceof VsCommandError ? err.telemetryMessage : err.message;
+                    const telemetryMessage = err instanceof VsCommandError ? ` ${err.telemetryMessage}` : '';
                     throw new VsCommandError(`Failed to delete Application with error '${err.message}'`,
-                            `Failed to delete Application with error ${telemetryMessage}`, err);
+                            `Failed to delete Application with error${telemetryMessage}`, err);
                 }
             }
         }

test/unit/openshift/application.test.ts

@@ -21,17 +21,19 @@ suite('OpenShift/Application', () => {
     let quickPickStub: sinon.SinonStub;
     let sandbox: sinon.SinonSandbox;
     let execStub: sinon.SinonStub;
+    let getProjectsStub: sinon.SinonStub;
     const clusterItem = new TestItem(null, 'cluster', ContextType.CLUSTER);
     const projectItem = new TestItem(clusterItem, 'project', ContextType.PROJECT);
     const appItem = new TestItem(projectItem, 'app', ContextType.APPLICATION);
-    const compItem = new TestItem(appItem, 'app', ContextType.COMPONENT_NO_CONTEXT, [], null);
+    const compItem = new TestItem(appItem, 'component', ContextType.COMPONENT_NO_CONTEXT, [], null);
     compItem.path = 'path/to/component';
     appItem.getChildren().push(compItem);
 
     setup(() => {
         sandbox = sinon.createSandbox();
         execStub = sandbox.stub(OdoImpl.prototype, 'execute').resolves({error: null, stdout: '', stderr: ''});
         sandbox.stub(OdoImpl.prototype, 'getClusters').resolves([clusterItem]);
+        getProjectsStub = sandbox.stub(OdoImpl.prototype, 'getProjects').resolves([projectItem]);
         sandbox.stub(OdoImpl.prototype, 'getApplications').resolves([appItem]);
         sandbox.stub(OpenShiftItem, 'getApplicationNames').resolves([appItem]);
         sandbox.stub(vscode.window, 'showInputBox');
@@ -60,7 +62,7 @@ suite('OpenShift/Application', () => {
         suite('called from command palette', () => {
 
             test('calls the appropriate error message when no project found', async () => {
-                sandbox.stub(OdoImpl.prototype, 'getProjects').resolves([]);
+                getProjectsStub.onFirstCall().resolves([]);
                 try {
                     await Application.describe(null);
                 } catch (err) {
@@ -72,7 +74,6 @@ suite('OpenShift/Application', () => {
             });
 
             test('asks to select a project and an application', async () => {
-                sandbox.stub(OdoImpl.prototype, 'getProjects').resolves([projectItem]);
                 const apps = [appItem];
                 quickPickStub = sandbox.stub(vscode.window, 'showQuickPick');
                 quickPickStub.onFirstCall().resolves(appItem);
@@ -83,7 +84,6 @@ suite('OpenShift/Application', () => {
             });
 
             test('skips odo command execution if canceled by user', async () => {
-                sandbox.stub(OdoImpl.prototype, 'getProjects').resolves([projectItem]);
                 quickPickStub = sandbox.stub(vscode.window, 'showQuickPick').resolves(null);
                 await Application.describe(null);
                 expect(termStub).not.called;
@@ -96,16 +96,17 @@ suite('OpenShift/Application', () => {
 
         setup(() => {
             warnStub = sandbox.stub(vscode.window, 'showWarningMessage');
-            sandbox.stub(OdoImpl.prototype, 'getProjects').resolves([projectItem]);
-            sandbox.stub(OdoImpl.prototype, 'getComponents').resolves([compItem]);
+            getProjectsStub.onFirstCall().resolves([projectItem]);
+            const pushedCompItem = new TestItem(appItem, 'app', ContextType.COMPONENT_PUSHED, []);
+            sandbox.stub(OdoImpl.prototype, 'getApplicationChildren').resolves([pushedCompItem]);
         });
 
         test('calls the appropriate odo command if confirmed', async () => {
             warnStub.resolves('Yes');
 
             await Application.del(appItem);
 
-            expect(execStub).calledOnceWith(Command.deleteApplication(projectItem.getName(), appItem.getName()));
+            expect(execStub).calledWith(Command.deleteApplication(projectItem.getName(), appItem.getName()));
         });
 
         test('returns a confirmation message text when successful', async () => {