@redhat-developer/page-objects 1.0.0

package/out/components/statusBar/StatusBar.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusBar = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const AbstractElement_1 = require("../AbstractElement");
+const NotificationsCenter_1 = require("../workbench/NotificationsCenter");
+/**
+ * Page object for the status bar at the bottom
+ */
+class StatusBar extends AbstractElement_1.AbstractElement {
+    constructor() {
+        super(StatusBar.locators.StatusBar.constructor, StatusBar.locators.Workbench.constructor);
+    }
+    /**
+     * Retrieve all status bar items currently displayed
+     * @returns Promise resolving to an array of WebElement
+     */
+    async getItems() {
+        return await this.findElements(StatusBar.locators.StatusBar.item);
+    }
+    /**
+     * Find status bar item by title/visible label
+     * @param title title of the item
+     * @returns Promise resolving to a WebElement if item is found, to undefined otherwise
+     */
+    async getItem(title) {
+        const items = await this.getItems();
+        for (const item of items) {
+            try {
+                if (await item.getAttribute(StatusBar.locators.StatusBar.itemTitle) === title) {
+                    return item;
+                }
+            }
+            catch (err) {
+                if (!(err instanceof selenium_webdriver_1.error.StaleElementReferenceError)) {
+                    throw err;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Open the notifications center
+     * @returns Promise resolving to NotificationsCenter object
+     */
+    async openNotificationsCenter() {
+        await this.toggleNotificationsCentre(true);
+        return new NotificationsCenter_1.NotificationsCenter();
+    }
+    /**
+     * Close the notifications center
+     * @returns Promise resolving when the notifications center is closed
+     */
+    async closeNotificationsCenter() {
+        await this.toggleNotificationsCentre(false);
+    }
+    /**
+     * Open the language selection quick pick
+     * Only works with an open editor
+     * @returns Promise resolving when the language selection is opened
+     */
+    async openLanguageSelection() {
+        await this.findElement(StatusBar.locators.StatusBar.language).click();
+    }
+    /**
+     * Get the current language label text
+     * Only works with an open editor
+     * @returns Promise resolving to string representation of current language
+     */
+    async getCurrentLanguage() {
+        return await this.getPartText(StatusBar.locators.StatusBar.language);
+    }
+    /**
+     * Open the quick pick for line endings selection
+     * Only works with an open editor
+     * @returns Promise resolving when the line ending selection is opened
+     */
+    async openLineEndingSelection() {
+        await this.findElement(StatusBar.locators.StatusBar.lines).click();
+    }
+    /**
+     * Get the currently selected line ending as text
+     * Only works with an open editor
+     * @returns Promise resolving to string representation of current line ending
+     */
+    async getCurrentLineEnding() {
+        return await this.getPartText(StatusBar.locators.StatusBar.lines);
+    }
+    /**
+     * Open the encoding selection quick pick
+     * Only works with an open editor
+     * @returns Promise resolving when the encoding selection is opened
+     */
+    async openEncodingSelection() {
+        await this.findElement(StatusBar.locators.StatusBar.encoding).click();
+    }
+    /**
+     * Get the name of the current encoding as text
+     * Only works with an open editor
+     * @returns Promise resolving to string representation of current encoding
+     */
+    async getCurrentEncoding() {
+        return await this.getPartText(StatusBar.locators.StatusBar.encoding);
+    }
+    /**
+     * Open the indentation selection quick pick
+     * Only works with an open editor
+     * @returns Promise resolving when the indentation selection is opened
+     */
+    async openIndentationSelection() {
+        await this.findElement(StatusBar.locators.StatusBar.indent).click();
+    }
+    /**
+     * Get the current indentation option label as text
+     * Only works with an open editor
+     * @returns Promise resolving to string representation of current indentation
+     */
+    async getCurrentIndentation() {
+        return await this.getPartText(StatusBar.locators.StatusBar.indent);
+    }
+    /**
+     * Open the line selection input box
+     * Only works with an open editor
+     * @returns Promise resolving when the line selection is opened
+     */
+    async openLineSelection() {
+        await this.findElement(StatusBar.locators.StatusBar.selection).click();
+    }
+    /**
+     * Get the current editor coordinates as text
+     * Only works with an open editor
+     * @returns Promise resolving to string representation of current position in the editor
+     */
+    async getCurrentPosition() {
+        return await this.getPartText(StatusBar.locators.StatusBar.selection);
+    }
+    /**
+     * Open/Close notification centre
+     * @param open true to open, false to close
+     */
+    async toggleNotificationsCentre(open) {
+        let visible = false;
+        try {
+            const klass = await this.enclosingItem.findElement(StatusBar.locators.StatusBar.notifications).getAttribute('class');
+            visible = klass.indexOf('visible') > -1;
+        }
+        catch (err) {
+            // element doesn't exist until the button is first clicked
+        }
+        if (visible !== open) {
+            await this.findElement(StatusBar.locators.StatusBar.bell).click();
+        }
+    }
+    async getPartText(locator) {
+        return await this.findElement(locator).findElement(selenium_webdriver_1.By.css('a')).getAttribute('innerHTML');
+    }
+}
+exports.StatusBar = StatusBar;
+//# sourceMappingURL=StatusBar.js.map

package/out/components/workbench/DebugToolbar.d.ts

@@ -0,0 +1,52 @@
+import { AbstractElement } from "../AbstractElement";
+/**
+ * Page object for the Debugger Toolbar
+ */
+export declare class DebugToolbar extends AbstractElement {
+    constructor();
+    /**
+     * Wait for the debug toolbar to appear and instantiate it.
+     * Assumes that debug session is already starting and it is just
+     * a matter of waiting for the toolbar to appear.
+     *
+     * @param timeout max time to wait in milliseconds, default 5000
+     */
+    static create(timeout?: number): Promise<DebugToolbar>;
+    /**
+     * Wait for the execution to pause at the next breakpoint
+     */
+    waitForBreakPoint(timeout?: undefined): Promise<void>;
+    /**
+     * Click Continue
+     */
+    continue(): Promise<void>;
+    /**
+     * Click Disconnect
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Click Pause
+     */
+    pause(): Promise<void>;
+    /**
+     * Click Step Over
+     */
+    stepOver(): Promise<void>;
+    /**
+     * Click Step Into
+     */
+    stepInto(): Promise<void>;
+    /**
+     * Click Step Out
+     */
+    stepOut(): Promise<void>;
+    /**
+     * Click Restart
+     */
+    restart(): Promise<void>;
+    /**
+     * Click Stop
+     */
+    stop(): Promise<void>;
+    private getButton;
+}

package/out/components/workbench/DebugToolbar.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugToolbar = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const AbstractElement_1 = require("../AbstractElement");
+const Workbench_1 = require("./Workbench");
+/**
+ * Page object for the Debugger Toolbar
+ */
+class DebugToolbar extends AbstractElement_1.AbstractElement {
+    constructor() {
+        super(DebugToolbar.locators.DebugToolbar.ctor, new Workbench_1.Workbench());
+    }
+    /**
+     * Wait for the debug toolbar to appear and instantiate it.
+     * Assumes that debug session is already starting and it is just
+     * a matter of waiting for the toolbar to appear.
+     *
+     * @param timeout max time to wait in milliseconds, default 5000
+     */
+    static async create(timeout = 5000) {
+        await DebugToolbar.driver.wait(selenium_webdriver_1.until.elementLocated(DebugToolbar.locators.DebugToolbar.ctor), timeout);
+        return new DebugToolbar().wait(timeout);
+    }
+    /**
+     * Wait for the execution to pause at the next breakpoint
+     */
+    async waitForBreakPoint(timeout = undefined) {
+        let btn = await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(DebugToolbar.locators.DebugToolbar.button('continue')));
+        await this.getDriver().wait(async () => {
+            try {
+                const enabled = await btn.isEnabled();
+                return enabled;
+            }
+            catch (err) {
+                btn = await this.findElement(DebugToolbar.locators.DebugToolbar.button('continue'));
+            }
+        }, timeout);
+    }
+    /**
+     * Click Continue
+     */
+    async continue() {
+        await (await this.getButton('continue')).click();
+    }
+    /**
+     * Click Disconnect
+     */
+    async disconnect() {
+        await (await this.getButton('disconnect')).click();
+    }
+    /**
+     * Click Pause
+     */
+    async pause() {
+        await (await this.getButton('pause')).click();
+    }
+    /**
+     * Click Step Over
+     */
+    async stepOver() {
+        await (await this.getButton('step-over')).click();
+    }
+    /**
+     * Click Step Into
+     */
+    async stepInto() {
+        await (await this.getButton('step-into')).click();
+    }
+    /**
+     * Click Step Out
+     */
+    async stepOut() {
+        await (await this.getButton('step-out')).click();
+    }
+    /**
+     * Click Restart
+     */
+    async restart() {
+        await (await this.getButton('restart')).click();
+    }
+    /**
+     * Click Stop
+     */
+    async stop() {
+        await (await this.getButton('stop')).click();
+    }
+    async getButton(name) {
+        return await this.findElement(DebugToolbar.locators.DebugToolbar.button(name));
+    }
+}
+exports.DebugToolbar = DebugToolbar;
+//# sourceMappingURL=DebugToolbar.js.map

package/out/components/workbench/Notification.d.ts

@@ -0,0 +1,78 @@
+import { ElementWithContexMenu } from "../ElementWithContextMenu";
+import { AbstractElement } from "../AbstractElement";
+import { By, WebElement } from "selenium-webdriver";
+/**
+ * Available types of notifications
+ */
+export declare enum NotificationType {
+    Info = "info",
+    Warning = "warning",
+    Error = "error",
+    Any = "any"
+}
+/**
+ * Abstract element representing a notification
+ */
+export declare abstract class Notification extends ElementWithContexMenu {
+    /**
+     * Get the message of the notification
+     * @returns Promise resolving to notification message
+     */
+    getMessage(): Promise<string>;
+    /**
+     * Get the type of the notification
+     * @returns Promise resolving to NotificationType
+     */
+    getType(): Promise<NotificationType>;
+    /**
+     * Get the source of the notification as text
+     * @returns Promise resolving to notification source
+     */
+    getSource(): Promise<string>;
+    /**
+     * Find whether the notification has an active progress bar
+     * @returns Promise resolving to true/false
+     */
+    hasProgress(): Promise<boolean>;
+    /**
+     * Dismiss the notification
+     * @returns Promise resolving when notification is dismissed
+     */
+    dismiss(): Promise<void>;
+    /**
+     * Get the action buttons of the notification as an array
+     * of NotificationButton objects
+     * @returns Promise resolving to array of NotificationButton objects
+     */
+    getActions(): Promise<NotificationButton[]>;
+    /**
+     * Click on an action button with the given title
+     * @param title title of the action/button
+     * @returns Promise resolving when the select button is pressed
+     */
+    takeAction(title: string): Promise<void>;
+    /**
+     * Expand the notification if possible
+     */
+    expand(): Promise<void>;
+}
+/**
+ * Notification displayed on its own in the notifications-toasts container
+ */
+export declare class StandaloneNotification extends Notification {
+    constructor(notification: WebElement);
+}
+/**
+ * Notification displayed within the notifications center
+ */
+export declare class CenterNotification extends Notification {
+    constructor(notification: WebElement);
+}
+/**
+ * Notification button
+ */
+declare class NotificationButton extends AbstractElement {
+    constructor(buttonConstructor: By, notification: Notification);
+    getTitle(): Promise<string>;
+}
+export {};

package/out/components/workbench/Notification.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CenterNotification = exports.StandaloneNotification = exports.Notification = exports.NotificationType = void 0;
+const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
+const AbstractElement_1 = require("../AbstractElement");
+const selenium_webdriver_1 = require("selenium-webdriver");
+/**
+ * Available types of notifications
+ */
+var NotificationType;
+(function (NotificationType) {
+    NotificationType["Info"] = "info";
+    NotificationType["Warning"] = "warning";
+    NotificationType["Error"] = "error";
+    NotificationType["Any"] = "any";
+})(NotificationType || (exports.NotificationType = NotificationType = {}));
+/**
+ * Abstract element representing a notification
+ */
+class Notification extends ElementWithContextMenu_1.ElementWithContexMenu {
+    /**
+     * Get the message of the notification
+     * @returns Promise resolving to notification message
+     */
+    async getMessage() {
+        return await (await this.findElement(Notification.locators.Notification.message)).getText();
+    }
+    /**
+     * Get the type of the notification
+     * @returns Promise resolving to NotificationType
+     */
+    async getType() {
+        const iconType = await (await this.findElement(Notification.locators.Notification.icon)).getAttribute('class');
+        if (iconType.indexOf('icon-info') > -1) {
+            return NotificationType.Info;
+        }
+        else if (iconType.indexOf('icon-warning') > -1) {
+            return NotificationType.Warning;
+        }
+        else {
+            return NotificationType.Error;
+        }
+    }
+    /**
+     * Get the source of the notification as text
+     * @returns Promise resolving to notification source
+     */
+    async getSource() {
+        await this.expand();
+        return await (await this.findElement(Notification.locators.Notification.source)).getAttribute('title');
+    }
+    /**
+     * Find whether the notification has an active progress bar
+     * @returns Promise resolving to true/false
+     */
+    async hasProgress() {
+        const klass = await (await this.findElement(Notification.locators.Notification.progress)).getAttribute('class');
+        return klass.indexOf('done') < 0;
+    }
+    /**
+     * Dismiss the notification
+     * @returns Promise resolving when notification is dismissed
+     */
+    async dismiss() {
+        await this.getDriver().actions().move({ origin: this }).perform();
+        const btn = await this.findElement(Notification.locators.Notification.dismiss);
+        await this.getDriver().wait(selenium_webdriver_1.until.elementIsVisible(btn), 2000);
+        await btn.click();
+    }
+    /**
+     * Get the action buttons of the notification as an array
+     * of NotificationButton objects
+     * @returns Promise resolving to array of NotificationButton objects
+     */
+    async getActions() {
+        const buttons = [];
+        const elements = await this.findElement(Notification.locators.Notification.actions)
+            .findElements(Notification.locators.Notification.action);
+        for (const button of elements) {
+            const title = await Notification.locators.Notification.actionLabel.value(button);
+            buttons.push(await new NotificationButton(Notification.locators.Notification.buttonConstructor(title), this).wait());
+        }
+        return buttons;
+    }
+    /**
+     * Click on an action button with the given title
+     * @param title title of the action/button
+     * @returns Promise resolving when the select button is pressed
+     */
+    async takeAction(title) {
+        await new NotificationButton(Notification.locators.Notification.buttonConstructor(title), this).click();
+    }
+    /**
+     * Expand the notification if possible
+     */
+    async expand() {
+        await this.getDriver().actions().move({ origin: this }).perform();
+        const exp = await this.findElements(Notification.locators.Notification.expand);
+        if (exp[0]) {
+            await exp[0].click();
+        }
+    }
+}
+exports.Notification = Notification;
+/**
+ * Notification displayed on its own in the notifications-toasts container
+ */
+class StandaloneNotification extends Notification {
+    constructor(notification) {
+        super(notification, StandaloneNotification.locators.Notification.standaloneContainer);
+    }
+}
+exports.StandaloneNotification = StandaloneNotification;
+/**
+ * Notification displayed within the notifications center
+ */
+class CenterNotification extends Notification {
+    constructor(notification) {
+        super(notification, CenterNotification.locators.NotificationsCenter.constructor);
+    }
+}
+exports.CenterNotification = CenterNotification;
+/**
+ * Notification button
+ */
+class NotificationButton extends AbstractElement_1.AbstractElement {
+    constructor(buttonConstructor, notification) {
+        super(buttonConstructor, notification);
+    }
+    async getTitle() {
+        return await Notification.locators.Notification.actionLabel.value(this);
+    }
+}
+//# sourceMappingURL=Notification.js.map

package/out/components/workbench/NotificationsCenter.d.ts

@@ -0,0 +1,27 @@
+import { AbstractElement } from "../AbstractElement";
+import { Notification, NotificationType } from "./Notification";
+/**
+ * Notifications center page object
+ */
+export declare class NotificationsCenter extends AbstractElement {
+    constructor();
+    /**
+     * Close the notifications center
+     * @returns Promise resolving when the center is closed
+     */
+    close(): Promise<void>;
+    /**
+     * Clear all notifications in the notifications center
+     * Note that this will also hide the notifications center
+     * @returns Promise resolving when the clear all button is pressed
+     */
+    clearAllNotifications(): Promise<void>;
+    /**
+     * Get all notifications of a given type
+     * @param type type of the notifications to look for,
+     * NotificationType.Any will retrieve all notifications
+     *
+     * @returns Promise resolving to array of Notification objects
+     */
+    getNotifications(type: NotificationType): Promise<Notification[]>;
+}

package/out/components/workbench/NotificationsCenter.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsCenter = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const AbstractElement_1 = require("../AbstractElement");
+const Notification_1 = require("./Notification");
+/**
+ * Notifications center page object
+ */
+class NotificationsCenter extends AbstractElement_1.AbstractElement {
+    constructor() {
+        super(NotificationsCenter.locators.NotificationsCenter.constructor, NotificationsCenter.locators.Workbench.constructor);
+    }
+    /**
+     * Close the notifications center
+     * @returns Promise resolving when the center is closed
+     */
+    async close() {
+        if (await this.isDisplayed()) {
+            try {
+                await this.findElement(NotificationsCenter.locators.NotificationsCenter.close).click();
+            }
+            catch (error) {
+                await this.click();
+                this.getDriver().actions().sendKeys(selenium_webdriver_1.Key.ESCAPE).perform();
+            }
+        }
+    }
+    /**
+     * Clear all notifications in the notifications center
+     * Note that this will also hide the notifications center
+     * @returns Promise resolving when the clear all button is pressed
+     */
+    async clearAllNotifications() {
+        await this.findElement(NotificationsCenter.locators.NotificationsCenter.clear).click();
+    }
+    /**
+     * Get all notifications of a given type
+     * @param type type of the notifications to look for,
+     * NotificationType.Any will retrieve all notifications
+     *
+     * @returns Promise resolving to array of Notification objects
+     */
+    async getNotifications(type) {
+        const notifications = [];
+        const elements = await this.findElements(NotificationsCenter.locators.NotificationsCenter.row);
+        for (const element of elements) {
+            const not = new Notification_1.CenterNotification(element);
+            if (type === Notification_1.NotificationType.Any || await not.getType() === type) {
+                notifications.push(await not.wait());
+            }
+        }
+        return notifications;
+    }
+}
+exports.NotificationsCenter = NotificationsCenter;
+//# sourceMappingURL=NotificationsCenter.js.map

package/out/components/workbench/Workbench.d.ts

@@ -0,0 +1,69 @@
+import { AbstractElement } from "../AbstractElement";
+import { TitleBar } from "../menu/TitleBar";
+import { SideBarView } from "../sidebar/SideBarView";
+import { ActivityBar } from "../activityBar/ActivityBar";
+import { StatusBar } from "../statusBar/StatusBar";
+import { EditorView } from "../editor/EditorView";
+import { BottomBarPanel } from "../bottomBar/BottomBarPanel";
+import { Notification } from "./Notification";
+import { NotificationsCenter } from "./NotificationsCenter";
+import { QuickOpenBox } from "./input/QuickOpenBox";
+import { SettingsEditor } from "../editor/SettingsEditor";
+import { InputBox } from "./input/InputBox";
+/**
+ * Handler for general workbench related actions
+ */
+export declare class Workbench extends AbstractElement {
+    constructor();
+    /**
+     * Get a title bar handle
+     */
+    getTitleBar(): TitleBar;
+    /**
+     * Get a side bar handle
+     */
+    getSideBar(): SideBarView;
+    /**
+     * Get an activity bar handle
+     */
+    getActivityBar(): ActivityBar;
+    /**
+     * Get a status bar handle
+     */
+    getStatusBar(): StatusBar;
+    /**
+     * Get a bottom bar handle
+     */
+    getBottomBar(): BottomBarPanel;
+    /**
+     * Get a handle for the editor view
+     */
+    getEditorView(): EditorView;
+    /**
+     * Get all standalone notifications (notifications outside the notifications center)
+     * @returns Promise resolving to array of Notification objects
+     */
+    getNotifications(): Promise<Notification[]>;
+    /**
+     * Opens the notifications center
+     * @returns Promise resolving to NotificationsCenter object
+     */
+    openNotificationsCenter(): Promise<NotificationsCenter>;
+    /**
+     * Opens the settings editor
+     *
+     * @returns promise that resolves to a SettingsEditor instance
+     */
+    openSettings(): Promise<SettingsEditor>;
+    /**
+     * Open the VS Code command line prompt
+     * @returns Promise resolving to InputBox (vscode 1.44+) or QuickOpenBox (vscode up to 1.43) object
+     */
+    openCommandPrompt(): Promise<QuickOpenBox | InputBox>;
+    /**
+     * Open the command prompt, type in a command and execute
+     * @param command text of the command to be executed
+     * @returns Promise resolving when the command prompt is confirmed
+     */
+    executeCommand(command: string): Promise<void>;
+}