@redhat-developer/page-objects 1.0.0

package/out/components/editor/WebView.d.ts

@@ -0,0 +1,11 @@
+import { WebElement } from "selenium-webdriver";
+import { Editor } from "./Editor";
+/**
+ * Page object representing an open editor containing a web view
+ */
+declare class WebViewBase extends Editor {
+    getViewToSwitchTo(handle: string): Promise<WebElement | undefined>;
+}
+export declare const WebView: new (...args: any[]) => WebViewBase & import("../WebviewMixin").WebviewMixinType;
+export type WebView = InstanceType<typeof WebView>;
+export {};

package/out/components/editor/WebView.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebView = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const WebviewMixin_1 = __importDefault(require("../WebviewMixin"));
+const Editor_1 = require("./Editor");
+/**
+ * Page object representing an open editor containing a web view
+ */
+class WebViewBase extends Editor_1.Editor {
+    async getViewToSwitchTo(handle) {
+        const handles = await this.getDriver().getAllWindowHandles();
+        for (const handle of handles) {
+            await this.getDriver().switchTo().window(handle);
+            if ((await this.getDriver().getTitle()).includes('Virtual Document')) {
+                await this.getDriver().switchTo().frame(0);
+                return;
+            }
+        }
+        await this.getDriver().switchTo().window(handle);
+        const reference = await this.findElement(WebViewBase.locators.EditorView.webView);
+        const containers = await this.getDriver().wait(selenium_webdriver_1.until.elementsLocated(WebViewBase.locators.WebView.container(await reference.getAttribute(WebViewBase.locators.WebView.attribute))), 5000);
+        return await containers[0].getDriver().wait(async () => {
+            for (let container of containers) {
+                const tries = await container.findElements(WebViewBase.locators.WebView.iframe);
+                if (tries.length > 0) {
+                    return tries[0];
+                }
+            }
+            return undefined;
+        }, 5000);
+    }
+}
+exports.WebView = (0, WebviewMixin_1.default)(WebViewBase);
+//# sourceMappingURL=WebView.js.map

package/out/components/menu/ContextMenu.d.ts

@@ -0,0 +1,37 @@
+import { Menu, MenuItem } from "../..";
+import { WebElement } from "selenium-webdriver";
+/**
+ * Object representing a context menu
+ */
+export declare class ContextMenu extends Menu {
+    constructor(containingElement: WebElement);
+    /**
+     * Get context menu item by name
+     * @param name name of the item to search by
+     * @returns Promise resolving to ContextMenuItem object
+     */
+    getItem(name: string): Promise<ContextMenuItem | undefined>;
+    /**
+     * Get all context menu items
+     * @returns Promise resolving to array of ContextMenuItem objects
+     */
+    getItems(): Promise<ContextMenuItem[]>;
+    /**
+     * Close the context menu
+     * @returns Promise resolving when the menu is closed
+     */
+    close(): Promise<void>;
+    /**
+     * Wait for the menu to appear and load all its items
+     */
+    wait(timeout?: number): Promise<this>;
+}
+/**
+ * Object representing an item of a context menu
+ */
+export declare class ContextMenuItem extends MenuItem {
+    constructor(item: WebElement, parent: Menu);
+    select(): Promise<Menu | undefined>;
+    getLabel(): Promise<string>;
+    private isNesting;
+}

