@redhat-developer/page-objects 1.0.0

package/out/components/sidebar/tree/custom/CustomTreeSection.d.ts

@@ -0,0 +1,26 @@
+import { TreeSection } from "../TreeSection";
+import { TreeItem } from "../../ViewItem";
+import { WebElement } from "selenium-webdriver";
+import { CustomTreeItem, ViewContent } from "../../../..";
+export type GenericCustomTreeItemConstructor<T extends TreeItem> = {
+    new (rootElement: WebElement, tree: TreeSection): T;
+};
+/**
+ * Generic custom tree view, e.g. contributed by an extension
+ */
+export declare class GenericCustomTreeSection<T extends TreeItem> extends TreeSection {
+    private _viewContent;
+    private _itemConstructor;
+    constructor(panel: WebElement, _viewContent: ViewContent, itemConstructor: GenericCustomTreeItemConstructor<T>);
+    private get viewContent();
+    private get itemConstructor();
+    getVisibleItems(): Promise<T[]>;
+    findItem(labelOrPredicate: string | ((el: T) => (PromiseLike<boolean> | boolean)), maxLevel?: number): Promise<T | undefined>;
+    private getContainer;
+}
+/**
+ * Custom tree view, e.g. contributed by an extension
+ */
+export declare class CustomTreeSection extends GenericCustomTreeSection<CustomTreeItem> {
+    constructor(panel: WebElement, viewContent: ViewContent);
+}

package/out/components/sidebar/tree/custom/CustomTreeSection.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomTreeSection = exports.GenericCustomTreeSection = void 0;
+const TreeSection_1 = require("../TreeSection");
+const selenium_webdriver_1 = require("selenium-webdriver");
+const __1 = require("../../../..");
+/**
+ * Generic custom tree view, e.g. contributed by an extension
+ */
+class GenericCustomTreeSection extends TreeSection_1.TreeSection {
+    _viewContent;
+    _itemConstructor;
+    constructor(panel, _viewContent, itemConstructor) {
+        super(panel, _viewContent);
+        this._viewContent = _viewContent;
+        this._itemConstructor = itemConstructor;
+    }
+    get viewContent() {
+        return this._viewContent;
+    }
+    get itemConstructor() {
+        return this._itemConstructor;
+    }
+    async getVisibleItems() {
+        const items = [];
+        const container = await this.getContainer();
+        const elements = await container.findElements(CustomTreeSection.locators.CustomTreeSection.itemRow);
+        for (const element of elements) {
+            if (await element.isDisplayed()) {
+                items.push(new this.itemConstructor(element, this));
+            }
+        }
+        return items;
+    }
+    async findItem(labelOrPredicate, maxLevel = 0) {
+        const predicate = typeof labelOrPredicate === 'string' ? (async (el) => await el.getLabel() === labelOrPredicate) : (labelOrPredicate);
+        const elements = await this.getVisibleItems();
+        for (const element of elements) {
+            if (await predicate(element)) {
+                const level = +await element.getAttribute(CustomTreeSection.locators.ViewSection.level);
+                if (maxLevel < 1 || level <= maxLevel) {
+                    return element;
+                }
+            }
+        }
+        return undefined;
+    }
+    async getContainer() {
+        await this.expand();
+        await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(CustomTreeSection.locators.CustomTreeSection.rowContainer), 5000);
+        const container = await this.findElement(CustomTreeSection.locators.CustomTreeSection.rowContainer);
+        await container.sendKeys(selenium_webdriver_1.Key.HOME);
+        return new GenericCustomTreeSection(container, this.viewContent, this.itemConstructor);
+    }
+}
+exports.GenericCustomTreeSection = GenericCustomTreeSection;
+/**
+ * Custom tree view, e.g. contributed by an extension
+ */
+class CustomTreeSection extends GenericCustomTreeSection {
+    constructor(panel, viewContent) {
+        super(panel, viewContent, __1.CustomTreeItem);
+    }
+}
+exports.CustomTreeSection = CustomTreeSection;
+//# sourceMappingURL=CustomTreeSection.js.map

package/out/components/sidebar/tree/debug/BreakpointSectionItem.d.ts

