@redhat-developer/page-objects 1.0.0

package/out/components/activityBar/ViewControl.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewControl = void 0;
+const __1 = require("../..");
+const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
+const NewScmView_1 = require("../sidebar/scm/NewScmView");
+/**
+ * Page object representing a view container item in the activity bar
+ */
+class ViewControl extends ElementWithContextMenu_1.ElementWithContexMenu {
+    constructor(element, bar) {
+        super(element, bar);
+    }
+    /**
+     * Opens the associated view if not already open
+     * @returns Promise resolving to SideBarView object representing the opened view
+     */
+    async openView() {
+        // Check whether view is already open
+        const klass = await this.getAttribute(ViewControl.locators.ViewControl.attribute);
+        if (klass.indexOf(ViewControl.locators.ViewControl.klass) < 0) {
+            await this.click();
+            await ViewControl.driver.sleep(500);
+        }
+        const view = await new __1.SideBarView().wait();
+        if ((await view.findElements(ViewControl.locators.ViewControl.scmId)).length > 0) {
+            if (ViewControl.versionInfo.browser === 'vscode' && ViewControl.versionInfo.version >= '1.47.0') {
+                return new NewScmView_1.NewScmView().wait();
+            }
+            return new __1.ScmView().wait();
+        }
+        if ((await view.findElements(ViewControl.locators.ViewControl.debugId)).length > 0) {
+            return new __1.DebugView().wait();
+        }
+        return view;
+    }
+    /**
+     * Closes the associated view if not already closed
+     * @returns Promise resolving when the view closes
+     */
+    async closeView() {
+        const klass = await this.getAttribute(ViewControl.locators.ViewControl.attribute);
+        if (klass.indexOf(ViewControl.locators.ViewControl.klass) > -1) {
+            await this.click();
+        }
+    }
+    /**
+     * Returns the title of the associated view
+     */
+    async getTitle() {
+        const badge = await this.findElement(ViewControl.locators.ViewControl.badge);
+        return await badge.getAttribute('aria-label');
+    }
+}
+exports.ViewControl = ViewControl;
+//# sourceMappingURL=ViewControl.js.map

package/out/components/bottomBar/AbstractViews.d.ts

@@ -0,0 +1,38 @@
+import { ElementWithContexMenu } from "../ElementWithContextMenu";
+/**
+ * View with channel selector
+ */
+export declare abstract class ChannelView extends ElementWithContexMenu {
+    protected actionsLabel: string;
+    /**
+    * Get names of all selectable channels
+    * @returns Promise resolving to array of strings - channel names
+    */
+    getChannelNames(): Promise<string[]>;
+    /**
+     * Get name of the current channel
+     * @returns Promise resolving to the current channel name
+     */
+    getCurrentChannel(): Promise<string>;
+    /**
+     * Select a channel using the selector combo
+     * @param name name of the channel to open
+     */
+    selectChannel(name: string): Promise<void>;
+}
+/**
+ * View with channel selection and text area
+ */
+export declare abstract class TextView extends ChannelView {
+    protected actionsLabel: string;
+    /**
+     * Get all text from the currently open channel
+     * @returns Promise resolving to the view's text
+     */
+    getText(): Promise<string>;
+    /**
+     * Clear the text in the current channel
+     * @returns Promise resolving when the clear text button is pressed
+     */
+    clearText(): Promise<void>;
+}

