@applitools/spec-driver-selenium 1.3.1 → 1.3.2

package/CHANGELOG.md

@@ -3,6 +3,10 @@
 ## Unreleased
 
 
+## 1.3.2 - 2022/1/12
+
+- no changes
+
 ## 1.3.1 - 2022/1/12
 
 - use chromedriver instead of selenium docker container for testing

package/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const spec = __importStar(require("./spec-driver"));
+if (!process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION) {
+    try {
+        const { version } = require('selenium-webdriver/package.json');
+        const [major] = version.split('.', 1);
+        process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION = major;
+    }
+    catch (_a) {
+        // NOTE: ignore error
+    }
+}
+__exportStar(require("./spec-driver"), exports);
+exports.default = spec;

package/dist/spec-driver.js

@@ -0,0 +1,392 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = exports.performAction = exports.getElementText = exports.getElementAttribute = exports.getElementRegion = exports.getOrientation = exports.getBarsHeight = exports.waitUntilDisplayed = exports.scrollIntoView = exports.type = exports.hover = exports.click = exports.takeScreenshot = exports.visit = exports.getUrl = exports.getTitle = exports.getCapabilities = exports.getDriverInfo = exports.getCookies = exports.setWindowSize = exports.getWindowSize = exports.findElements = exports.findElement = exports.childContext = exports.parentContext = exports.mainContext = exports.executeScript = exports.isEqualElements = exports.isStaleElementError = exports.transformSelector = exports.transformDriver = exports.isSelector = exports.isElement = exports.isDriver = void 0;
+const Selenium = __importStar(require("selenium-webdriver"));
+const utils = __importStar(require("@applitools/utils"));
+// #region HELPERS
+const byHash = ['className', 'css', 'id', 'js', 'linkText', 'name', 'partialLinkText', 'tagName', 'xpath'];
+function extractElementId(element) {
+    return isElement(element) ? element.getId() : element['shadow-6066-11e4-a52e-4f735466cecf'];
+}
+function transformShadowRoot(driver, shadowRoot) {
+    return isElement(shadowRoot)
+        ? shadowRoot
+        : new Selenium.WebElement(driver, shadowRoot['shadow-6066-11e4-a52e-4f735466cecf']);
+}
+// #endregion
+// #region UTILITY
+function isDriver(driver) {
+    return utils.types.instanceOf(driver, 'WebDriver');
+}
+exports.isDriver = isDriver;
+function isElement(element) {
+    return utils.types.instanceOf(element, 'WebElement');
+}
+exports.isElement = isElement;
+function isSelector(selector) {
+    if (!selector)
+        return false;
+    return utils.types.has(selector, ['using', 'value']) || byHash.includes(Object.keys(selector)[0]);
+}
+exports.isSelector = isSelector;
+function transformDriver(driver) {
+    driver.getExecutor().defineCommand('getSessionDetails', 'GET', '/session/:sessionId');
+    driver.getExecutor().defineCommand('getOrientation', 'GET', '/session/:sessionId/orientation');
+    driver.getExecutor().defineCommand('getSystemBars', 'GET', '/session/:sessionId/appium/device/system_bars');
+    driver.getExecutor().defineCommand('getWindowSize', 'GET', '/session/:sessionId/window/current/size');
+    driver.getExecutor().defineCommand('setWindowSize', 'POST', '/session/:sessionId/window/current/size');
+    driver.getExecutor().defineCommand('setWindowPosition', 'POST', '/session/:sessionId/window/current/position');
+    driver.getExecutor().defineCommand('performTouch', 'POST', '/session/:sessionId/touch/perform');
+    driver.getExecutor().defineCommand('executeCdp', 'POST', '/session/:sessionId/chromium/send_command_and_get_result');
+    if (process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION === '3') {
+        driver.getExecutor().defineCommand('switchToParentFrame', 'POST', '/session/:sessionId/frame/parent');
+    }
+    return driver;
+}
+exports.transformDriver = transformDriver;
+function transformSelector(selector) {
+    if (utils.types.isString(selector)) {
+        return { css: selector };
+    }
+    else if (utils.types.has(selector, 'selector')) {
+        if (!utils.types.isString(selector.selector))
+            return selector.selector;
+        if (!utils.types.has(selector, 'type'))
+            return { css: selector.selector };
+        if (selector.type === 'css')
+            return { css: selector.selector };
+        else
+            return { using: selector.type, value: selector.selector };
+    }
+    return selector;
+}
+exports.transformSelector = transformSelector;
+function isStaleElementError(error) {
+    if (!error)
+        return false;
+    error = error.originalError || error;
+    return error instanceof Error && error.name === 'StaleElementReferenceError';
+}
+exports.isStaleElementError = isStaleElementError;
+async function isEqualElements(_driver, element1, element2) {
+    if (!element1 || !element2)
+        return false;
+    const elementId1 = await extractElementId(element1);
+    const elementId2 = await extractElementId(element2);
+    return elementId1 === elementId2;
+}
+exports.isEqualElements = isEqualElements;
+// #endregion
+// #region COMMANDS
+async function executeScript(driver, script, arg) {
+    return driver.executeScript(script, arg);
+}
+exports.executeScript = executeScript;
+async function mainContext(driver) {
+    await driver.switchTo().defaultContent();
+    return driver;
+}
+exports.mainContext = mainContext;
+async function parentContext(driver) {
+    if (process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION === '3') {
+        const { Command } = require('selenium-webdriver/lib/command');
+        await driver.schedule(new Command('switchToParentFrame'));
+        return driver;
+    }
+    await driver.switchTo().parentFrame();
+    return driver;
+}
+exports.parentContext = parentContext;
+async function childContext(driver, element) {
+    await driver.switchTo().frame(element);
+    return driver;
+}
+exports.childContext = childContext;
+async function findElement(driver, selector, parent) {
+    try {
+        const root = parent ? transformShadowRoot(driver, parent) : driver;
+        return await root.findElement(selector);
+    }
+    catch (err) {
+        if (err.name === 'NoSuchElementError')
+            return null;
+        else
+            throw err;
+    }
+}
+exports.findElement = findElement;
+async function findElements(driver, selector, parent) {
+    const root = parent ? transformShadowRoot(driver, parent) : driver;
+    return root.findElements(selector);
+}
+exports.findElements = findElements;
+async function getWindowSize(driver) {
+    try {
+        const rect = await driver.manage().window().getRect();
+        return { width: rect.width, height: rect.height };
+    }
+    catch (_a) {
+        const { Command } = require('selenium-webdriver/lib/command');
+        const getWindowSizeCommand = new Command('getWindowSize');
+        const size = driver.manage().window().getSize
+            ? await driver.manage().window().getSize()
+            : await driver.execute(getWindowSizeCommand);
+        return { width: size.width, height: size.height };
+    }
+}
+exports.getWindowSize = getWindowSize;
+async function setWindowSize(driver, size) {
+    try {
+        await driver.manage().window().setRect({ x: 0, y: 0, width: size.width, height: size.height });
+    }
+    catch (_a) {
+        const { Command } = require('selenium-webdriver/lib/command');
+        const setWindowPositionCommand = new Command('setWindowPosition').setParameters({ x: 0, y: 0 });
+        if (driver.manage().window().setPosition)
+            await driver.manage().window().setPosition(0, 0);
+        else
+            await driver.execute(setWindowPositionCommand);
+        const setWindowSizeCommand = new Command('setWindowSize').setParameters(Object.assign({}, size));
+        if (driver.manage().window().setSize)
+            await driver.manage().window().setSize(size.width, size.height);
+        else
+            await driver.execute(setWindowSizeCommand);
+    }
+}
+exports.setWindowSize = setWindowSize;
+async function getCookies(driver, context) {
+    if (context)
+        return driver.manage().getCookies();
+    let cookies;
+    if (utils.types.isFunction(driver, 'sendAndGetDevToolsCommand')) {
+        const response = await driver.sendAndGetDevToolsCommand('Network.getAllCookies');
+        cookies = response.cookies;
+    }
+    else {
+        const { Command } = require('selenium-webdriver/lib/command');
+        const executeCdpCommand = new Command('executeCdp')
+            .setParameter('cmd', 'Network.getAllCookies')
+            .setParameter('params', {});
+        const response = process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION === '3'
+            ? await driver.schedule(executeCdpCommand)
+            : await driver.execute(executeCdpCommand);
+        cookies = response.cookies;
+    }
+    return cookies.map((cookie) => {
+        const copy = Object.assign(Object.assign({}, cookie), { expiry: cookie.expires });
+        delete copy.expires;
+        delete copy.size;
+        delete copy.priority;
+        delete copy.session;
+        delete copy.sameParty;
+        delete copy.sourceScheme;
+        delete copy.sourcePort;
+        return copy;
+    });
+}
+exports.getCookies = getCookies;
+async function getDriverInfo(driver) {
+    const session = await driver.getSession();
+    return { sessionId: session.getId() };
+}
+exports.getDriverInfo = getDriverInfo;
+async function getCapabilities(driver) {
+    try {
+        const { Command } = require('selenium-webdriver/lib/command');
+        const getSessionDetailsCommand = new Command('getSessionDetails');
+        return process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION === '3'
+            ? await driver.schedule(getSessionDetailsCommand)
+            : await driver.execute(getSessionDetailsCommand);
+    }
+    catch (_a) {
+        const capabilities = await driver.getCapabilities();
+        return Array.from(capabilities.keys()).reduce((obj, key) => Object.assign(obj, { key: capabilities.get(key) }), {});
+    }
+}
+exports.getCapabilities = getCapabilities;
+async function getTitle(driver) {
+    return driver.getTitle();
+}
+exports.getTitle = getTitle;
+async function getUrl(driver) {
+    return driver.getCurrentUrl();
+}
+exports.getUrl = getUrl;
+async function visit(driver, url) {
+    await driver.get(url);
+}
+exports.visit = visit;
+async function takeScreenshot(driver) {
+    return driver.takeScreenshot();
+}
+exports.takeScreenshot = takeScreenshot;
+async function click(driver, element) {
+    if (isSelector(element))
+        element = await findElement(driver, element);
+    await element.click();
+}
+exports.click = click;
+async function hover(driver, element) {
+    if (isSelector(element))
+        element = await findElement(driver, element);
+    if (process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION === '3') {
+        const { ActionSequence } = require('selenium-webdriver');
+        const action = new ActionSequence(driver);
+        await action.mouseMove(element).perform();
+    }
+    else {
+        await driver.actions().move({ origin: element }).perform();
+    }
+}
+exports.hover = hover;
+async function type(driver, element, keys) {
+    if (isSelector(element))
+        element = await findElement(driver, element);
+    await element.sendKeys(keys);
+}
+exports.type = type;
+async function scrollIntoView(driver, element, align = false) {
+    if (isSelector(element))
+        element = await findElement(driver, element);
+    await driver.executeScript('arguments[0].scrollIntoView(arguments[1])', element, align);
+}
+exports.scrollIntoView = scrollIntoView;
+async function waitUntilDisplayed(driver, selector, timeout) {
+    const element = await findElement(driver, selector);
+    await driver.wait(Selenium.until.elementIsVisible(element), timeout);
+}
+exports.waitUntilDisplayed = waitUntilDisplayed;
+// #endregion
+// #region MOBILE COMMANDS
+async function getBarsHeight(driver) {
+    const { Command } = require('selenium-webdriver/lib/command');
+    const getSystemBarsCommand = new Command('getSystemBars');
+    const { statusBar, navigationBar } = process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION === '3'
+        ? await driver.schedule(getSystemBarsCommand)
+        : await driver.execute(getSystemBarsCommand);
+    return {
+        statusBarHeight: statusBar.visible ? statusBar.height : 0,
+        navigationBarHeight: navigationBar.visible ? navigationBar.height : 0,
+    };
+}
+exports.getBarsHeight = getBarsHeight;
+async function getOrientation(driver) {
+    const { Command } = require('selenium-webdriver/lib/command');
+    const getOrientationCommand = new Command('getOrientation');
+    const orientation = process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION === '3'
+        ? await driver.schedule(getOrientationCommand)
+        : await driver.execute(getOrientationCommand);
+    return orientation.toLowerCase();
+}
+exports.getOrientation = getOrientation;
+async function getElementRegion(_driver, element) {
+    if (utils.types.isFunction(element.getRect)) {
+        return element.getRect();
+    }
+    else {
+        const { x, y } = await element.getLocation();
+        const { width, height } = await element.getSize();
+        return { x, y, width, height };
+    }
+}
+exports.getElementRegion = getElementRegion;
+async function getElementAttribute(_driver, element, attr) {
+    return element.getAttribute(attr);
+}
+exports.getElementAttribute = getElementAttribute;
+async function getElementText(_driver, element) {
+    return element.getText();
+}
+exports.getElementText = getElementText;
+async function performAction(driver, steps) {
+    const { Command } = require('selenium-webdriver/lib/command');
+    const performTouchCommand = new Command('performTouch').setParameters({
+        actions: steps.map((_a) => {
+            var { action } = _a, options = __rest(_a, ["action"]);
+            return ({ action, options });
+        }),
+    });
+    if (process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION === '3') {
+        await driver.schedule(performTouchCommand);
+    }
+    else {
+        await driver.execute(performTouchCommand);
+    }
+}
+exports.performAction = performAction;
+// #endregion
+// #region TESTING
+const browserOptionsNames = {
+    chrome: 'goog:chromeOptions',
+    firefox: 'moz:firefoxOptions',
+};
+async function build(env) {
+    var _a;
+    const parseEnv = require('@applitools/test-utils/src/parse-env');
+    const { browser, capabilities, url, attach, proxy, configurable = true, appium = false, args = [], headless, } = parseEnv(Object.assign(Object.assign({}, env), { legacy: (_a = env.legacy) !== null && _a !== void 0 ? _a : process.env.APPLITOOLS_SELENIUM_MAJOR_VERSION === '3' }));
+    const desiredCapabilities = Object.assign({}, capabilities);
+    if (configurable) {
+        const browserOptionsName = browserOptionsNames[browser || desiredCapabilities.browserName];
+        if (browserOptionsName) {
+            const browserOptions = desiredCapabilities[browserOptionsName] || {};
+            browserOptions.args = [...(browserOptions.args || []), ...args];
+            if (headless)
+                browserOptions.args.push('headless');
+            if (attach) {
+                browserOptions.debuggerAddress = attach === true ? 'localhost:9222' : attach;
+                if (browser !== 'firefox')
+                    browserOptions.w3c = false;
+            }
+            desiredCapabilities[browserOptionsName] = browserOptions;
+        }
+    }
+    if (appium && browser === 'chrome') {
+        desiredCapabilities['appium:chromeOptions'] = { w3c: false };
+    }
+    const builder = new Selenium.Builder().withCapabilities(desiredCapabilities);
+    if (url && !attach)
+        builder.usingServer(url.href);
+    if (proxy) {
+        builder.setProxy({
+            proxyType: 'manual',
+            httpProxy: proxy.http || proxy.server,
+            sslProxy: proxy.https || proxy.server,
+            ftpProxy: proxy.ftp,
+            noProxy: proxy.bypass,
+        });
+    }
+    const driver = await builder.build();
+    return [driver, () => driver.quit()];
+}
+exports.build = build;
+// #endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/spec-driver-selenium",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "keywords": [
     "selenium",
     "selenium-webdriver",

