@redhat-developer/page-objects 1.0.0

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

@@ -0,0 +1,57 @@
+import { SideBarView, ViewSection, ViewSectionConstructor } from "../..";
+import { AbstractElement } from "../AbstractElement";
+/**
+ * Page object representing the view container of a side bar view
+ */
+export declare class ViewContent extends AbstractElement {
+    constructor(view?: SideBarView);
+    /**
+     * Finds whether a progress bar is active at the top of the view
+     * @returns Promise resolving to true/false
+     */
+    hasProgress(): Promise<boolean>;
+    /**
+     * Retrieves a collapsible view content section by its title.
+     * Generic parameter allows caller to cast returned section to
+     * desired type, however it is caller's responsibility to check
+     * whether type is compatible with desired type.
+     * @param title Title of the section
+     * @returns Promise resolving to ViewSection object
+     */
+    getSection<T extends ViewSection>(title: string): Promise<T>;
+    /**
+     * Retrieves a collapsible view content section by its title.
+     * Type parameter allows caller to use custom section implementation,
+     * however it is caller's responsibility to check
+     * whether type is compatible with desired type.
+     * @param title Title of the section
+     * @param type ViewSection constructor to be used
+     * @returns Promise resolving to object specified by type
+     */
+    getSection<T extends ViewSection>(title: string, type: ViewSectionConstructor<T>): Promise<T>;
+    /**
+     * Retrieves a collapsible view content section by predicate.
+     * Generic parameter allows caller to cast returned section to
+     * desired type, however it is caller's responsibility to check
+     * whether type is compatible with desired type.
+     * @param predicate Predicate to be used when searching
+     * @returns Promise resolving to ViewSection object
+     */
+    getSection<T extends ViewSection>(predicate: ((section: ViewSection) => boolean | PromiseLike<boolean>)): Promise<T>;
+    /**
+     * Retrieves a collapsible view content section by predicate.
+     * Type parameter allows caller to use custom section implementation,
+     * however it is caller's responsibility to check
+     * whether type is compatible with desired type.
+     * @param predicate Predicate to be used when searching
+     * @param type ViewSection constructor to be used
+     * @returns Promise resolving to object specified by type
+     */
+    getSection<T extends ViewSection>(predicate: ((section: ViewSection) => boolean | PromiseLike<boolean>), type: ViewSectionConstructor<T>): Promise<T>;
+    /**
+     * Retrieves all the collapsible view content sections
+     * @returns Promise resolving to array of ViewSection objects
+     */
+    getSections(): Promise<ViewSection[]>;
+    private createSection;
+}

package/out/components/sidebar/ViewContent.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewContent = void 0;
+const __1 = require("../..");
+const selenium_webdriver_1 = require("selenium-webdriver");
+const AbstractElement_1 = require("../AbstractElement");
+/**
+ * Page object representing the view container of a side bar view
+ */
+class ViewContent extends AbstractElement_1.AbstractElement {
+    constructor(view = new __1.SideBarView()) {
+        super(ViewContent.locators.ViewContent.constructor, view);
+    }
+    /**
+     * Finds whether a progress bar is active at the top of the view
+     * @returns Promise resolving to true/false
+     */
+    async hasProgress() {
+        const progress = await this.findElement(ViewContent.locators.ViewContent.progress);
+        const hidden = await progress.getAttribute('aria-hidden');
+        if (hidden === 'true') {
+            return false;
+        }
+        return true;
+    }
+    async getSection(titleOrPredicate, type) {
+        const sections = await this.getSections();
+        const predicate = typeof titleOrPredicate === 'string' ?
+            (async (section) => await section.getTitle() === titleOrPredicate) : titleOrPredicate;
+        for (const section of sections) {
+            if (await predicate(section)) {
+                if (type !== undefined && !(section instanceof type)) {
+                    return new type(section, this);
+                }
+                return section;
+            }
+        }
+        if (typeof titleOrPredicate === 'string') {
+            throw new selenium_webdriver_1.error.NoSuchElementError(`No section with title '${titleOrPredicate}' found`);
+        }
+        else {
+            throw new selenium_webdriver_1.error.NoSuchElementError(`No section satisfying predicate found`);
+        }
+    }
+    /**
+     * Retrieves all the collapsible view content sections
+     * @returns Promise resolving to array of ViewSection objects
+     */
+    async getSections() {
+        const sections = [];
+        const elements = await this.findElements(ViewContent.locators.ViewContent.section);
+        for (const element of elements) {
+            sections.push(await this.createSection(element));
+        }
+        return sections;
+    }
+    async createSection(panel, type) {
+        if (type !== undefined) {
+            return new type(panel, this);
+        }
+        let section = new __1.DefaultTreeSection(panel, this);
+        const types = ViewContent.locators.DefaultTreeSection.type;
+        const locators = ViewContent.locators;
+        if (await types.default(section, locators)) {
+            return section;
+        }
+        else if (await types.marketplace.extension(section, locators)) {
+            return new __1.ExtensionsViewSection(panel, this);
+        }
+        else {
+            return new __1.CustomTreeSection(panel, this);
+        }
+    }
+}
+exports.ViewContent = ViewContent;
+//# sourceMappingURL=ViewContent.js.map

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

