@theia/playwright 1.23.0-next.26

package/src/theia-text-editor.ts

@@ -0,0 +1,168 @@
+/********************************************************************************
+ * Copyright (C) 2021 logi.cals GmbH, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { ElementHandle } from '@playwright/test';
+
+import { TheiaApp } from './theia-app';
+import { TheiaEditor } from './theia-editor';
+import { normalizeId } from './util';
+
+export class TheiaTextEditor extends TheiaEditor {
+
+    constructor(filePath: string, app: TheiaApp) {
+        super({
+            tabSelector: normalizeId(`#shell-tab-code-editor-opener:file://${app.workspace.escapedPath}/${filePath}:1`),
+            viewSelector: normalizeId(`#code-editor-opener:file://${app.workspace.escapedPath}/${filePath}:1`) + '.theia-editor'
+        }, app);
+    }
+
+    async numberOfLines(): Promise<number | undefined> {
+        await this.activate();
+        const viewElement = await this.viewElement();
+        const lineElements = await viewElement?.$$('.view-lines .view-line');
+        return lineElements?.length;
+    }
+
+    async textContentOfLineByLineNumber(lineNumber: number): Promise<string | undefined> {
+        const lineElement = await this.lineByLineNumber(lineNumber);
+        const content = await lineElement?.textContent();
+        return content ? this.replaceEditorSymbolsWithSpace(content) : undefined;
+    }
+
+    async replaceLineWithLineNumber(text: string, lineNumber: number): Promise<void> {
+        await this.selectLineWithLineNumber(lineNumber);
+        await this.typeTextAndHitEnter(text);
+    }
+
+    protected async typeTextAndHitEnter(text: string): Promise<void> {
+        await this.page.keyboard.type(text);
+        await this.page.keyboard.press('Enter');
+    }
+
+    async selectLineWithLineNumber(lineNumber: number): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+        await this.activate();
+        const lineElement = await this.lineByLineNumber(lineNumber);
+        await this.selectLine(lineElement);
+        return lineElement;
+    }
+
+    async placeCursorInLineWithLineNumber(lineNumber: number): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+        await this.activate();
+        const lineElement = await this.lineByLineNumber(lineNumber);
+        await this.placeCursorInLine(lineElement);
+        return lineElement;
+    }
+
+    async deleteLineByLineNumber(lineNumber: number): Promise<void> {
+        await this.selectLineWithLineNumber(lineNumber);
+        await this.page.keyboard.press('Backspace');
+    }
+
+    protected async lineByLineNumber(lineNumber: number): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+        await this.activate();
+        const viewElement = await this.viewElement();
+        const lines = await viewElement?.$$('.view-lines .view-line');
+        if (!lines) {
+            throw new Error(`Couldn't retrieve lines of text editor ${this.tabSelector}`);
+        }
+
+        const linesWithXCoordinates = [];
+        for (const lineElement of lines) {
+            const box = await lineElement.boundingBox();
+            linesWithXCoordinates.push({ x: box ? box.x : Number.MAX_VALUE, lineElement });
+        }
+        linesWithXCoordinates.sort((a, b) => a.x.toString().localeCompare(b.x.toString()));
+        return linesWithXCoordinates[lineNumber - 1].lineElement;
+    }
+
+    async textContentOfLineContainingText(text: string): Promise<string | undefined> {
+        await this.activate();
+        const lineElement = await this.lineContainingText(text);
+        const content = await lineElement?.textContent();
+        return content ? this.replaceEditorSymbolsWithSpace(content) : undefined;
+    }
+
+    async replaceLineContainingText(newText: string, oldText: string): Promise<void> {
+        await this.selectLineContainingText(oldText);
+        await this.typeTextAndHitEnter(newText);
+    }
+
+    async selectLineContainingText(text: string): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+        await this.activate();
+        const lineElement = await this.lineContainingText(text);
+        await this.selectLine(lineElement);
+        return lineElement;
+    }
+
+    async placeCursorInLineContainingText(text: string): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+        await this.activate();
+        const lineElement = await this.lineContainingText(text);
+        await this.placeCursorInLine(lineElement);
+        return lineElement;
+    }
+
+    async deleteLineContainingText(text: string): Promise<void> {
+        await this.selectLineContainingText(text);
+        await this.page.keyboard.press('Backspace');
+    }
+
+    async addTextToNewLineAfterLineContainingText(textContainedByExistingLine: string, newText: string): Promise<void> {
+        const existingLine = await this.lineContainingText(textContainedByExistingLine);
+        await this.placeCursorInLine(existingLine);
+        await this.page.keyboard.press('End');
+        await this.page.keyboard.press('Enter');
+        await this.page.keyboard.type(newText);
+    }
+
+    async addTextToNewLineAfterLineByLineNumber(lineNumber: number, newText: string): Promise<void> {
+        const existingLine = await this.lineByLineNumber(lineNumber);
+        await this.placeCursorInLine(existingLine);
+        await this.page.keyboard.press('End');
+        await this.page.keyboard.press('Enter');
+        await this.page.keyboard.type(newText);
+    }
+
+    protected async lineContainingText(text: string): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+        const viewElement = await this.viewElement();
+        return viewElement?.waitForSelector(`.view-lines .view-line:has-text("${text}")`);
+    }
+
+    protected async selectLine(lineElement: ElementHandle<SVGElement | HTMLElement> | undefined): Promise<void> {
+        await lineElement?.click({ clickCount: 3 });
+    }
+
+    protected async placeCursorInLine(lineElement: ElementHandle<SVGElement | HTMLElement> | undefined): Promise<void> {
+        await lineElement?.click();
+    }
+
+    protected replaceEditorSymbolsWithSpace(content: string): string | Promise<string | undefined> {
+        // [ ] &nbsp; => \u00a0
+        // [·] &middot; => \u00b7
+        return content.replace(/[\u00a0\u00b7]/g, ' ');
+    }
+
+    protected async selectedSuggestion(): Promise<ElementHandle<SVGElement | HTMLElement>> {
+        return this.page.waitForSelector(this.viewSelector + ' .monaco-list-row.show-file-icons.focused');
+    }
+
+    async getSelectedSuggestionText(): Promise<string> {
+        const suggestion = await this.selectedSuggestion();
+        const text = await suggestion.textContent();
+        if (text === null) { throw new Error('Text content could not be found'); }
+        return text;
+    }
+
+}

package/src/theia-toggle-bottom-indicator.ts

@@ -0,0 +1,25 @@
+/********************************************************************************
+ * Copyright (C) 2021 logi.cals GmbH, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { TheiaStatusIndicator } from './theia-status-indicator';
+
+const TOGGLE_BOTTOM_ICON = 'codicon-window';
+
+export class TheiaToggleBottomIndicator extends TheiaStatusIndicator {
+    async isVisible(): Promise<boolean> {
+        return super.isVisible(TOGGLE_BOTTOM_ICON);
+    }
+}

package/src/theia-tree-node.ts

@@ -0,0 +1,60 @@
+/********************************************************************************
+ * Copyright (C) 2021 logi.cals GmbH, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { ElementHandle } from '@playwright/test';
+
+import { TheiaApp } from './theia-app';
+import { TheiaContextMenu } from './theia-context-menu';
+import { TheiaMenu } from './theia-menu';
+
+export class TheiaTreeNode {
+
+    labelElementCssClass = '.theia-TreeNodeSegmentGrow';
+    expansionToggleCssClass = '.theia-ExpansionToggle';
+    collapsedCssClass = '.theia-mod-collapsed';
+
+    constructor(protected elementHandle: ElementHandle<SVGElement | HTMLElement>, protected app: TheiaApp) { }
+
+    async label(): Promise<string | null> {
+        const labelNode = await this.elementHandle.$(this.labelElementCssClass);
+        if (!labelNode) {
+            throw new Error('Cannot read label of ' + this.elementHandle);
+        }
+        return labelNode.textContent();
+    }
+
+    async isCollapsed(): Promise<boolean> {
+        return !! await this.elementHandle.$(this.collapsedCssClass);
+    }
+
+    async isExpandable(): Promise<boolean> {
+        return !! await this.elementHandle.$(this.expansionToggleCssClass);
+    }
+
+    async expand(): Promise<void> {
+        if (! await this.isCollapsed()) {
+            return;
+        }
+        const expansionToggle = await this.elementHandle.waitForSelector(this.expansionToggleCssClass);
+        await expansionToggle.click();
+        await this.elementHandle.waitForSelector(`${this.expansionToggleCssClass}:not(${this.collapsedCssClass})`);
+    }
+
+    async openContextMenu(): Promise<TheiaMenu> {
+        return TheiaContextMenu.open(this.app, () => this.elementHandle.waitForSelector(this.labelElementCssClass));
+    }
+
+}

package/src/theia-view.ts

@@ -0,0 +1,177 @@
+/********************************************************************************
+ * Copyright (C) 2021 logi.cals GmbH, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { ElementHandle } from '@playwright/test';
+
+import { TheiaApp } from './theia-app';
+import { TheiaContextMenu } from './theia-context-menu';
+import { TheiaMenu } from './theia-menu';
+import { TheiaPageObject } from './theia-page-object';
+import { containsClass, isElementVisible, textContent } from './util';
+
+export interface TheiaViewData {
+    tabSelector: string;
+    viewSelector: string;
+    viewName?: string;
+}
+
+export class TheiaView extends TheiaPageObject {
+
+    constructor(protected readonly data: TheiaViewData, app: TheiaApp) {
+        super(app);
+    }
+
+    get tabSelector(): string {
+        return this.data.tabSelector;
+    }
+
+    get viewSelector(): string {
+        return this.data.viewSelector;
+    }
+
+    get name(): string | undefined {
+        return this.data.viewName;
+    }
+
+    async open(): Promise<TheiaView> {
+        if (!this.data.viewName) {
+            throw new Error('View name must be specified to open via command palette');
+        }
+        await this.app.quickCommandPalette.trigger('View: Open View...', this.data.viewName);
+        await this.waitForVisible();
+        return this;
+    }
+
+    async focus(): Promise<void> {
+        await this.activate();
+        const view = await this.viewElement();
+        await view?.click();
+    }
+
+    async activate(): Promise<void> {
+        await this.page.waitForSelector(this.tabSelector, { state: 'visible' });
+        if (!await this.isActive()) {
+            const tab = await this.tabElement();
+            await tab?.click();
+        }
+        return this.waitForVisible();
+    }
+
+    async waitForVisible(): Promise<void> {
+        await this.page.waitForSelector(this.viewSelector, { state: 'visible' });
+    }
+
+    async isTabVisible(): Promise<boolean> {
+        return isElementVisible(this.tabElement());
+    }
+
+    async isDisplayed(): Promise<boolean> {
+        return isElementVisible(this.viewElement());
+    }
+
+    async isActive(): Promise<boolean> {
+        return await this.isTabVisible() && containsClass(this.tabElement(), 'p-mod-current');
+    }
+
+    async isClosable(): Promise<boolean> {
+        return await this.isTabVisible() && containsClass(this.tabElement(), 'p-mod-closable');
+    }
+
+    async close(waitForClosed = true): Promise<void> {
+        if (!(await this.isTabVisible())) {
+            return;
+        }
+        if (!(await this.isClosable())) {
+            throw Error(`View ${this.tabSelector} is not closable`);
+        }
+        const tab = await this.tabElement();
+        const side = await this.side();
+        if (side === 'main' || side === 'bottom') {
+            const closeIcon = await tab?.waitForSelector('div.p-TabBar-tabCloseIcon');
+            await closeIcon?.click();
+        } else {
+            const menu = await this.openContextMenuOnTab();
+            const closeItem = await menu.menuItemByName('Close');
+            await closeItem?.click();
+        }
+        if (waitForClosed) {
+            await this.waitUntilClosed();
+        }
+    }
+
+    protected async waitUntilClosed(): Promise<void> {
+        await this.page.waitForSelector(this.tabSelector, { state: 'detached' });
+    }
+
+    async title(): Promise<string | undefined> {
+        if ((await this.isInSidePanel()) && !(await this.isActive())) {
+            // we can only determine the label of a side-panel view, if it is active
+            await this.activate();
+        }
+        switch (await this.side()) {
+            case 'left':
+                return textContent(this.page.waitForSelector('div.theia-left-side-panel > div.theia-sidepanel-title'));
+            case 'right':
+                return textContent(this.page.waitForSelector('div.theia-right-side-panel > div.theia-sidepanel-title'));
+        }
+        const tab = await this.tabElement();
+        if (tab) {
+            return textContent(tab.waitForSelector('div.theia-tab-icon-label > div.p-TabBar-tabLabel'));
+        }
+        return undefined;
+    }
+
+    async isInSidePanel(): Promise<boolean> {
+        return (await this.side() === 'left') || (await this.side() === 'right');
+    }
+
+    async side(): Promise<'left' | 'right' | 'bottom' | 'main'> {
+        if (!await this.isTabVisible()) {
+            throw Error(`Unable to determine side of invisible view tab '${this.tabSelector}'`);
+        }
+        const tab = await this.tabElement();
+        let appAreaElement = tab?.$('xpath=../..');
+        if (await containsClass(appAreaElement, 'theia-app-left')) {
+            return 'left';
+        }
+        if (await containsClass(appAreaElement, 'theia-app-right')) {
+            return 'right';
+        }
+
+        appAreaElement = (await appAreaElement)?.$('xpath=../..');
+        if (await containsClass(appAreaElement, 'theia-app-bottom')) {
+            return 'bottom';
+        }
+        if (await containsClass(appAreaElement, 'theia-app-main')) {
+            return 'main';
+        }
+        throw Error(`Unable to determine side of view tab '${this.tabSelector}'`);
+    }
+
+    async openContextMenuOnTab(): Promise<TheiaMenu> {
+        await this.activate();
+        return TheiaContextMenu.open(this.app, () => this.page.waitForSelector(this.tabSelector));
+    }
+
+    protected viewElement(): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
+        return this.page.$(this.viewSelector);
+    }
+
+    protected tabElement(): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
+        return this.page.$(this.tabSelector);
+    }
+
+}

package/src/theia-workspace.ts

@@ -0,0 +1,65 @@
+/********************************************************************************
+ * Copyright (C) 2021 logi.cals GmbH, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import * as fs from 'fs-extra';
+import { tmpdir } from 'os';
+import { sep } from 'path';
+import * as path from 'path';
+
+export class TheiaWorkspace {
+
+    protected workspacePath: string;
+
+    /**
+     * Creates a Theia workspace location with the specified path to files that shall be copied to this workspace.
+     * The `pathOfFilesToInitialize` must be relative to cwd of the node process.
+     *
+     * @param {string[]} pathOfFilesToInitialize Path to files or folders that shall be copied to the workspace
+     */
+    constructor(protected pathOfFilesToInitialize?: string[]) {
+        this.workspacePath = fs.mkdtempSync(`${tmpdir}${sep}cloud-ws-`);
+    }
+
+    /** Performs the file system operations preparing the workspace location synchronously. */
+    initialize(): void {
+        if (this.pathOfFilesToInitialize) {
+            for (const initPath of this.pathOfFilesToInitialize) {
+                const absoluteInitPath = path.resolve(process.cwd(), initPath);
+                if (!fs.pathExistsSync(absoluteInitPath)) {
+                    throw Error('Workspace does not exist at ' + absoluteInitPath);
+                }
+                fs.copySync(absoluteInitPath, this.workspacePath);
+            }
+        }
+    }
+
+    get path(): string {
+        return this.workspacePath;
+    }
+
+    get urlEncodedPath(): string {
+        return this.path.replace(/[\\]/g, '/');
+    }
+
+    get escapedPath(): string {
+        return this.path.replace(/:/g, '%3A').replace(/[\\]/g, '%5C');
+    }
+
+    clear(): void {
+        fs.emptyDirSync(this.workspacePath);
+    }
+
+}