package/out/components/bottomBar/AbstractViews.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextView = exports.ChannelView = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
+/**
+ * View with channel selector
+ */
+class ChannelView extends ElementWithContextMenu_1.ElementWithContexMenu {
+    actionsLabel;
+    /**
+    * Get names of all selectable channels
+    * @returns Promise resolving to array of strings - channel names
+    */
+    async getChannelNames() {
+        const names = [];
+        const elements = await (await this.enclosingItem.findElement(ChannelView.locators.BottomBarViews.actionsContainer(this.actionsLabel)))
+            .findElements(ChannelView.locators.BottomBarViews.channelOption);
+        await Promise.all(elements.map(async (element) => {
+            const disabled = await element.getAttribute('disabled');
+            if (!disabled) {
+                names.push(await element.getAttribute('value'));
+            }
+        }));
+        return names;
+    }
+    /**
+     * Get name of the current channel
+     * @returns Promise resolving to the current channel name
+     */
+    async getCurrentChannel() {
+        if (ChannelView.versionInfo.version >= '1.87.0' && process.platform !== 'darwin') {
+            throw Error(`The 'ChannelView.getCurrentChannel' method is broken! Read more information in 'Known Issues > Limitations in testing with VS Code 1.87+' - https://github.com/microsoft/vscode/issues/206897.`);
+        }
+        const combo = await this.enclosingItem.findElement(ChannelView.locators.BottomBarViews.channelCombo);
+        return await combo.getAttribute('title');
+    }
+    /**
+     * Select a channel using the selector combo
+     * @param name name of the channel to open
+     */
+    async selectChannel(name) {
+        const combo = await this.enclosingItem.findElement(ChannelView.locators.BottomBarViews.channelCombo);
+        const option = await combo.findElement(ChannelView.locators.OutputView.optionByName(name));
+        await option.click();
+    }
+}
+exports.ChannelView = ChannelView;
+/**
+ * View with channel selection and text area
+ */
+class TextView extends ChannelView {
+    /**
+     * Get all text from the currently open channel
+     * @returns Promise resolving to the view's text
+     */
+    async getText() {
+        const clipboard = (await import('clipboardy')).default;
+        let originalClipboard = '';
+        try {
+            originalClipboard = clipboard.readSync();
+        }
+        catch (error) {
+            // workaround issue https://github.com/redhat-developer/vscode-extension-tester/issues/835
+            // do not fail if clipboard is empty
+        }
+        let textarea = await this.findElement(ChannelView.locators.BottomBarViews.textArea);
+        await textarea.sendKeys(selenium_webdriver_1.Key.chord(TextView.ctlKey, 'a'));
+        await textarea.sendKeys(selenium_webdriver_1.Key.chord(TextView.ctlKey, 'c'));
+        const text = clipboard.readSync();
+        // workaround as we are getting "element click intercepted" during the send keys actions.
+        // await textarea.click();
+        if (originalClipboard.length > 0) {
+            clipboard.writeSync(originalClipboard);
+        }
+        return text;
+    }
+    /**
+     * Clear the text in the current channel
+     * @returns Promise resolving when the clear text button is pressed
+     */
+    async clearText() {
+        await this.enclosingItem.findElement(ChannelView.locators.BottomBarViews.actionsContainer(this.actionsLabel))
+            .findElement(ChannelView.locators.BottomBarViews.clearText).click();
+    }
+}
+exports.TextView = TextView;
+//# sourceMappingURL=AbstractViews.js.map

package/out/components/bottomBar/BottomBarPanel.d.ts

@@ -0,0 +1,47 @@
+import { AbstractElement } from "../AbstractElement";
+import { ProblemsView, OutputView, DebugConsoleView, TerminalView } from "../..";
+/**
+ * Page object for the bottom view panel
+ */
+export declare class BottomBarPanel extends AbstractElement {
+    constructor();
+    /**
+     * Open/Close the bottom bar panel
+     * @param open true to open. false to close
+     * @returns Promise resolving when the view visibility is toggled
+     */
+    toggle(open: boolean): Promise<void>;
+    /**
+     * Open the Problems view in the bottom panel
+     * @returns Promise resolving to a ProblemsView object
+     */
+    openProblemsView(): Promise<ProblemsView>;
+    /**
+     * Open the Output view in the bottom panel
+     * @returns Promise resolving to OutputView object
+     */
+    openOutputView(): Promise<OutputView>;
+    /**
+     * Open the Debug Console view in the bottom panel
+     * @returns Promise resolving to DebugConsoleView object
+     */
+    openDebugConsoleView(): Promise<DebugConsoleView>;
+    /**
+     * Open the Terminal view in the bottom panel
+     * @returns Promise resolving to TerminalView object
+     */
+    openTerminalView(): Promise<TerminalView>;
+    /**
+     * Maximize the the bottom panel if not maximized
+     * @returns Promise resolving when the maximize button is pressed
+     */
+    maximize(): Promise<void>;
+    /**
+     * Restore the the bottom panel if maximized
+     * @returns Promise resolving when the restore button is pressed
+     */
+    restore(): Promise<void>;
+    private openTab;
+    private resize;
+    closePanel(): Promise<void>;
+}

