@redhat-developer/page-objects 1.21.0 → 1.22.0

package/out/components/AbstractElement.js

@@ -160,7 +160,8 @@ class AbstractElement extends selenium_webdriver_1.WebElement {
             catch (err) {
                 const isRecoverable = err.name === 'StaleElementReferenceError' ||
                     err.name === 'ElementNotInteractableError' ||
-                    /element.*(detached|not interactable)/i.test(err.message);
+                    err.name === 'ElementClickInterceptedError' ||
+                    /element.*(detached|not interactable|click intercepted)/i.test(err.message);
                 if (isRecoverable && attempt < maxRetries) {
                     try {
                         recoveredElement = await this.reinitialize();

package/out/components/ElementWithContextMenu.d.ts

@@ -24,4 +24,15 @@ export declare abstract class ElementWithContextMenu extends AbstractElement {
      * Open context menu on the element
      */
     openContextMenu(): Promise<ContextMenu>;
+    /**
+     * Since VS Code ~1.133 some context menus (notably the text editor's) render
+     * inside an open shadow root on a `.shadow-root-host` element attached
+     * directly to the workbench, instead of the document-level `.context-view`
+     * container. Which shape a given install uses is not strictly version-bound,
+     * so poll for either: resolve the menu from the shadow root when it appears,
+     * or return undefined as soon as the legacy container shows up (or the
+     * timeout runs out) so the caller can take the regular `.context-view` path.
+     */
+    protected waitForShadowRootMenu(timeout?: number): Promise<ContextMenu | undefined>;
+    private menuContainerInShadowRoot;
 }

package/out/components/ElementWithContextMenu.js

@@ -28,26 +28,74 @@ class ElementWithContextMenu extends AbstractElement_1.AbstractElement {
      * Open context menu on the element
      */
     async openContextMenu() {
-        const workbench = await this.getDriver().findElement(ElementWithContextMenu.locators.Workbench.constructor);
-        const menus = await workbench.findElements(ElementWithContextMenu.locators.ContextMenu.contextView);
-        if (menus.length < 1) {
-            await this.getDriver().actions().contextClick(this).perform();
-            await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(ElementWithContextMenu.locators.ContextMenu.contextView), 2000);
+        return await this.withRecovery(async (self) => {
+            const workbench = await self.getDriver().findElement(ElementWithContextMenu.locators.Workbench.constructor);
+            const menus = await workbench.findElements(ElementWithContextMenu.locators.ContextMenu.contextView);
+            if (menus.length < 1) {
+                await self.getDriver().actions().contextClick(self).perform();
+                await self.getDriver().wait(selenium_webdriver_1.until.elementLocated(ElementWithContextMenu.locators.ContextMenu.contextView), 2000);
+                return new __1.ContextMenu(workbench).wait();
+            }
+            else if ((await workbench.findElements(ElementWithContextMenu.locators.ContextMenu.viewBlock)).length > 0) {
+                await self.getDriver().actions().contextClick(self).perform();
+                try {
+                    await self.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(self), 1000);
+                }
+                catch (err) {
+                    if (!(err instanceof selenium_webdriver_1.error.StaleElementReferenceError)) {
+                        throw err;
+                    }
+                }
+            }
+            await self.getDriver().actions().contextClick(self).perform();
             return new __1.ContextMenu(workbench).wait();
-        }
-        else if ((await workbench.findElements(ElementWithContextMenu.locators.ContextMenu.viewBlock)).length > 0) {
-            await this.getDriver().actions().contextClick(this).perform();
-            try {
-                await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this), 1000);
+        });
+    }
+    /**
+     * Since VS Code ~1.133 some context menus (notably the text editor's) render
+     * inside an open shadow root on a `.shadow-root-host` element attached
+     * directly to the workbench, instead of the document-level `.context-view`
+     * container. Which shape a given install uses is not strictly version-bound,
+     * so poll for either: resolve the menu from the shadow root when it appears,
+     * or return undefined as soon as the legacy container shows up (or the
+     * timeout runs out) so the caller can take the regular `.context-view` path.
+     */
+    async waitForShadowRootMenu(timeout = 2000) {
+        const driver = this.getDriver();
+        const end = Date.now() + timeout;
+        while (Date.now() < end) {
+            const hosts = await driver.findElements(ElementWithContextMenu.locators.ContextMenu.shadowRootHost);
+            for (const host of hosts) {
+                try {
+                    const container = await this.menuContainerInShadowRoot(host);
+                    if (container && (await container.isDisplayed())) {
+                        return await new __1.ContextMenu(host, container).wait();
+                    }
+                }
+                catch (err) {
+                    // the host or menu got removed mid-check - keep polling
+                }
             }
-            catch (err) {
-                if (!(err instanceof selenium_webdriver_1.error.StaleElementReferenceError)) {
-                    throw err;
+            const legacy = await driver.findElements(ElementWithContextMenu.locators.ContextMenu.contextView);
+            for (const view of legacy) {
+                if (await view.isDisplayed().catch(() => false)) {
+                    return undefined;
                 }
             }
+            await new Promise((res) => setTimeout(res, 100));
+        }
+        return undefined;
+    }
+    async menuContainerInShadowRoot(host) {
+        const driver = this.getDriver();
+        const capabilities = await driver.getCapabilities();
+        const chromiumVersion = capabilities.getBrowserVersion();
+        if (chromiumVersion && Number.parseInt(chromiumVersion.split('.')[0]) >= 96) {
+            const shadowRoot = await host.getShadowRoot();
+            const containers = await shadowRoot.findElements(ElementWithContextMenu.locators.ContextMenu.constructor);
+            return containers.length > 0 ? containers[0] : undefined;
         }
-        await this.getDriver().actions().contextClick(this).perform();
-        return new __1.ContextMenu(workbench).wait();
+        return (await driver.executeScript('return arguments[0].shadowRoot ? arguments[0].shadowRoot.querySelector(".monaco-menu-container") : undefined;', host));
     }
 }
 exports.ElementWithContextMenu = ElementWithContextMenu;

package/out/components/WebviewMixin.js

@@ -28,7 +28,9 @@ const AbstractElement_1 = require("./AbstractElement");
 function default_1(Base) {
     return class extends Base {
         /**
-         * Cannot use static element, since this class is unnamed.
+         * Window handle captured once at switchToFrame() time so that switchBack()
+         * always returns to the correct top-level context even when called from
+         * within a nested frame.
          */
         handle;
         /**
@@ -58,25 +60,89 @@ function default_1(Base) {
          * This allows using the findWebElement methods.
          * Note that only elements inside the webview iframe will be accessible.
          * Use the switchBack method to switch to the original context.
+         *
+         * The method polls for both the outer iframe and the inner active-frame to
+         * appear in the DOM under a single shared deadline, so `timeout` is always
+         * honoured regardless of how long each phase takes.  The driver is always
+         * returned to the top-level context before any error is thrown.
+         *
+         * @throws Error when the webview iframe cannot be located within the timeout
          */
         async switchToFrame(timeout = 5000) {
             if (!this.handle) {
                 this.handle = await this.getDriver().getWindowHandle();
             }
-            const view = await this.getViewToSwitchTo();
+            const deadline = Date.now() + timeout;
+            const pollInterval = 200;
+            const minPhase2Budget = Math.min(5000, Math.floor(timeout / 3));
+            // Phase 1 — poll for the outer webview iframe. Stop early to
+            // guarantee at least minPhase2Budget ms for the inner-frame lookup.
+            let view;
+            while (Date.now() < deadline - minPhase2Budget) {
+                try {
+                    view = await this.getViewToSwitchTo();
+                }
+                catch (e) {
+                    if (!(e instanceof selenium_webdriver_1.error.StaleElementReferenceError || e instanceof selenium_webdriver_1.error.NoSuchElementError)) {
+                        throw e;
+                    }
+                }
+                if (view) {
+                    break;
+                }
+                await this.getDriver().sleep(pollInterval);
+            }
             if (!view) {
-                return;
+                throw new Error(`WebviewMixin.switchToFrame: webview iframe was not found within ${timeout}ms. ` +
+                    `The webview may not have been opened, or the locator no longer matches the current VS Code version. ` +
+                    `See https://github.com/redhat-developer/vscode-extension-tester/issues/2450`);
+            }
+            // Phase 2 — switch into the outer iframe, then poll for the inner
+            // active-frame under the remaining budget (at least minPhase2Budget ms).
+            try {
+                await this.getDriver().switchTo().frame(view);
+            }
+            catch (e) {
+                if (e instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    throw new Error(`WebviewMixin.switchToFrame: outer iframe became stale during frame switch. ` +
+                        `See https://github.com/redhat-developer/vscode-extension-tester/issues/2450`);
+                }
+                throw e;
+            }
+            let frame;
+            while (Date.now() < deadline) {
+                try {
+                    const frames = await this.getDriver().findElements(AbstractElement_1.AbstractElement.locators.WebView.activeFrame);
+                    if (frames.length > 0) {
+                        frame = frames[0];
+                        break;
+                    }
+                }
+                catch (e) {
+                    if (!(e instanceof selenium_webdriver_1.error.StaleElementReferenceError || e instanceof selenium_webdriver_1.error.NoSuchElementError)) {
+                        await this.getDriver().switchTo().window(this.handle);
+                        throw e;
+                    }
+                }
+                await this.getDriver().sleep(pollInterval);
+            }
+            if (!frame) {
+                // Return to top-level before throwing so callers are not left inside a frame.
+                await this.getDriver().switchTo().window(this.handle);
+                throw new Error(`WebviewMixin.switchToFrame: active-frame iframe was not found within ${timeout}ms. ` +
+                    `The webview content may still be loading. ` +
+                    `See https://github.com/redhat-developer/vscode-extension-tester/issues/2450`);
             }
-            await this.getDriver().switchTo().frame(view);
-            await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(AbstractElement_1.AbstractElement.locators.WebView.activeFrame), timeout);
-            const frame = await this.getDriver().findElement(AbstractElement_1.AbstractElement.locators.WebView.activeFrame);
             await this.getDriver().switchTo().frame(frame);
         }
         /**
-         * Switch the underlying webdriver back to the original window
+         * Switch the underlying webdriver back to the original window.
+         * Uses the handle captured at switchToFrame() time; safe to call even when
+         * the driver context is already at the top level.
          */
         async switchBack() {
             if (!this.handle) {
+                // switchToFrame() was never called — capture and stay at top level
                 this.handle = await this.getDriver().getWindowHandle();
             }
             return await this.getDriver().switchTo().window(this.handle);

package/out/components/activityBar/ViewControl.d.ts

@@ -21,6 +21,11 @@ import { WebElement } from 'selenium-webdriver';
  * Page object representing a view container item in the activity bar
  */
 export declare class ViewControl extends ElementWithContextMenu {
+    /**
+     * Title of this control, cached on the first successful getTitle() call so the
+     * control can be re-located in the activity bar after its element goes stale.
+     */
+    private cachedTitle;
     constructor(element: WebElement, bar: ActivityBar);
     /**
      * Opens the associated view if not already open
@@ -36,4 +41,15 @@ export declare class ViewControl extends ElementWithContextMenu {
      * Returns the title of the associated view
      */
     getTitle(): Promise<string>;
+    /**
+     * Re-locate this control in the activity bar by its cached title.
+     * Used by withRecovery()-based helpers (safeClick, safeGetKlass) when the
+     * stored element reference goes stale, e.g. after the activity bar re-renders.
+     */
+    protected reinitialize(): Promise<this>;
+    /**
+     * Read the CSS class attribute from this element, recovering transparently if
+     * the stored reference has become stale.
+     */
+    private safeGetKlass;
 }

package/out/components/activityBar/ViewControl.js

@@ -25,6 +25,11 @@ const compare_versions_1 = require("compare-versions");
  * Page object representing a view container item in the activity bar
  */
 class ViewControl extends ElementWithContextMenu_1.ElementWithContextMenu {
+    /**
+     * Title of this control, cached on the first successful getTitle() call so the
+     * control can be re-located in the activity bar after its element goes stale.
+     */
+    cachedTitle;
     constructor(element, bar) {
         super(element, bar);
     }
@@ -33,14 +38,19 @@ class ViewControl extends ElementWithContextMenu_1.ElementWithContextMenu {
      * @returns Promise resolving to SideBarView object representing the opened view
      */
     async openView() {
-        // Check whether view is already open
-        const klass = (await this.getAttribute(ViewControl.locators.ViewControl.attribute));
+        // Use safeGetKlass so a stale reference is transparently re-fetched.
+        const klass = await this.safeGetKlass();
         if (klass.indexOf(ViewControl.locators.ViewControl.klass) < 0) {
-            await this.click();
+            await this.safeClick();
             // Wait for view to be marked as active
             await this.getWaitHelper().forCondition(async () => {
-                const newKlass = (await this.getAttribute(ViewControl.locators.ViewControl.attribute));
-                return newKlass.includes(ViewControl.locators.ViewControl.klass);
+                try {
+                    const newKlass = await this.safeGetKlass();
+                    return newKlass.includes(ViewControl.locators.ViewControl.klass);
+                }
+                catch {
+                    return false;
+                }
             }, { timeout: 2000, pollInterval: 100 });
         }
         const view = await new __1.SideBarView().wait();
@@ -60,9 +70,9 @@ class ViewControl extends ElementWithContextMenu_1.ElementWithContextMenu {
      * @returns Promise resolving when the view closes
      */
     async closeView() {
-        const klass = (await this.getAttribute(ViewControl.locators.ViewControl.attribute));
+        const klass = await this.safeGetKlass();
         if (klass.indexOf(ViewControl.locators.ViewControl.klass) > -1) {
-            await this.click();
+            await this.safeClick();
         }
     }
     /**
@@ -70,7 +80,34 @@ class ViewControl extends ElementWithContextMenu_1.ElementWithContextMenu {
      */
     async getTitle() {
         const badge = await this.findElement(ViewControl.locators.ViewControl.badge);
-        return (await badge.getAttribute('aria-label'));
+        const title = (await badge.getAttribute('aria-label'));
+        this.cachedTitle = title;
+        return title;
+    }
+    /**
+     * Re-locate this control in the activity bar by its cached title.
+     * Used by withRecovery()-based helpers (safeClick, safeGetKlass) when the
+     * stored element reference goes stale, e.g. after the activity bar re-renders.
+     */
+    async reinitialize() {
+        if (!this.cachedTitle) {
+            throw new Error(`ViewControl: element is stale and no cached title is available to re-locate it`);
+        }
+        // getViewControls() always queries live elements, so the new reference is fresh.
+        const fresh = await new __1.ActivityBar().getViewControl(this.cachedTitle);
+        if (!fresh) {
+            throw new Error(`ViewControl: could not re-locate stale element '${this.cachedTitle}' in the activity bar`);
+        }
+        return fresh;
+    }
+    /**
+     * Read the CSS class attribute from this element, recovering transparently if
+     * the stored reference has become stale.
+     */
+    async safeGetKlass() {
+        return await this.withRecovery(async (self) => {
+            return (await self.getAttribute(ViewControl.locators.ViewControl.attribute));
+        });
     }
 }
 exports.ViewControl = ViewControl;

package/out/components/bottomBar/BottomBarPanel.js

@@ -49,7 +49,7 @@ class BottomBarPanel extends AbstractElement_1.AbstractElement {
             }
             else {
                 await this.closePanel();
-                await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this));
+                await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(this), 5_000);
             }
         }
     }
@@ -124,16 +124,31 @@ class BottomBarPanel extends AbstractElement_1.AbstractElement {
     }
     async resize(label) {
         await this.toggle(true);
-        let action;
-        try {
-            action = await this.findElement(BottomBarPanel.locators.BottomBarPanel.globalActions).findElement(BottomBarPanel.locators.BottomBarPanel.action(label));
-        }
-        catch (err) {
-            // the panel is already maximized
-        }
-        if (action) {
-            await action.click();
-        }
+        // The resize action button may briefly be non-interactable (or get replaced)
+        // while the panel's open/maximize animation is running — poll the click
+        // instead of failing on the first attempt.
+        await this.getDriver()
+            .wait(async () => {
+            let action;
+            try {
+                action = await this.findElement(BottomBarPanel.locators.BottomBarPanel.globalActions).findElement(BottomBarPanel.locators.BottomBarPanel.action(label));
+            }
+            catch (err) {
+                // the panel is already maximized/restored — the action is absent
+                return true;
+            }
+            try {
+                await action.click();
+                return true;
+            }
+            catch (err) {
+                // not interactable or stale mid-animation — retry
+                return false;
+            }
+        }, 5000, `BottomBarPanel: could not click the '${label}' action`)
+            .catch(() => {
+            // keep previous lenient behavior — resize is best-effort
+        });
     }
     async closePanel() {
         const closeButton = await this.findElement(BottomBarPanel.locators.BottomBarPanel.closeAction);

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

@@ -26,9 +26,17 @@ export declare class ContentAssist extends Menu {
      * until the item is found, or the end is reached
      *
      * @param name name/text to search by
+     * @param timeout overall time budget in ms for the search (default 30000)
      * @returns Promise resolving to ContentAssistItem object if found, undefined otherwise
      */
-    getItem(name: string): Promise<ContentAssistItem | undefined>;
+    getItem(name: string, timeout?: number): Promise<ContentAssistItem | undefined>;
+    /**
+     * Read all currently rendered suggestion rows in a single script call.
+     * Returns the row elements together with their label text, virtual list index
+     * and whether the row is marked as the last element of the list.
+     */
+    private snapshotVisibleRows;
+    private static readonly SNAPSHOT_ROWS_SCRIPT;
     /**
      * Get all visible content assist items
      * @returns Promise resolving to array of ContentAssistItem objects

package/out/components/editor/ContentAssist.js

@@ -31,31 +31,106 @@ class ContentAssist extends __1.Menu {
      * until the item is found, or the end is reached
      *
      * @param name name/text to search by
+     * @param timeout overall time budget in ms for the search (default 30000)
      * @returns Promise resolving to ContentAssistItem object if found, undefined otherwise
      */
-    async getItem(name) {
-        let lastItem = false;
+    async getItem(name, timeout = 30000) {
+        const deadline = Date.now() + timeout;
         const scrollable = await this.findElement(ContentAssist.locators.ContentAssist.itemList);
+        await this.getDriver().wait(async () => {
+            return (await this.isLoaded()) && (await this.findElements(ContentAssist.locators.ContentAssist.itemRow)).length > 0;
+        }, Math.min(10000, Math.max(1000, deadline - Date.now())), 'Content assist item list did not populate');
+        // Scroll back to the top of the list in case it is not there already
         let firstItem = await this.findElements(ContentAssist.locators.ContentAssist.firstItem);
-        while (firstItem.length < 1) {
+        while (firstItem.length < 1 && Date.now() < deadline) {
             await scrollable.sendKeys(selenium_webdriver_1.Key.PAGE_UP, selenium_webdriver_1.Key.NULL);
+            await this.getWaitHelper().sleep(100);
             firstItem = await this.findElements(ContentAssist.locators.ContentAssist.firstItem);
         }
-        while (!lastItem) {
-            const items = await this.getItems();
-            for (const item of items) {
-                if ((await item.getLabel()) === name) {
-                    return item;
+        while (Date.now() < deadline) {
+            let rows;
+            try {
+                rows = await this.snapshotVisibleRows();
+            }
+            catch (err) {
+                if (err instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                    // The list re-rendered mid-read — take a fresh snapshot
+                    continue;
                 }
-                lastItem = lastItem || (await item.getAttribute('data-last-element')) === 'true';
+                throw err;
             }
-            if (!lastItem) {
-                await scrollable.sendKeys(selenium_webdriver_1.Key.PAGE_DOWN);
-                // Minimal delay for scroll to render new items
-                await this.getWaitHelper().sleep(100);
+            const match = rows.find((row) => row.label === name);
+            if (match) {
+                try {
+                    return await new ContentAssistItem(match.element, this).wait();
+                }
+                catch (err) {
+                    if (err instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
+                        continue;
+                    }
+                    throw err;
+                }
+            }
+            if (rows.some((row) => row.last)) {
+                // Reached the end of the list without finding the item
+                return undefined;
             }
+            const maxIndex = rows.reduce((max, row) => Math.max(max, row.index), -1);
+            await scrollable.sendKeys(selenium_webdriver_1.Key.PAGE_DOWN);
+            // Wait for the visible range to actually move instead of sleeping a fixed amount
+            await this.getDriver()
+                .wait(async () => {
+                const next = await this.snapshotVisibleRows().catch(() => undefined);
+                return next !== undefined && (next.some((row) => row.last) || next.reduce((max, row) => Math.max(max, row.index), -1) > maxIndex);
+            }, Math.min(2000, Math.max(200, deadline - Date.now())))
+                .catch(() => {
+                // The list did not move — keep looping, the deadline will end the search
+            });
         }
+        return undefined;
+    }
+    /**
+     * Read all currently rendered suggestion rows in a single script call.
+     * Returns the row elements together with their label text, virtual list index
+     * and whether the row is marked as the last element of the list.
+     */
+    async snapshotVisibleRows() {
+        const container = await this.findElement(ContentAssist.locators.ContentAssist.itemRows);
+        const rowLocator = ContentAssist.locators.ContentAssist.itemRow;
+        const labelLocator = ContentAssist.locators.ContentAssist.itemLabel;
+        const raw = (await this.getDriver().executeScript(ContentAssist.SNAPSHOT_ROWS_SCRIPT, container, rowLocator.using, rowLocator.value, labelLocator.using, labelLocator.value));
+        return raw.map((row) => ({ element: row.element, label: row.label, index: row.index, last: row.last }));
     }
+    static SNAPSHOT_ROWS_SCRIPT = `
+		var container = arguments[0];
+		var rowUsing = arguments[1], rowValue = arguments[2];
+		var labelUsing = arguments[3], labelValue = arguments[4];
+		function findAll(root, using, value) {
+			if (using === 'xpath') {
+				var out = [];
+				var it = document.evaluate(value, root, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+				for (var i = 0; i < it.snapshotLength; i++) { out.push(it.snapshotItem(i)); }
+				return out;
+			}
+			return Array.prototype.slice.call(root.querySelectorAll(value));
+		}
+		function findOne(root, using, value) {
+			if (using === 'xpath') {
+				return document.evaluate(value, root, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+			}
+			return root.querySelector(value);
+		}
+		return findAll(container, rowUsing, rowValue).map(function (row) {
+			var labelEl = findOne(row, labelUsing, labelValue);
+			var label = labelEl ? (labelEl.innerText !== undefined ? labelEl.innerText : labelEl.textContent) : '';
+			return {
+				element: row,
+				label: (label || '').trim(),
+				index: parseInt(row.getAttribute('data-index') || '-1', 10),
+				last: row.getAttribute('data-last-element') === 'true'
+			};
+		});
+	`;
     /**
      * Get all visible content assist items
      * @returns Promise resolving to array of ContentAssistItem objects

package/out/components/editor/CustomEditor.js

@@ -28,7 +28,7 @@ class CustomEditor extends __1.Editor {
      * @returns WebView page object
      */
     getWebView() {
-        return new __1.WebView();
+        return new __1.WebView(this.enclosingItem);
     }
     /**
      * Check if the editor has unsaved changes

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

@@ -120,6 +120,12 @@ export declare class EditorGroup extends AbstractElement {
      * @returns Promise resolving once all tabs have had their close button pressed
      */
     closeAllEditors(): Promise<void>;
+    /**
+     * If a "save changes?" modal dialog is currently blocking the workbench,
+     * dismiss it by discarding the changes ("Don't Save") so the underlying
+     * dirty editor closes. Returns true when a dialog was found and handled.
+     */
+    private discardDirtyEditorDialog;
     /**
      * Retrieve all open editor tab titles in an array
      * @returns Promise resolving to array of editor titles