package/src/util.ts

@@ -0,0 +1,72 @@
+/********************************************************************************
+ * Copyright (C) 2021 logi.cals GmbH, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { ElementHandle } from '@playwright/test';
+
+export const USER_KEY_TYPING_DELAY = 80;
+
+export function normalizeId(nodeId: string): string {
+    // Special characters (i.e. in our case '.',':','/','%', and '\\') in CSS IDs have to be escaped
+    return nodeId.replace(/[.:,%/\\]/g, matchedChar => '\\' + matchedChar);
+}
+
+export async function toTextContentArray(items: ElementHandle<SVGElement | HTMLElement>[]): Promise<string[]> {
+    const contents = items.map(item => item.textContent());
+    const resolvedContents = await Promise.all(contents);
+    return resolvedContents.filter(text => text !== undefined) as string[];
+}
+
+export function isDefined(content: string | undefined): content is string {
+    return content !== undefined;
+}
+
+export function isNotNull(content: string | null): content is string {
+    return content !== null;
+}
+
+export async function textContent(elementPromise: Promise<ElementHandle<SVGElement | HTMLElement> | null>): Promise<string | undefined> {
+    const element = await elementPromise;
+    if (!element) {
+        return undefined;
+    }
+    const content = await element.textContent();
+    return content ? content : undefined;
+}
+
+export async function containsClass(elementPromise: Promise<ElementHandle<SVGElement | HTMLElement> | null> | undefined, cssClass: string): Promise<boolean> {
+    return elementContainsClass(await elementPromise, cssClass);
+}
+
+export async function elementContainsClass(element: ElementHandle<SVGElement | HTMLElement> | null | undefined, cssClass: string): Promise<boolean> {
+    if (element) {
+        const classValue = await element.getAttribute('class');
+        if (classValue) {
+            return classValue?.split(' ').includes(cssClass);
+        }
+    }
+    return false;
+}
+
+export async function isElementVisible(elementPromise: Promise<ElementHandle<SVGElement | HTMLElement> | null>): Promise<boolean> {
+    const element = await elementPromise;
+    return element ? element.isVisible() : false;
+}
+
+export async function elementId(element: ElementHandle<SVGElement | HTMLElement>): Promise<string> {
+    const id = await element.getAttribute('id');
+    if (id === null) { throw new Error('Could not get ID of ' + element); }
+    return id;
+}