@eclipse-che/che-e2e 7.73.0-dev-1397a5e → 7.73.0-dev-ed57855

package/utils/workspace/TestWorkspaceUtil.ts

@@ -9,7 +9,7 @@
  **********************************************************************/
 
 import 'reflect-metadata';
-import { injectable, inject } from 'inversify';
+import { inject, injectable } from 'inversify';
 import { DriverHelper } from '../DriverHelper';
 import { WorkspaceStatus } from './WorkspaceStatus';
 import { error } from 'selenium-webdriver';
@@ -23,142 +23,146 @@ import { TimeoutConstants } from '../../constants/TimeoutConstants';
 
 @injectable()
 export class TestWorkspaceUtil implements ITestWorkspaceUtil {
-    readonly polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
-    readonly attempts: number = TimeoutConstants.TS_DASHBOARD_WORKSPACE_STOP_TIMEOUT / this.polling;
+  readonly polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+  readonly attempts: number = TimeoutConstants.TS_DASHBOARD_WORKSPACE_STOP_TIMEOUT / this.polling;
 
-    constructor(
-        @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper,
-        @inject(CLASSES.CheApiRequestHandler) private readonly processRequestHandler: CheApiRequestHandler,
-        @inject(CLASSES.ApiUrlResolver) private readonly apiUrlResolver: ApiUrlResolver
-    ) { }
+  constructor(
+    @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper,
+    @inject(CLASSES.CheApiRequestHandler) private readonly processRequestHandler: CheApiRequestHandler,
+    @inject(CLASSES.ApiUrlResolver) private readonly apiUrlResolver: ApiUrlResolver
+  ) { }
 
-    async waitWorkspaceStatus(workspaceName: string, expectedWorkspaceStatus: WorkspaceStatus): Promise<void> {
-        Logger.debug('TestWorkspaceUtil.waitWorkspaceStatus');
+  async waitWorkspaceStatus(workspaceName: string, expectedWorkspaceStatus: WorkspaceStatus): Promise<void> {
+    Logger.debug();
 
-        let workspaceStatus: string = '';
-        let expectedStatus: boolean = false;
-        for (let i: number = 0; i < this.attempts; i++) {
-            const response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName));
+    let workspaceStatus: string = '';
+    let expectedStatus: boolean = false;
+    for (let i: number = 0; i < this.attempts; i++) {
+      const response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName));
 
-            if (response.status !== 200) {
-                throw new Error(`Can not get status of a workspace. Code: ${response.status} Data: ${response.data}`);
-            }
+      if (response.status !== 200) {
+        throw new Error(`Can not get status of a workspace. Code: ${response.status} Data: ${response.data}`);
+      }
 
-            workspaceStatus = await response.data.status.phase;
+      workspaceStatus = await response.data.status.phase;
 
-            if (workspaceStatus === expectedWorkspaceStatus) {
-                expectedStatus = true;
-                break;
-            }
+      if (workspaceStatus === expectedWorkspaceStatus) {
+        expectedStatus = true;
+        break;
+      }
 
-            await this.driverHelper.wait(this.polling);
-        }
-
-        if (!expectedStatus) {
-            let waitTime: number = this.attempts * this.polling;
-            throw new error.TimeoutError(`The workspace was not stopped in ${waitTime} ms. Current status is: ${workspaceStatus}`);
-        }
+      await this.driverHelper.wait(this.polling);
     }
 
-    async stopWorkspaceByName(workspaceName: string): Promise<void> {
-        Logger.debug(`TestWorkspaceUtil.stopWorkspaceByName: ${workspaceName}`);
-
-        const stopWorkspaceApiUrl: string = await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName);
-        let stopWorkspaceResponse: AxiosResponse;
-
-        try {
-            stopWorkspaceResponse = await this.processRequestHandler.patch(stopWorkspaceApiUrl, [{'op': 'replace', 'path': '/spec/started', 'value': false}]);
-        } catch (err) {
-            Logger.error(`Stop workspace call failed. URL used: ${stopWorkspaceApiUrl}`);
-            throw err;
-        }
-
-        if (stopWorkspaceResponse.status !== 200) {
-            throw new Error(`Cannot stop workspace. Code: ${stopWorkspaceResponse.status} Data: ${stopWorkspaceResponse.data}`);
-        }
-
-        await this.waitWorkspaceStatus(workspaceName, WorkspaceStatus.STOPPED);
-        Logger.debug(`TestWorkspaceUtil.stopWorkspaceByName: ${workspaceName} stopped successfully`);
+    if (!expectedStatus) {
+      let waitTime: number = this.attempts * this.polling;
+      throw new error.TimeoutError(`The workspace was not stopped in ${waitTime} ms. Current status is: ${workspaceStatus}`);
+    }
+  }
+
+  async stopWorkspaceByName(workspaceName: string): Promise<void> {
+    Logger.debug(`${workspaceName}`);
+
+    const stopWorkspaceApiUrl: string = await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName);
+    let stopWorkspaceResponse: AxiosResponse;
+
+    try {
+      stopWorkspaceResponse = await this.processRequestHandler.patch(stopWorkspaceApiUrl, [{
+        'op': 'replace',
+        'path': '/spec/started',
+        'value': false
+      }]);
+    } catch (err) {
+      Logger.error(`stop workspace call failed. URL used: ${stopWorkspaceApiUrl}`);
+      throw err;
     }
 
