@assert-equals/dappdriver/dist/src/playwright/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.PlaywrightPageObject = void 0;
const page_1 = require("../page");
const dapp_driver_1 = require("../session/dapp-driver");
const utils_1 = require("../utils");
class PlaywrightPageObject {
    page;
    driver;
    pageObject;
    url;
    title;
    constructor(page) {
        this.initialize(page);
        this.driver = dapp_driver_1.DappDriver.Instance.Driver;
        this.pageObject = new page_1.PageObject();
    }
    initialize(page) {
        this.page = page;
        dapp_driver_1.DappDriver.Instance.Page = this.page;
    }
    async addCookie(cookie) {
        return await this.driver.addCookies([cookie]);
    }
    async back(page) {
        await this.page.goBack();
        if (page) {
            return await dapp_driver_1.DappDriver.getPage(page);
        }
    }
    async clearCookie(name) {
        return await this.driver.clearCookies({ name });
    }
    async clearCookies() {
        return await this.driver.clearCookies();
    }
    async close(page) {
        await this.page.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.newPage();
        await this.opensInNewWindow();
    }
    async executeScript(script) {
        return await this.page.evaluate(script);
    }
    async executeScriptAndOpensInWindow(script, page) {
        this.page.evaluate(script);
        return await this.opensInWindow(page);
    }
    async getAllWindowHandles() {
        return await Promise.resolve(this.driver.pages());
    }
    async getCookie(name) {
        const url = await this.getCurrentUrl();
        const origin = new URL(url).origin;
        const cookies = await this.driver.cookies(origin);
        const [cookie] = cookies.filter((cookie) => cookie.name === name);
        return cookie || null;
    }
    async getCookies() {
        const url = await this.getCurrentUrl();
        const origin = new URL(url).origin;
        return await this.driver.cookies(origin);
    }
    async getCurrentUrl() {
        return await Promise.resolve(this.page.url());
    }
    async getTitle() {
        return await this.page.title();
    }
    async getWindowHandle() {
        return await Promise.resolve(this.page);
    }
    async maximize() {
        const { width, height } = await this.executeScript('window.screen');
        await this.page.setViewportSize({ width, height });
    }
    async navigateTo(url, page) {
        await this.page.goto(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.page.reload();
        if (page) {
            return await dapp_driver_1.DappDriver.getPage(page);
        }
    }
    async setSize(width, height) {
        await this.page.setViewportSize({ width, height });
    }
    async switchBack() {
        dapp_driver_1.DappDriver.Instance.Frame = null;
    }
    async switchToFrame(cssLocator) {
        const frame = this.page.frameLocator(cssLocator);
        dapp_driver_1.DappDriver.Instance.Frame = frame;
    }
    async switchToMainWindow(page) {
        const handles = await this.getAllWindowHandles();
        return await this.switchToWindow(handles[0], page);
    }
    async switchToWindow(nameOrHandle, page) {
        this.initialize(nameOrHandle);
        if (page) {
            return await dapp_driver_1.DappDriver.getPage(page);
        }
    }
    async waitForElement(cssLocator) {
        await this.pageObject.waitForFunction(async () => (await this.page.locator(cssLocator).count()) > 0, `Waiting for element to be located ${cssLocator}`);
    }
    async waitForTitle(title) {
        await this.pageObject.waitForFunction(async () => RegExp(title).exec(await this.getTitle()) !== null, `Waiting for title to match ${title}`, 20000);
    }
    async waitForURL(url) {
        await this.pageObject.waitForFunction(async () => RegExp(url).exec(await this.getCurrentUrl()) !== null, `Waiting for url to match ${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.PlaywrightPageObject = PlaywrightPageObject;