@@ -0,0 +1,97 @@
+import { ElementWithContexMenu } from "../ElementWithContextMenu";
+import { AbstractElement } from "../AbstractElement";
+import { WebElement, By } from "selenium-webdriver";
+/**
+ * Arbitrary item in the side bar view
+ */
+export declare abstract class ViewItem extends ElementWithContexMenu {
+    /**
+     * Select the item in the view.
+     * Note that selecting the item will toggle its expand state when applicable.
+     * @returns Promise resolving when the item has been clicked
+     */
+    select(): Promise<void>;
+}
+/**
+ * Abstract representation of a row in the tree inside a view content section
+ */
+export declare abstract class TreeItem extends ViewItem {
+    /**
+     * Retrieves the label of this view item
+     */
+    abstract getLabel(): Promise<string>;
+    /**
+     * Retrieves the tooltip of this TreeItem.
+     * @returns A promise resolving to the tooltip or undefined if the TreeItem has no tooltip.
+     */
+    getTooltip(): Promise<string | undefined>;
+    /**
+     * Retrieves the description of this TreeItem.
+     * @returns A promise resolving to the tooltip or undefined if the TreeItem has no description.
+     */
+    getDescription(): Promise<string | undefined>;
+    /**
+     * Finds if the item has children by actually counting the child items
+     * Note that this will expand the item if it was collapsed
+     * @returns Promise resolving to true/false
+     */
+    hasChildren(): Promise<boolean>;
+    /**
+     * Finds whether the item is expanded. Always returns false if item has no children.
+     * @returns Promise resolving to true/false
+     */
+    abstract isExpanded(): Promise<boolean>;
+    /**
+     * Find children of an item, will try to expand the item in the process
+     * @returns Promise resolving to array of TreeItem objects, empty array if item has no children
+     */
+    abstract getChildren(): Promise<TreeItem[]>;
+    /**
+     * Finds if the item is expandable/collapsible
+     * @returns Promise resolving to true/false
+     */
+    abstract isExpandable(): Promise<boolean>;
+    /**
+     * Expands the current item, if it can be expanded and is collapsed.
+     */
+    expand(): Promise<void>;
+    /**
+     * Find a child item with the given name
+     * @returns Promise resolving to TreeItem object if the child item exists, undefined otherwise
+     */
+    findChildItem(name: string): Promise<TreeItem | undefined>;
+    /**
+     * Collapse the item if expanded
+     */
+    collapse(): Promise<void>;
+    /**
+     * Find all action buttons bound to the view item
+     *
+     * @returns array of ViewItemAction objects, empty array if item has no
+     * actions associated
+     */
+    getActionButtons(): Promise<ViewItemAction[]>;
+    /**
+     * Find action button for view item by label
+     * @param label label of the button to search by
+     *
+     * @returns ViewItemAction object if such button exists, undefined otherwise
+     */
+    getActionButton(label: string): Promise<ViewItemAction | undefined>;
+    /**
+     * Find all child elements of a tree item
+     * @param locator locator of a given type of tree item
+     */
+    protected getChildItems(locator: By): Promise<WebElement[]>;
+    protected findTwistie(): Promise<WebElement>;
+}
+/**
+ * Action button bound to a view item
+ */
+export declare class ViewItemAction extends AbstractElement {
+    constructor(actionConstructor: By, viewItem: TreeItem);
+    /**
+     * Get label of the action button
+     */
+    getLabel(): Promise<string>;
+}

