@assert-equals/dappdriver/dist/src/webdriver/page-object.js

DappDriver is an e2e testing framework designed for testing decentralized applications (dApps) using MetaMask, Rainbow or Zerion

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.WebDriverPageObject = void 0;
const selenium_webdriver_1 = require("selenium-webdriver");
const dapp_driver_1 = require("../session/dapp-driver");
const utils_1 = require("../utils");
class WebDriverPageObject {
    driver;
    url;
    title;
    constructor() {
        this.driver = dapp_driver_1.DappDriver.Instance.Driver;
    }
    async addCookie(cookie) {
        return await this.driver.manage().addCookie(cookie);
    }
    async back(page) {
        await this.driver.navigate().back();
        if (page) {
            return await dapp_driver_1.DappDriver.getPage(page);
        }
    }
    async clearCookie(name) {
        return await this.driver.manage().deleteCookie(name);
    }
    async clearCookies() {
        return await this.driver.manage().deleteAllCookies();
    }
    async close(page) {
        await this.driver.close();
        if (page) {
            return await dapp_driver_1.DappDriver.getPage(page);
        }
    }
    async closeAndSwitchToMainWindow(page) {
        await this.close();
        return await this.switchToMainWindow(page);
    }
    async createNewWindow() {
        await this.driver.switchTo().newWindow('tab');
        await this.opensInNewWindow();
    }
    async executeScript(script) {
        script = script.startsWith('return ') ? script : ''.concat('return ', script);
        return await this.driver.executeScript(script);
    }
    async executeScriptAndOpensInWindow(script, page) {
        this.driver.executeScript(script);
        return await this.opensInWindow(page);
    }
    async getAllWindowHandles() {
        return await this.driver.getAllWindowHandles();
    }
    async getCookie(name) {
        let cookie = null;
        try {
            cookie = await this.driver.manage().getCookie(name);
        }
        catch (e) { }
        return cookie;
    }
    async getCookies() {
        return await this.driver.manage().getCookies();
    }
    async getCurrentUrl() {
        return await this.driver.getCurrentUrl();
    }
    async getTitle() {
        return await this.driver.getTitle();
    }
    async getWindowHandle() {
        return await this.driver.getWindowHandle();
    }
    async maximize() {
        await this.driver.manage().window().maximize();
    }
    async navigateTo(url, page) {
        await this.driver.navigate().to(url);
        if (page) {
            return await dapp_driver_1.DappDriver.getPage(page);
        }
    }
    async navigateToPageInNewWindow(url, page) {
        await this.createNewWindow();
        await this.navigateTo(url);
        if (page) {
            return await dapp_driver_1.DappDriver.getPage(page);
        }
    }
    async opensInNewWindow(page) {
        const handles = await this.waitForWindows(2);
        return await this.switchToWindow(handles[1], page);
    }
    async opensInWindow(page) {
        const delay = 1000;
        const retries = 10;
        for (let attempt = 1; attempt <= retries; attempt++) {
            const handles = await this.waitForWindows(2, utils_1.isAtLeast);
            for (const handle of handles) {
                try {
                    await this.switchToWindow(handle);
                    const actualTitle = await this.getTitle();
                    const actualUrl = await this.getCurrentUrl();
                    const newPage = new page();
                    const title = (0, utils_1.toRegExp)(newPage.title);
                    const url = (0, utils_1.toRegExp)(newPage.url);
                    if (RegExp(title).exec(actualTitle) !== null && RegExp(url).exec(actualUrl) !== null) {
                        return await dapp_driver_1.DappDriver.getPage(page);
                    }
                }
                catch (e) { }
            }
            await dapp_driver_1.DappDriver.sleep(delay);
        }
        throw new Error('waitForWindow timed out polling window handles');
    }
    async refresh(page) {
        await this.driver.navigate().refresh();
        if (page) {
            return await dapp_driver_1.DappDriver.getPage(page);
        }
    }
    async setSize(width, height) {
        await this.driver.manage().window().setSize(width, height);
    }
    async switchBack() {
        return await this.driver.switchTo().defaultContent();
    }
    async switchToFrame(cssLocator) {
        const frameElement = await this.driver.findElement({ css: cssLocator });
        return await this.driver.switchTo().frame(frameElement);
    }
    async switchToMainWindow(page) {
        const handles = await this.getAllWindowHandles();
        return await this.switchToWindow(handles[0], page);
    }
    async switchToWindow(nameOrHandle, page) {
        await this.driver.switchTo().window(nameOrHandle);
        if (page) {
            return await dapp_driver_1.DappDriver.getPage(page);
        }
    }
    async waitForElement(cssLocator) {
        await this.driver.wait(selenium_webdriver_1.until.elementLocated({ css: cssLocator }), 20000);
    }
    async waitForTitle(title) {
        await this.driver.wait(selenium_webdriver_1.until.titleMatches(title), 20000);
    }
    async waitForURL(url) {
        await this.driver.wait(selenium_webdriver_1.until.urlMatches(url), 20000);
    }
    async waitForWindows(total, comparator = utils_1.strictEqual) {
        const timeout = 10_000;
        const delay = 100;
        let timeElapsed = 0;
        let windowHandles = [];
        while (timeElapsed <= timeout) {
            windowHandles = await this.getAllWindowHandles();
            if (comparator(windowHandles.length, total)) {
                return windowHandles;
            }
            await dapp_driver_1.DappDriver.sleep(delay);
            timeElapsed += delay;
        }
        throw new Error('waitForWindows timed out polling window handles');
    }
}
exports.WebDriverPageObject = WebDriverPageObject;