package/out/components/bottomBar/BottomBarPanel.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BottomBarPanel = void 0;
+const AbstractElement_1 = require("../AbstractElement");
+const selenium_webdriver_1 = require("selenium-webdriver");
+const __1 = require("../..");
+/**
+ * Page object for the bottom view panel
+ */
+class BottomBarPanel extends AbstractElement_1.AbstractElement {
+    constructor() {
+        super(BottomBarPanel.locators.BottomBarPanel.constructor, BottomBarPanel.locators.Workbench.constructor);
+    }
+    /**
+     * Open/Close the bottom bar panel
+     * @param open true to open. false to close
+     * @returns Promise resolving when the view visibility is toggled
+     */
+    async toggle(open) {
+        try {
+            const tab = await new __1.EditorView().getActiveTab();
+            await tab?.click();
+        }
+        catch (err) {
+            // ignore and move on
+        }
+        const height = (await this.getRect()).height;
+        if ((open && height === 0) || !open && height > 0) {
+            if (open) {
+                await this.getDriver().actions().clear();
+                await this.getDriver().actions().keyDown(BottomBarPanel.ctlKey).sendKeys('j').perform();
+                await this.wait();
+            }
+            else {
+                await this.closePanel();
+                await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this));
+            }
+        }
+    }
+    /**
+     * Open the Problems view in the bottom panel
+     * @returns Promise resolving to a ProblemsView object
+     */
+    async openProblemsView() {
+        await this.openTab(BottomBarPanel.locators.BottomBarPanel.problemsTab);
+        return new __1.ProblemsView(this).wait();
+    }
+    /**
+     * Open the Output view in the bottom panel
+     * @returns Promise resolving to OutputView object
+     */
+    async openOutputView() {
+        await this.openTab(BottomBarPanel.locators.BottomBarPanel.outputTab);
+        return new __1.OutputView(this).wait();
+    }
+    /**
+     * Open the Debug Console view in the bottom panel
+     * @returns Promise resolving to DebugConsoleView object
+     */
+    async openDebugConsoleView() {
+        await this.openTab(BottomBarPanel.locators.BottomBarPanel.debugTab);
+        return new __1.DebugConsoleView(this).wait();
+    }
+    /**
+     * Open the Terminal view in the bottom panel
+     * @returns Promise resolving to TerminalView object
+     */
+    async openTerminalView() {
+        await this.openTab(BottomBarPanel.locators.BottomBarPanel.terminalTab);
+        return new __1.TerminalView(this).wait();
+    }
+    /**
+     * Maximize the the bottom panel if not maximized
+     * @returns Promise resolving when the maximize button is pressed
+     */
+    async maximize() {
+        await this.resize(BottomBarPanel.locators.BottomBarPanel.maximize);
+    }
+    /**
+     * Restore the the bottom panel if maximized
+     * @returns Promise resolving when the restore button is pressed
+     */
+    async restore() {
+        await this.resize(BottomBarPanel.locators.BottomBarPanel.restore);
+    }
+    async openTab(title) {
+        await this.toggle(true);
+        const tabContainer = await this.findElement(BottomBarPanel.locators.BottomBarPanel.tabContainer);
+        try {
+            const tabs = await tabContainer.findElements(BottomBarPanel.locators.BottomBarPanel.tab(title));
+            if (tabs.length > 0) {
+                await tabs[0].click();
+            }
+            else {
+                const label = await tabContainer.findElement(selenium_webdriver_1.By.xpath(`.//a[starts-with(@aria-label, '${title}')]`));
+                await label.click();
+            }
+        }
+        catch (err) {
+            await new __1.Workbench().executeCommand(`${title}: Focus on ${title} View`);
+        }
+    }
+    async resize(label) {
+        await this.toggle(true);
+        let action;
+        try {
+            action = await this.findElement(BottomBarPanel.locators.BottomBarPanel.globalActions)
+                .findElement(BottomBarPanel.locators.BottomBarPanel.action(label));
+        }
+        catch (err) {
+            // the panel is already maximized
+        }
+        if (action) {
+            await action.click();
+        }
+    }
+    async closePanel() {
+        let closeButton = await this.findElement(BottomBarPanel.locators.BottomBarPanel.closeAction);
+        await closeButton.click();
+    }
+}
+exports.BottomBarPanel = BottomBarPanel;
+//# sourceMappingURL=BottomBarPanel.js.map