package/out/components/menu/ContextMenu.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextMenuItem = exports.ContextMenu = void 0;
+const __1 = require("../..");
+const selenium_webdriver_1 = require("selenium-webdriver");
+/**
+ * Object representing a context menu
+ */
+class ContextMenu extends __1.Menu {
+    constructor(containingElement) {
+        super(ContextMenu.locators.ContextMenu.constructor, containingElement);
+    }
+    /**
+     * Get context menu item by name
+     * @param name name of the item to search by
+     * @returns Promise resolving to ContextMenuItem object
+     */
+    async getItem(name) {
+        try {
+            const items = await this.getItems();
+            for (const item of items) {
+                if (await item.getLabel() === name) {
+                    return item;
+                }
+            }
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    /**
+     * Get all context menu items
+     * @returns Promise resolving to array of ContextMenuItem objects
+     */
+    async getItems() {
+        const items = [];
+        const elements = await this.findElements(ContextMenu.locators.ContextMenu.itemElement);
+        for (const element of elements) {
+            const klass = await element.getAttribute('class');
+            if (klass.indexOf('disabled') < 0) {
+                items.push(await new ContextMenuItem(element, this).wait());
+            }
+        }
+        return items;
+    }
+    /**
+     * Close the context menu
+     * @returns Promise resolving when the menu is closed
+     */
+    async close() {
+        let actions = this.getDriver().actions();
+        await actions.clear();
+        await this.getDriver().actions().sendKeys(selenium_webdriver_1.Key.ESCAPE).perform();
+        try {
+            await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this));
+        }
+        catch (err) {
+            if (!(err instanceof selenium_webdriver_1.error.StaleElementReferenceError)) {
+                throw err;
+            }
+        }
+    }
+    /**
+     * Wait for the menu to appear and load all its items
+     */
+    async wait(timeout = 5000) {
+        await this.getDriver().wait(selenium_webdriver_1.until.elementIsVisible(this), timeout);
+        let items = (await this.getItems()).length;
+        try {
+            await this.getDriver().wait(async () => {
+                const temp = (await this.getItems()).length;
+                if (temp === items) {
+                    return true;
+                }
+                else {
+                    items = temp;
+                    return false;
+                }
+            }, 1000);
+        }
+        catch (err) {
+            if (err instanceof selenium_webdriver_1.error.TimeoutError) {
+                // ignore timeout
+            }
+            else {
+                throw err;
+            }
+        }
+        return this;
+    }
+}
+exports.ContextMenu = ContextMenu;
+/**
+ * Object representing an item of a context menu
+ */
+class ContextMenuItem extends __1.MenuItem {
+    constructor(item, parent) {
+        super(item, parent);
+        this.parent = parent;
+    }
+    async select() {
+        await this.click();
+        await new Promise(res => setTimeout(res, 500));
+        if (await this.isNesting()) {
+            return await new ContextMenu(this).wait();
+        }
+        return undefined;
+    }
+    async getLabel() {
+        const labelItem = await this.findElement(ContextMenu.locators.ContextMenu.itemLabel);
+        return await labelItem.getAttribute(ContextMenu.locators.ContextMenu.itemText);
+    }
+    async isNesting() {
+        try {
+            return await this.findElement(ContextMenu.locators.ContextMenu.itemNesting).isDisplayed();
+        }
+        catch (err) {
+            return false;
+        }
+    }
+}
+exports.ContextMenuItem = ContextMenuItem;
+//# sourceMappingURL=ContextMenu.js.map

package/out/components/menu/MacTitleBar.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Handler object for macOS based title bar
+ */
+export declare class MacTitleBar {
+    /**
+     * Select an item from the mac menu bar by its path,
+     * does not actually visibly open the menus.
+     *
+     * @param items varargs path to the given menu item
+     *  each argument serves as a part of the path in order,
+     *
+     *  e.g. ('File', 'Save') will select the 'Save' item from
+     *  the 'File' submenu
+     */
+    static select(...items: string[]): void;
+}

package/out/components/menu/MacTitleBar.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MacTitleBar = void 0;
+const child_process_1 = require("child_process");
+/**
+ * Handler object for macOS based title bar
+ */
+class MacTitleBar {
+    /**
+     * Select an item from the mac menu bar by its path,
+     * does not actually visibly open the menus.
+     *
+     * @param items varargs path to the given menu item
+     *  each argument serves as a part of the path in order,
+     *
+     *  e.g. ('File', 'Save') will select the 'Save' item from
+     *  the 'File' submenu
+     */
+    static select(...items) {
+        let menuCounter = 0;
+        const commands = [
+            `tell application "System Events"`,
+            `tell process "Code"`,
+            `tell menu bar item "${items[0]}" of menu bar 1`
+        ];
+        for (let i = 1; i < items.length - 1; i++) {
+            commands.push(`tell menu item "${items[i]}" of menu 1`);
+            ++menuCounter;
+        }
+        if (items.length > 1) {
+            commands.push(`click menu item "${items[items.length - 1]}" of menu 1`);
+        }
+        for (let i = 0; i < menuCounter + 3; i++) {
+            commands.push(`end tell`);
+        }
+        const command = `osascript -e '${commands.join('\n')}'`;
+        (0, child_process_1.execSync)(command);
+    }
+}
+exports.MacTitleBar = MacTitleBar;
+//# sourceMappingURL=MacTitleBar.js.map

