@theia/playwright 1.37.0-next.3 → 1.37.0-next.30

package/src/tests/theia-explorer-view.test.ts

@@ -54,24 +54,29 @@ test.describe('Theia Explorer View', () => {
         expect(await explorer.isActive()).toBe(true);
     });
 
-    test('should show one folder named "sampleFolder" and one file named "sample.txt"', async () => {
+    test('should show one folder named "sampleFolder", one named "sampleFolderCompact" and one file named "sample.txt"', async () => {
         await explorer.selectTreeNode('sampleFolder');
         expect(await explorer.isTreeNodeSelected('sampleFolder')).toBe(true);
         const fileStatElements = await explorer.visibleFileStatNodes(DOT_FILES_FILTER);
-        expect(fileStatElements.length).toBe(2);
+        expect(fileStatElements.length).toBe(3);
 
-        let file; let folder;
+        let file; let folder; let compactFolder;
         if (await fileStatElements[0].isFolder()) {
             folder = fileStatElements[0];
-            file = fileStatElements[1];
+            compactFolder = fileStatElements[1];
+            file = fileStatElements[2];
         } else {
-            folder = fileStatElements[1];
+            folder = fileStatElements[2];
+            compactFolder = fileStatElements[1];
             file = fileStatElements[0];
         }
 
         expect(await folder.label()).toBe('sampleFolder');
         expect(await folder.isFile()).toBe(false);
         expect(await folder.isFolder()).toBe(true);
+        expect(await compactFolder.label()).toBe('sampleFolderCompact');
+        expect(await compactFolder.isFile()).toBe(false);
+        expect(await compactFolder.isFolder()).toBe(true);
         expect(await file.label()).toBe('sample.txt');
         expect(await file.isFolder()).toBe(false);
         expect(await file.isFile()).toBe(true);
@@ -84,7 +89,7 @@ test.describe('Theia Explorer View', () => {
         expect(await file.isFile()).toBe(true);
     });
 
-    test('should provide file stat nodes that can define whether they are collapsed or not and that can be expanded', async () => {
+    test('should provide file stat nodes that can define whether they are collapsed or not and that can be expanded and collapsed', async () => {
         const file = await explorer.getFileStatNodeByLabel('sample.txt');
         expect(await file.isCollapsed()).toBe(false);
 
@@ -93,6 +98,9 @@ test.describe('Theia Explorer View', () => {
 
         await folder.expand();
         expect(await folder.isCollapsed()).toBe(false);
+
+        await folder.collapse();
+        expect(await folder.isCollapsed()).toBe(true);
     });
 
     test('should provide file stat node by path "sampleFolder/sampleFolder1/sampleFolder1-1/sampleFile1-1-1.txt"', async () => {
@@ -101,6 +109,17 @@ test.describe('Theia Explorer View', () => {
         expect(await file.label()).toBe('sampleFile1-1-1.txt');
     });
 
+    test('should be able to check if compact folder "sampleFolderCompact/nestedFolder1/nestedFolder2" exists', async () => {
+        // default setting `explorer.compactFolders=true` renders folders in a compact form - single child folders will be compressed in a combined tree element
+        expect(await explorer.existsDirectoryNode('sampleFolderCompact/nestedFolder1/nestedFolder2', true /* compact */)).toBe(true);
+    });
+
+    test('should provide file stat node by path of compact folder "sampleFolderCompact/nestedFolder1/nestedFolder2/sampleFile1-1.txt"', async () => {
+        const file = await explorer.fileStatNode('sampleFolderCompact/nestedFolder1/nestedFolder2/sampleFile1-1.txt', true /* compact */);
+        if (!file) { throw Error('File stat node could not be retrieved by path'); }
+        expect(await file.label()).toBe('sampleFile1-1.txt');
+    });
+
     test('should open context menu on "sample.txt"', async () => {
         const file = await explorer.getFileStatNodeByLabel('sample.txt');
         const menu = await file.openContextMenu();

package/src/tests/theia-main-menu.test.ts

@@ -74,10 +74,10 @@ test.describe('Theia Main Menu', () => {
 
     test('should be able to show menu item in submenu by path', async () => {
         const mainMenu = await menuBar.openMenu('File');
-        const openPreferencesItem = await mainMenu.menuItemByNamePath('Preferences', 'Open Settings (UI)');
+        const openPreferencesItem = await mainMenu.menuItemByNamePath('Preferences', 'Settings');
 
         const label = await openPreferencesItem?.label();
-        expect(label).toBe('Open Settings (UI)');
+        expect(label).toBe('Settings');
     });
 
     test('should close main menu', async () => {

package/src/tests/theia-output-view.test.ts

@@ -0,0 +1,85 @@
+// *****************************************************************************
+// 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 { expect } from '@playwright/test';
+import { TheiaOutputViewChannel } from 'src/theia-output-channel';
+import { TheiaApp } from '../theia-app';
+import { TheiaOutputView } from '../theia-output-view';
+import test, { page } from './fixtures/theia-fixture';
+
+let app: TheiaApp;
+let outputView: TheiaOutputView;
+let testChannel: TheiaOutputViewChannel;
+
+test.describe('Theia Output View', () => {
+
+    test.beforeAll(async () => {
+        app = await TheiaApp.load(page);
+    });
+
+    test('should open the output view and check if is visible and active', async () => {
+        outputView = await app.openView(TheiaOutputView);
+        expect(await outputView.isTabVisible()).toBe(true);
+        expect(await outputView.isDisplayed()).toBe(true);
+        expect(await outputView.isActive()).toBe(true);
+    });
+    test('should be opened at the bottom and have the title "Output"', async () => {
+        expect(await outputView.isInSidePanel()).toBe(false);
+        expect(await outputView.side()).toBe('bottom');
+        expect(await outputView.title()).toBe('Output');
+    });
+    test('should be closable', async () => {
+        expect(await outputView.isClosable()).toBe(true);
+        await outputView.close();
+        expect(await outputView.isTabVisible()).toBe(false);
+        expect(await outputView.isDisplayed()).toBe(false);
+        expect(await outputView.isActive()).toBe(false);
+    });
+    test('should select a test output channel', async () => {
+        outputView = await app.openView(TheiaOutputView);
+        expect(await outputView.isTabVisible()).toBe(true);
+        expect(await outputView.isDisplayed()).toBe(true);
+        expect(await outputView.isActive()).toBe(true);
+
+        const testChannelName = 'API Sample: my test channel';
+        expect(await outputView.selectOutputChannel(testChannelName)).toBe(true);
+    });
+    test('should check if the output view of the test output channel', async () => {
+        const testChannelName = 'API Sample: my test channel';
+        expect(await outputView.isOutputChannelSelected(testChannelName));
+        const channel = await outputView.getOutputChannel(testChannelName);
+        expect(channel).toBeDefined;
+        testChannel = channel!;
+        expect(await testChannel!.isDisplayed()).toBe(true);
+    });
+    test('should check if the output view test channel shows the test output', async () => {
+        expect(await testChannel.numberOfLines()).toBe(5);
+        expect(await testChannel.textContentOfLineByLineNumber(1)).toMatch('hello info1');
+        expect(await testChannel.maxSeverityOfLineByLineNumber(1)).toMatch('info');
+        expect(await testChannel.textContentOfLineByLineNumber(2)).toMatch('hello info2');
+        expect(await testChannel.maxSeverityOfLineByLineNumber(2)).toMatch('info');
+        expect(await testChannel.textContentOfLineByLineNumber(3)).toMatch('hello error');
+        expect(await testChannel.maxSeverityOfLineByLineNumber(3)).toMatch('error');
+        expect(await testChannel.textContentOfLineByLineNumber(4)).toMatch('hello warning');
+        expect(await testChannel.maxSeverityOfLineByLineNumber(4)).toMatch('warning');
+        expect(await testChannel.textContentOfLineByLineNumber(5)).toMatch(
+            'inlineInfo1 inlineWarning inlineError inlineInfo2'
+        );
+        expect(await testChannel.maxSeverityOfLineByLineNumber(5)).toMatch('error');
+    });
+
+});
+

package/src/tests/theia-quick-command.test.ts

@@ -18,6 +18,8 @@ import { expect } from '@playwright/test';
 import { TheiaAboutDialog } from '../theia-about-dialog';
 import { TheiaApp } from '../theia-app';
 import { TheiaExplorerView } from '../theia-explorer-view';
+import { TheiaNotificationIndicator } from '../theia-notification-indicator';
+import { TheiaNotificationOverlay } from '../theia-notification-overlay';
 import { TheiaQuickCommandPalette } from '../theia-quick-command-palette';
 import test, { page } from './fixtures/theia-fixture';
 
@@ -34,6 +36,10 @@ test.describe('Theia Quick Command', () => {
     test('should show quick command palette', async () => {
         await quickCommand.open();
         expect(await quickCommand.isOpen()).toBe(true);
+        await quickCommand.hide();
+        expect(await quickCommand.isOpen()).toBe(false);
+        await quickCommand.open();
+        expect(await quickCommand.isOpen()).toBe(true);
     });
 
     test('should trigger \'About\' command after typing', async () => {
@@ -58,4 +64,13 @@ test.describe('Theia Quick Command', () => {
         expect(await explorerView.isDisplayed()).toBe(true);
     });
 
+    test('should trigger \'Quick Input: Test Positive Integer\' command by confirming via Enter', async () => {
+        await quickCommand.type('Test Positive', true);
+        expect(await quickCommand.isOpen()).toBe(true);
+        await quickCommand.type('6', true);
+        const notificationIndicator = new TheiaNotificationIndicator(app);
+        const notification = new TheiaNotificationOverlay(app, notificationIndicator);
+        expect(await notification.isEntryVisible('Positive Integer: 6')).toBe(true);
+    });
+
 });

package/src/tests/theia-sample-app.test.ts

@@ -14,44 +14,13 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { TheiaApp } from '../theia-app';
-
 import { expect } from '@playwright/test';
+import { TheiaApp } from '../theia-app';
+import { TheiaToolbar } from '../theia-toolbar';
 import test, { page } from './fixtures/theia-fixture';
-import { TheiaPageObject } from '../theia-page-object';
-
-class TheiaSampleToolbar extends TheiaPageObject {
-    protected selector = '#main-toolbar';
-
-    async show(): 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 isShown(): Promise<boolean> {
-        const toolbar = await this.page.$(this.selector);
-        return !!toolbar && toolbar.isVisible();
-    }
-}
 
 class TheiaSampleApp extends TheiaApp {
-    protected toolbar = new TheiaSampleToolbar(this);
+    protected toolbar = new TheiaToolbar(this);
 
     override async waitForInitialized(): Promise<void> {
         await this.toolbar.show();

package/src/tests/theia-terminal-view.test.ts

@@ -0,0 +1,85 @@
+// *****************************************************************************
+// 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 { expect } from '@playwright/test';
+import { TheiaApp } from '../theia-app';
+import { TheiaWorkspace } from '../theia-workspace';
+import test, { page } from './fixtures/theia-fixture';
+import { TheiaTerminal } from '../theia-terminal';
+
+let app: TheiaApp;
+
+test.describe('Theia Terminal View', () => {
+
+    test.beforeAll(async () => {
+        const ws = new TheiaWorkspace(['src/tests/resources/sample-files1']);
+        app = await TheiaApp.load(page, ws);
+    });
+
+    test('should be possible to open a new terminal', async () => {
+        const terminal = await app.openTerminal(TheiaTerminal);
+        expect(await terminal.isTabVisible()).toBe(true);
+        expect(await terminal.isDisplayed()).toBe(true);
+        expect(await terminal.isActive()).toBe(true);
+    });
+
+    test('should be possible to open two terminals, switch among them, and close them', async () => {
+        const terminal1 = await app.openTerminal(TheiaTerminal);
+        const terminal2 = await app.openTerminal(TheiaTerminal);
+        const allTerminals = [terminal1, terminal2];
+
+        // all terminal tabs should be visible
+        for (const terminal of allTerminals) {
+            expect(await terminal.isTabVisible()).toBe(true);
+        }
+
+        // activate one terminal after the other and check that only this terminal is active
+        for (const terminal of allTerminals) {
+            await terminal.activate();
+            expect(await terminal1.isActive()).toBe(terminal1 === terminal);
+            expect(await terminal2.isActive()).toBe(terminal2 === terminal);
+        }
+
+        // close all terminals
+        for (const terminal of allTerminals) {
+            await terminal.close();
+        }
+
+        // check that all terminals are closed
+        for (const terminal of allTerminals) {
+            expect(await terminal.isTabVisible()).toBe(false);
+        }
+    });
+
+    test('should allow to write and read terminal contents', async () => {
+        const terminal = await app.openTerminal(TheiaTerminal);
+        await terminal.write('hello');
+        const contents = await terminal.contents();
+        expect(contents).toContain('hello');
+    });
+
+    test('should allow to submit a command and read output', async () => {
+        const terminal = await app.openTerminal(TheiaTerminal);
+        if (process.platform === 'win32') {
+            await terminal.submit('dir');
+        } else {
+            await terminal.submit('ls');
+        }
+        const contents = await terminal.contents();
+        expect(contents).toContain('sample.txt');
+    });
+
+});

package/src/tests/theia-toolbar.test.ts

@@ -0,0 +1,65 @@
+// *****************************************************************************
+// 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 { expect } from '@playwright/test';
+import { TheiaApp } from '../theia-app';
+import { TheiaToolbar } from '../theia-toolbar';
+import test, { page } from './fixtures/theia-fixture';
+
+let app: TheiaApp;
+let toolbar: TheiaToolbar;
+
+test.describe('Theia Toolbar', () => {
+
+    test.beforeAll(async () => {
+        app = await TheiaApp.load(page);
+        toolbar = new TheiaToolbar(app);
+    });
+
+    test('should toggle the toolbar and check visibility', async () => {
+        // depending on the user settings we have different starting conditions for the toolbar
+        const isShownInitially = await toolbar.isShown();
+        expect(await toolbar.isShown()).toBe(isShownInitially);
+        await toolbar.toggle();
+        expect(await toolbar.isShown()).toBe(!isShownInitially);
+        await toolbar.hide();
+        expect(await toolbar.isShown()).toBe(false);
+        await toolbar.show();
+        expect(await toolbar.isShown()).toBe(true);
+    });
+
+    test('should show the default toolbar tools of the sample Theia application', async () => {
+        expect(await toolbar.toolbarItems()).toHaveLength(5);
+        expect(await toolbar.toolbarItemIds()).toStrictEqual([
+            'textEditor.commands.go.back',
+            'textEditor.commands.go.forward',
+            'workbench.action.splitEditorRight',
+            'theia-sample-toolbar-contribution',
+            'workbench.action.showCommands'
+        ]);
+    });
+
+    test('should trigger the "Command Palette" toolbar tool as expect the command palette to open', async () => {
+        const commandPaletteTool = await toolbar.toolBarItem('workbench.action.showCommands');
+        expect(commandPaletteTool).toBeDefined;
+        expect(await commandPaletteTool!.isEnabled()).toBe(true);
+
+        await commandPaletteTool!.trigger();
+        expect(await app.quickCommandPalette.isOpen()).toBe(true);
+        await app.quickCommandPalette.hide();
+        expect(await app.quickCommandPalette.isOpen()).toBe(false);
+    });
+});

package/src/tests/theia-workspace.test.ts

@@ -14,10 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { expect } from '@playwright/test';
 import { TheiaApp } from '../theia-app';
 import { DOT_FILES_FILTER, TheiaExplorerView } from '../theia-explorer-view';
 import { TheiaWorkspace } from '../theia-workspace';
-import { expect } from '@playwright/test';
 import test, { page } from './fixtures/theia-fixture';
 
 test.describe('Theia Workspace', () => {
@@ -33,8 +33,9 @@ test.describe('Theia Workspace', () => {
         const ws = new TheiaWorkspace(['src/tests/resources/sample-files1']);
         const app = await TheiaApp.load(page, ws);
         const explorer = await app.openView(TheiaExplorerView);
-        // resources/sample-files1 contains one folder and one file
+        // resources/sample-files1 contains two folders and one file
         expect(await explorer.existsDirectoryNode('sampleFolder')).toBe(true);
+        expect(await explorer.existsDirectoryNode('sampleFolderCompact')).toBe(true);
         expect(await explorer.existsFileNode('sample.txt')).toBe(true);
     });
 
@@ -42,8 +43,9 @@ test.describe('Theia Workspace', () => {
         const ws = new TheiaWorkspace(['src/tests/resources/sample-files1', 'src/tests/resources/sample-files2']);
         const app = await TheiaApp.load(page, ws);
         const explorer = await app.openView(TheiaExplorerView);
-        // resources/sample-files1 contains one folder and one file
+        // resources/sample-files1 contains two folders and one file
         expect(await explorer.existsDirectoryNode('sampleFolder')).toBe(true);
+        expect(await explorer.existsDirectoryNode('sampleFolderCompact')).toBe(true);
         expect(await explorer.existsFileNode('sample.txt')).toBe(true);
         // resources/sample-files2 contains one file
         expect(await explorer.existsFileNode('another-sample.txt')).toBe(true);

package/src/theia-app.ts

@@ -1,5 +1,5 @@
 // *****************************************************************************
-// Copyright (C) 2021 logi.cals GmbH, EclipseSource and others.
+// Copyright (C) 2021-2023 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
@@ -21,6 +21,7 @@ import { TheiaMenuBar } from './theia-main-menu';
 import { TheiaPreferenceScope, TheiaPreferenceView } from './theia-preference-view';
 import { TheiaQuickCommandPalette } from './theia-quick-command-palette';
 import { TheiaStatusBar } from './theia-status-bar';
+import { TheiaTerminal } from './theia-terminal';
 import { TheiaView } from './theia-view';
 import { TheiaWorkspace } from './theia-workspace';
 
@@ -147,6 +148,41 @@ export class TheiaApp {
         return editor;
     }
 
+    async openTerminal<T extends TheiaTerminal>(terminalFactory: { new(id: string, app: TheiaApp): T }): Promise<T> {
+        const mainMenu = await this.menuBar.openMenu('Terminal');
+        const menuItem = await mainMenu.menuItemByName('New Terminal');
+        if (!menuItem) {
+            throw Error('Menu item \'New Terminal\' could not be found.');
+        }
+
+        const newTabIds = await this.runAndWaitForNewTabs(() => menuItem.click());
+        if (newTabIds.length > 1) {
+            console.warn('More than one new tab detected after opening the terminal');
+        }
+
+        return new terminalFactory(newTabIds[0], this);
+    }
+
+    protected async runAndWaitForNewTabs(command: () => Promise<void>): Promise<string[]> {
+        const tabIdsBefore = await this.visibleTabIds();
+        await command();
+        return (await this.waitForNewTabs(tabIdsBefore)).filter(item => !tabIdsBefore.includes(item));
+    }
+
+    protected async waitForNewTabs(tabIds: string[]): Promise<string[]> {
+        let tabIdsCurrent: string[];
+        while ((tabIdsCurrent = (await this.visibleTabIds())).length <= tabIds.length) {
+            console.debug('Awaiting a new tab to appear');
+        }
+        return tabIdsCurrent;
+    }
+
+    protected async visibleTabIds(): Promise<string[]> {
+        const tabs = await this.page.$$('.p-TabBar-tab');
+        const tabIds = (await Promise.all(tabs.map(tab => tab.getAttribute('id')))).filter(id => !!id);
+        return tabIds as string[];
+    }
+
     /** Specific Theia apps may add additional conditions to wait for. */
     async waitForInitialized(): Promise<void> {
         // empty by default

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));
@@ -181,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;
         }
@@ -202,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> {

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