package/out/components/bottomBar/ProblemsView.d.ts

@@ -0,0 +1,88 @@
+import { BottomBarPanel } from "../..";
+import { AbstractElement } from "../AbstractElement";
+import { WebElement } from 'selenium-webdriver';
+import { ElementWithContexMenu } from "../ElementWithContextMenu";
+/**
+ * Problems view in the bottom panel
+ */
+export declare class ProblemsView extends AbstractElement {
+    constructor(panel?: BottomBarPanel);
+    /**
+     * Set the filter using the input box on the problems view
+     * @param pattern filter to use, preferably a glob pattern
+     * @returns Promise resolving when the filter pattern is filled in
+     */
+    setFilter(pattern: string): Promise<void>;
+    /**
+     * Clear all filters
+     * @returns Promise resolving to the filter field WebElement
+     */
+    clearFilter(): Promise<WebElement>;
+    /**
+     * Collapse all collapsible markers in the problems view
+     * @returns Promise resolving when the collapse all button is pressed
+     */
+    collapseAll(): Promise<void>;
+    /**
+     * @deprecated The method should not be used and getAllVisibleMarkers() should be used instead.
+     */
+    getAllMarkers(type: MarkerType): Promise<Marker[]>;
+    /**
+     * Get all visible markers from the problems view with the given type.
+     * Warning: this only returns the markers that are visible, and not the
+     * entire list, so calls to this function may change depending on the
+     * environment  in which the tests are running in.
+     * To get all markers regardless of type, use MarkerType.Any
+     * @param type type of markers to retrieve
+     * @returns Promise resolving to array of Marker objects
+     */
+    getAllVisibleMarkers(type: MarkerType): Promise<Marker[]>;
+    /**
+     * Gets the count badge
+     * @returns Promise resolving to the WebElement representing the count badge
+     */
+    getCountBadge(): Promise<WebElement>;
+}
+/**
+ * Page object for a Marker in Problems view
+ */
+export declare class Marker extends ElementWithContexMenu {
+    constructor(element: WebElement, view: ProblemsView);
+    /**
+     * Get the type of the marker. Possible types are:
+     * - File
+     * - Error
+     * - Warning
+     * @returns Promise resolving to a MarkerType
+     */
+    getType(): Promise<MarkerType>;
+    /**
+     * Get the full text of the Marker row
+     * @returns Promise resolving to a Marker row text
+     */
+    getText(): Promise<string>;
+    /**
+     * Get the Marker label text
+     * @returns Promise resolving to a Marker label
+     */
+    getLabel(): Promise<string>;
+    /**
+     * Expand/Collapse the Marker if possible
+     * @param expand True to expand, False to collapse
+     * @returns Promise resolving when the expand/collapse twistie is clicked
+     */
+    toggleExpand(expand: boolean): Promise<void>;
+}
+/**
+ * Possible types of markers
+ *  - File = expandable item representing a file
+ *  - Error = an error marker
+ *  - Warning = a warning marker
+ *  - Any = any of the above
+ */
+export declare enum MarkerType {
+    File = "file",
+    Error = "error",
+    Warning = "warning",
+    Any = "any"
+}

