@redhat-developer/page-objects 1.0.0

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

@@ -0,0 +1,10 @@
+import { EditorGroup } from "./EditorView";
+import { AbstractElement } from "../AbstractElement";
+import { WebElement } from "../..";
+export declare class EditorAction extends AbstractElement {
+    constructor(element: WebElement, parent: EditorGroup);
+    /**
+     * Get text description of the action.
+     */
+    getTitle(): Promise<string>;
+}

package/out/components/editor/EditorAction.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorAction = void 0;
+const AbstractElement_1 = require("../AbstractElement");
+class EditorAction extends AbstractElement_1.AbstractElement {
+    constructor(element, parent) {
+        super(element, parent);
+    }
+    /**
+     * Get text description of the action.
+     */
+    async getTitle() {
+        return await this.getAttribute(EditorAction.locators.EditorView.attribute);
+    }
+}
+exports.EditorAction = EditorAction;
+//# sourceMappingURL=EditorAction.js.map

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

@@ -0,0 +1,153 @@
+import { WebElement } from "selenium-webdriver";
+import { AbstractElement } from "../AbstractElement";
+import { ElementWithContexMenu } from "../ElementWithContextMenu";
+import { Editor } from "./Editor";
+import { EditorAction } from "./EditorAction";
+export declare class EditorTabNotFound extends Error {
+    constructor(title: string, group: number);
+}
+/**
+ * View handling the open editors
+ */
+export declare class EditorView extends AbstractElement {
+    constructor();
+    /**
+     * Switch to an editor tab with the given title
+     * @param title title of the tab
+     * @param groupIndex zero based index for the editor group (0 for the left most group)
+     * @returns Promise resolving to Editor object
+     */
+    openEditor(title: string, groupIndex?: number): Promise<Editor>;
+    /**
+     * Close an editor tab with the given title
+     * @param title title of the tab
+     * @param groupIndex zero based index for the editor group (0 for the left most group)
+     * @returns Promise resolving when the tab's close button is pressed
+     */
+    closeEditor(title: string, groupIndex?: number): Promise<void>;
+    /**
+     * Close all open editor tabs
+     * @param groupIndex optional index to specify an editor group
+     * @returns Promise resolving once all tabs have had their close button pressed
+     */
+    closeAllEditors(groupIndex?: number): Promise<void>;
+    /**
+     * Retrieve all open editor tab titles in an array
+     * @param groupIndex optional index to specify an editor group, if left empty will search all groups
+     * @returns Promise resolving to array of editor titles
+     */
+    getOpenEditorTitles(groupIndex?: number): Promise<string[]>;
+    /**
+     * Retrieve an editor tab from a given group by title
+     * @param title title of the tab
+     * @param groupIndex zero based index of the editor group, default 0 (leftmost one)
+     * @returns promise resolving to EditorTab object
+     */
+    getTabByTitle(title: string, groupIndex?: number): Promise<EditorTab>;
+    /**
+     * Retrieve all open editor tabs
+     * @param groupIndex index of group to search for tabs, if left undefined, all groups are searched
+     * @returns promise resolving to EditorTab list
+     */
+    getOpenTabs(groupIndex?: number): Promise<EditorTab[]>;
+    /**
+     * Retrieve the active editor tab
+     * @returns promise resolving to EditorTab object, undefined if no tab is active
+     */
+    getActiveTab(): Promise<EditorTab | undefined>;
+    /**
+     * Retrieve all editor groups in a list, sorted left to right
+     * @returns promise resolving to an array of EditorGroup objects
+     */
+    getEditorGroups(): Promise<EditorGroup[]>;
+    /**
+     * Retrieve an editor group with a given index (counting from left to right)
+     * @param index zero based index of the editor group (leftmost group has index 0)
+     * @returns promise resolving to an EditorGroup object
+     */
+    getEditorGroup(index: number): Promise<EditorGroup>;
+    /**
+     * Get editor actions of a select editor group
+     * @param groupIndex zero based index of the editor group (leftmost group has index 0), default 0
+     * @returns promise resolving to list of EditorAction objects
+     */
+    getActions(groupIndex?: number): Promise<EditorAction[]>;
+    /**
+     * Get editor action of a select editor group, search by title or predicate
+     * @param predicateOrTitle title or predicate to be used in search process
+     * @param groupIndex zero based index of the editor group (leftmost group has index 0), default 0
+     * @returns promise resolving to EditorAction object if found, undefined otherwise
+     */
+    getAction(predicateOrTitle: string | ((action: EditorAction) => boolean | PromiseLike<boolean>), groupIndex?: number): Promise<EditorAction | undefined>;
+}
+/**
+ * Page object representing an editor group
+ */
+export declare class EditorGroup extends AbstractElement {
+    private index;
+    constructor(element: WebElement, view?: EditorView, index?: number);
+    /**
+     * Switch to an editor tab with the given title
+     * @param title title of the tab
+     * @returns Promise resolving to Editor object
+     */
+    openEditor(title: string): Promise<Editor>;
+    /**
+     * Close an editor tab with the given title
+     * @param title title of the tab
+     * @returns Promise resolving when the tab's close button is pressed
+     */
+    closeEditor(title: string): Promise<void>;
+    /**
+     * Close all open editor tabs
+     * @returns Promise resolving once all tabs have had their close button pressed
+     */
+    closeAllEditors(): Promise<void>;
+    /**
+     * Retrieve all open editor tab titles in an array
+     * @returns Promise resolving to array of editor titles
+     */
+    getOpenEditorTitles(): Promise<string[]>;
+    /**
+     * Retrieve an editor tab by title
+     * @param title title of the tab
+     * @returns promise resolving to EditorTab object
+     */
+    getTabByTitle(title: string): Promise<EditorTab>;
+    /**
+     * Retrieve all open editor tabs
+     * @returns promise resolving to EditorTab list
+     */
+    getOpenTabs(): Promise<EditorTab[]>;
+    /**
+     * Retrieve the active editor tab
+     * @returns promise resolving to EditorTab object, undefined if no tab is active
+     */
+    getActiveTab(): Promise<EditorTab | undefined>;
+    /**
+     * Retrieve the editor action buttons as EditorActions
+     * @returns promise resolving to list of EditorAction objects
+     */
+    getActions(): Promise<EditorAction[]>;
+    /**
+     * Find an editor action button by predicate or title
+     * @param predicateOrTitle predicate/title to be used
+     * @returns promise resolving to EditorAction representing the button if found, undefined otherwise
+     */
+    getAction(predicateOrTitle: string | ((action: EditorAction) => boolean | PromiseLike<boolean>)): Promise<EditorAction | undefined>;
+}
+/**
+ * Page object for editor view tab
+ */
+export declare class EditorTab extends ElementWithContexMenu {
+    constructor(element: WebElement, view: EditorView);
+    /**
+     * Get the tab title as string
+     */
+    getTitle(): Promise<string>;
+    /**
+     * Select (click) the tab
+     */
+    select(): Promise<void>;
+    isSelected(): Promise<boolean>;
+}

