@theia/playwright 1.37.0-next.1 → 1.37.0-next.11

package/src/theia-explorer-view.ts

@@ -112,11 +112,11 @@ export class TheiaExplorerView extends TheiaView {
         return file;
     }
 
-    async fileStatNode(filePath: string): Promise<TheiaExplorerFileStatNode | undefined> {
-        return this.fileStatNodeBySegments(...filePath.split('/'));
+    async fileStatNode(filePath: string, compact = false): Promise<TheiaExplorerFileStatNode | undefined> {
+        return compact ? this.compactFileStatNode(filePath) : this.fileStatNodeBySegments(...filePath.split('/'));
     }
 
-    async fileStatNodeBySegments(...pathFragments: string[]): Promise<TheiaExplorerFileStatNode | undefined> {
+    protected async fileStatNodeBySegments(...pathFragments: string[]): Promise<TheiaExplorerFileStatNode | undefined> {
         await super.activate();
         const viewElement = await this.viewElement();
 
@@ -141,6 +141,35 @@ export class TheiaExplorerView extends TheiaView {
         return currentTreeNode;
     }
 
+    protected async compactFileStatNode(path: string): Promise<TheiaExplorerFileStatNode | undefined> {
+        // default setting `explorer.compactFolders=true` renders folders in a compact form - single child folders will be compressed in a combined tree element
+        await super.activate();
+        const viewElement = await this.viewElement();
+
+        // check if first segment folder needs to be expanded first (if folder has never been expanded, it will not show the compact folder structure)
+        await this.waitForVisibleFileNodes();
+        const firstSegment = path.split('/')[0];
+        const selector = this.treeNodeSelector(firstSegment);
+        const folderElement = await viewElement?.$(selector);
+        if (folderElement && await folderElement.isVisible()) {
+            const folderNode = await viewElement?.waitForSelector(selector, { state: 'visible' });
+            if (!folderNode) {
+                throw new Error(`Tree node '${selector}' not found in explorer`);
+            }
+            const folderFileStatNode = new TheiaExplorerFileStatNode(folderNode, this);
+            if (await folderFileStatNode.isCollapsed()) {
+                await folderFileStatNode.expand();
+            }
+        }
+        // now get tree node via the full path
+        const fullPathSelector = this.treeNodeSelector(path);
+        const treeNode = await viewElement?.waitForSelector(fullPathSelector, { state: 'visible' });
+        if (!treeNode) {
+            throw new Error(`Tree node '${fullPathSelector}' not found in explorer`);
+        }
+        return new TheiaExplorerFileStatNode(treeNode, this);
+    }
+
     async selectTreeNode(filePath: string): Promise<void> {
         await this.activate();
         const treeNode = await this.page.waitForSelector(this.treeNodeSelector(filePath));
@@ -148,6 +177,10 @@ export class TheiaExplorerView extends TheiaView {
             await treeNode.focus();
         } else {
             await treeNode.click({ modifiers: ['Control'] });
+            // make sure the click has been acted-upon before returning
+            while (!await this.isTreeNodeSelected(filePath)) {
+                console.debug('Waiting for clicked tree node to be selected: ' + filePath);
+            }
         }
     }
 
@@ -177,8 +210,8 @@ export class TheiaExplorerView extends TheiaView {
         await menuItem.click();
     }
 
-    protected async existsNode(path: string, isDirectory: boolean): Promise<boolean> {
-        const fileStatNode = await this.fileStatNode(path);
+    protected async existsNode(path: string, isDirectory: boolean, compact = false): Promise<boolean> {
+        const fileStatNode = await this.fileStatNode(path, compact);
         if (!fileStatNode) {
             return false;
         }
@@ -198,8 +231,14 @@ export class TheiaExplorerView extends TheiaView {
         return this.existsNode(path, false);
     }
 
-    async existsDirectoryNode(path: string): Promise<boolean> {
-        return this.existsNode(path, true);
+    async existsDirectoryNode(path: string, compact = false): Promise<boolean> {
+        return this.existsNode(path, true, compact);
+    }
+
+    async waitForTreeNodeVisible(path: string): Promise<void> {
+        // wait for tree node to be visible, e.g. after triggering create
+        const viewElement = await this.viewElement();
+        await viewElement?.waitForSelector(this.treeNodeSelector(path), { state: 'visible' });
     }
 
     async getNumberOfVisibleNodes(): Promise<number> {
@@ -231,4 +270,18 @@ export class TheiaExplorerView extends TheiaView {
         await this.refresh();
     }
 
+    override async waitForVisible(): Promise<void> {
+        await super.waitForVisible();
+        await this.page.waitForSelector(this.tabSelector, { state: 'visible' });
+    }
+
+    /**
+     * Waits until some non-dot file nodes are visible
+     */
+    async waitForVisibleFileNodes(): Promise<void> {
+        while ((await this.visibleFileStatNodes(DOT_FILES_FILTER)).length === 0) {
+            console.debug('Awaiting for tree nodes to appear');
+        }
+    }
+
 }

package/src/theia-monaco-editor.ts

@@ -0,0 +1,83 @@
+// *****************************************************************************
+// 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 { TheiaApp } from './theia-app';
+
+export class TheiaMonacoEditor extends TheiaPageObject {
+    constructor(protected readonly selector: string, app: TheiaApp) {
+        super(app);
+    }
+
+    async waitForVisible(): Promise<void> {
+        await this.page.waitForSelector(this.selector, { state: 'visible' });
+    }
+
+    protected viewElement(): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
+        return this.page.$(this.selector);
+    }
+
+    async numberOfLines(): Promise<number | undefined> {
+        await this.waitForVisible();
+        const viewElement = await this.viewElement();
+        const lineElements = await viewElement?.$$('.view-lines .view-line');
+        return lineElements?.length;
+    }
+
+    async textContentOfLineByLineNumber(lineNumber: number): Promise<string | undefined> {
+        await this.waitForVisible();
+        const lineElement = await this.lineByLineNumber(lineNumber);
+        const content = await lineElement?.textContent();
+        return content ? this.replaceEditorSymbolsWithSpace(content) : undefined;
+    }
+
+    async lineByLineNumber(lineNumber: number): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+        await this.waitForVisible();
+        const viewElement = await this.viewElement();
+        const lines = await viewElement?.$$('.view-lines > .view-line');
+        if (!lines) {
+            throw new Error('Couldn\'t retrieve lines of monaco editor');
+        }
+
+        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.waitForVisible();
+        const lineElement = await this.lineContainingText(text);
+        const content = await lineElement?.textContent();
+        return content ? this.replaceEditorSymbolsWithSpace(content) : undefined;
+    }
+
+    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 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, '');
+    }
+}

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();
+    }
+}