-    // delete a workspace without stopping phase (similar with force deleting)
-    async deleteWorkspaceByName(workspaceName: string): Promise<void> {
-        Logger.debug(`TestWorkspaceUtil.deleteWorkspaceByName: ${workspaceName}` );
-
-        const deleteWorkspaceApiUrl: string = await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName);
-        let deleteWorkspaceResponse: AxiosResponse;
-        let deleteWorkspaceStatus: boolean = false;
-        try {
-            deleteWorkspaceResponse = await this.processRequestHandler.delete(deleteWorkspaceApiUrl);
-        } catch (error) {
-            if (axios.isAxiosError(error) && error.response?.status === 404) {
-                Logger.error(`The workspace :${workspaceName} not found`);
-                throw error;
-            }
-            Logger.error(`Delete workspace call failed. URL used: ${deleteWorkspaceStatus}`);
-            throw error;
-        }
-
-        if (deleteWorkspaceResponse.status !== 204) {
-            throw new Error(`Can not delete workspace. Code: ${deleteWorkspaceResponse.status} Data: ${deleteWorkspaceResponse.data}`);
-        }
-
-        for (let i: number = 0; i < this.attempts; i++) {
-            try {
-                deleteWorkspaceResponse = await this.processRequestHandler.get(deleteWorkspaceApiUrl);
-            } catch (error) {
-                if (axios.isAxiosError(error) && error.response?.status === 404) {
-                    deleteWorkspaceStatus = true;
-                    Logger.debug(`TestWorkspaceUtil.stopWorkspaceByName: ${workspaceName} deleted successfully`);
-                    break;
-                }
-            }
-        }
-
-        if (!deleteWorkspaceStatus) {
-            let waitTime: number = this.attempts * this.polling;
-            throw new error.TimeoutError(`The workspace was not deleted in ${waitTime} ms.`);
-        }
+    if (stopWorkspaceResponse.status !== 200) {
+      throw new Error(`Cannot stop workspace. Code: ${stopWorkspaceResponse.status} Data: ${stopWorkspaceResponse.data}`);
     }
 
-    // stop workspace before deleting with checking stopping phase
-    async stopAndDeleteWorkspaceByName(workspaceName: string): Promise<void> {
-        Logger.debug('TestWorkspaceUtil.stopAndDeleteWorkspaceByName');
+    await this.waitWorkspaceStatus(workspaceName, WorkspaceStatus.STOPPED);
+    Logger.debug(`${workspaceName} stopped successfully`);
+  }
+
+  // delete a workspace without stopping phase (similar with force deleting)
+  async deleteWorkspaceByName(workspaceName: string): Promise<void> {
+    Logger.debug(`${workspaceName}`);
+
+    const deleteWorkspaceApiUrl: string = await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName);
+    let deleteWorkspaceResponse: AxiosResponse;
+    let deleteWorkspaceStatus: boolean = false;
+    try {
+      deleteWorkspaceResponse = await this.processRequestHandler.delete(deleteWorkspaceApiUrl);
+    } catch (error) {
+      if (axios.isAxiosError(error) && error.response?.status === 404) {
+        Logger.error(`the workspace :${workspaceName} not found`);
+        throw error;
+      }
+      Logger.error(`delete workspace call failed. URL used: ${deleteWorkspaceStatus}`);
+      throw error;
+    }
 
-        await this.stopWorkspaceByName(workspaceName);
-        await this.deleteWorkspaceByName(workspaceName);
+    if (deleteWorkspaceResponse.status !== 204) {
+      throw new Error(`Can not delete workspace. Code: ${deleteWorkspaceResponse.status} Data: ${deleteWorkspaceResponse.data}`);
     }
 
