@eclipse-che/che-e2e 7.50.0-dev-d6432ff → 7.51.0-dev-6c69f4f

package/testsLibrary/WorkspaceHandlingTests.ts

@@ -15,46 +15,109 @@ import { Dashboard } from '../pageobjects/dashboard/Dashboard';
 import { CreateWorkspace } from '../pageobjects/dashboard/CreateWorkspace';
 import { Workspaces } from '../pageobjects/dashboard/Workspaces';
 import { BrowserTabsUtil } from '../utils/BrowserTabsUtil';
-import { Logger } from '..';
+import { Logger } from '../utils/Logger';
+import { ApiUrlResolver } from '../utils/workspace/ApiUrlResolver';
+import { TimeoutConstants } from '../TimeoutConstants';
+import { DriverHelper } from '../utils/DriverHelper';
+import { Ide } from '../pageobjects/ide/Ide';
+import { By, error } from 'selenium-webdriver';
 
 @injectable()
 export class WorkspaceHandlingTests {
 
+    private static START_WORKSPACE_PAGE_NAME_LOCATOR: By = By.xpath(`//div[@class="ui-container"]/div[@class="pf-c-page"]//div[@class="pf-c-content"]/h1`);
     private static workspaceName: string = 'undefined';
+    private static parentGUID: string;
 
     public static getWorkspaceName(): string {
         return WorkspaceHandlingTests.workspaceName;
     }
 
+    public static setWorkspaceName(workspaceName: string) {
+        WorkspaceHandlingTests.workspaceName = workspaceName;
+    }
+
+    public setWindowHandle(guid: string) {
+        WorkspaceHandlingTests.parentGUID = guid;
+    }
+
+    public getWindowHandle(): string {
+        return WorkspaceHandlingTests.parentGUID;
+    }
+
     constructor(
         @inject(CLASSES.Dashboard) private readonly dashboard: Dashboard,
         @inject(CLASSES.CreateWorkspace) private readonly createWorkspace: CreateWorkspace,
         @inject(CLASSES.Workspaces) private readonly workspaces: Workspaces,
-        @inject(CLASSES.BrowserTabsUtil) private readonly browserTabsUtil: BrowserTabsUtil) {}
+        @inject(CLASSES.BrowserTabsUtil) private readonly browserTabsUtil: BrowserTabsUtil,
+        @inject(CLASSES.ApiUrlResolver) private readonly apiUrlResolver: ApiUrlResolver,
+        @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper,
+        @inject(CLASSES.Ide) private readonly ide: Ide) {}
 
     public createAndOpenWorkspace(stack: string) {
-        test(`Open 'New Workspace' page`, async () => {
+        test(`Create and open new workspace, stack:${stack}`, async () => {
             await this.dashboard.waitPage();
+            Logger.debug(`Fetching user kubernetes namespace, storing auth token by getting workspaces API URL.`);
+            await this.apiUrlResolver.getWorkspacesApiUrl();
             await this.dashboard.clickCreateWorkspaceButton();
             await this.createWorkspace.waitPage();
-            const parentGUID = await this.browserTabsUtil.getCurrentWindowHandle();
+            WorkspaceHandlingTests.parentGUID = await this.browserTabsUtil.getCurrentWindowHandle();
             await this.createWorkspace.clickOnSample(stack);
-            await this.browserTabsUtil.switchToWindow(parentGUID);
-            WorkspaceHandlingTests.workspaceName = await this.dashboard.getRecentWorkspaceName(10000);
-            Logger.debug(`Workspace Name is: ${WorkspaceHandlingTests.workspaceName}`);
-            await this.browserTabsUtil.waitAndSwitchToAnotherWindow(parentGUID, 10000);
+            await this.browserTabsUtil.waitAndSwitchToAnotherWindow(WorkspaceHandlingTests.parentGUID, TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
         });
     }
 
     public openExistingWorkspace(workspaceName: string) {
-        test('Start workspace', async () => {
+        test('Open and start existing workspace', async () => {
             await this.dashboard.waitPage();
+            Logger.debug(`Fetching user kubernetes namespace, storing auth token by getting workspaces API URL.`);
+            await this.apiUrlResolver.getWorkspacesApiUrl();
             await this.dashboard.clickWorkspacesButton();
             await this.workspaces.waitPage();
             await this.workspaces.clickOpenButton(workspaceName);
         });
     }
 
+    public obtainWorkspaceNameFromStartingPage() {
+        test('Obtain workspace name from workspace loader page', async() => {
+            try {
+                await this.driverHelper.waitVisibility(WorkspaceHandlingTests.START_WORKSPACE_PAGE_NAME_LOCATOR, TimeoutConstants.TS_WAIT_LOADER_PRESENCE_TIMEOUT);
+                // it takes a while to update the element with the workspace name
+                await this.driverHelper.wait(TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
+                let startingWorkspaceLineContent = await this.driverHelper.getDriver().findElement(WorkspaceHandlingTests.START_WORKSPACE_PAGE_NAME_LOCATOR).getAttribute('innerHTML');
+                // cutting away leading text
+                WorkspaceHandlingTests.workspaceName = startingWorkspaceLineContent.substring('Starting workspace '.length).trim();
+                Logger.info(`Obtained workspace name from workspace loader page: ${WorkspaceHandlingTests.workspaceName}`);
+            } catch (err) {
+                Logger.error(`Failed to obtain workspace name from workspace loader page: ${err}`);
+                throw err;
+            }
+        });
+    }
+
+    public switchBackToFirstOpenIdeTabFromLeftToRight() {
+        test('WorkspaceHandlingTests.switchBackToIdeTab', async () => {
+            let tabs = await this.driverHelper.getDriver().getAllWindowHandles();
+            Logger.trace(`WorkspaceHandlingTests.switchBackToIdeTab Found ${tabs.length} window handles, iterating...`);
+            for (let i = 0; i < tabs.length; i++) {
+                await this.browserTabsUtil.switchToWindow(tabs[i]);
+                try {
+                    await this.ide.waitIde(TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
+                    Logger.debug(`WorkspaceHandlingTests.switchBackToIdeTab located and switched to IDE tab`);
+                    return;
+                } catch (err) {
+                    if (err instanceof error.TimeoutError) {
+                        Logger.warn(`WorkspaceHandlingTests.switchBackToIdeTab Locator timed out, trying with another window handle.`);
+                        continue;
+                    }
+                    Logger.error(`WorkspaceHandlingTests.switchBackToIdeTab Received unexpected exception while trying to locate IDE tab:${err}`);
+                    throw err;
+                }
+            }
+            Logger.error(`WorkspaceHandlingTests.switchBackToIdeTab Failed to locate IDE tab, out of window handles.`);
+        });
+    }
+
     public async stopWorkspace(workspaceName: string) {
         await this.dashboard.openDashboard();
         await this.dashboard.stopWorkspaceByUI(workspaceName);

package/utils/requestHandlers/CheApiRequestHandler.ts

@@ -100,7 +100,7 @@ export class CheApiRequestHandler {
     }
 
     async patch(relativeUrl: string, patchParams: object): Promise<AxiosResponse> {
-       return await axios.patch(this.assembleUrl(relativeUrl), patchParams, await this.headerHandler.get());
+        return await axios.patch(this.assembleUrl(relativeUrl), patchParams, await this.headerHandler.get());
     }
 
     private assembleUrl(relativeUrl: string): string {

package/utils/requestHandlers/headers/CheMultiuserAuthorizationHeaderHandler.ts

@@ -12,13 +12,28 @@ import { IAuthorizationHeaderHandler } from './IAuthorizationHeaderHandler';
 import { inject, injectable } from 'inversify';
 import { DriverHelper } from '../../DriverHelper';
 import { CLASSES } from '../../../inversify.types';
+import { Logger } from '../../Logger';
 
 @injectable()
 export class CheMultiuserAuthorizationHeaderHandler implements IAuthorizationHeaderHandler {
+    private authorizationToken: string = '';
+
     constructor(@inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) { }
 
     async get(): Promise<AxiosRequestConfig> {
-        let token = await this.driverHelper.getDriver().manage().getCookie('_oauth_proxy');
-        return { headers: { 'cookie': `_oauth_proxy=${token.value}` } };
+        try {
+            let token = await this.driverHelper.getDriver().manage().getCookie('_oauth_proxy');
+            if (this.authorizationToken !== token.value) {
+                this.authorizationToken = token.value;
+            }
+        } catch (err) {
+            if (this.authorizationToken.length > 0) {
+                Logger.warn(`Could not obtain _oauth_proxy cookie from chromedriver, browser session may have been killed. Using stored value.`);
+            } else {
+                throw new Error(`Could not obtain _oauth_proxy cookie from chromedriver, browser session may have been killed. No stored token present!`);
+            }
+        }
+
+        return { headers: { 'cookie': `_oauth_proxy=${this.authorizationToken}` } };
     }
 }

package/utils/workspace/ApiUrlResolver.ts

@@ -0,0 +1,50 @@
+/*********************************************************************
+ * Copyright (c) 2019 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+import { inject, injectable } from 'inversify';
+import { CLASSES } from '../../inversify.types';
+import { Logger } from '../Logger';
+import { CheApiRequestHandler } from '../requestHandlers/CheApiRequestHandler';
+
+@injectable()
+export class ApiUrlResolver {
+    private static readonly DASHBOARD_API_URL: string = 'dashboard/api/namespace';
+    private static readonly KUBERNETES_API_URL: string = 'api/kubernetes/namespace';
+
+    private userNamespace: string = '';
+
+    constructor(@inject(CLASSES.CheApiRequestHandler) private readonly processRequestHandler: CheApiRequestHandler) {}
+
+    public async getWorkspaceApiUrl(workspaceName: string): Promise<string> {
+        return `${await this.getWorkspacesApiUrl()}/${workspaceName}`;
+    }
+
+    public async getWorkspacesApiUrl(): Promise<string> {
+        const namespace = await this.obtainUserNamespace();
+        return `${ApiUrlResolver.DASHBOARD_API_URL}/${namespace}/devworkspaces`;
+    }
+
+    public getKubernetesApiUrl(): string {
+        return ApiUrlResolver.KUBERNETES_API_URL;
+    }
+
+    private async obtainUserNamespace() : Promise<string> {
+        Logger.debug(`ApiUrlResolver.obtainUserNamespace ${this.userNamespace}`);
+        if (this.userNamespace.length === 0) {
+            Logger.trace(`ApiUrlResolver.obtainUserNamespace USER_NAMESPACE.length = 0, calling kubernetes API`);
+            const kubernetesResponse = await this.processRequestHandler.get(ApiUrlResolver.KUBERNETES_API_URL);
+            if (kubernetesResponse.status !== 200) {
+                throw new Error(`Cannot get user namespace from kubernetes API. Code: ${kubernetesResponse.status} Data: ${kubernetesResponse.data}`);
+            }
+            this.userNamespace = kubernetesResponse.data[0].name;
+            Logger.debug(`ApiUrlResolver.obtainUserNamespace kubeapi success: ${this.userNamespace}`);
+        }
+        return this.userNamespace;
+    }
+}

package/utils/workspace/ITestWorkspaceUtil.ts

@@ -12,15 +12,87 @@ import { WorkspaceStatus } from './WorkspaceStatus';
 import { che } from '@eclipse-che/api';
 
 export interface ITestWorkspaceUtil {
+    waitWorkspaceStatus(namespace: string, workspaceName: string, expectedWorkspaceStatus: WorkspaceStatus) : void;
+
+    stopWorkspaceByName(workspaceName: string) : void;
+
+    /**
+     * Delete a worksapce without stopping phase (similar with force deleting)
+     */
+    deleteWorkspaceByName(workspaceName: string) : void;
+
+    /**
+     * Stop workspace before deleting with checking stopping phase
+     */
+    stopAndDeleteWorkspaceByName(workspaceName: string) : void;
+
+    /**
+     * Stop all run workspaces in the namespace
+     */
+    stopAllRunningWorkspaces(namespace: string) : void;
+
+    /**
+     * Stop all run workspaces, check statused and remove the workspaces
+     */
+    stopAndDeleteAllRunningWorkspaces(namespace: string) : void;
+
+    /**
+     * Stop all run workspaces without stopping and waiting for of 'Stopped' phase
+     * Similar with 'force' deleting
+     */
+    deleteAllWorkspaces(namespace: string) : void;
+
+    /*=====================
+     * DEPRECATED METHODS *
+     *====================*/
+
+    /**
+     * @deprecated Method deprecated. Works with CHE server only
+     */
     cleanUpAllWorkspaces() : void;
+
+    /**
+     * @deprecated Method deprecated. Works with CHE server only
+     */
     cleanUpRunningWorkspace(workspaceName: string) : void;
-    waitWorkspaceStatus(namespace: string, workspaceName: string, expectedWorkspaceStatus: WorkspaceStatus) : void;
+
+    /**
+     * @deprecated Method deprecated. Works with CHE server only
+     */
     waitPluginAdding(namespace: string, workspaceName: string, pluginId: string) : void;
+
+    /**
+     * @deprecated Method deprecated. Works with CHE server only
+     */
     removeWorkspaceById(id: string) : void;
+
+    /**
+     * @deprecated Method deprecated. Works with CHE server only
+     */
     stopWorkspaceById(id: string) : void;
+
+    /**
+     * @deprecated Method deprecated. Works with CHE server only
+     */
     getIdOfRunningWorkspace(workspaceName: string): Promise<string>;
+
+    /**
+     * @deprecated Method deprecated. Works with CHE server only
+     */
     getIdOfRunningWorkspaces(): Promise<Array<string>>;
+
+    /**
+     * @deprecated Method deprecated. Works with CHE server only
+     */
     createWsFromDevFile(customTemplate: che.workspace.devfile.Devfile): void;
+
+    /**
+     * @deprecated Method deprecated. Works with CHE server only
+     */
     getBaseDevfile(): Promise<che.workspace.devfile.Devfile>;
+
+    /**
+     * @deprecated Method deprecated. Works with CHE server only
+     */
     startWorkspace(workspaceId: string): void;
 }

package/utils/workspace/TestWorkspaceUtil.ts

@@ -8,38 +8,38 @@
  * SPDX-License-Identifier: EPL-2.0
  **********************************************************************/
 
+import 'reflect-metadata';
 import { che } from '@eclipse-che/api';
 import { TestConstants } from '../../TestConstants';
 import { injectable, inject } from 'inversify';
 import { DriverHelper } from '../DriverHelper';
-import 'reflect-metadata';
 import { WorkspaceStatus } from './WorkspaceStatus';
-import { ITestWorkspaceUtil } from './ITestWorkspaceUtil';
 import { error } from 'selenium-webdriver';
 import { CheApiRequestHandler } from '../requestHandlers/CheApiRequestHandler';
 import { CLASSES } from '../../inversify.types';
 import { Logger } from '../Logger';
 import axios from 'axios';
+import { ITestWorkspaceUtil } from './ITestWorkspaceUtil';
+import { ApiUrlResolver } from './ApiUrlResolver';
 
 @injectable()
 export class TestWorkspaceUtil implements ITestWorkspaceUtil {
-
-    static readonly WORKSPACE_API_URL: string = 'dashboard/api/namespace';
     readonly attempts: number = TestConstants.TS_SELENIUM_WORKSPACE_STATUS_ATTEMPTS;
     readonly polling: number = TestConstants.TS_SELENIUM_WORKSPACE_STATUS_POLLING;
+
     constructor(
         @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper,
-        @inject(CLASSES.CheApiRequestHandler) private readonly processRequestHandler: CheApiRequestHandler
+        @inject(CLASSES.CheApiRequestHandler) private readonly processRequestHandler: CheApiRequestHandler,
+        @inject(CLASSES.ApiUrlResolver) private readonly apiUrlResolver: ApiUrlResolver
     ) { }
 
-    public async waitWorkspaceStatus(namespace: string, workspaceName: string, expectedWorkspaceStatus: WorkspaceStatus) {
+    public async waitWorkspaceStatus(workspaceName: string, expectedWorkspaceStatus: WorkspaceStatus) {
         Logger.debug('TestWorkspaceUtil.waitWorkspaceStatus');
 
-        const workspaceStatusApiUrl: string = `${TestWorkspaceUtil.WORKSPACE_API_URL}/${namespace}-che/devworkspaces/${workspaceName}`;
         let workspaceStatus: string = '';
         let expectedStatus: boolean = false;
         for (let i = 0; i < this.attempts; i++) {
-            const response = await this.processRequestHandler.get(workspaceStatusApiUrl);
+            const response = 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}`);
@@ -61,10 +61,10 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
         }
     }
 
-    public async stopWorkspaceByName(namespace: string, workspaceName: string) {
+    public async stopWorkspaceByName(workspaceName: string) {
         Logger.debug('TestWorkspaceUtil.stopWorkspaceByName');
 
-        const stopWorkspaceApiUrl: string = `${TestWorkspaceUtil.WORKSPACE_API_URL}/${namespace}-che/devworkspaces/${workspaceName}`;
+        const stopWorkspaceApiUrl: string = await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName);
         let stopWorkspaceResponse;
 
         try {
@@ -78,14 +78,14 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
             throw new Error(`Cannot stop workspace. Code: ${stopWorkspaceResponse.status} Data: ${stopWorkspaceResponse.data}`);
         }
 
-        await this.waitWorkspaceStatus(namespace, workspaceName, WorkspaceStatus.STOPPED);
+        await this.waitWorkspaceStatus(workspaceName, WorkspaceStatus.STOPPED);
     }
 
     // delete a worksapce without stopping phase (similar with force deleting)
-    public async deleteWorkspaceByName(namespace: string, workspaceName: string) {
-        Logger.debug('TestWorkspaceUtil.deleteWorkspaceByName');
+    public async deleteWorkspaceByName(workspaceName: string) {
+        Logger.debug(`TestWorkspaceUtil.deleteWorkspaceByName ${workspaceName}` );
 
-        const deleteWorkspaceApiUrl: string = `${TestWorkspaceUtil.WORKSPACE_API_URL}/${namespace}-che/devworkspaces/${workspaceName}`;
+        const deleteWorkspaceApiUrl: string = await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName);
         let deleteWorkspaceResponse;
         let deleteWorkspaceStatus: boolean = false;
         try {
@@ -95,16 +95,15 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
                 Logger.error(`The workspace :${workspaceName} not found`);
                 throw error;
             }
-            Logger.error(`Stop workspace call failed. URL used: ${deleteWorkspaceStatus}`);
+            Logger.error(`Delete workspace call failed. URL used: ${deleteWorkspaceStatus}`);
             throw error;
         }
 
         if (deleteWorkspaceResponse.status !== 204) {
-            throw new Error(`Can not stop workspace. Code: ${deleteWorkspaceResponse.status} Data: ${deleteWorkspaceResponse.data}`);
+            throw new Error(`Can not delete workspace. Code: ${deleteWorkspaceResponse.status} Data: ${deleteWorkspaceResponse.data}`);
         }
 
         for (let i = 0; i < this.attempts; i++) {
-
             try {
                 deleteWorkspaceResponse = await this.processRequestHandler.get(deleteWorkspaceApiUrl);
             } catch (error) {
@@ -122,11 +121,44 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
     }
 
     // stop workspace before deleting with checking stopping phase
-    public async stopAndDeleteWorkspaceByName(namespace: string, workspaceName: string) {
+    public async stopAndDeleteWorkspaceByName(workspaceName: string) {
         Logger.debug('TestWorkspaceUtil.stopAndDeleteWorkspaceByName');
 
-        await this.stopWorkspaceByName(namespace, workspaceName);
-        await this.deleteWorkspaceByName(namespace, workspaceName);
+        await this.stopWorkspaceByName(workspaceName);
+        await this.deleteWorkspaceByName(workspaceName);
+    }
+
+    // stop all run workspaces in the namespace
+    public async stopAllRunningWorkspaces(namespace: string) {
+        Logger.debug('TestWorkspaceUtil.stopAllRunProjects');
+        let response = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
+        for (let i = 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 statused and remove the workspaces
+    public async stopAndDeleteAllRunningWorkspaces(namespace: string) {
+        Logger.debug('TestWorkspaceUtil.stopAndDeleteAllRunProjects');
+        let response = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
+        await this.stopAllRunningWorkspaces(namespace);
+        for (let i = 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
+    public async deleteAllWorkspaces(namespace: string) {
+        Logger.debug('TestWorkspaceUtil.deleteAllRunProjects');
+        let response = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
+
+        for (let i = 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);
+        }
     }
 
     /**
@@ -135,7 +167,7 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
     public async waitPluginAdding(namespace: string, workspaceName: string, pluginName: string) {
         Logger.debug('TestWorkspaceUtil.waitPluginAdding');
 
-        const workspaceStatusApiUrl: string = `${TestWorkspaceUtil.WORKSPACE_API_URL}/${namespace}:${workspaceName}`;
+        const workspaceStatusApiUrl: string = `${await this.apiUrlResolver.getWorkspacesApiUrl()}/${namespace}:${workspaceName}`;
         const attempts: number = TestConstants.TS_SELENIUM_PLUGIN_PRECENCE_ATTEMPTS;
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
 
@@ -168,7 +200,7 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
     public async getListOfWorkspaceId(): Promise<string[]> {
         Logger.debug('TestWorkspaceUtil.getListOfWorkspaceId');
 
-        const getAllWorkspacesResponse = await this.processRequestHandler.get(TestWorkspaceUtil.WORKSPACE_API_URL);
+        const getAllWorkspacesResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
 
         interface IMyObj {
             id: string;
@@ -192,7 +224,7 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
     public async getIdOfRunningWorkspace(wsName: string): Promise<string> {
         Logger.debug('TestWorkspaceUtil.getIdOfRunningWorkspace');
 
-        const getWorkspacesByNameResponse = await this.processRequestHandler.get(`${TestWorkspaceUtil.WORKSPACE_API_URL}/:${wsName}`);
+        const getWorkspacesByNameResponse = await this.processRequestHandler.get(`${await this.apiUrlResolver.getWorkspacesApiUrl()}/:${wsName}`);
         return getWorkspacesByNameResponse.data.id;
 
     }
@@ -204,7 +236,7 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
         Logger.debug('TestWorkspaceUtil.getIdOfRunningWorkspaces');
 
         try {
-            const getAllWorkspacesResponse = await this.processRequestHandler.get(TestWorkspaceUtil.WORKSPACE_API_URL);
+            const getAllWorkspacesResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
 
             interface IMyObj {
                 id: string;
@@ -222,7 +254,7 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
 
             return idOfRunningWorkspace;
         } catch (err) {
-            console.log(`Getting id of running workspaces failed. URL used: ${TestWorkspaceUtil.WORKSPACE_API_URL}`);
+            console.log(`Getting id of running workspaces failed. URL used: ${await this.apiUrlResolver.getWorkspacesApiUrl()}`);
             throw err;
         }
     }
@@ -233,7 +265,7 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
     public async removeWorkspaceById(id: string) {
         Logger.debug('TestWorkspaceUtil.removeWorkspaceById');
 
-        const workspaceIdUrl: string = `${TestWorkspaceUtil.WORKSPACE_API_URL}/${id}`;
+        const workspaceIdUrl: string = `${await this.apiUrlResolver.getWorkspacesApiUrl()}/${id}`;
         try {
             const deleteWorkspaceResponse = await this.processRequestHandler.delete(workspaceIdUrl);
             if (deleteWorkspaceResponse.status !== 204) {
@@ -251,7 +283,7 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
     public async stopWorkspaceById(id: string) {
         Logger.debug('TestWorkspaceUtil.stopWorkspaceById');
 
-        const stopWorkspaceApiUrl: string = `${TestWorkspaceUtil.WORKSPACE_API_URL}/${id}`;
+        const stopWorkspaceApiUrl: string = `${await this.apiUrlResolver.getWorkspacesApiUrl()}/${id}`;
         let stopWorkspaceResponse;
 
         try {
@@ -306,16 +338,16 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
      */
     public async cleanUpRunningWorkspace(workspaceName: string) {
         if (workspaceName === undefined || workspaceName.length === 0) {
-          Logger.warn(`Could nod delete workspace because workspaceName is undefined or empty`);
-          return;
+            Logger.warn(`Could nod delete workspace because workspaceName is undefined or empty`);
+            return;
         }
 
         Logger.debug(`TestWorkspaceUtil.cleanUpRunningWorkspace ${workspaceName}`);
         const workspaceID: string = await this.getIdOfRunningWorkspace(workspaceName);
 
         if (workspaceID === undefined || workspaceID.length === 0) {
-          Logger.error(`Could nod delete workspace with name ${workspaceName} because workspaceID is undefined or empty`);
-          return;
+            Logger.error(`Could nod delete workspace with name ${workspaceName} because workspaceID is undefined or empty`);
+            return;
         }
 
         Logger.trace(`TestWorkspaceUtil.cleanUpRunningWorkspace Stopping workspace:${workspaceName} with ID:${workspaceID}`);
@@ -331,7 +363,7 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
         Logger.debug('TestWorkspaceUtil.createWsFromDevFile');
 
         try {
-            await this.processRequestHandler.post(TestWorkspaceUtil.WORKSPACE_API_URL + '/devfile', customTemplate);
+            await this.processRequestHandler.post(await this.apiUrlResolver.getWorkspacesApiUrl() + '/devfile', customTemplate);
         } catch (error) {
             console.error(error);
             throw error;
@@ -361,7 +393,7 @@ export class TestWorkspaceUtil implements ITestWorkspaceUtil {
         Logger.debug('TestWorkspaceUtil.startWorkspace');
 
         try {
-            await this.processRequestHandler.post(`${TestWorkspaceUtil.WORKSPACE_API_URL}/${workspaceId}/runtime`);
+            await this.processRequestHandler.post(`${await this.apiUrlResolver.getWorkspacesApiUrl()}/${workspaceId}/runtime`);
         } catch (error) {
             console.error(error);
             throw error;

package/utils/workspace/WorkspaceStatus.ts

@@ -8,7 +8,7 @@
  * SPDX-License-Identifier: EPL-2.0
  **********************************************************************/
 
- export enum WorkspaceStatus {
+export enum WorkspaceStatus {
     RUNNING = 'Running',
     STOPPED = 'Stopped',
     STARTING = 'Starting'