@@ -0,0 +1,33 @@
+import { WebElement } from "selenium-webdriver";
+import { TreeSection } from "../TreeSection";
+import { CustomTreeItem } from "../custom/CustomTreeItem";
+import { SectionBreakpoint } from "./SectionBreakpoint";
+export declare class BreakpointSectionItem extends CustomTreeItem {
+    constructor(element: WebElement, viewPart: TreeSection);
+    /**
+     * Get breakpoint element which has context menu.
+     * @returns SectionBreakpoint page object
+     */
+    getBreakpoint(): Promise<SectionBreakpoint>;
+    /**
+     * Get status of the breakpoint.
+     * @returns boolean indicating status
+     */
+    isBreakpointEnabled(): Promise<boolean>;
+    /**
+     * Change breakpoint status to desired state.
+     * @param value new state
+     */
+    setBreakpointEnabled(value: boolean): Promise<void>;
+    getLabel(): Promise<string>;
+    /**
+     * Get breakpoint file path. Empty string is returned if path is not specified.
+     * @returns file path of breakpoint or empty string
+     */
+    getBreakpointFilePath(): Promise<string>;
+    /**
+     * Get line number of the breakpoint.
+     * @returns number indicating line position in file
+     */
+    getBreakpointLine(): Promise<number>;
+}

package/out/components/sidebar/tree/debug/BreakpointSectionItem.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BreakpointSectionItem = void 0;
+const CustomTreeItem_1 = require("../custom/CustomTreeItem");
+const SectionBreakpoint_1 = require("./SectionBreakpoint");
+class BreakpointSectionItem extends CustomTreeItem_1.CustomTreeItem {
+    constructor(element, viewPart) {
+        super(element, viewPart);
+    }
+    /**
+     * Get breakpoint element which has context menu.
+     * @returns SectionBreakpoint page object
+     */
+    async getBreakpoint() {
+        return new SectionBreakpoint_1.SectionBreakpoint(BreakpointSectionItem.locators.BreakpointSectionItem.breakpoint.constructor, this);
+    }
+    /**
+     * Get status of the breakpoint.
+     * @returns boolean indicating status
+     */
+    async isBreakpointEnabled() {
+        const locator = BreakpointSectionItem.locators.BreakpointSectionItem.breakpointCheckbox;
+        const el = await this.findElement(locator.constructor);
+        return await locator.value(el);
+    }
+    /**
+     * Change breakpoint status to desired state.
+     * @param value new state
+     */
+    async setBreakpointEnabled(value) {
+        if (await this.isBreakpointEnabled() === value) {
+            return;
+        }
+        const locator = BreakpointSectionItem.locators.BreakpointSectionItem.breakpointCheckbox;
+        const el = await this.findElement(locator.constructor);
+        await el.click();
+    }
+    async getLabel() {
+        const locator = BreakpointSectionItem.locators.BreakpointSectionItem.label;
+        const el = await this.findElement(locator.constructor);
+        return await locator.value(el);
+    }
+    /**
+     * Get breakpoint file path. Empty string is returned if path is not specified.
+     * @returns file path of breakpoint or empty string
+     */
+    async getBreakpointFilePath() {
+        const locator = BreakpointSectionItem.locators.BreakpointSectionItem.filePath;
+        const el = await this.findElement(locator.constructor);
+        return await locator.value(el);
+    }
+    /**
+     * Get line number of the breakpoint.
+     * @returns number indicating line position in file
+     */
+    async getBreakpointLine() {
+        const locator = BreakpointSectionItem.locators.BreakpointSectionItem.lineNumber;
+        const el = await this.findElement(locator.constructor);
+        return Number.parseInt(await locator.value(el));
+    }
+}
+exports.BreakpointSectionItem = BreakpointSectionItem;
+//# sourceMappingURL=BreakpointSectionItem.js.map

package/out/components/sidebar/tree/debug/DebugBreakpointSection.d.ts

@@ -0,0 +1,7 @@
+import { WebElement } from "selenium-webdriver";
+import { ViewContent } from "../../ViewContent";
+import { GenericCustomTreeSection } from "../custom/CustomTreeSection";
+import { BreakpointSectionItem } from "./BreakpointSectionItem";
+export declare class DebugBreakpointSection extends GenericCustomTreeSection<BreakpointSectionItem> {
+    constructor(panel: WebElement, viewContent: ViewContent);
+}

package/out/components/sidebar/tree/debug/DebugBreakpointSection.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugBreakpointSection = void 0;
+const CustomTreeSection_1 = require("../custom/CustomTreeSection");
+const BreakpointSectionItem_1 = require("./BreakpointSectionItem");
+class DebugBreakpointSection extends CustomTreeSection_1.GenericCustomTreeSection {
+    constructor(panel, viewContent) {
+        super(panel, viewContent, BreakpointSectionItem_1.BreakpointSectionItem);
+    }
+}
+exports.DebugBreakpointSection = DebugBreakpointSection;
+//# sourceMappingURL=DebugBreakpointSection.js.map