package/out/components/bottomBar/ProblemsView.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkerType = exports.Marker = exports.ProblemsView = void 0;
+const __1 = require("../..");
+const AbstractElement_1 = require("../AbstractElement");
+const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
+/**
+ * Problems view in the bottom panel
+ */
+class ProblemsView extends AbstractElement_1.AbstractElement {
+    constructor(panel = new __1.BottomBarPanel()) {
+        super(ProblemsView.locators.ProblemsView.constructor, panel);
+    }
+    /**
+     * Set the filter using the input box on the problems view
+     * @param pattern filter to use, preferably a glob pattern
+     * @returns Promise resolving when the filter pattern is filled in
+     */
+    async setFilter(pattern) {
+        const filterField = await this.clearFilter();
+        await filterField.sendKeys(pattern);
+    }
+    /**
+     * Clear all filters
+     * @returns Promise resolving to the filter field WebElement
+     */
+    async clearFilter() {
+        const filterField = await this.enclosingItem.findElement(ProblemsView.locators.BottomBarPanel.actions)
+            .findElement(ProblemsView.locators.ProblemsView.markersFilter)
+            .findElement(ProblemsView.locators.ProblemsView.input);
+        await filterField.clear();
+        return filterField;
+    }
+    /**
+     * Collapse all collapsible markers in the problems view
+     * @returns Promise resolving when the collapse all button is pressed
+     */
+    async collapseAll() {
+        const button = await this.enclosingItem.findElement(ProblemsView.locators.BottomBarPanel.actions)
+            .findElement(ProblemsView.locators.ProblemsView.collapseAll);
+        await button.click();
+    }
+    /**
+     * @deprecated The method should not be used and getAllVisibleMarkers() should be used instead.
+     */
+    async getAllMarkers(type) {
+        return this.getAllVisibleMarkers(type);
+    }
+    /**
+     * Get all visible markers from the problems view with the given type.
+     * Warning: this only returns the markers that are visible, and not the
+     * entire list, so calls to this function may change depending on the
+     * environment  in which the tests are running in.
+     * To get all markers regardless of type, use MarkerType.Any
+     * @param type type of markers to retrieve
+     * @returns Promise resolving to array of Marker objects
+     */
+    async getAllVisibleMarkers(type) {
+        const markers = [];
+        const elements = await this.findElements(ProblemsView.locators.ProblemsView.markerRow);
+        for (const element of elements) {
+            let marker;
+            marker = await new Marker(element, this).wait();
+            if (type === MarkerType.Any || type === await marker.getType()) {
+                markers.push(marker);
+            }
+        }
+        return markers;
+    }
+    /**
+     * Gets the count badge
+     * @returns Promise resolving to the WebElement representing the count badge
+     */
+    async getCountBadge() {
+        return await this.findElement(ProblemsView.locators.ProblemsView.changeCount);
+    }
+}
+exports.ProblemsView = ProblemsView;
+/**
+ * Page object for a Marker in Problems view
+ */
+class Marker extends ElementWithContextMenu_1.ElementWithContexMenu {
+    constructor(element, view) {
+        super(element, view);
+    }
+    /**
+     * Get the type of the marker. Possible types are:
+     * - File
+     * - Error
+     * - Warning
+     * @returns Promise resolving to a MarkerType
+     */
+    async getType() {
+        const twist = await this.findElement(ProblemsView.locators.ProblemsView.markerTwistie);
+        if ((await twist.getAttribute('class')).indexOf('collapsible') > -1) {
+            return MarkerType.File;
+        }
+        const text = await this.getText();
+        if (text.startsWith('Error')) {
+            return MarkerType.Error;
+        }
+        else {
+            return MarkerType.Warning;
+        }
+    }
+    /**
+     * Get the full text of the Marker row
+     * @returns Promise resolving to a Marker row text
+     */
+    async getText() {
+        return await this.getAttribute(ProblemsView.locators.ProblemsView.rowLabel);
+    }
+    /**
+     * Get the Marker label text
+     * @returns Promise resolving to a Marker label
+     */
+    async getLabel() {
+        return await (await this.findElement(ProblemsView.locators.ProblemsView.label)).getText();
+    }
+    /**
+     * Expand/Collapse the Marker if possible
+     * @param expand True to expand, False to collapse
+     * @returns Promise resolving when the expand/collapse twistie is clicked
+     */
+    async toggleExpand(expand) {
+        if (await this.getType() === MarkerType.File) {
+            const klass = await this.findElement(ProblemsView.locators.ProblemsView.markerTwistie).getAttribute('class');
+            if ((klass.indexOf('collapsed') > -1) === expand) {
+                await this.click();
+            }
+        }
+    }
+}
+exports.Marker = Marker;
+/**
+ * Possible types of markers
+ *  - File = expandable item representing a file
+ *  - Error = an error marker
+ *  - Warning = a warning marker
+ *  - Any = any of the above
+ */
+var MarkerType;
+(function (MarkerType) {
+    MarkerType["File"] = "file";
+    MarkerType["Error"] = "error";
+    MarkerType["Warning"] = "warning";
+    MarkerType["Any"] = "any";
+})(MarkerType || (exports.MarkerType = MarkerType = {}));
+//# sourceMappingURL=ProblemsView.js.map

