@theia/playwright 1.37.0-next.8 → 1.37.0

package/src/theia-output-channel.ts

@@ -0,0 +1,88 @@
+// *****************************************************************************
+// Copyright (C) 2023 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 { TheiaOutputView } from './theia-output-view';
+import { TheiaPageObject } from './theia-page-object';
+import { isElementVisible } from './util';
+import { TheiaMonacoEditor } from './theia-monaco-editor';
+
+export interface TheiaOutputViewChannelData {
+    viewSelector: string;
+    dataUri: string;
+    channelName: string;
+}
+
+export class TheiaOutputViewChannel extends TheiaPageObject {
+
+    protected monacoEditor: TheiaMonacoEditor;
+
+    constructor(protected readonly data: TheiaOutputViewChannelData, protected readonly outputView: TheiaOutputView) {
+        super(outputView.app);
+        this.monacoEditor = new TheiaMonacoEditor(this.viewSelector, outputView.app);
+    }
+
+    protected get viewSelector(): string {
+        return this.data.viewSelector;
+    }
+
+    protected get dataUri(): string | undefined {
+        return this.data.dataUri;
+    }
+
+    protected get channelName(): string | undefined {
+        return this.data.channelName;
+    }
+
+    async waitForVisible(): Promise<void> {
+        await this.page.waitForSelector(this.viewSelector, { state: 'visible' });
+    }
+
+    async isDisplayed(): Promise<boolean> {
+        return isElementVisible(this.viewElement());
+    }
+
+    protected viewElement(): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
+        return this.page.$(this.viewSelector);
+    }
+
+    async numberOfLines(): Promise<number | undefined> {
+        await this.waitForVisible();
+        return this.monacoEditor.numberOfLines();
+    }
+
+    async maxSeverityOfLineByLineNumber(lineNumber: number): Promise<'error' | 'warning' | 'info'> {
+        await this.waitForVisible();
+        const lineElement = await this.monacoEditor.lineByLineNumber(lineNumber);
+        const contents = await lineElement?.$$('span > span.mtk1');
+        if (!contents || contents.length < 1) {
+            throw new Error(`Could not find contents of line number ${lineNumber}!`);
+        }
+        const severityClassNames = await Promise.all(contents.map(
+            async content => (await content.getAttribute('class'))?.split(' ')[1]));
+
+        if (severityClassNames.includes('theia-output-error')) {
+            return 'error';
+        } else if (severityClassNames.includes('theia-output-warning')) {
+            return 'warning';
+        }
+        return 'info';
+    }
+
+    async textContentOfLineByLineNumber(lineNumber: number): Promise<string | undefined> {
+        return this.monacoEditor.textContentOfLineByLineNumber(lineNumber);
+    }
+}

package/src/theia-output-view.ts

