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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theia/playwright",
-  "version": "1.37.0-next.1+be8d78537",
+  "version": "1.37.0-next.11+c33553806",
   "description": "System tests for Theia",
   "license": "EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0",
   "repository": {
@@ -12,14 +12,15 @@
   },
   "homepage": "https://github.com/eclipse-theia/theia",
   "scripts": {
-    "clean": "rimraf lib *.tsbuildinfo",
-    "build": "tsc --incremental && npx playwright install chromium",
+    "clean": "rimraf lib *.tsbuildinfo .eslintcache",
+    "build": "yarn && yarn clean && tsc --incremental && yarn lint && yarn playwright:install",
+    "watch": "tsc -w --incremental",
     "theia:start": "rimraf .tmp.cfg && THEIA_CONFIG_DIR=$PWD/.tmp.cfg yarn --cwd ../browser start",
     "lint": "eslint -c ./.eslintrc.js --ext .ts ./src",
     "lint:fix": "eslint -c ./.eslintrc.js --ext .ts ./src --fix",
-    "ui-tests": "yarn && playwright test --config=./configs/playwright.config.ts",
-    "ui-tests-ci": "yarn && playwright test --config=./configs/playwright.ci.config.ts",
-    "ui-tests-headful": "yarn && playwright test --config=./configs/playwright.headful.config.ts",
+    "playwright:install": "playwright install chromium",
+    "ui-tests": "yarn build && playwright test",
+    "ui-tests-headful": "yarn build && playwright test --headed",
     "ui-tests-report-generate": "allure generate ./allure-results --clean -o allure-results/allure-report",
     "ui-tests-report": "yarn ui-tests-report-generate && allure open allure-results/allure-report"
   },
@@ -28,17 +29,19 @@
     "src"
   ],
   "dependencies": {
-    "@playwright/test": "^1.30.0",
+    "@playwright/test": "^1.32.1",
     "fs-extra": "^9.0.8"
   },
   "devDependencies": {
     "@types/fs-extra": "^9.0.8",
-    "allure-commandline": "^2.13.8",
-    "allure-playwright": "^2.0.0-beta.14"
+    "allure-commandline": "^2.21.0",
+    "allure-playwright": "^2.1.0",
+    "rimraf": "^2.6.1",
+    "typescript": "~4.5.5"
   },
   "publishConfig": {
     "access": "public"
   },
   "main": "lib/index",
-  "gitHead": "be8d78537cc3eb08515c6ec62c46d5d0c2ab41b1"
+  "gitHead": "c33553806b7dc3d17d4a820627104280bc84ab3a"
 }

package/src/index.ts

@@ -25,6 +25,8 @@ export * from './theia-menu-item';
 export * from './theia-menu';
 export * from './theia-notification-indicator';
 export * from './theia-notification-overlay';
+export * from './theia-output-channel';
+export * from './theia-output-view';
 export * from './theia-page-object';
 export * from './theia-preference-view';
 export * from './theia-problem-indicator';
@@ -35,6 +37,8 @@ export * from './theia-status-bar';
 export * from './theia-status-indicator';
 export * from './theia-text-editor';
 export * from './theia-toggle-bottom-indicator';
+export * from './theia-toolbar';
+export * from './theia-toolbar-item';
 export * from './theia-tree-node';
 export * from './theia-view';
 export * from './theia-workspace';

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

@@ -29,6 +29,7 @@ test.describe('Theia Explorer View', () => {
         const ws = new TheiaWorkspace(['src/tests/resources/sample-files1']);
         app = await TheiaApp.load(page, ws);
         explorer = await app.openView(TheiaExplorerView);
+        await explorer.waitForVisibleFileNodes();
     });
 
     test('should be visible and active after being opened', async () => {
@@ -53,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);
@@ -83,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);
 
@@ -92,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 () => {
@@ -100,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';
 
@@ -109,6 +110,7 @@ export class TheiaApp {
             throw Error('TheiaExplorerView could not be opened.');
         }
         if (expectFileNodes) {
+            await explorer.waitForVisibleFileNodes();
             const fileStatElements = await explorer.visibleFileStatNodes(DOT_FILES_FILTER);
             if (fileStatElements.length < 1) {
                 throw Error('TheiaExplorerView is empty.');
@@ -146,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