package/out/components/sidebar/tree/debug/DebugVariablesSection.d.ts

@@ -0,0 +1,7 @@
+import { WebElement } from "selenium-webdriver";
+import { ViewContent } from "../../ViewContent";
+import { GenericCustomTreeSection } from "../custom/CustomTreeSection";
+import { VariableSectionItem } from "./VariableSectionItem";
+export declare class DebugVariableSection extends GenericCustomTreeSection<VariableSectionItem> {
+    constructor(panel: WebElement, viewContent: ViewContent);
+}

package/out/components/sidebar/tree/debug/DebugVariablesSection.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugVariableSection = void 0;
+const CustomTreeSection_1 = require("../custom/CustomTreeSection");
+const VariableSectionItem_1 = require("./VariableSectionItem");
+class DebugVariableSection extends CustomTreeSection_1.GenericCustomTreeSection {
+    constructor(panel, viewContent) {
+        super(panel, viewContent, VariableSectionItem_1.VariableSectionItem);
+    }
+}
+exports.DebugVariableSection = DebugVariableSection;
+//# sourceMappingURL=DebugVariablesSection.js.map

package/out/components/sidebar/tree/debug/SectionBreakpoint.d.ts

@@ -0,0 +1,3 @@
+import { ElementWithContexMenu } from "../../../ElementWithContextMenu";
+export declare class SectionBreakpoint extends ElementWithContexMenu {
+}

package/out/components/sidebar/tree/debug/SectionBreakpoint.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SectionBreakpoint = void 0;
+const ElementWithContextMenu_1 = require("../../../ElementWithContextMenu");
+class SectionBreakpoint extends ElementWithContextMenu_1.ElementWithContexMenu {
+}
+exports.SectionBreakpoint = SectionBreakpoint;
+//# sourceMappingURL=SectionBreakpoint.js.map

package/out/components/sidebar/tree/debug/VariableSectionItem.d.ts

@@ -0,0 +1,33 @@
+import { WebElement } from "selenium-webdriver";
+import { TreeSection } from "../TreeSection";
+import { CustomTreeItem } from "../custom/CustomTreeItem";
+export declare class VariableSectionItem extends CustomTreeItem {
+    constructor(element: WebElement, viewPart: TreeSection);
+    /**
+     * Get name of the variable.
+     * @returns a promise resolving to variable name string
+     */
+    getVariableName(): Promise<string>;
+    /**
+     * Get value of the variable.
+     * @returns a promise resolving to value string of the variable
+     */
+    getVariableValue(): Promise<string>;
+    /**
+     * Get variable name tooltip.
+     * @returns a promise resolving to variable name tooltip string
+     */
+    getVariableNameTooltip(): Promise<string>;
+    /**
+     * Get variable value tooltip.
+     * @returns a promise resolving to variable value tooltip string
+     */
+    getVariableValueTooltip(): Promise<string>;
+    getLabel(): Promise<string>;
+    getTooltip(): Promise<string>;
+    /**
+     * Assign new value to the variable.
+     * @param value new value
+     */
+    setVariableValue(value: string): Promise<void>;
+}

package/out/components/sidebar/tree/debug/VariableSectionItem.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableSectionItem = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const CustomTreeItem_1 = require("../custom/CustomTreeItem");
+class VariableSectionItem extends CustomTreeItem_1.CustomTreeItem {
+    constructor(element, viewPart) {
+        super(element, viewPart);
+    }
+    /**
+     * Get name of the variable.
+     * @returns a promise resolving to variable name string
+     */
+    async getVariableName() {
+        const name = await this.findElement(VariableSectionItem.locators.VariableSectionItem.name.constructor);
+        return VariableSectionItem.locators.VariableSectionItem.name.value(name);
+    }
+    /**
+     * Get value of the variable.
+     * @returns a promise resolving to value string of the variable
+     */
+    async getVariableValue() {
+        const value = await this.findElement(VariableSectionItem.locators.VariableSectionItem.value.constructor);
+        return VariableSectionItem.locators.VariableSectionItem.value.value(value);
+    }
+    /**
+     * Get variable name tooltip.
+     * @returns a promise resolving to variable name tooltip string
+     */
+    async getVariableNameTooltip() {
+        const name = await this.findElement(VariableSectionItem.locators.VariableSectionItem.name.constructor);
+        return VariableSectionItem.locators.VariableSectionItem.name.tooltip(name);
+    }
+    /**
+     * Get variable value tooltip.
+     * @returns a promise resolving to variable value tooltip string
+     */
+    async getVariableValueTooltip() {
+        const value = await this.findElement(VariableSectionItem.locators.VariableSectionItem.value.constructor);
+        return VariableSectionItem.locators.VariableSectionItem.value.tooltip(value);
+    }
+    async getLabel() {
+        return VariableSectionItem.locators.VariableSectionItem.label(this);
+    }
+    getTooltip() {
+        throw new Error('unsupported: use either getVariableNameTooltip or getVariableValueTooltip');
+    }
+    /**
+     * Assign new value to the variable.
+     * @param value new value
+     */
+    async setVariableValue(value) {
+        const valueRootElement = await this.findElement(VariableSectionItem.locators.VariableSectionItem.value.constructor);
+        const driver = this.getDriver();
+        await driver.actions().clear();
+        await driver.actions().doubleClick(valueRootElement).sendKeys(value, selenium_webdriver_1.Key.ENTER).perform();
+    }
+}
+exports.VariableSectionItem = VariableSectionItem;
+//# sourceMappingURL=VariableSectionItem.js.map