@@ -0,0 +1,87 @@
+// *****************************************************************************
+// Copyright (C) 2023 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 { TheiaApp } from './theia-app';
+import { TheiaOutputViewChannel } from './theia-output-channel';
+import { TheiaView } from './theia-view';
+import { normalizeId } from './util';
+
+const TheiaOutputViewData = {
+    tabSelector: '#shell-tab-outputView',
+    viewSelector: '#outputView',
+    viewName: 'Output'
+};
+
+export class TheiaOutputView extends TheiaView {
+    constructor(app: TheiaApp) {
+        super(TheiaOutputViewData, app);
+    }
+
+    async isOutputChannelSelected(outputChannelName: string): Promise<boolean> {
+        await this.activate();
+        const contentPanel = await this.page.$('#theia-bottom-content-panel');
+        if (contentPanel && (await contentPanel.isVisible())) {
+            const channelList = await contentPanel.$('#outputChannelList');
+            const selectedChannel = await channelList?.$('div.theia-select-component-label');
+            if (selectedChannel && (await selectedChannel.textContent()) === outputChannelName) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    async getOutputChannel(outputChannelName: string): Promise<TheiaOutputViewChannel | undefined> {
+        await this.activate();
+        const channel = new TheiaOutputViewChannel(
+            {
+                viewSelector: 'div.p-Widget.theia-editor.p-DockPanel-widget > div.monaco-editor',
+                dataUri: normalizeId(`output:/${encodeURIComponent(outputChannelName)}`),
+                channelName: outputChannelName
+            },
+            this
+        );
+        await channel.waitForVisible();
+        if (await channel.isDisplayed()) {
+            return channel;
+        }
+        return undefined;
+    }
+
+    async selectOutputChannel(outputChannelName: string): Promise<boolean> {
+        await this.activate();
+        const contentPanel = await this.page.$('#theia-bottom-content-panel');
+        if (contentPanel && (await contentPanel.isVisible())) {
+            const channelSelectComponent = await contentPanel.$('#outputChannelList');
+            if (!channelSelectComponent) {
+                throw Error('Output Channel List not visible.');
+            }
+            // open output channel list component
+            await channelSelectComponent.click();
+            const channelContainer = await this.page.waitForSelector('#select-component-container > div.theia-select-component-dropdown');
+            if (!channelContainer) {
+                throw Error('Output Channel List could not be opened.');
+            }
+            const channels = await channelContainer.$$('div.theia-select-component-option-value');
+            for (const channel of channels) {
+                if (await channel.textContent() === outputChannelName) {
+                    await channel.click();
+                }
+            }
+            return this.isOutputChannelSelected(outputChannelName);
+        }
+        return false;
+    }
+}

package/src/theia-quick-command-palette.ts

@@ -27,6 +27,11 @@ export class TheiaQuickCommandPalette extends TheiaPageObject {
         await this.page.waitForSelector(this.selector);
     }
 
+    async hide(): Promise<void> {
+        await this.page.keyboard.press('Escape');
+        await this.page.waitForSelector(this.selector, { state: 'hidden' });
+    }
+
     async isOpen(): Promise<boolean> {
         try {
             await this.page.waitForSelector(this.selector, { timeout: 5000 });
@@ -54,14 +59,17 @@ export class TheiaQuickCommandPalette extends TheiaPageObject {
         await this.page.keyboard.press('Enter');
     }
 
-    async type(command: string): Promise<void> {
+    async type(value: string, confirm = false): Promise<void> {
         if (!await this.isOpen()) {
             this.open();
         }
         const input = await this.page.waitForSelector(`${this.selector} .monaco-inputbox .input`);
         if (input != null) {
             await input.focus();
-            await input.type(command, { delay: USER_KEY_TYPING_DELAY });
+            await input.type(value, { delay: USER_KEY_TYPING_DELAY });
+            if (confirm) {
+                await this.page.keyboard.press('Enter');
+            }
         }
     }
 

package/src/theia-terminal.ts

@@ -0,0 +1,69 @@
+// *****************************************************************************
+// Copyright (C) 2023 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 { TheiaView } from './theia-view';
+
+export class TheiaTerminal extends TheiaView {
+
+    constructor(tabId: string, app: TheiaApp) {
+        super({
+            tabSelector: `#shell-tab-terminal-${getTerminalId(tabId)}`,
+            viewSelector: `#terminal-${getTerminalId(tabId)}`
+        }, app);
+    }
+
+    async submit(text: string): Promise<void> {
+        await this.write(text);
+        const input = await this.waitForInputArea();
+        await input.press('Enter');
+    }
+
+    async write(text: string): Promise<void> {
+        await this.activate();
+        const input = await this.waitForInputArea();
+        await input.type(text);
+    }
+
+    async contents(): Promise<string> {
+        await this.activate();
+        await (await this.openContextMenu()).clickMenuItem('Select All');
+        await (await this.openContextMenu()).clickMenuItem('Copy');
+        return this.page.evaluate('navigator.clipboard.readText()');
+    }
+
+    protected async openContextMenu(): Promise<TheiaMenu> {
+        await this.activate();
+        return TheiaContextMenu.open(this.app, () => this.waitForVisibleView());
+    }
+
+    protected async waitForInputArea(): Promise<ElementHandle<SVGElement | HTMLElement>> {
+        const view = await this.waitForVisibleView();
+        return view.waitForSelector('.xterm-helper-textarea');
+    }
+
+    protected async waitForVisibleView(): Promise<ElementHandle<SVGElement | HTMLElement>> {
+        return this.page.waitForSelector(this.viewSelector, { state: 'visible' });
+    }
+
+}
+
+function getTerminalId(tabId: string): string {
+    return tabId.substring(tabId.lastIndexOf('-') + 1);
+}

package/src/theia-text-editor.ts

@@ -20,9 +20,12 @@ import { join } from 'path';
 import { TheiaApp } from './theia-app';
 import { TheiaEditor } from './theia-editor';
 import { normalizeId, OSUtil, urlEncodePath } from './util';
+import { TheiaMonacoEditor } from './theia-monaco-editor';
 
 export class TheiaTextEditor extends TheiaEditor {
 
+    protected monacoEditor: TheiaMonacoEditor;
+
     constructor(filePath: string, app: TheiaApp) {
         // shell-tab-code-editor-opener:file:///c%3A/Users/user/AppData/Local/Temp/cloud-ws-JBUhb6/sample.txt:1
         // code-editor-opener:file:///c%3A/Users/user/AppData/Local/Temp/cloud-ws-JBUhb6/sample.txt:1
@@ -30,19 +33,16 @@ export class TheiaTextEditor extends TheiaEditor {
             tabSelector: normalizeId(`#shell-tab-code-editor-opener:file://${urlEncodePath(join(app.workspace.escapedPath, OSUtil.fileSeparator, filePath))}:1`),
             viewSelector: normalizeId(`#code-editor-opener:file://${urlEncodePath(join(app.workspace.escapedPath, OSUtil.fileSeparator, filePath))}:1`) + '.theia-editor'
         }, app);
+        this.monacoEditor = new TheiaMonacoEditor(this.viewSelector, 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;
+        return this.monacoEditor.numberOfLines();
     }
 
     async textContentOfLineByLineNumber(lineNumber: number): Promise<string | undefined> {
-        const lineElement = await this.lineByLineNumber(lineNumber);
-        const content = await lineElement?.textContent();
-        return content ? this.replaceEditorSymbolsWithSpace(content) : undefined;
+        return this.monacoEditor.textContentOfLineByLineNumber(lineNumber);
     }
 
     async replaceLineWithLineNumber(text: string, lineNumber: number): Promise<void> {
@@ -57,14 +57,14 @@ export class TheiaTextEditor extends TheiaEditor {
 
     async selectLineWithLineNumber(lineNumber: number): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
         await this.activate();
-        const lineElement = await this.lineByLineNumber(lineNumber);
+        const lineElement = await this.monacoEditor.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);
+        const lineElement = await this.monacoEditor.lineByLineNumber(lineNumber);
         await this.placeCursorInLine(lineElement);
         return lineElement;
     }
@@ -74,28 +74,9 @@ export class TheiaTextEditor extends TheiaEditor {
         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;
+        return this.monacoEditor.textContentOfLineContainingText(text);
     }
 
     async replaceLineContainingText(newText: string, oldText: string): Promise<void> {
@@ -105,14 +86,14 @@ export class TheiaTextEditor extends TheiaEditor {
 
     async selectLineContainingText(text: string): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
         await this.activate();
-        const lineElement = await this.lineContainingText(text);
+        const lineElement = await this.monacoEditor.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);
+        const lineElement = await this.monacoEditor.lineContainingText(text);
         await this.placeCursorInLine(lineElement);
         return lineElement;
     }
@@ -123,7 +104,7 @@ export class TheiaTextEditor extends TheiaEditor {
     }
 
     async addTextToNewLineAfterLineContainingText(textContainedByExistingLine: string, newText: string): Promise<void> {
-        const existingLine = await this.lineContainingText(textContainedByExistingLine);
+        const existingLine = await this.monacoEditor.lineContainingText(textContainedByExistingLine);
         await this.placeCursorInLine(existingLine);
         await this.page.keyboard.press('End');
         await this.page.keyboard.press('Enter');
@@ -131,18 +112,13 @@ export class TheiaTextEditor extends TheiaEditor {
     }
 
     async addTextToNewLineAfterLineByLineNumber(lineNumber: number, newText: string): Promise<void> {
-        const existingLine = await this.lineByLineNumber(lineNumber);
+        const existingLine = await this.monacoEditor.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 });
     }
@@ -151,13 +127,6 @@ export class TheiaTextEditor extends TheiaEditor {
         await lineElement?.click();
     }
 
-    protected replaceEditorSymbolsWithSpace(content: string): string | Promise<string | undefined> {
-        // [ ] &nbsp; => \u00a0 -- NO-BREAK SPACE
-        // [·] &middot; => \u00b7 -- MIDDLE DOT
-        // [] &zwnj; => \u200c -- ZERO WIDTH NON-JOINER
-        return content.replace(/[\u00a0\u00b7]/g, ' ').replace(/[\u200c]/g, '');
-    }
-
     protected async selectedSuggestion(): Promise<ElementHandle<SVGElement | HTMLElement>> {
         return this.page.waitForSelector(this.viewSelector + ' .monaco-list-row.show-file-icons.focused');
     }

package/src/theia-toolbar-item.ts

@@ -0,0 +1,41 @@
+// *****************************************************************************
+// Copyright (C) 2023 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 { TheiaPageObject } from './theia-page-object';
+
+export class TheiaToolbarItem extends TheiaPageObject {
+    constructor(app: TheiaApp, protected element: ElementHandle<SVGElement | HTMLElement>) {
+        super(app);
+    }
+
+    async commandId(): Promise<string | null> {
+        return this.element.getAttribute('id');
+    }
+
+    async isEnabled(): Promise<boolean> {
+        const classAttribute = await this.element.getAttribute('class');
+        if (classAttribute === undefined || classAttribute === null) {
+            return false;
+        }
+        return classAttribute.includes('enabled');
+    }
+
+    async trigger(): Promise<void> {
+        await this.element.click();
+    }
+}

package/src/theia-toolbar.ts

@@ -0,0 +1,99 @@
+// *****************************************************************************
+// Copyright (C) 2023 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 { TheiaPageObject } from './theia-page-object';
+import { TheiaToolbarItem } from './theia-toolbar-item';
+
+export class TheiaToolbar extends TheiaPageObject {
+    selector = 'div#main-toolbar.p-TabBar-toolbar';
+
+    protected async toolbarElementHandle(): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
+        return this.page.$(this.selector);
+    }
+
+    async waitForVisible(): Promise<void> {
+        await this.page.waitForSelector(this.selector, { state: 'visible' });
+    }
+
+    async isShown(): Promise<boolean> {
+        const statusBar = await this.toolbarElementHandle();
+        return !!statusBar && statusBar.isVisible();
+    }
+
+    async show(): Promise<void> {
+        if (!await this.isShown()) {
+            await this.toggle();
+        }
+    }
+
+    async hide(): Promise<void> {
+        if (await this.isShown()) {
+            await this.toggle();
+        }
+    }
+
+    async toggle(): Promise<void> {
+        const isShown = await this.isShown();
+        const viewMenu = await this.app.menuBar.openMenu('View');
+        await viewMenu.clickMenuItem('Toggle Toolbar');
+        isShown ? await this.waitUntilHidden() : await this.waitUntilShown();
+    }
+
+    async waitUntilHidden(): Promise<void> {
+        await this.page.waitForSelector(this.selector, { state: 'hidden' });
+    }
+
+    async waitUntilShown(): Promise<void> {
+        await this.page.waitForSelector(this.selector, { state: 'visible' });
+    }
+
+    async toolbarItems(): Promise<TheiaToolbarItem[]> {
+        const toolbarHandle = await this.toolbarElementHandle();
+        if (!toolbarHandle) {
+            return [];
+        }
+        const items = await toolbarHandle.$$(this.toolBarItemSelector());
+        return items.map(element => new TheiaToolbarItem(this.app, element));
+    }
+
+    async toolbarItemIds(): Promise<string[]> {
+        const items = await this.toolbarItems();
+        return this.toCommandIdArray(items);
+    }
+
+    async toolBarItem(commandId: string): Promise<TheiaToolbarItem | undefined> {
+        const toolbarHandle = await this.toolbarElementHandle();
+        if (!toolbarHandle) {
+            return undefined;
+        }
+        const item = await toolbarHandle.$(this.toolBarItemSelector(commandId));
+        if (item) {
+            return new TheiaToolbarItem(this.app, item);
+        }
+        return undefined;
+    }
+
+    protected toolBarItemSelector(toolbarItemId = ''): string {
+        return `div.toolbar-item${toolbarItemId ? `[id="${toolbarItemId}"]` : ''}`;
+    }
+
+    protected async toCommandIdArray(items: TheiaToolbarItem[]): Promise<string[]> {
+        const contents = items.map(item => item.commandId());
+        const resolvedContents = await Promise.all(contents);
+        return resolvedContents.filter(id => id !== undefined) as string[];
+    }
+}

package/src/theia-tree-node.ts

@@ -45,7 +45,7 @@ export class TheiaTreeNode {
     }
 
     async expand(): Promise<void> {
-        if (! await this.isCollapsed()) {
+        if (!await this.isCollapsed()) {
             return;
         }
         const expansionToggle = await this.elementHandle.waitForSelector(this.expansionToggleCssClass);
@@ -53,6 +53,15 @@ export class TheiaTreeNode {
         await this.elementHandle.waitForSelector(`${this.expansionToggleCssClass}:not(${this.collapsedCssClass})`);
     }
 
+    async collapse(): Promise<void> {
+        if (await this.isCollapsed()) {
+            return;
+        }
+        const expansionToggle = await this.elementHandle.waitForSelector(this.expansionToggleCssClass);
+        await expansionToggle.click();
+        await this.elementHandle.waitForSelector(`${this.expansionToggleCssClass}${this.collapsedCssClass}`);
+    }
+
     async openContextMenu(): Promise<TheiaMenu> {
         return TheiaContextMenu.open(this.app, () => this.elementHandle.waitForSelector(this.labelElementCssClass));
     }