@eclipse-che/che-e2e 7.39.0

package/testsLibrary/CodeExecutionTests.ts

@@ -0,0 +1,196 @@
+/*********************************************************************
+ * 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 'reflect-metadata';
+import Axios from 'axios';
+import { CLASSES } from '../inversify.types';
+import { inject, injectable } from 'inversify';
+import { By, error, Key } from 'selenium-webdriver';
+import { Ide } from '../pageobjects/ide/Ide';
+import { Terminal } from '../pageobjects/ide/Terminal';
+import { TopMenu } from '../pageobjects/ide/TopMenu';
+import { DialogWindow } from '../pageobjects/ide/DialogWindow';
+import { DriverHelper } from '../utils/DriverHelper';
+import { PreviewWidget } from '../pageobjects/ide/PreviewWidget';
+import { RightToolBar } from '../pageobjects/ide/RightToolBar';
+import { Logger } from '../utils/Logger';
+import { QuickOpenContainer } from '../pageobjects/ide/QuickOpenContainer';
+
+@injectable()
+export class CodeExecutionTests {
+
+    private static lastApplicationUrl: string = '';
+
+    constructor(
+        @inject(CLASSES.Terminal) private readonly terminal: Terminal,
+        @inject(CLASSES.TopMenu) private readonly topMenu: TopMenu,
+        @inject(CLASSES.Ide) private readonly ide: Ide,
+        @inject(CLASSES.DialogWindow) private readonly dialogWindow: DialogWindow,
+        @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper,
+        @inject(CLASSES.PreviewWidget) private readonly previewWidget: PreviewWidget,
+        @inject(CLASSES.RightToolBar) private readonly rightToolBar: RightToolBar,
+        @inject(CLASSES.QuickOpenContainer) private readonly quickOpenContainer: QuickOpenContainer) {}
+
+    public runTask(taskName: string, timeout: number) {
+        test(`Run command '${taskName}'`, async () => {
+            await this.runTaskUsingQuickOpenContainer(taskName);
+            await this.terminal.waitIconSuccess(taskName, timeout);
+        });
+    }
+
+    public runTaskInputText(taskName: string, expectedQuery: string, inputText: string, timeout: number) {
+        test(`Run command '${taskName}' expecting dialog shell`, async () => {
+            await this.runTaskUsingQuickOpenContainer(taskName);
+            await this.terminal.waitText(taskName, expectedQuery, timeout);
+            await this.terminal.clickOnTab(taskName);
+            await this.terminal.type(taskName, inputText);
+            await this.terminal.type(taskName, Key.ENTER);
+            await this.terminal.waitIconSuccess(taskName, timeout);
+        });
+    }
+
+    public runTaskConsoleOutput(taskName: string, expectedText: string, timeout: number) {
+        test(`Run command '${taskName}' expecting console putput: ${expectedText}`, async () => {
+            await this.runTaskUsingQuickOpenContainer(taskName);
+            await this.terminal.waitText(taskName, expectedText, timeout);
+        });
+    }
+
+    public runTaskWithDialogShellAndOpenLink(taskName: string, expectedDialogText: string, timeout: number) {
+        test(`Run command '${taskName}' expecting dialog shell`, async () => {
+            await this.runTaskUsingQuickOpenContainer(taskName);
+            await this.dialogWindow.waitDialogAndOpenLink(expectedDialogText, timeout);
+        });
+    }
+
+    public runTaskWithDialogShellDjangoWorkaround(taskName: string, expectedDialogText: string, urlSubPath: string, timeout: number) {
+        test(`Run command '${taskName}' expecting dialog shell`, async () => {
+            await this.runTaskUsingQuickOpenContainer(taskName);
+            await this.dialogWindow.waitDialog(expectedDialogText, timeout);
+            const dialogRedirectUrl: string = await this.dialogWindow.getApplicationUrlFromDialog(expectedDialogText);
+            const augmentedPreviewUrl: string = dialogRedirectUrl + urlSubPath;
+            await this.dialogWindow.closeDialog();
+            await this.dialogWindow.waitDialogDissappearance();
+            await this.driverHelper.getDriver().wait(async () => {
+                try {
+                    const res = await Axios.get(augmentedPreviewUrl);
+                    if (res.status === 200) { return true; }
+                } catch (error) { await this.driverHelper.wait(1_000); }
+            }, timeout);
+        });
+    }
+
+    public runTaskWithDialogShellAndClose(taskName: string, expectedDialogText: string, timeout: number) {
+        test(`Run command '${taskName}' expecting dialog shell`, async () => {
+            await this.runTaskUsingQuickOpenContainer(taskName);
+            await this.dialogWindow.waitDialog(expectedDialogText, timeout);
+            await this.dialogWindow.closeDialog();
+            await this.dialogWindow.waitDialogDissappearance();
+        });
+    }
+
+    public runTaskWithNotification(taskName: string, notificationText: string, timeout: number) {
+        test(`Run command '${taskName}' expecting notification pops up`, async () => {
+            await this.runTaskUsingQuickOpenContainer(taskName);
+            await this.ide.waitNotification(notificationText, timeout);
+        });
+    }
+
+    public runTaskWithNotificationAndOpenLink(taskName: string, notificationText: string, buttonText: string, timeout: number) {
+        test(`Run command '${taskName}' expecting notification`, async () => {
+            await this.runTaskUsingQuickOpenContainer(taskName);
+            await this.ide.waitNotification(notificationText, timeout);
+            await this.ide.clickOnNotificationButton(notificationText, buttonText);
+            CodeExecutionTests.lastApplicationUrl = await this.previewWidget.getUrl();
+        });
+    }
+
+    public runTaskWithNotificationAndOpenLinkPreviewNoUrl(taskName: string, notificationText: string, timeout: number) {
+        test(`Run command '${taskName}' expecting notification`, async () => {
+            await this.runTaskUsingQuickOpenContainer(taskName);
+            await this.ide.waitNotification(notificationText, timeout);
+            await this.ide.clickOnNotificationButton(notificationText, 'Open In Preview');
+            CodeExecutionTests.lastApplicationUrl = await this.previewWidget.getUrl();
+        });
+    }
+
+    public runTaskWithNotificationAndOpenLinkUnexposedPort(taskName: string, notificationText: string, portOpenText: string, timeout: number) {
+        test(`Run command '${taskName}' expecting notification with unexposed port`, async () => {
+            await this.runTaskUsingQuickOpenContainer(taskName);
+            await this.ide.waitNotificationAndConfirm(notificationText, timeout);
+            await this.ide.waitNotificationAndOpenLink(portOpenText, timeout);
+            CodeExecutionTests.lastApplicationUrl = await this.previewWidget.getUrl();
+        });
+    }
+
+    public verifyRunningApplication(locator: By, applicationCheckTimeout: number, polling: number) {
+        test(`Verify running application by locator: '${locator}'`, async () => {
+            await this.previewWidget.waitApplicationOpened(CodeExecutionTests.lastApplicationUrl, applicationCheckTimeout);
+            try {
+                await this.previewWidget.waitContentAvailable(locator, applicationCheckTimeout, polling);
+            } catch (err) {
+                // fix for preloader / application not available in preview widget
+                // https://issues.redhat.com/browse/CRW-2175
+                if (err instanceof error.TimeoutError) {
+                    Logger.warn(`CodeExecutionTests.verifyRunningApplication application not located, probably blocked by preloader or content not available. Retrying.`);
+                    await this.driverHelper.getDriver().switchTo().defaultContent();
+                    await this.ide.waitAndSwitchToIdeFrame();
+                    await this.previewWidget.refreshPage();
+                    await this.previewWidget.waitContentAvailable(locator, applicationCheckTimeout, polling);
+                }
+            }
+        });
+    }
+
+    public getLastApplicationUrl(): string {
+        return CodeExecutionTests.lastApplicationUrl;
+    }
+
+    public refreshPreviewWindow() {
+        test('Refreshing preview widget', async () => {
+            await this.previewWidget.refreshPage();
+        });
+    }
+
+    public closePreviewWidget() {
+        test('Close preview widget', async () => {
+            await this.rightToolBar.clickOnToolIcon('Preview');
+            await this.previewWidget.waitPreviewWidgetAbsence();
+        });
+    }
+
+    public waitTerminalPresent(terminalTabName: string, timeout: number) {
+        test('Wait terminal presence', async () => {
+            await this.terminal.waitTab(terminalTabName, timeout);
+            await this.driverHelper.wait(5000);
+        });
+    }
+
+    public closeTerminal(taskName: string) {
+        test('Close the terminal tasks', async () => {
+            await this.ide.closeAllNotifications();
+            await this.terminal.rejectTerminalProcess(taskName);
+            await this.terminal.closeTerminalTab(taskName);
+            await this.dialogWindow.waitAndCloseIfAppear();
+        });
+    }
+
+    private async runTaskUsingQuickOpenContainer(taskName: string) {
+        await this.topMenu.selectOption('Terminal', 'Run Task...');
+            try {
+                await this.quickOpenContainer.waitContainer();
+            } catch (err) {
+                Logger.warn(`CodeExecutionTests.runTaskInputText quickOpenContainer failed to open, retrying.`);
+                await this.topMenu.selectOption('Terminal', 'Run Task...');
+                await this.quickOpenContainer.waitContainer();
+            }
+            await this.quickOpenContainer.type(`${taskName}${Key.ENTER}`);
+    }
+}

package/testsLibrary/LanguageServerTests.ts

@@ -0,0 +1,210 @@
+/*********************************************************************
+ * 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 'reflect-metadata';
+import { inject, injectable } from 'inversify';
+import { CLASSES } from '../inversify.types';
+import { TimeoutConstants } from '../TimeoutConstants';
+import { Editor } from '../pageobjects/ide/Editor';
+import { Ide, LeftToolbarButton } from '../pageobjects/ide/Ide';
+import { TopMenu } from '../pageobjects/ide/TopMenu';
+import { DebugView } from '../pageobjects/ide/DebugView';
+import { Key, error } from 'selenium-webdriver';
+import { Logger } from '../utils/Logger';
+import { BrowserTabsUtil } from '../utils/BrowserTabsUtil';
+import { DriverHelper } from '../utils/DriverHelper';
+
+@injectable()
+export class LanguageServerTests {
+
+    constructor(
+        @inject(CLASSES.Editor) private readonly editor: Editor,
+        @inject(CLASSES.Ide) private readonly ide: Ide,
+        @inject(CLASSES.TopMenu) private readonly topMenu: TopMenu,
+        @inject(CLASSES.DebugView) private readonly debugView: DebugView,
+        @inject(CLASSES.BrowserTabsUtil) private readonly browserTabsUtil: BrowserTabsUtil,
+        @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) { }
+
+    public errorHighlighting(openedTab: string, textToWrite: string, line: number) {
+        test('Error highlighting', async () => {
+            await this.editor.type(openedTab, textToWrite, line);
+            try {
+                await this.editor.waitErrorInLine(line);
+            } catch (err) {
+                if (!(err instanceof error.TimeoutError)) {
+                    throw err;
+                }
+            }
+            for (let i = 0; i < textToWrite.length; i++) {
+                await this.editor.performKeyCombination(openedTab, Key.BACK_SPACE);
+            }
+            await this.editor.waitErrorInLineDisappearance(line);
+        });
+    }
+
+    public suggestionInvoking(openedTab: string, line: number, char: number, suggestionText: string) {
+        test('Suggestion invoking', async () => {
+            await this.ide.closeAllNotifications();
+            await this.editor.waitEditorAvailable(openedTab);
+            await this.editor.clickOnTab(openedTab);
+            await this.editor.waitEditorAvailable(openedTab);
+            await this.editor.waitTabFocused(openedTab);
+            await this.editor.moveCursorToLineAndChar(openedTab, line, char);
+            await this.editor.pressControlSpaceCombination(openedTab);
+            await this.editor.waitSuggestion(openedTab, suggestionText);
+        });
+    }
+
+    public autocomplete(openedTab: string, line: number, char: number, expectedText: string) {
+        test('Autocomplete', async () => {
+            await this.editor.moveCursorToLineAndChar(openedTab, line, char);
+            await this.editor.pressControlSpaceCombination(openedTab);
+            await this.editor.waitSuggestionContainer();
+            await this.editor.waitSuggestionWithScrolling(openedTab, expectedText);
+        });
+    }
+
+    public waitLSInitialization(startingNote: string, alternateNote: string = '', startTimeout: number = TimeoutConstants.TS_SELENIUM_LANGUAGE_SERVER_START_TIMEOUT) {
+        test('LS initialization', async () => {
+            try {
+                await this.ide.checkLsInitializationStart(startingNote);
+            } catch (err) {
+                if (alternateNote.length === 0) {
+                    throw err;
+                }
+                if (!(err instanceof error.TimeoutError)) {
+                    throw err;
+                }
+                Logger.warn('Known flakiness has occurred https://github.com/eclipse/che/issues/17864');
+                await this.ide.waitStatusBarContains(alternateNote);
+                await this.ide.waitStatusBarTextAbsence(alternateNote, startTimeout);
+                return;
+            }
+            await this.ide.waitStatusBarTextAbsence(startingNote, startTimeout);
+            Logger.debug('Starting note successfully disappeared.');
+            if (alternateNote.length > 0) {
+                Logger.debug('AlternateNote value is set, waiting for presence and disappearance.');
+                await this.ide.waitStatusBarContains(alternateNote);
+                await this.ide.waitStatusBarTextAbsence(alternateNote, startTimeout);
+            }
+            Logger.debug('Language Server successfully initialized.');
+        });
+    }
+
+    public goToDefinition(openedFile: string, line: number, char: number, codeNavigationClassName: string, timeout : number = TimeoutConstants.TS_EDITOR_TAB_INTERACTION_TIMEOUT) {
+        test('Go to Definition', async () => {
+            try {
+                await this.editor.moveCursorToLineAndChar(openedFile, line, char);
+                await this.editor.performKeyCombination(openedFile, Key.chord(Key.CONTROL, Key.F11));
+                await this.editor.waitEditorAvailable(codeNavigationClassName, timeout);
+            } catch (err) {
+                // https://github.com/eclipse/che/issues/17411 was fixed by adding a retry
+                if (err instanceof error.TimeoutError) {
+                    Logger.warn('Code navigation (definition) didn\'t work. Trying again.');
+                    try {
+                        await this.editor.moveCursorToLineAndChar(openedFile, line, char);
+                        await this.editor.performKeyCombination(openedFile, Key.chord(Key.CONTROL, Key.F11));
+                        await this.editor.waitEditorAvailable(codeNavigationClassName, timeout);
+                    } catch (err) {
+                        Logger.error('Code navigation (definition) didn\'t work even after retrying.');
+                        throw err;
+                    }
+                } else {
+                    Logger.error('Code navigation (definition) failed with unexpected exception.');
+                    throw err;
+                }
+            }
+        });
+    }
+
+    public goToImplementations(openedFile: string, line: number, char: number, codeNavigationClassName: string, timeout : number = TimeoutConstants.TS_EDITOR_TAB_INTERACTION_TIMEOUT) {
+        test('Go to Implementations', async () => {
+            try {
+                await this.editor.moveCursorToLineAndChar(openedFile, line, char);
+                await this.editor.performKeyCombination(openedFile, Key.chord(Key.CONTROL, Key.F12));
+                await this.editor.waitEditorAvailable(codeNavigationClassName, timeout);
+            } catch (err) {
+                // https://github.com/eclipse/che/issues/17411 was fixed by adding a retry
+                if (err instanceof error.TimeoutError) {
+                    Logger.warn('Code navigation (implementations) didn\'t work. Trying again.');
+                    try {
+                        await this.editor.moveCursorToLineAndChar(openedFile, line, char);
+                        await this.editor.performKeyCombination(openedFile, Key.chord(Key.CONTROL, Key.F12));
+                        await this.editor.waitEditorAvailable(codeNavigationClassName, timeout);
+                    } catch (err) {
+                        Logger.error('Code navigation (implementations) didn\'t work even after retrying.');
+                        throw err;
+                    }
+                } else {
+                    Logger.error('Code navigation (implementations) failed with unexpected exception.');
+                    throw err;
+                }
+            }
+        });
+    }
+
+    public startAndAttachDebugger(openedFile: string) {
+        test('Open debug panel', async () => {
+            await this.editor.selectTab(openedFile);
+            await this.topMenu.selectOption('View', 'Debug');
+            await this.ide.waitLeftToolbarButton(LeftToolbarButton.Debug);
+        });
+
+        test('Run debug', async () => {
+            try {
+                await this.debugView.clickOnRunDebugButton();
+            } catch (err) {
+                // debug config is probably missing, refresh IDE and try again https://github.com/eclipse/che/issues/19887
+                await this.browserTabsUtil.refreshPage();
+                await this.driverHelper.wait(TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
+                await this.ide.waitAndSwitchToIdeFrame();
+                await this.driverHelper.wait(TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM);
+                await this.debugView.clickOnRunDebugButton();
+            }
+        });
+    }
+
+    public startAndAttachDebuggerWithConfiguration(openedFile: string, configurationName: string) {
+        test('Open debug panel', async () => {
+            await this.editor.selectTab(openedFile);
+            await this.topMenu.selectOption('View', 'Debug');
+            await this.ide.waitLeftToolbarButton(LeftToolbarButton.Debug);
+        });
+
+        test('Run debug', async () => {
+            try {
+                await this.debugView.clickOnDebugConfigurationDropDown();
+                await this.debugView.clickOnDebugConfigurationItem(configurationName);
+                await this.debugView.clickOnRunDebugButton();
+            } catch (err) {
+                // debug config is probably missing, refresh IDE and try again https://github.com/eclipse/che/issues/19887
+                await this.browserTabsUtil.refreshPage();
+                await this.driverHelper.wait(TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
+                await this.ide.waitAndSwitchToIdeFrame();
+                await this.driverHelper.wait(TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM);
+                await this.debugView.clickOnDebugConfigurationDropDown();
+                await this.debugView.clickOnDebugConfigurationItem(configurationName);
+                await this.debugView.clickOnRunDebugButton();
+            }
+        });
+    }
+
+    public setBreakpoint(openedFile: string, line: number) {
+        test('Activating breakpoint', async () => {
+            await this.editor.activateBreakpoint(openedFile, line);
+        });
+    }
+
+    public checkDebuggerStoppedAtBreakpoint(openedFile: string, line: number, timeout: number) {
+        test('Check that debug stopped at the breakpoint', async () => {
+            await this.editor.waitStoppedDebugBreakpoint(openedFile, line, timeout);
+        });
+    }
+}

package/testsLibrary/ProjectAndFileTests.ts

@@ -0,0 +1,82 @@
+/*********************************************************************
+ * 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 'reflect-metadata';
+import { inject, injectable } from 'inversify';
+import { By } from 'selenium-webdriver';
+import { Ide } from '../pageobjects/ide/Ide';
+import { ProjectTree } from '../pageobjects/ide/ProjectTree';
+import { Editor } from '../pageobjects/ide/Editor';
+import { TimeoutConstants } from '../TimeoutConstants';
+import { DriverHelper } from '../utils/DriverHelper';
+import { CLASSES } from '../inversify.types';
+
+@injectable()
+export class ProjectAndFileTests {
+
+    constructor(
+        @inject(CLASSES.Ide) private readonly ide: Ide,
+        @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper,
+        @inject(CLASSES.ProjectTree) private readonly projectTree: ProjectTree,
+        @inject(CLASSES.Editor) private readonly editor: Editor) {}
+
+    public waitWorkspaceReadiness(sampleName : string, folder: string, checkNotification: boolean = true, restartWorkspaceDialogIsExpected: boolean = false) {
+        test('Wait for workspace readiness', async () => {
+            await this.ide.waitAndSwitchToIdeFrame();
+            await this.ide.waitIde(TimeoutConstants.TS_SELENIUM_START_WORKSPACE_TIMEOUT);
+            if (checkNotification) {
+                await this.ide.waitNotificationAndClickOnButton('Do you trust the authors of', 'Yes, I trust', 60_000);
+            }
+            if (restartWorkspaceDialogIsExpected) {
+                await this.ide.clickOnCancelDialogButton();
+
+            }
+            await this.projectTree.openProjectTreeContainer();
+            await this.projectTree.waitProjectImported(sampleName, folder);
+        });
+    }
+
+    public waitWorkspaceReadinessNoSubfolder(sampleName : string, checkNotification: boolean = true) {
+        test('Wait for workspace readiness', async () => {
+            await this.ide.waitAndSwitchToIdeFrame();
+            await this.ide.waitIde(TimeoutConstants.TS_SELENIUM_START_WORKSPACE_TIMEOUT);
+            if (checkNotification) {
+                await this.ide.waitNotificationAndClickOnButton('Do you trust the authors of', 'Yes, I trust', 60_000);
+            }
+            await this.projectTree.openProjectTreeContainer();
+            await this.projectTree.waitProjectImportedNoSubfolder(sampleName);
+        });
+    }
+
+    public openFile(filePath: string, fileName: string) {
+        test('Expand project and open file in editor', async () => {
+            await this.projectTree.expandPathAndOpenFile(filePath, fileName);
+            await this.editor.selectTab(fileName);
+        });
+    }
+
+    public checkFilePresence(filePath: string, timeout: number) {
+        test('Check that file is present in project', async () => {
+            await this.projectTree.waitItem(filePath, timeout);
+        });
+    }
+
+    public checkFileNotExists(filePath: string) {
+        test('Check that file is not exist in project', async () => {
+            await this.projectTree.waitItemDisappearance(filePath);
+        });
+    }
+
+    public checkProjectBranchName(branchName: string) {
+        test('Check branch name is ${}', async () => {
+            await this.driverHelper.waitVisibility(By.xpath(`//div[@id='theia-statusBar']/div//span[text()=' ${branchName}']`));
+        });
+    }
+}

package/testsLibrary/WorkspaceHandlingTests.ts

@@ -0,0 +1,68 @@
+/*********************************************************************
+ * 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 'reflect-metadata';
+import { inject, injectable } from 'inversify';
+import { CLASSES } from '../inversify.types';
+import { Dashboard } from '../pageobjects/dashboard/Dashboard';
+import { CreateWorkspace } from '../pageobjects/dashboard/CreateWorkspace';
+import { Workspaces } from '../pageobjects/dashboard/Workspaces';
+import { WorkspaceNameHandler } from '../utils/WorkspaceNameHandler';
+
+@injectable()
+export class WorkspaceHandlingTests {
+
+    private static workspaceName: string = 'undefined';
+
+    public static getWorkspaceName(): string {
+        return WorkspaceHandlingTests.workspaceName;
+    }
+
+    constructor(
+        @inject(CLASSES.Dashboard) private readonly dashboard: Dashboard,
+        @inject(CLASSES.CreateWorkspace) private readonly createWorkspace: CreateWorkspace,
+        @inject(CLASSES.Workspaces) private readonly workspaces: Workspaces,
+        @inject(CLASSES.WorkspaceNameHandler) private readonly workspaceNameHandler: WorkspaceNameHandler) {}
+
+    public createAndOpenWorkspace(stack: string) {
+        test(`Open 'New Workspace' page`, async () => {
+            await this.dashboard.waitPage();
+            await this.dashboard.clickCreateWorkspaceButton();
+            await this.createWorkspace.waitPage();
+            await this.createWorkspace.clickOnSample(stack);
+            await this.dashboard.waitWorkspaceStartingPage();
+            WorkspaceHandlingTests.workspaceName = await this.workspaceNameHandler.getNameFromUrl();
+        });
+    }
+
+    public openExistingWorkspace(workspaceName: string) {
+        test('Start workspace', async () => {
+            await this.dashboard.waitPage();
+            await this.dashboard.clickWorkspacesButton();
+            await this.workspaces.waitPage();
+            await this.workspaces.clickOpenButton(workspaceName);
+        });
+    }
+
+    public async stopWorkspace(workspaceName: string) {
+        await this.dashboard.openDashboard();
+        await this.dashboard.stopWorkspaceByUI(workspaceName);
+    }
+
+    public async removeWorkspace(workspaceName: string) {
+        await this.dashboard.openDashboard();
+        await this.dashboard.deleteStoppedWorkspaceByUI(workspaceName);
+    }
+
+    public async stopAndRemoveWorkspace(workspaceName: string) {
+        await this.dashboard.openDashboard();
+        await this.dashboard.stopAndRemoveWorkspaceByUI(workspaceName);
+    }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "skipLibCheck": true,
+    "target": "es2017",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+
+    "outDir": "dist",
+    "lib": ["es2017", "dom"],
+    "types": ["reflect-metadata", "@types/mocha", "@types/node"],
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "sourceMap": true
+  }
+}