package/out/components/sidebar/tree/default/DefaultTreeItem.d.ts

@@ -0,0 +1,14 @@
+import { TreeItem } from "../../ViewItem";
+import { TreeSection } from "../TreeSection";
+import { WebElement } from "selenium-webdriver";
+/**
+ * Default tree item base on the items in explorer view
+ */
+export declare class DefaultTreeItem extends TreeItem {
+    constructor(element: WebElement, viewPart: TreeSection);
+    getLabel(): Promise<string>;
+    getTooltip(): Promise<string>;
+    isExpanded(): Promise<boolean>;
+    getChildren(): Promise<TreeItem[]>;
+    isExpandable(): Promise<boolean>;
+}

package/out/components/sidebar/tree/default/DefaultTreeItem.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultTreeItem = void 0;
+const ViewItem_1 = require("../../ViewItem");
+const NullAttributeError_1 = require("../../../../errors/NullAttributeError");
+/**
+ * Default tree item base on the items in explorer view
+ */
+class DefaultTreeItem extends ViewItem_1.TreeItem {
+    constructor(element, viewPart) {
+        super(element, viewPart);
+    }
+    async getLabel() {
+        const value = await this.getAttribute(DefaultTreeItem.locators.DefaultTreeSection.itemLabel);
+        if (value === null) {
+            throw new NullAttributeError_1.NullAttributeError(`${this.constructor.name}.getLabel returned null`);
+        }
+        return value;
+    }
+    async getTooltip() {
+        const tooltip = await this.findElement(DefaultTreeItem.locators.DefaultTreeItem.tooltip);
+        return await tooltip.getAttribute(DefaultTreeItem.locators.DefaultTreeItem.labelAttribute);
+    }
+    async isExpanded() {
+        const twistieClass = await this.findElement(DefaultTreeItem.locators.DefaultTreeItem.twistie).getAttribute('class');
+        return twistieClass.indexOf('collapsed') < 0;
+    }
+    async getChildren() {
+        const rows = await this.getChildItems(DefaultTreeItem.locators.DefaultTreeSection.itemRow);
+        const items = await Promise.all(rows.map(async (row) => new DefaultTreeItem(row, this.enclosingItem).wait()));
+        return items;
+    }
+    async isExpandable() {
+        const twistieClass = await this.findElement(DefaultTreeItem.locators.DefaultTreeItem.twistie).getAttribute('class');
+        return twistieClass.indexOf('collapsible') > -1;
+    }
+}
+exports.DefaultTreeItem = DefaultTreeItem;
+//# sourceMappingURL=DefaultTreeItem.js.map

package/out/components/sidebar/tree/default/DefaultTreeSection.d.ts

@@ -0,0 +1,9 @@
+import { TreeSection } from "../TreeSection";
+import { TreeItem } from "../../../..";
+/**
+ * Default view section
+ */
+export declare class DefaultTreeSection extends TreeSection {
+    getVisibleItems(): Promise<TreeItem[]>;
+    findItem(label: string, maxLevel?: number): Promise<TreeItem | undefined>;
+}