package/types/index.d.ts

@@ -0,0 +1,39 @@
+declare const _default: import('@applitools/types').SpecDriver<Driver, Driver, Element, Selector>;
+export default _default;
+export function isDriver(driver: any): driver is Driver;
+export function isElement(element: any): element is Element;
+export function isSelector(selector: any): selector is Selector;
+export function transformDriver(driver: Driver): Driver;
+export function transformSelector(selector: Selector | (string | { selector: string | Selector; type?: string; })): Selector;
+export function isStaleElementError(error: any): boolean;
+export function isEqualElements(_driver: Driver, element1: Element, element2: Element): Promise<boolean>;
+export function executeScript(driver: Driver, script: string | ((arg: any) => any), arg: any): Promise<any>;
+export function mainContext(driver: Driver): Promise<Driver>;
+export function parentContext(driver: Driver): Promise<Driver>;
+export function childContext(driver: Driver, element: Element): Promise<Driver>;
+export function findElement(driver: Driver, selector: Selector, parent?: Element): Promise<Element>;
+export function findElements(driver: Driver, selector: Selector, parent?: Element): Promise<Array<Element>>;
+export function getWindowSize(driver: Driver): Promise<import('@applitools/types').Size>;
+export function setWindowSize(driver: Driver, size: import('@applitools/types').Size): Promise<void>;
+export function getCookies(driver: Driver, context?: boolean): Promise<Array<import('@applitools/types').Cookie>>;
+export function getDriverInfo(driver: Driver): Promise<import('@applitools/types').DriverInfo>;
+export function getCapabilities(driver: Driver): Promise<Record<string, any>>;
+export function getTitle(driver: Driver): Promise<string>;
+export function getUrl(driver: Driver): Promise<string>;
+export function visit(driver: Driver, url: string): Promise<void>;
+export function takeScreenshot(driver: Driver): Promise<string>;
+export function click(driver: Driver, element: Element | Selector): Promise<void>;
+export function hover(driver: Driver, element: Element | Selector): Promise<void>;
+export function type(driver: Driver, element: Element | Selector, keys: string): Promise<void>;
+export function scrollIntoView(driver: Driver, element: Element | Selector, align: boolean): Promise<void>;
+export function waitUntilDisplayed(driver: Driver, selector: Selector, timeout: number): Promise<void>;
+export function getBarsHeight(driver: Driver): Promise<{ statusBarHeight: number; navigationBarHeight: number; }>;
+export function getOrientation(driver: Driver): Promise<"portrait" | "landscape">;
+export function getElementRegion(_driver: Driver, element: Element): Promise<import('@applitools/types').Region>;
+export function getElementAttribute(_driver: Driver, element: Element, attr: string): Promise<string>;
+export function getElementText(_driver: Driver, element: Element): Promise<string>;
+export function performAction(driver: Driver, steps: Array<any>): Promise<void>;
+export function build(env: any): Promise<[Driver, () => Promise<void>]>;
+export type Driver = import('selenium-webdriver').WebDriver & { __applitoolsBrand?: never; };
+export type Element = import('selenium-webdriver').WebElement & { __applitoolsBrand?: never; };
+export type Selector = (import('selenium-webdriver').Locator | { using: string; value: string; }) & { __applitoolsBrand?: never; };