-    // stop all run workspaces in the namespace
-    async stopAllRunningWorkspaces(namespace: string): Promise<void> {
-        Logger.debug('TestWorkspaceUtil.stopAllRunProjects');
-        let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
-        for (let i: number = 0; i < response.data.items.length; i++) {
-            Logger.info('The project is being stopped: ' +  response.data.items[i].metadata.name);
-            await this.stopWorkspaceByName(response.data.items[i].metadata.name);
+    for (let i: number = 0; i < this.attempts; i++) {
+      try {
+        deleteWorkspaceResponse = await this.processRequestHandler.get(deleteWorkspaceApiUrl);
+      } catch (error) {
+        if (axios.isAxiosError(error) && error.response?.status === 404) {
+          deleteWorkspaceStatus = true;
+          Logger.debug(`${workspaceName} deleted successfully`);
+          break;
         }
+      }
     }
 
-    // stop all run workspaces, check statuses and remove the workspaces
-    async stopAndDeleteAllRunningWorkspaces(namespace: string): Promise<void> {
-        Logger.debug('TestWorkspaceUtil.stopAndDeleteAllRunProjects');
-        let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
-        await this.stopAllRunningWorkspaces(namespace);
-        for (let i: number = 0; i < response.data.items.length; i++) {
-            Logger.info('The project is being deleted: ' +  response.data.items[i].metadata.name);
-            await this.deleteWorkspaceByName(response.data.items[i].metadata.name);
-        }
+    if (!deleteWorkspaceStatus) {
+      let waitTime: number = this.attempts * this.polling;
+      throw new error.TimeoutError(`The workspace was not deleted in ${waitTime} ms.`);
+    }
+  }
+
+  // stop workspace before deleting with checking stopping phase
+  async stopAndDeleteWorkspaceByName(workspaceName: string): Promise<void> {
+    Logger.debug();
+
+    await this.stopWorkspaceByName(workspaceName);
+    await this.deleteWorkspaceByName(workspaceName);
+  }
+
+  // stop all run workspaces in the namespace
+  async stopAllRunningWorkspaces(namespace: string): Promise<void> {
+    Logger.debug();
+    let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
+    for (let i: number = 0; i < response.data.items.length; i++) {
+      Logger.info('the project is being stopped: ' + response.data.items[i].metadata.name);
+      await this.stopWorkspaceByName(response.data.items[i].metadata.name);
     }
+  }
+
+  // stop all run workspaces, check statuses and remove the workspaces
+  async stopAndDeleteAllRunningWorkspaces(namespace: string): Promise<void> {
+    Logger.debug();
+    let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
+    await this.stopAllRunningWorkspaces(namespace);
+    for (let i: number = 0; i < response.data.items.length; i++) {
+      Logger.info('the project is being deleted: ' + response.data.items[i].metadata.name);
+      await this.deleteWorkspaceByName(response.data.items[i].metadata.name);
+    }
+  }
 
-    // stop all run workspaces without stopping and waiting for of 'Stopped' phase
-    // similar with 'force' deleting
-    async deleteAllWorkspaces(namespace: string): Promise<void> {
-        Logger.debug('TestWorkspaceUtil.deleteAllRunProjects');
-        let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
+  // stop all run workspaces without stopping and waiting for of 'Stopped' phase
+  // similar with 'force' deleting
+  async deleteAllWorkspaces(namespace: string): Promise<void> {
+    Logger.debug();
+    let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
 
-        for (let i: number = 0; i < response.data.items.length; i++) {
-            Logger.info('The project is being deleted .......: ' +  response.data.items[i].metadata.name);
-            await this.deleteWorkspaceByName(response.data.items[i].metadata.name);
-        }
+    for (let i: number = 0; i < response.data.items.length; i++) {
+      Logger.info('the project is being deleted .......: ' + response.data.items[i].metadata.name);
+      await this.deleteWorkspaceByName(response.data.items[i].metadata.name);
     }
+  }
 }

package/utils/workspace/WorkspaceStatus.ts

@@ -9,7 +9,7 @@
  **********************************************************************/
 
 export enum WorkspaceStatus {
-    RUNNING = 'Running',
-    STOPPED = 'Stopped',
-    STARTING = 'Starting'
+  RUNNING = 'Running',
+  STOPPED = 'Stopped',
+  STARTING = 'Starting'
 }