package/out/components/menu/Menu.d.ts

@@ -0,0 +1,38 @@
+import { AbstractElement } from "../AbstractElement";
+import { MenuItem } from "./MenuItem";
+/**
+ * Abstract element representing a menu
+ */
+export declare abstract class Menu extends AbstractElement {
+    /**
+     * Find whether the menu has an item of a given name
+     * @param name name of the item to search for
+     * @returns true if menu has an item with the given name, false otherwise
+     */
+    hasItem(name: string): Promise<boolean>;
+    /**
+     * Return a menu item of a given name, undefined if not found
+     * @param name name of the item to search for
+     */
+    abstract getItem(name: string): Promise<MenuItem | undefined>;
+    /**
+     * Get all items of a menu
+     * @returns array of MenuItem object representing the menu items
+     */
+    abstract getItems(): Promise<MenuItem[]>;
+    /**
+     * Recursively select an item with a given path.
+     *
+     * E.g. calling select('File', 'Preferences', 'Settings') will
+     * open the 'File' -> 'Preferences' submenus and then click on 'Settings'.
+     *
+     * Selection happens in order of the arguments, if one of the items in the middle
+     * of the path has no children, the consequent path arguments will be ignored.
+     *
+     *
+     * @param path path to the item to select, represented by a sequence of strings
+     * @returns void if the last clicked item is a leaf, Menu item representing
+     * its submenu otherwise
+     */
+    select(...path: string[]): Promise<Menu | undefined>;
+}

package/out/components/menu/Menu.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Menu = void 0;
+const AbstractElement_1 = require("../AbstractElement");
+/**
+ * Abstract element representing a menu
+ */
+class Menu extends AbstractElement_1.AbstractElement {
+    /**
+     * Find whether the menu has an item of a given name
+     * @param name name of the item to search for
+     * @returns true if menu has an item with the given name, false otherwise
+     */
+    async hasItem(name) {
+        const item = await this.getItem(name);
+        return !!item && (item).isDisplayed();
+    }
+    /**
+     * Recursively select an item with a given path.
+     *
+     * E.g. calling select('File', 'Preferences', 'Settings') will
+     * open the 'File' -> 'Preferences' submenus and then click on 'Settings'.
+     *
+     * Selection happens in order of the arguments, if one of the items in the middle
+     * of the path has no children, the consequent path arguments will be ignored.
+     *
+     *
+     * @param path path to the item to select, represented by a sequence of strings
+     * @returns void if the last clicked item is a leaf, Menu item representing
+     * its submenu otherwise
+     */
+    async select(...path) {
+        let parent = this;
+        for (const label of path) {
+            const item = await parent.getItem(label);
+            if (!item)
+                return parent;
+            await Menu.driver.wait(async function () {
+                return await item.isDisplayed() && await item.isEnabled();
+            });
+            const submenu = await item.select();
+            if (submenu) {
+                parent = submenu;
+            }
+            else {
+                return;
+            }
+        }
+        return parent;
+    }
+}
+exports.Menu = Menu;
+//# sourceMappingURL=Menu.js.map

package/out/components/menu/MenuItem.d.ts

@@ -0,0 +1,24 @@
+import { AbstractElement } from "../AbstractElement";
+import { Menu } from "./Menu";
+/**
+ * Abstract element representing a menu item
+ */
+export declare abstract class MenuItem extends AbstractElement {
+    protected parent: Menu;
+    protected label: string;
+    /**
+     * Use the given menu item: Opens the submenu if the item has children,
+     * otherwise simply click the item.
+     *
+     * @returns Menu object representing the submenu if the item has children, void otherwise.
+     */
+    select(): Promise<Menu | undefined>;
+    /**
+     * Return the Menu object representing the menu this item belongs to
+     */
+    getParent(): Menu;
+    /**
+     * Returns the label of the menu item
+     */
+    getLabel(): string | Promise<string>;
+}