package/out/components/bottomBar/Views.d.ts

@@ -0,0 +1,75 @@
+import { BottomBarPanel, ContentAssist } from "../..";
+import { TextView, ChannelView } from "./AbstractViews";
+import { ElementWithContexMenu } from "../ElementWithContextMenu";
+/**
+ * Output view of the bottom panel
+ */
+export declare class OutputView extends TextView {
+    constructor(panel?: BottomBarPanel);
+    /**
+     * Select a channel using the selector combo
+     * @param name name of the channel to open
+     */
+    selectChannel(name: string): Promise<void>;
+}
+/**
+ * Debug Console view on the bottom panel
+ * Most functionality will only be available when a debug session is running
+ */
+export declare class DebugConsoleView extends ElementWithContexMenu {
+    constructor(panel?: BottomBarPanel);
+    /**
+     * Clear the console of all text
+     */
+    clearText(): Promise<void>;
+    /**
+     * Type an expression into the debug console text area
+     * @param expression expression in form of a string
+     */
+    setExpression(expression: string): Promise<void>;
+    /**
+     * Evaluate an expression:
+     *  - if no argument is supplied, evaluate the current expression present in debug console text area
+     *  - if a string argument is supplied, replace the current expression with the `expression` argument and evaluate
+     *
+     * @param expression expression to evaluate. To use existing contents of the debug console text area instead, don't define this argument
+     */
+    evaluateExpression(expression?: string): Promise<void>;
+    /**
+     * Create a content assist page object
+     * @returns promise resolving to ContentAssist object
+     */
+    getContentAssist(): Promise<ContentAssist>;
+}
+/**
+ * Terminal view on the bottom panel
+ */
+export declare class TerminalView extends ChannelView {
+    constructor(panel?: BottomBarPanel);
+    /**
+     * Execute command in the internal terminal and wait for results
+     * @param command text of the command
+     * @param timeout optional maximum time to wait for completion in milliseconds, 0 for unlimited
+     * @returns Promise resolving when the command is finished
+     */
+    executeCommand(command: string, timeout?: number): Promise<void>;
+    /**
+     * Get all text from the internal terminal
+     * Beware, no formatting.
+     *
+     * @returns Promise resolving to all terminal text
+     */
+    getText(): Promise<string>;
+    /**
+     * Destroy the currently open terminal
+     * @returns Promise resolving when Kill Terminal button is pressed
+     */
+    killTerminal(): Promise<void>;
+    /**
+     * Initiate new terminal creation
+     * @returns Promise resolving when New Terminal button is pressed
+     */
+    newTerminal(): Promise<void>;
+    getCurrentChannel(): Promise<string>;
+    selectChannel(name: string): Promise<void>;
+}