package/out/components/sidebar/ViewItem.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewItemAction = exports.TreeItem = exports.ViewItem = void 0;
+const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
+const AbstractElement_1 = require("../AbstractElement");
+const selenium_webdriver_1 = require("selenium-webdriver");
+const NullAttributeError_1 = require("../../errors/NullAttributeError");
+/**
+ * Arbitrary item in the side bar view
+ */
+class ViewItem extends ElementWithContextMenu_1.ElementWithContexMenu {
+    /**
+     * Select the item in the view.
+     * Note that selecting the item will toggle its expand state when applicable.
+     * @returns Promise resolving when the item has been clicked
+     */
+    async select() {
+        await this.click();
+    }
+}
+exports.ViewItem = ViewItem;
+/**
+ * Abstract representation of a row in the tree inside a view content section
+ */
+class TreeItem extends ViewItem {
+    /**
+     * Retrieves the tooltip of this TreeItem.
+     * @returns A promise resolving to the tooltip or undefined if the TreeItem has no tooltip.
+     */
+    async getTooltip() {
+        return undefined;
+    }
+    /**
+     * Retrieves the description of this TreeItem.
+     * @returns A promise resolving to the tooltip or undefined if the TreeItem has no description.
+     */
+    async getDescription() {
+        return undefined;
+    }
+    /**
+     * Finds if the item has children by actually counting the child items
+     * Note that this will expand the item if it was collapsed
+     * @returns Promise resolving to true/false
+     */
+    async hasChildren() {
+        const children = await this.getChildren();
+        return children && children.length > 0;
+    }
+    /**
+     * Expands the current item, if it can be expanded and is collapsed.
+     */
+    async expand() {
+        if (await this.isExpandable() && !await this.isExpanded()) {
+            await (await this.findTwistie()).click();
+        }
+    }
+    /**
+     * Find a child item with the given name
+     * @returns Promise resolving to TreeItem object if the child item exists, undefined otherwise
+     */
+    async findChildItem(name) {
+        const children = await this.getChildren();
+        for (const item of children) {
+            if (await item.getLabel() === name) {
+                return item;
+            }
+        }
+    }
+    /**
+     * Collapse the item if expanded
+     */
+    async collapse() {
+        if (await this.isExpandable() && await this.isExpanded()) {
+            await (await this.findTwistie()).click();
+        }
+    }
+    /**
+     * Find all action buttons bound to the view item
+     *
+     * @returns array of ViewItemAction objects, empty array if item has no
+     * actions associated
+     */
+    async getActionButtons() {
+        await this.getDriver().actions().move({ origin: this }).perform();
+        let container;
+        try {
+            container = await this.findElement(TreeItem.locators.TreeItem.actions);
+        }
+        catch (e) {
+            if (e instanceof selenium_webdriver_1.error.NoSuchElementError) {
+                return [];
+            }
+            throw e;
+        }
+        const actions = [];
+        const items = await container.findElements(TreeItem.locators.TreeItem.actionLabel);
+        for (const item of items) {
+            const label = await item.getAttribute(TreeItem.locators.TreeItem.actionTitle);
+            if (label === '' || label === null) {
+                // unknown, skip the item
+                continue;
+            }
+            try {
+                actions.push(new ViewItemAction(ViewItemAction.locators.ViewSection.actionConstructor(label), this));
+            }
+            catch (e) {
+                // the item was destroyed in meantime
+                if (e instanceof selenium_webdriver_1.error.NoSuchElementError) {
+                    continue;
+                }
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    console.warn('ViewItem has become stale');
+                }
+                throw e;
+            }
+        }
+        return actions;
+    }
+    /**
+     * Find action button for view item by label
+     * @param label label of the button to search by
+     *
+     * @returns ViewItemAction object if such button exists, undefined otherwise
+     */
+    async getActionButton(label) {
+        const actions = await this.getActionButtons();
+        for (const action of actions) {
+            try {
+                if ((await action.getLabel()).includes(label)) {
+                    return action;
+                }
+            }
+            catch (e) {
+                if (e instanceof NullAttributeError_1.NullAttributeError || e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    continue;
+                }
+                throw e;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find all child elements of a tree item
+     * @param locator locator of a given type of tree item
+     */
+    async getChildItems(locator) {
+        const items = [];
+        await this.expand();
+        const rows = await this.enclosingItem.findElements(locator);
+        const baseIndex = +await this.getAttribute(TreeItem.locators.ViewSection.index);
+        const baseLevel = +await this.getAttribute(TreeItem.locators.ViewSection.level);
+        for (const row of rows) {
+            const level = +await row.getAttribute(TreeItem.locators.ViewSection.level);
+            const index = +await row.getAttribute(TreeItem.locators.ViewSection.index);
+            if (index <= baseIndex) {
+                continue;
+            }
+            if (level > baseLevel + 1) {
+                continue;
+            }
+            if (level <= baseLevel) {
+                break;
+            }
+            items.push(row);
+        }
+        return items;
+    }
+    async findTwistie() {
+        return await this.findElement(TreeItem.locators.TreeItem.twistie);
+    }
+}
+exports.TreeItem = TreeItem;
+/**
+ * Action button bound to a view item
+ */
+class ViewItemAction extends AbstractElement_1.AbstractElement {
+    constructor(actionConstructor, viewItem) {
+        super(actionConstructor, viewItem);
+    }
+    /**
+     * Get label of the action button
+     */
+    async getLabel() {
+        const value = await this.getAttribute(ViewItemAction.locators.ViewSection.buttonLabel);
+        if (value === null) {
+            throw new NullAttributeError_1.NullAttributeError(`${this.constructor.name}.getLabel returned null`);
+        }
+        return value;
+    }
+}
+exports.ViewItemAction = ViewItemAction;
+//# sourceMappingURL=ViewItem.js.map

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

@@ -0,0 +1,98 @@
+import { WebElement } from "selenium-webdriver";
+import { ContextMenu, ViewContent, ViewItem, WelcomeContentSection } from "../..";
+import { AbstractElement } from "../AbstractElement";
+export type ViewSectionConstructor<T extends ViewSection> = {
+    new (rootElement: WebElement, tree: ViewContent): T;
+};
+/**
+ * Page object representing a collapsible content section of the side bar view
+ */
+export declare abstract class ViewSection extends AbstractElement {
+    constructor(panel: WebElement, content: ViewContent);
+    /**
+     * Get the title of the section as string
+     * @returns Promise resolving to section title
+     */
+    getTitle(): Promise<string>;
+    /**
+     * Expand the section if collapsed
+     * @returns Promise resolving when the section is expanded
+     */
+    expand(): Promise<void>;
+    /**
+     * Collapse the section if expanded
+     * @returns Promise resolving when the section is collapsed
+     */
+    collapse(): Promise<void>;
+    /**
+     * Finds whether the section is expanded
+     * @returns Promise resolving to true/false
+     */
+    isExpanded(): Promise<boolean>;
+    /**
+     * Finds [Welcome Content](https://code.visualstudio.com/api/extension-guides/tree-view#welcome-content)
+     * present in this ViewSection and returns it. If none is found, then `undefined` is returned
+     *
+     */
+    findWelcomeContent(): Promise<WelcomeContentSection | undefined>;
+    /**
+     * Retrieve all items currently visible in the view section.
+     * Note that any item currently beyond the visible list, i.e. not scrolled to, will not be retrieved.
+     * @returns Promise resolving to array of ViewItem objects
+     */
+    abstract getVisibleItems(): Promise<ViewItem[]>;
+    /**
+     * Find an item in this view section by label. Does not perform recursive search through the whole tree.
+     * Does however scroll through all the expanded content. Will find items beyond the current scroll range.
+     * @param label Label of the item to search for.
+     * @param maxLevel Limit how deep the algorithm should look into any expanded items, default unlimited (0)
+     * @returns Promise resolving to ViewItem object is such item exists, undefined otherwise
+     */
+    abstract findItem(label: string, maxLevel?: number): Promise<ViewItem | undefined>;
+    /**
+     * Open an item with a given path represented by a sequence of labels
+     *
+     * e.g to open 'file' inside 'folder', call
+     * openItem('folder', 'file')
+     *
+     * The first item is only searched for directly within the root element (depth 1).
+     * The label sequence is handled in order. If a leaf item (a file for example) is found in the middle
+     * of the sequence, the rest is ignored.
+     *
+     * If the item structure is flat, use the item's title to search by.
+     *
+     * @param path Sequence of labels that make up the path to a given item.
+     * @returns Promise resolving to array of ViewItem objects representing the last item's children.
+     * If the last item is a leaf, empty array is returned.
+     */
+    abstract openItem(...path: string[]): Promise<ViewItem[]>;
+    /**
+     * Retrieve the action buttons on the section's header
+     * @returns Promise resolving to array of ViewPanelAction objects
+     */
+    getActions(): Promise<ViewPanelAction[]>;
+    /**
+     * Retrieve an action button on the sections's header by its label
+     * @param label label/title of the button
+     * @returns ViewPanelAction object if found, undefined otherwise
+     */
+    getAction(label: string): Promise<ViewPanelAction | undefined>;
+    /**
+     * Click on the More Actions... item if it exists
+     *
+     * @returns ContextMenu page object if the action succeeds, undefined otherwise
+     */
+    moreActions(): Promise<ContextMenu | undefined>;
+    private isHeaderHidden;
+}
+/**
+ * Action button on the header of a view section
+ */
+export declare class ViewPanelAction extends AbstractElement {
+    constructor(element: WebElement, viewPart: ViewSection);
+    /**
+     * Get label of the action button
+     */
+    getLabel(): Promise<string>;
+    wait(timeout?: number): Promise<this>;
+}

package/out/components/sidebar/ViewSection.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewPanelAction = exports.ViewSection = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const __1 = require("../..");
+const AbstractElement_1 = require("../AbstractElement");
+const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
+/**
+ * Page object representing a collapsible content section of the side bar view
+ */
+class ViewSection extends AbstractElement_1.AbstractElement {
+    constructor(panel, content) {
+        super(panel, content);
+    }
+    /**
+     * Get the title of the section as string
+     * @returns Promise resolving to section title
+     */
+    async getTitle() {
+        const title = await this.findElement(ViewSection.locators.ViewSection.title);
+        return await title.getAttribute(ViewSection.locators.ViewSection.titleText);
+    }
+    /**
+     * Expand the section if collapsed
+     * @returns Promise resolving when the section is expanded
+     */
+    async expand() {
+        if (await this.isHeaderHidden()) {
+            return;
+        }
+        if (!await this.isExpanded()) {
+            const panel = await this.findElement(ViewSection.locators.ViewSection.header);
+            await panel.click();
+            await this.getDriver().wait((0, __1.waitForAttributeValue)(panel, ViewSection.locators.ViewSection.headerExpanded, 'true'), 1000);
+        }
+    }
+    /**
+     * Collapse the section if expanded
+     * @returns Promise resolving when the section is collapsed
+     */
+    async collapse() {
+        if (await this.isHeaderHidden()) {
+            return;
+        }
+        if (await this.isExpanded()) {
+            const panel = await this.findElement(ViewSection.locators.ViewSection.header);
+            await panel.click();
+            await this.getDriver().wait((0, __1.waitForAttributeValue)(panel, ViewSection.locators.ViewSection.headerExpanded, 'false'), 1000);
+        }
+    }
+    /**
+     * Finds whether the section is expanded
+     * @returns Promise resolving to true/false
+     */
+    async isExpanded() {
+        const header = await this.findElement(ViewSection.locators.ViewSection.header);
+        const expanded = await header.getAttribute(ViewSection.locators.ViewSection.headerExpanded);
+        return expanded === 'true';
+    }
+    /**
+     * Finds [Welcome Content](https://code.visualstudio.com/api/extension-guides/tree-view#welcome-content)
+     * present in this ViewSection and returns it. If none is found, then `undefined` is returned
+     *
+     */
+    async findWelcomeContent() {
+        try {
+            const res = await this.findElement(ViewSection.locators.ViewSection.welcomeContent);
+            if (!await res.isDisplayed()) {
+                return undefined;
+            }
+            return new __1.WelcomeContentSection(res, this);
+        }
+        catch (_err) {
+            return undefined;
+        }
+    }
+    /**
+     * Retrieve the action buttons on the section's header
+     * @returns Promise resolving to array of ViewPanelAction objects
+     */
+    async getActions() {
+        const actions = [];
+        if (!await this.isHeaderHidden()) {
+            const header = await this.findElement(ViewSection.locators.ViewSection.header);
+            const act = await header.findElement(ViewSection.locators.ViewSection.actions);
+            const elements = await act.findElements(ViewSection.locators.ViewSection.button);
+            for (const element of elements) {
+                actions.push(await new ViewPanelAction(element, this).wait());
+            }
+        }
+        return actions;
+    }
+    /**
+     * Retrieve an action button on the sections's header by its label
+     * @param label label/title of the button
+     * @returns ViewPanelAction object if found, undefined otherwise
+     */
+    async getAction(label) {
+        const actions = await this.getActions();
+        for (const action of actions) {
+            if (await action.getLabel() === label) {
+                return action;
+            }
+        }
+    }
+    /**
+     * Click on the More Actions... item if it exists
+     *
+     * @returns ContextMenu page object if the action succeeds, undefined otherwise
+     */
+    async moreActions() {
+        let more = await this.getAction('More Actions...');
+        if (!more) {
+            return undefined;
+        }
+        const section = this;
+        const btn = new class extends ElementWithContextMenu_1.ElementWithContexMenu {
+            async openContextMenu() {
+                await this.click();
+                const shadowRootHost = await section.findElements(selenium_webdriver_1.By.className('shadow-root-host'));
+                if (shadowRootHost.length > 0) {
+                    let shadowRoot;
+                    const webdriverCapabilities = await this.getDriver().getCapabilities();
+                    const chromiumVersion = webdriverCapabilities.getBrowserVersion();
+                    if (chromiumVersion && parseInt(chromiumVersion.split('.')[0]) >= 96) {
+                        shadowRoot = await shadowRootHost[0].getShadowRoot();
+                        return new __1.ContextMenu(await shadowRoot.findElement(selenium_webdriver_1.By.className('monaco-menu-container'))).wait();
+                    }
+                    else {
+                        shadowRoot = await this.getDriver().executeScript('return arguments[0].shadowRoot', shadowRootHost[0]);
+                        return new __1.ContextMenu(shadowRoot).wait();
+                    }
+                }
+                return await super.openContextMenu();
+            }
+        }(more, this);
+        return await btn.openContextMenu();
+    }
+    async isHeaderHidden() {
+        const header = await this.findElement(ViewSection.locators.ViewSection.header);
+        return (await header.getAttribute('class')).indexOf('hidden') > -1;
+    }
+}
+exports.ViewSection = ViewSection;
+/**
+ * Action button on the header of a view section
+ */
+class ViewPanelAction extends AbstractElement_1.AbstractElement {
+    constructor(element, viewPart) {
+        super(element, viewPart);
+    }
+    /**
+     * Get label of the action button
+     */
+    async getLabel() {
+        return await this.getAttribute(ViewSection.locators.ViewSection.buttonLabel);
+    }
+    async wait(timeout = 1000) {
+        await this.getDriver().wait(selenium_webdriver_1.until.elementIsEnabled(this), timeout);
+        return this;
+    }
+}
+exports.ViewPanelAction = ViewPanelAction;
+//# sourceMappingURL=ViewSection.js.map