package/out/components/sidebar/tree/default/DefaultTreeSection.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultTreeSection = void 0;
+const TreeSection_1 = require("../TreeSection");
+const selenium_webdriver_1 = require("selenium-webdriver");
+const DefaultTreeItem_1 = require("./DefaultTreeItem");
+/**
+ * Default view section
+ */
+class DefaultTreeSection extends TreeSection_1.TreeSection {
+    async getVisibleItems() {
+        const items = [];
+        const elements = await this.findElements(DefaultTreeSection.locators.DefaultTreeSection.itemRow);
+        for (const element of elements) {
+            items.push(await new DefaultTreeItem_1.DefaultTreeItem(element, this).wait());
+        }
+        return items;
+    }
+    async findItem(label, maxLevel = 0) {
+        await this.expand();
+        const container = await this.findElement(DefaultTreeSection.locators.DefaultTreeSection.rowContainer);
+        await container.sendKeys(selenium_webdriver_1.Key.HOME);
+        let item = undefined;
+        do {
+            const temp = await container.findElements(DefaultTreeSection.locators.DefaultTreeItem.ctor(label));
+            if (temp.length > 0) {
+                const level = +await temp[0].getAttribute(DefaultTreeSection.locators.ViewSection.level);
+                if (maxLevel < 1 || level <= maxLevel) {
+                    item = await new DefaultTreeItem_1.DefaultTreeItem(temp[0], this).wait();
+                }
+            }
+            if (!item) {
+                const lastrow = await container.findElements(DefaultTreeSection.locators.DefaultTreeSection.lastRow);
+                if (lastrow.length > 0) {
+                    break;
+                }
+                await container.sendKeys(selenium_webdriver_1.Key.PAGE_DOWN);
+            }
+        } while (!item);
+        return item;
+    }
+}
+exports.DefaultTreeSection = DefaultTreeSection;
+//# sourceMappingURL=DefaultTreeSection.js.map

package/out/components/statusBar/StatusBar.d.ts

@@ -0,0 +1,96 @@
+import { WebElement } from "selenium-webdriver";
+import { AbstractElement } from "../AbstractElement";
+import { NotificationsCenter } from "../workbench/NotificationsCenter";
+/**
+ * Page object for the status bar at the bottom
+ */
+export declare class StatusBar extends AbstractElement {
+    constructor();
+    /**
+     * Retrieve all status bar items currently displayed
+     * @returns Promise resolving to an array of WebElement
+     */
+    getItems(): Promise<WebElement[]>;
+    /**
+     * 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
+     */
+    getItem(title: string): Promise<WebElement | undefined>;
+    /**
+     * Open the notifications center
+     * @returns Promise resolving to NotificationsCenter object
+     */
+    openNotificationsCenter(): Promise<NotificationsCenter>;
+    /**
+     * Close the notifications center
+     * @returns Promise resolving when the notifications center is closed
+     */
+    closeNotificationsCenter(): Promise<void>;
+    /**
+     * Open the language selection quick pick
+     * Only works with an open editor
+     * @returns Promise resolving when the language selection is opened
+     */
+    openLanguageSelection(): Promise<void>;
+    /**
+     * Get the current language label text
+     * Only works with an open editor
+     * @returns Promise resolving to string representation of current language
+     */
+    getCurrentLanguage(): Promise<string>;
+    /**
+     * Open the quick pick for line endings selection
+     * Only works with an open editor
+     * @returns Promise resolving when the line ending selection is opened
+     */
+    openLineEndingSelection(): Promise<void>;
+    /**
+     * Get the currently selected line ending as text
+     * Only works with an open editor
+     * @returns Promise resolving to string representation of current line ending
+     */
+    getCurrentLineEnding(): Promise<string>;
+    /**
+     * Open the encoding selection quick pick
+     * Only works with an open editor
+     * @returns Promise resolving when the encoding selection is opened
+     */
+    openEncodingSelection(): Promise<void>;
+    /**
+     * Get the name of the current encoding as text
+     * Only works with an open editor
+     * @returns Promise resolving to string representation of current encoding
+     */
+    getCurrentEncoding(): Promise<string>;
+    /**
+     * Open the indentation selection quick pick
+     * Only works with an open editor
+     * @returns Promise resolving when the indentation selection is opened
+     */
+    openIndentationSelection(): Promise<void>;
+    /**
+     * Get the current indentation option label as text
+     * Only works with an open editor
+     * @returns Promise resolving to string representation of current indentation
+     */
+    getCurrentIndentation(): Promise<string>;
+    /**
+     * Open the line selection input box
+     * Only works with an open editor
+     * @returns Promise resolving when the line selection is opened
+     */
+    openLineSelection(): Promise<void>;
+    /**
+     * 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
+     */
+    getCurrentPosition(): Promise<string>;
+    /**
+     * Open/Close notification centre
+     * @param open true to open, false to close
+     */
+    private toggleNotificationsCentre;
+    private getPartText;
+}