package/out/components/editor/EditorView.js

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorTab = exports.EditorGroup = exports.EditorView = exports.EditorTabNotFound = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const __1 = require("../..");
+const AbstractElement_1 = require("../AbstractElement");
+const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
+const DiffEditor_1 = require("./DiffEditor");
+const EditorAction_1 = require("./EditorAction");
+const SettingsEditor_1 = require("./SettingsEditor");
+const WebView_1 = require("./WebView");
+class EditorTabNotFound extends Error {
+    constructor(title, group) {
+        super(`No editor with title '${title}' in group '${group}' available`);
+    }
+}
+exports.EditorTabNotFound = EditorTabNotFound;
+/**
+ * View handling the open editors
+ */
+class EditorView extends AbstractElement_1.AbstractElement {
+    constructor() {
+        super(EditorView.locators.EditorView.constructor, EditorView.locators.Workbench.constructor);
+    }
+    /**
+     * Switch to an editor tab with the given title
+     * @param title title of the tab
+     * @param groupIndex zero based index for the editor group (0 for the left most group)
+     * @returns Promise resolving to Editor object
+     */
+    async openEditor(title, groupIndex = 0) {
+        const group = await this.getEditorGroup(groupIndex);
+        return group.openEditor(title);
+    }
+    /**
+     * Close an editor tab with the given title
+     * @param title title of the tab
+     * @param groupIndex zero based index for the editor group (0 for the left most group)
+     * @returns Promise resolving when the tab's close button is pressed
+     */
+    async closeEditor(title, groupIndex = 0) {
+        const group = await this.getEditorGroup(groupIndex);
+        return group.closeEditor(title);
+    }
+    /**
+     * Close all open editor tabs
+     * @param groupIndex optional index to specify an editor group
+     * @returns Promise resolving once all tabs have had their close button pressed
+     */
+    async closeAllEditors(groupIndex) {
+        let groups = await this.getEditorGroups();
+        if (groupIndex !== undefined) {
+            return groups[groupIndex].closeAllEditors();
+        }
+        while (groups.length > 0 && (await groups[0].getOpenEditorTitles()).length > 0) {
+            await groups[0].closeAllEditors();
+            await new Promise(res => setTimeout(res, 1000));
+            groups = await this.getEditorGroups();
+        }
+    }
+    /**
+     * Retrieve all open editor tab titles in an array
+     * @param groupIndex optional index to specify an editor group, if left empty will search all groups
+     * @returns Promise resolving to array of editor titles
+     */
+    async getOpenEditorTitles(groupIndex) {
+        const groups = await this.getEditorGroups();
+        if (groupIndex !== undefined) {
+            return groups[groupIndex].getOpenEditorTitles();
+        }
+        const titles = [];
+        for (const group of groups) {
+            titles.push(...(await group.getOpenEditorTitles()));
+        }
+        return titles;
+    }
+    /**
+     * Retrieve an editor tab from a given group by title
+     * @param title title of the tab
+     * @param groupIndex zero based index of the editor group, default 0 (leftmost one)
+     * @returns promise resolving to EditorTab object
+     */
+    async getTabByTitle(title, groupIndex = 0) {
+        const group = await this.getEditorGroup(groupIndex);
+        return group.getTabByTitle(title);
+    }
+    /**
+     * Retrieve all open editor tabs
+     * @param groupIndex index of group to search for tabs, if left undefined, all groups are searched
+     * @returns promise resolving to EditorTab list
+     */
+    async getOpenTabs(groupIndex) {
+        const groups = await this.getEditorGroups();
+        if (groupIndex !== undefined) {
+            return groups[groupIndex].getOpenTabs();
+        }
+        const tabs = [];
+        for (const group of groups) {
+            tabs.push(...(await group.getOpenTabs()));
+        }
+        return tabs;
+    }
+    /**
+     * Retrieve the active editor tab
+     * @returns promise resolving to EditorTab object, undefined if no tab is active
+     */
+    async getActiveTab() {
+        const tabs = await this.getOpenTabs();
+        for (const tab of tabs) {
+            if (await tab.isSelected()) {
+                return tab;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Retrieve all editor groups in a list, sorted left to right
+     * @returns promise resolving to an array of EditorGroup objects
+     */
+    async getEditorGroups() {
+        const elements = await this.findElements(EditorGroup.locators.EditorView.editorGroup);
+        const groups = await Promise.all(elements.map(async (element, index) => new EditorGroup(element, this, index).wait()));
+        // sort the groups by x coordinates, so the leftmost is always at index 0
+        for (let i = 0; i < groups.length - 1; i++) {
+            for (let j = 0; j < groups.length - i - 1; j++) {
+                if ((await groups[j].getRect()).x > (await groups[j + 1].getRect()).x) {
+                    let temp = groups[j];
+                    groups[j] = groups[j + 1];
+                    groups[j + 1] = temp;
+                }
+            }
+        }
+        return groups;
+    }
+    /**
+     * Retrieve an editor group with a given index (counting from left to right)
+     * @param index zero based index of the editor group (leftmost group has index 0)
+     * @returns promise resolving to an EditorGroup object
+     */
+    async getEditorGroup(index) {
+        return (await this.getEditorGroups())[index];
+    }
+    /**
+     * Get editor actions of a select editor group
+     * @param groupIndex zero based index of the editor group (leftmost group has index 0), default 0
+     * @returns promise resolving to list of EditorAction objects
+     */
+    async getActions(groupIndex = 0) {
+        const group = await this.getEditorGroup(groupIndex);
+        return group.getActions();
+    }
+    /**
+     * Get editor action of a select editor group, search by title or predicate
+     * @param predicateOrTitle title or predicate to be used in search process
+     * @param groupIndex zero based index of the editor group (leftmost group has index 0), default 0
+     * @returns promise resolving to EditorAction object if found, undefined otherwise
+     */
+    async getAction(predicateOrTitle, groupIndex = 0) {
+        const group = await this.getEditorGroup(groupIndex);
+        return group.getAction(predicateOrTitle);
+    }
+}
+exports.EditorView = EditorView;
+/**
+ * Page object representing an editor group
+ */
+class EditorGroup extends AbstractElement_1.AbstractElement {
+    index;
+    constructor(element, view = new EditorView(), index = 0) {
+        super(element, view);
+        this.index = index;
+    }
+    /**
+     * Switch to an editor tab with the given title
+     * @param title title of the tab
+     * @returns Promise resolving to Editor object
+     */
+    async openEditor(title) {
+        const tab = await this.getTabByTitle(title);
+        await tab.select();
+        try {
+            await this.findElement(EditorView.locators.EditorView.settingsEditor);
+            return new SettingsEditor_1.SettingsEditor(this).wait();
+        }
+        catch (err) {
+            try {
+                await this.findElement(EditorView.locators.EditorView.webView);
+                return new WebView_1.WebView(this).wait();
+            }
+            catch (err) {
+                try {
+                    await this.findElement(EditorView.locators.EditorView.diffEditor);
+                    return new DiffEditor_1.DiffEditor(this).wait();
+                }
+                catch (err) {
+                    return new __1.TextEditor(this).wait();
+                }
+            }
+        }
+    }
+    /**
+     * Close an editor tab with the given title
+     * @param title title of the tab
+     * @returns Promise resolving when the tab's close button is pressed
+     */
+    async closeEditor(title) {
+        const tab = await this.getTabByTitle(title);
+        const closeButton = await tab.findElement(EditorView.locators.EditorView.closeTab);
+        await closeButton.click();
+    }
+    /**
+     * Close all open editor tabs
+     * @returns Promise resolving once all tabs have had their close button pressed
+     */
+    async closeAllEditors() {
+        let titles = await this.getOpenEditorTitles();
+        while (titles.length > 0) {
+            await this.closeEditor(titles[0]);
+            try {
+                // check if the group still exists
+                await this.getTagName();
+            }
+            catch (err) {
+                break;
+            }
+            titles = await this.getOpenEditorTitles();
+        }
+    }
+    /**
+     * Retrieve all open editor tab titles in an array
+     * @returns Promise resolving to array of editor titles
+     */
+    async getOpenEditorTitles() {
+        const tabs = await this.findElements(EditorView.locators.EditorView.tab);
+        const titles = [];
+        for (const tab of tabs) {
+            try {
+                const title = await new EditorTab(tab, this.enclosingItem).getTitle();
+                titles.push(title);
+            }
+            catch (e) {
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    continue;
+                }
+                throw e;
+            }
+        }
+        return titles;
+    }
+    /**
+     * Retrieve an editor tab by title
+     * @param title title of the tab
+     * @returns promise resolving to EditorTab object
+     */
+    async getTabByTitle(title) {
+        const tabs = await this.findElements(EditorView.locators.EditorView.tab);
+        for (const element of tabs) {
+            try {
+                const tab = new EditorTab(element, this.enclosingItem);
+                const label = await tab.getTitle();
+                if (label === title) {
+                    return tab;
+                }
+            }
+            catch (e) {
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    continue;
+                }
+                throw e;
+            }
+        }
+        throw new EditorTabNotFound(title, this.index);
+    }
+    /**
+     * Retrieve all open editor tabs
+     * @returns promise resolving to EditorTab list
+     */
+    async getOpenTabs() {
+        const tabs = await this.findElements(EditorView.locators.EditorView.tab);
+        return Promise.all(tabs.map(async (tab) => new EditorTab(tab, this.enclosingItem).wait()));
+    }
+    /**
+     * Retrieve the active editor tab
+     * @returns promise resolving to EditorTab object, undefined if no tab is active
+     */
+    async getActiveTab() {
+        const tabs = await this.getOpenTabs();
+        for (const tab of tabs) {
+            if (await tab.isSelected()) {
+                return tab;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Retrieve the editor action buttons as EditorActions
+     * @returns promise resolving to list of EditorAction objects
+     */
+    async getActions() {
+        const actions = await this.findElement(EditorGroup.locators.EditorView.actionContainer)
+            .findElements(EditorGroup.locators.EditorView.actionItem);
+        return actions.map((action) => new EditorAction_1.EditorAction(action, this));
+    }
+    /**
+     * Find an editor action button by predicate or title
+     * @param predicateOrTitle predicate/title to be used
+     * @returns promise resolving to EditorAction representing the button if found, undefined otherwise
+     */
+    async getAction(predicateOrTitle) {
+        const predicate = (typeof predicateOrTitle === 'string') ?
+            (async (action) => await action.getTitle() === predicateOrTitle) : (predicateOrTitle);
+        const actions = await this.getActions();
+        for (const action of actions) {
+            if (await predicate(action)) {
+                return action;
+            }
+        }
+        return undefined;
+    }
+}
+exports.EditorGroup = EditorGroup;
+/**
+ * Page object for editor view tab
+ */
+class EditorTab extends ElementWithContextMenu_1.ElementWithContexMenu {
+    constructor(element, view) {
+        super(element, view);
+    }
+    /**
+     * Get the tab title as string
+     */
+    async getTitle() {
+        const label = await this.findElement(EditorTab.locators.Editor.title);
+        return await label.getText();
+    }
+    /**
+     * Select (click) the tab
+     */
+    async select() {
+        const tabCoords = await this.getRect();
+        await this.getDriver().actions().move({ x: Math.ceil(tabCoords.x + 10), y: Math.ceil(tabCoords.y + 10) }).click().perform();
+    }
+    async isSelected() {
+        const klass = await this.getAttribute('class');
+        const segments = klass?.split(/\s+/g) ?? [];
+        return await super.isSelected() || segments.includes('active');
+    }
+}
+exports.EditorTab = EditorTab;
+//# sourceMappingURL=EditorView.js.map

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

@@ -0,0 +1,121 @@
+import { Editor } from "./Editor";
+import { ContextMenu } from "../menu/ContextMenu";
+import { By } from "selenium-webdriver";
+import { AbstractElement } from "../AbstractElement";
+import { EditorView, EditorGroup } from "../..";
+/**
+ * Page object representing the internal VSCode settings editor
+ */
+export declare class SettingsEditor extends Editor {
+    private divider;
+    constructor(view?: EditorView | EditorGroup);
+    /**
+     * Search for a setting with a particular title and category.
+     * Returns an appropriate Setting object if the label is found,
+     * undefined otherwise.
+     *
+     * If your setting has nested categories (i.e `example.general.test`),
+     * pass in each category as a separate string.
+     *
+     * @param title title of the setting
+     * @param categories category of the setting
+     * @returns Promise resolving to a Setting object if found, undefined otherwise
+     */
+    findSetting(title: string, ...categories: string[]): Promise<Setting>;
+    /**
+     * Search for a setting with a precise ID.
+     * Returns an appropriate Setting object if it exists,
+     * undefined otherwise.
+     *
+     * @param id of the setting
+     * @returns Promise resolving to a Setting object if found, undefined otherwise
+     */
+    findSettingByID(id: string): Promise<Setting>;
+    private _getSettingItem;
+    /**
+     * Switch between settings perspectives
+     * Works only if your vscode instance has both user and workspace settings available
+     *
+     * @param perspective User or Workspace
+     * @returns Promise that resolves when the appropriate button is clicked
+     */
+    switchToPerspective(perspective: 'User' | 'Workspace'): Promise<void>;
+    /**
+     * Context menu is disabled in this editor, throw an error
+     */
+    openContextMenu(): Promise<ContextMenu>;
+    private createSetting;
+}
+/**
+ * Abstract item representing a Setting with title, description and
+ * an input element (combo/textbox/checkbox/link)
+ */
+export declare abstract class Setting extends AbstractElement {
+    constructor(settingsConstructor: By, settings: SettingsEditor);
+    /**
+     * Get the value of the setting based on its input type
+     *
+     * @returns promise that resolves to the current value of the setting
+     */
+    abstract getValue(): Promise<string | boolean>;
+    /**
+     * Set the value of the setting based on its input type
+     *
+     * @param value boolean for checkboxes, string otherwise
+     */
+    abstract setValue(value: string | boolean): Promise<void>;
+    /**
+     * Get the category of the setting
+     * All settings are labeled as Category: Title
+     */
+    getCategory(): Promise<string>;
+    /**
+     * Get description of the setting
+     * @returns Promise resolving to setting description
+     */
+    getDescription(): Promise<string>;
+    /**
+     * Get title of the setting
+     */
+    getTitle(): Promise<string>;
+}
+/**
+ * Setting with a combo box
+ */
+export declare class ComboSetting extends Setting {
+    getValue(): Promise<string>;
+    setValue(value: string): Promise<void>;
+    /**
+     * Get the labels of all options from the combo
+     * @returns Promise resolving to array of string values
+     */
+    getValues(): Promise<string[]>;
+    private getOptions;
+    private openCombo;
+}
+/**
+ * Setting with a text box input
+ */
+export declare class TextSetting extends Setting {
+    getValue(): Promise<string>;
+    setValue(value: string): Promise<void>;
+}
+/**
+ * Setting with a checkbox
+ */
+export declare class CheckboxSetting extends Setting {
+    getValue(): Promise<boolean>;
+    setValue(value: boolean): Promise<void>;
+}
+/**
+ * Setting with no value, with a link to settings.json instead
+ */
+export declare class LinkSetting extends Setting {
+    getValue(): Promise<string>;
+    setValue(value: string | boolean): Promise<void>;
+    /**
+     * Open the link that leads to the value in settings.json
+     * @returns Promise resolving when the link has been clicked
+     */
+    openLink(): Promise<void>;
+}