package/out/components/menu/MenuItem.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuItem = void 0;
+const AbstractElement_1 = require("../AbstractElement");
+/**
+ * Abstract element representing a menu item
+ */
+class MenuItem extends AbstractElement_1.AbstractElement {
+    parent;
+    label;
+    /**
+     * Use the given menu item: Opens the submenu if the item has children,
+     * otherwise simply click the item.
+     *
+     * @returns Menu object representing the submenu if the item has children, void otherwise.
+     */
+    async select() {
+        await this.click();
+        await new Promise(res => setTimeout(res, 500));
+        return undefined;
+    }
+    /**
+     * Return the Menu object representing the menu this item belongs to
+     */
+    getParent() {
+        return this.parent;
+    }
+    /**
+     * Returns the label of the menu item
+     */
+    getLabel() {
+        return this.label;
+    }
+}
+exports.MenuItem = MenuItem;
+//# sourceMappingURL=MenuItem.js.map

package/out/components/menu/TitleBar.d.ts

@@ -0,0 +1,36 @@
+import { WindowControls, ContextMenu } from "../..";
+import { Menu } from "./Menu";
+import { MenuItem } from "./MenuItem";
+/**
+ * Page object representing the custom VSCode title bar
+ */
+export declare class TitleBar extends Menu {
+    constructor();
+    /**
+     * Get title bar item by name
+     * @param name name of the item to search by
+     * @returns Promise resolving to TitleBarItem object
+     */
+    getItem(name: string): Promise<TitleBarItem | undefined>;
+    /**
+     * Get all title bar items
+     * @returns Promise resolving to array of TitleBarItem objects
+     */
+    getItems(): Promise<TitleBarItem[]>;
+    /**
+     * Get the window title
+     * @returns Promise resolving to the window title
+     */
+    getTitle(): Promise<string>;
+    /**
+     * Get a reference to the WindowControls
+     */
+    getWindowControls(): WindowControls;
+}
+/**
+ * Page object representing an item of the custom VSCode title bar
+ */
+export declare class TitleBarItem extends MenuItem {
+    constructor(label: string, parent: Menu);
+    select(): Promise<ContextMenu>;
+}

