@testring/plugin-selenium-driver 0.8.3 → 0.8.5

package/dist/plugin/index.js

@@ -28,6 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SeleniumPlugin = void 0;
 exports.default = seleniumProxy;
+const types_1 = require("@testring/types");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const webdriverio_1 = require("webdriverio");
@@ -152,6 +153,7 @@ class SeleniumPlugin {
         this.config = this.createConfig(config);
         if (this.config.host === undefined) {
             this.runLocalSelenium();
+            this.setupProcessCleanup();
         }
         this.initIntervals();
     }
@@ -191,6 +193,17 @@ class SeleniumPlugin {
             });
         }
     }
+    setupProcessCleanup() {
+        process.on('SIGINT', () => this.forceKillSelenium());
+        process.on('SIGTERM', () => this.forceKillSelenium());
+        // Note: SIGKILL cannot be caught or handled - it immediately terminates the process
+    }
+    forceKillSelenium() {
+        if (this.localSelenium && !this.localSelenium.killed) {
+            this.logger.debug('Force killing Selenium process due to signal');
+            this.localSelenium.kill('SIGKILL');
+        }
+    }
     stopAllSessions() {
         const clientsRequests = [];
         for (const [applicant] of this.browserClients) {
@@ -235,7 +248,12 @@ class SeleniumPlugin {
             this.logger.debug(`Starting Selenium with command: java ${seleniumArgs.join(' ')}`);
             this.localSelenium = (0, child_process_1.spawnWithPipes)('java', seleniumArgs);
             this.waitForReadyState = new Promise((resolve, reject) => {
-                setupProcessListeners(this.localSelenium, resolve, reject, version, this.logger);
+                if (this.localSelenium) {
+                    setupProcessListeners(this.localSelenium, resolve, reject, version, this.logger);
+                }
+                else {
+                    reject(new Error('Failed to spawn Selenium process'));
+                }
             });
             // Wait for the server to be ready
             await this.waitForReadyState;
@@ -376,6 +394,78 @@ class SeleniumPlugin {
     addCustromMethods(client) {
         return client;
     }
+    async getElement(applicant, selector) {
+        await this.createClient(applicant);
+        const client = this.getBrowserClient(applicant);
+        if ((0, types_1.isXpathSelector)(selector)) {
+            return client.$(selector.xpath);
+        }
+        else if ((0, types_1.isShadowCssSelector)(selector)) {
+            return this.getElementFromShadowCss(client, selector);
+        }
+        throw new Error('Unknown selector type');
+    }
+    async getElementFromShadowCss(client, selector) {
+        const { css, parentSelectors } = selector;
+        // Error first: validate selector structure
+        this.validateShadowCssSelector(selector);
+        try {
+            return await this.traverseShadowDom(client, css, parentSelectors);
+        }
+        catch (error) {
+            // Provide more context in error messages
+            if (error instanceof Error) {
+                throw new Error(`Shadow DOM traversal failed: ${error.message}. Selector: ${JSON.stringify(selector)}`);
+            }
+            throw error;
+        }
+    }
+    validateShadowCssSelector(selector) {
+        const { css, parentSelectors } = selector;
+        if (!css || typeof css !== 'string') {
+            throw new Error('Shadow CSS selector must have a valid CSS string');
+        }
+        if (!Array.isArray(parentSelectors) || parentSelectors.length === 0) {
+            throw new Error('Shadow CSS selector must have at least one parent selector');
+        }
+        // Validate all parent selectors are non-empty strings
+        for (const [index, parentSelector] of parentSelectors.entries()) {
+            if (!parentSelector || typeof parentSelector !== 'string') {
+                throw new Error(`Parent selector at index ${index} must be a non-empty string`);
+            }
+        }
+    }
+    async traverseToLastParentSelector(client, parentSelectors) {
+        const [firstParentSelector, ...restParentSelectors] = parentSelectors;
+        // TypeScript assertion: we know firstParentSelector exists due to validation
+        if (!firstParentSelector) {
+            throw new Error('First parent selector is required');
+        }
+        // Get the first parent element
+        let currentElement = await client.$(firstParentSelector);
+        if (!currentElement) {
+            throw new Error(`Failed to find parent element with selector: ${firstParentSelector}`);
+        }
+        // Traverse through shadow DOM hierarchy
+        for (const parentSelector of restParentSelectors) {
+            const shadowElement = await currentElement.shadow$(parentSelector);
+            if (!shadowElement) {
+                throw new Error(`Failed to find shadow element with selector: ${parentSelector}`);
+            }
+            currentElement = shadowElement;
+        }
+        return currentElement;
+    }
+    async traverseShadowDom(client, css, parentSelectors) {
+        // Traverse to the last parent selector
+        const lastParentElement = await this.traverseToLastParentSelector(client, parentSelectors);
+        // Get the final target element within the shadow DOM
+        const targetElement = await lastParentElement.shadow$(css);
+        if (!targetElement) {
+            throw new Error(`Failed to find target element with CSS selector: ${css}`);
+        }
+        return targetElement;
+    }
     async end(applicant) {
         await this.waitForReadyState;
         if (!this.hasBrowserClient(applicant)) {
@@ -483,17 +573,13 @@ class SeleniumPlugin {
         return client.refresh();
     }
     async click(applicant, selector, options) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const element = await client.$(selector);
+        const element = await this.getElement(applicant, selector);
         return options && Object.keys(options).length > 0
             ? element.click(options)
             : element.click();
     }
     async getSize(applicant, selector) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const element = await client.$(selector);
+        const element = await this.getElement(applicant, selector);
         return element.getSize();
     }
     async url(applicant, val) {
@@ -518,29 +604,21 @@ class SeleniumPlugin {
         });
         return (newWindow === null || newWindow === void 0 ? void 0 : newWindow.handle) || newWindow;
     }
-    async waitForExist(applicant, xpath, timeout) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.waitForExist({ timeout });
+    async waitForExist(applicant, selector, timeout) {
+        const element = await this.getElement(applicant, selector);
+        return element.waitForExist({ timeout });
     }
-    async waitForVisible(applicant, xpath, timeout) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.waitForDisplayed({ timeout });
+    async waitForVisible(applicant, selector, timeout) {
+        const element = await this.getElement(applicant, selector);
+        return element.waitForDisplayed({ timeout });
     }
-    async isVisible(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.isDisplayed();
+    async isVisible(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.isDisplayed();
     }
-    async moveToObject(applicant, xpath, xOffset = 0, yOffset = 0) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.moveTo({ xOffset, yOffset });
+    async moveToObject(applicant, selector, xOffset = 0, yOffset = 0) {
+        const element = await this.getElement(applicant, selector);
+        return element.moveTo({ xOffset, yOffset });
     }
     async execute(applicant, fn, args) {
         await this.createClient(applicant);
@@ -557,11 +635,9 @@ class SeleniumPlugin {
         const client = this.getBrowserClient(applicant);
         return client.getTitle();
     }
-    async clearValue(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.clearValue();
+    async clearValue(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.clearValue();
     }
     async keys(applicant, value) {
         await this.createClient(applicant);
@@ -573,18 +649,28 @@ class SeleniumPlugin {
         const client = this.getBrowserClient(applicant);
         return client.getElementText(elementId);
     }
-    async elements(applicant, xpath) {
+    async elements(applicant, selector) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
-        const elements = (await client.findElements('xpath', xpath));
-        return elements.map((o) => {
-            const keys = Object.keys(o);
-            const firstKey = keys[0];
-            if (firstKey === undefined) {
-                return { ELEMENT: '' };
-            }
-            return { ELEMENT: o[firstKey] };
-        });
+        if ((0, types_1.isXpathSelector)(selector)) {
+            const elements = (await client.findElements('xpath', selector.xpath));
+            return elements.map((o) => {
+                const keys = Object.keys(o);
+                const firstKey = keys[0];
+                if (firstKey === undefined) {
+                    return { ELEMENT: '' };
+                }
+                return { ELEMENT: o[firstKey] };
+            });
+        }
+        else if ((0, types_1.isShadowCssSelector)(selector)) {
+            const lastParentElement = await this.traverseToLastParentSelector(client, selector.parentSelectors);
+            const elements = lastParentElement.shadow$$(selector.css);
+            return elements.map((element) => {
+                return { ELEMENT: element.elementId };
+            });
+        }
+        throw new Error('Unknown selector type');
     }
     async frame(applicant, frameID) {
         await this.createClient(applicant);
@@ -596,64 +682,46 @@ class SeleniumPlugin {
         const client = this.getBrowserClient(applicant);
         return client.switchToParentFrame();
     }
-    async getValue(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.getValue();
+    async getValue(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.getValue();
     }
-    async setValue(applicant, xpath, value) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.setValue(value);
+    async setValue(applicant, selector, value) {
+        const element = await this.getElement(applicant, selector);
+        return element.setValue(value);
     }
-    async selectByIndex(applicant, xpath, value) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.selectByIndex(value);
+    async selectByIndex(applicant, selector, value) {
+        const element = await this.getElement(applicant, selector);
+        return element.selectByIndex(value);
     }
-    async selectByValue(applicant, xpath, value) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.selectByAttribute('value', value);
+    async selectByValue(applicant, selector, value) {
+        const element = await this.getElement(applicant, selector);
+        return element.selectByAttribute('value', value);
     }
-    async selectByVisibleText(applicant, xpath, str) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.selectByVisibleText(str);
+    async selectByVisibleText(applicant, selector, str) {
+        const element = await this.getElement(applicant, selector);
+        return element.selectByVisibleText(str);
     }
-    async getAttribute(applicant, xpath, attr) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.getAttribute(attr);
+    async getAttribute(applicant, selector, attr) {
+        const element = await this.getElement(applicant, selector);
+        return element.getAttribute(attr);
     }
     async windowHandleMaximize(applicant) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
         return client.maximizeWindow();
     }
-    async isEnabled(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.isEnabled();
+    async isEnabled(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.isEnabled();
     }
-    async scroll(applicant, xpath, xOffset, yOffset) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const element = await client.$(xpath);
+    async scroll(applicant, selector, xOffset, yOffset) {
+        const element = await this.getElement(applicant, selector);
         await element.scrollIntoView();
         return element.moveTo({ xOffset, yOffset });
     }
-    async scrollIntoView(applicant, xpath, scrollIntoViewOptions) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const element = await client.$(xpath);
+    async scrollIntoView(applicant, selector, scrollIntoViewOptions) {
+        const element = await this.getElement(applicant, selector);
         await element.scrollIntoView(scrollIntoViewOptions !== null ? scrollIntoViewOptions : undefined);
     }
     async isAlertOpen(applicant) {
@@ -685,11 +753,9 @@ class SeleniumPlugin {
         }
         throw Error('There is no open alert');
     }
-    async dragAndDrop(applicant, xpathSource, xpathDestination) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const sourceElement = await client.$(xpathSource);
-        const destinationElement = await client.$(xpathDestination);
+    async dragAndDrop(applicant, sourceSelector, destinationSelector) {
+        const sourceElement = await this.getElement(applicant, sourceSelector);
+        const destinationElement = await this.getElement(applicant, destinationSelector);
         return sourceElement.dragAndDrop(destinationElement);
     }
     async setCookie(applicant, cookieObj) {
@@ -720,11 +786,9 @@ class SeleniumPlugin {
         }
         return client.deleteAllCookies();
     }
-    async getHTML(applicant, xpath, b) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.getHTML(b);
+    async getHTML(applicant, selector, b) {
+        const element = await this.getElement(applicant, selector);
+        return element.getHTML(b);
     }
     async getCurrentTabId(applicant) {
         await this.createClient(applicant);
@@ -763,23 +827,17 @@ class SeleniumPlugin {
         await client.switchToWindow(tabId);
         return client.closeWindow();
     }
-    async getTagName(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.getTagName();
+    async getTagName(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.getTagName();
     }
-    async isSelected(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.isSelected();
+    async isSelected(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.isSelected();
     }
-    async getText(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.getText();
+    async getText(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.getText();
     }
     async elementIdSelected(applicant, id) {
         await this.createClient(applicant);
@@ -796,10 +854,8 @@ class SeleniumPlugin {
         const client = this.getBrowserClient(applicant);
         return client.uploadFile(filePath);
     }
-    async getCssProperty(applicant, xpath, cssProperty) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const element = await client.$(xpath);
+    async getCssProperty(applicant, selector, cssProperty) {
+        const element = await this.getElement(applicant, selector);
         const property = await element.getCSSProperty(cssProperty);
         return property.value;
     }
@@ -808,25 +864,25 @@ class SeleniumPlugin {
         const client = this.getBrowserClient(applicant);
         return client.getPageSource();
     }
-    async isExisting(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.isExisting();
+    async isExisting(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.isExisting();
     }
-    async waitForValue(applicant, xpath, timeout, reverse) {
+    async waitForValue(applicant, selector, timeout, reverse) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
         return client.waitUntil(async () => {
-            const elemValue = await (await client.$(xpath)).getValue();
+            const element = await this.getElement(applicant, selector);
+            const elemValue = await element.getValue();
             return reverse ? !elemValue : !!elemValue;
         }, { timeout });
     }
-    async waitForSelected(applicant, xpath, timeout, reverse) {
+    async waitForSelected(applicant, selector, timeout, reverse) {
         await this.createClient(applicant);
         const client = this.getBrowserClient(applicant);
         return client.waitUntil(async () => {
-            const isSelected = await (await client.$(xpath)).isSelected();
+            const element = await this.getElement(applicant, selector);
+            const isSelected = await element.isSelected();
             return reverse ? !isSelected : isSelected;
         }, { timeout });
     }
@@ -844,11 +900,9 @@ class SeleniumPlugin {
         }
         return client.waitUntil(condition, options);
     }
-    async selectByAttribute(applicant, xpath, attribute, value) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.selectByAttribute(attribute, value);
+    async selectByAttribute(applicant, selector, attribute, value) {
+        const element = await this.getElement(applicant, selector);
+        return element.selectByAttribute(attribute, value);
     }
     async gridTestSession(applicant) {
         await this.createClient(applicant);
@@ -921,10 +975,8 @@ class SeleniumPlugin {
         const client = this.getBrowserClient(applicant);
         return client.getActiveElement();
     }
-    async getLocation(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const element = client.$(xpath);
+    async getLocation(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
         return element.getLocation();
     }
     async setTimeZone(applicant, timeZone) {
@@ -943,53 +995,37 @@ class SeleniumPlugin {
         const { filepath, ...restOptions } = options;
         return client.savePDF(filepath, restOptions);
     }
-    async addValue(applicant, xpath, value) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.addValue(value);
+    async addValue(applicant, selector, value) {
+        const element = await this.getElement(applicant, selector);
+        return element.addValue(value);
     }
-    async doubleClick(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.doubleClick();
+    async doubleClick(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.doubleClick();
     }
-    async isClickable(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.isClickable();
+    async isClickable(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.isClickable();
     }
-    async waitForClickable(applicant, xpath, timeout) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.waitForClickable({ timeout });
+    async waitForClickable(applicant, selector, timeout) {
+        const element = await this.getElement(applicant, selector);
+        return element.waitForClickable({ timeout });
     }
-    async isFocused(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.isFocused();
+    async isFocused(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.isFocused();
     }
-    async isStable(applicant, xpath) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.isStable();
+    async isStable(applicant, selector) {
+        const element = await this.getElement(applicant, selector);
+        return element.isStable();
     }
-    async waitForEnabled(applicant, xpath, timeout) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.waitForEnabled({ timeout });
+    async waitForEnabled(applicant, selector, timeout) {
+        const element = await this.getElement(applicant, selector);
+        return element.waitForEnabled({ timeout });
     }
-    async waitForStable(applicant, xpath, timeout) {
-        await this.createClient(applicant);
-        const client = this.getBrowserClient(applicant);
-        const selector = await client.$(xpath);
-        return selector.waitForStable({ timeout });
+    async waitForStable(applicant, selector, timeout) {
+        const element = await this.getElement(applicant, selector);
+        return element.waitForStable({ timeout });
     }
 }
 exports.SeleniumPlugin = SeleniumPlugin;