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

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-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

@@ -109,6 +109,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.');

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