package/out/components/menu/TitleBar.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TitleBarItem = exports.TitleBar = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const __1 = require("../..");
+const Menu_1 = require("./Menu");
+const MenuItem_1 = require("./MenuItem");
+/**
+ * Page object representing the custom VSCode title bar
+ */
+class TitleBar extends Menu_1.Menu {
+    constructor() {
+        super(TitleBar.locators.TitleBar.constructor, TitleBar.locators.Workbench.constructor);
+    }
+    /**
+     * Get title bar item by name
+     * @param name name of the item to search by
+     * @returns Promise resolving to TitleBarItem object
+     */
+    async getItem(name) {
+        try {
+            await this.findElement(TitleBar.locators.TitleBar.itemConstructor(name));
+            return await new TitleBarItem(name, this).wait();
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    /**
+     * Get all title bar items
+     * @returns Promise resolving to array of TitleBarItem objects
+     */
+    async getItems() {
+        const items = [];
+        const elements = await this.findElements(TitleBar.locators.TitleBar.itemElement);
+        for (const element of elements) {
+            if (await element.isDisplayed()) {
+                items.push(await new TitleBarItem(await element.getAttribute(TitleBar.locators.TitleBar.itemLabel), this).wait());
+            }
+        }
+        return items;
+    }
+    /**
+     * Get the window title
+     * @returns Promise resolving to the window title
+     */
+    async getTitle() {
+        return await this.findElement(TitleBar.locators.TitleBar.title).getText();
+    }
+    /**
+     * Get a reference to the WindowControls
+     */
+    getWindowControls() {
+        return new __1.WindowControls(this);
+    }
+}
+exports.TitleBar = TitleBar;
+/**
+ * Page object representing an item of the custom VSCode title bar
+ */
+class TitleBarItem extends MenuItem_1.MenuItem {
+    constructor(label, parent) {
+        super(TitleBar.locators.TitleBar.itemConstructor(label), parent);
+        this.parent = parent;
+        this.label = label;
+    }
+    async select() {
+        const openMenus = await this.getDriver().findElements(TitleBar.locators.ContextMenu.constructor);
+        if (openMenus.length > 0 && await openMenus[0].isDisplayed()) {
+            await this.getDriver().actions().sendKeys(selenium_webdriver_1.Key.ESCAPE).perform();
+        }
+        await this.click();
+        await new Promise(res => setTimeout(res, 500));
+        return new __1.ContextMenu(this).wait();
+    }
+}
+exports.TitleBarItem = TitleBarItem;
+//# sourceMappingURL=TitleBar.js.map

package/out/components/menu/WindowControls.d.ts

@@ -0,0 +1,28 @@
+import { AbstractElement } from "../AbstractElement";
+import { TitleBar } from "../..";
+/**
+ * Page object for the windows controls part of the title bar
+ */
+export declare class WindowControls extends AbstractElement {
+    constructor(bar?: TitleBar);
+    /**
+     * Use the minimize window button
+     * @returns Promise resolving when minimize button is pressed
+     */
+    minimize(): Promise<void>;
+    /**
+     * Use the maximize window button if the window is not maximized
+     * @returns Promise resolving when maximize button is pressed
+     */
+    maximize(): Promise<void>;
+    /**
+     * Use the restore window button if the window is maximized
+     * @returns Promise resolving when restore button is pressed
+     */
+    restore(): Promise<void>;
+    /**
+     * Use the window close button. Use at your own risk.
+     * @returns Promise resolving when close button is pressed
+     */
+    close(): Promise<void>;
+}

package/out/components/menu/WindowControls.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowControls = void 0;
+const AbstractElement_1 = require("../AbstractElement");
+const __1 = require("../..");
+/**
+ * Page object for the windows controls part of the title bar
+ */
+class WindowControls extends AbstractElement_1.AbstractElement {
+    constructor(bar = new __1.TitleBar()) {
+        super(WindowControls.locators.WindowControls.constructor, bar);
+    }
+    /**
+     * Use the minimize window button
+     * @returns Promise resolving when minimize button is pressed
+     */
+    async minimize() {
+        const minButton = await this.findElement(WindowControls.locators.WindowControls.minimize);
+        await minButton.click();
+    }
+    /**
+     * Use the maximize window button if the window is not maximized
+     * @returns Promise resolving when maximize button is pressed
+     */
+    async maximize() {
+        let maxButton;
+        try {
+            maxButton = await this.findElement(WindowControls.locators.WindowControls.maximize);
+            await maxButton.click();
+        }
+        catch (err) {
+            console.log('Window is already maximized');
+        }
+    }
+    /**
+     * Use the restore window button if the window is maximized
+     * @returns Promise resolving when restore button is pressed
+     */
+    async restore() {
+        let maxButton;
+        try {
+            maxButton = await this.findElement(WindowControls.locators.WindowControls.restore);
+            await maxButton.click();
+        }
+        catch (err) {
+            console.log('Window is not maximized');
+        }
+    }
+    /**
+     * Use the window close button. Use at your own risk.
+     * @returns Promise resolving when close button is pressed
+     */
+    async close() {
+        const closeButton = await this.findElement(WindowControls.locators.WindowControls.close);
+        await closeButton.click();
+    }
+}
+exports.WindowControls = WindowControls;
+//# sourceMappingURL=WindowControls.js.map

package/out/components/sidebar/SideBarView.d.ts

@@ -0,0 +1,18 @@
+import { AbstractElement } from "../AbstractElement";
+import { ViewTitlePart, ViewContent } from "../..";
+/**
+ * Page object for the side bar view
+ */
+export declare class SideBarView extends AbstractElement {
+    constructor();
+    /**
+     * Get the top part of the open view (contains title and possibly some buttons)
+     * @returns ViewTitlePart object
+     */
+    getTitlePart(): ViewTitlePart;
+    /**
+     * Get the content part of the open view
+     * @returns ViewContent object
+     */
+    getContent(): ViewContent;
+}

package/out/components/sidebar/SideBarView.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SideBarView = void 0;
+const AbstractElement_1 = require("../AbstractElement");
+const __1 = require("../..");
+/**
+ * Page object for the side bar view
+ */
+class SideBarView extends AbstractElement_1.AbstractElement {
+    constructor() {
+        super(SideBarView.locators.SideBarView.constructor, SideBarView.locators.Workbench.constructor);
+    }
+    /**
+     * Get the top part of the open view (contains title and possibly some buttons)
+     * @returns ViewTitlePart object
+     */
+    getTitlePart() {
+        return new __1.ViewTitlePart(this);
+    }
+    /**
+     * Get the content part of the open view
+     * @returns ViewContent object
+     */
+    getContent() {
+        return new __1.ViewContent(this);
+    }
+}
+exports.SideBarView = SideBarView;
+//# sourceMappingURL=SideBarView.js.map