@telefonica/acceptance-testing 4.1.0 → 5.0.0-beta2

package/dist/index.js

@@ -1,8 +1,424 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./acceptance-testing.cjs.production.min.js')
-} else {
-  module.exports = require('./acceptance-testing.cjs.development.js')
-}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForElementToBeRemoved = exports.wait = exports.prepareFile = exports.within = exports.screen = exports.getScreen = exports.openPage = exports.createApiEndpointMock = exports.interceptRequest = exports.getPageApi = exports.serverPort = exports.serverHostName = exports.getGlobalPage = exports.getGlobalBrowser = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const pptr_testing_library_1 = require("pptr-testing-library");
+const jest_image_snapshot_1 = require("jest-image-snapshot");
+const glob_to_regexp_1 = __importDefault(require("glob-to-regexp"));
+const child_process_1 = require("child_process");
+const coverage_1 = require("./coverage");
+const utils_1 = require("./utils");
+const config_1 = require("./config");
+const wsl_1 = require("./wsl");
+const constants_1 = require("./constants");
+const { isCi, server, coveragePath, coverageUrls, collectCoverage } = (0, config_1.getConfig)();
+(0, utils_1.debug)('Config:', (0, config_1.getConfig)());
+const getGlobalBrowser = () => global.browser;
+exports.getGlobalBrowser = getGlobalBrowser;
+const getGlobalPage = () => global.page;
+exports.getGlobalPage = getGlobalPage;
+const isUsingDockerizedChromium = isCi || new URL((0, exports.getGlobalBrowser)().wsEndpoint()).port === '9223';
+exports.serverHostName = (() => {
+    if (isCi) {
+        return 'localhost';
+    }
+    if (isUsingDockerizedChromium) {
+        if ((0, wsl_1.isWsl)()) {
+            if ((0, wsl_1.isWsl2)()) {
+                return (0, wsl_1.getWslHostIp)();
+            }
+            throw new Error('WSL 1 is not supported. Please, use WSL 2.');
+        }
+        if (process.platform === 'win32') {
+            throw new Error('Windows is not supported. Please, use WSL 2.');
+        }
+        return process.platform === 'linux' ? constants_1.LINUX_DOCKER_HOST_IP : 'host.docker.internal';
+    }
+    return 'localhost';
+})();
+exports.serverPort = server.port;
+const toMatchImageSnapshot = (0, jest_image_snapshot_1.configureToMatchImageSnapshot)({
+    failureThreshold: 0,
+    failureThresholdType: 'percent',
+    customSnapshotIdentifier: ({ defaultIdentifier }) => defaultIdentifier,
+});
+let calledToMatchImageSnapshotOutsideDocker = false;
+const localToMatchImageSnapshot = () => {
+    calledToMatchImageSnapshotOutsideDocker = true;
+    // let the expectation pass, then fail in afterEach. This way we allow developers to debug screenshot tests in local
+    // but don't allow them to save screenshots taken outside the dockerized chromium
+    return {
+        message: () => '',
+        pass: true,
+    };
+};
+expect.extend({
+    toMatchImageSnapshot: isUsingDockerizedChromium ? toMatchImageSnapshot : localToMatchImageSnapshot,
+});
+afterEach(() => {
+    if (calledToMatchImageSnapshotOutsideDocker) {
+        const error = new Error(`Calling .toMatchImageSnapshot() is not allowed outside dockerized browser. Please, run your screenshot test in headless mode.`);
+        error.stack = (error.stack || '').split('\n')[0];
+        throw error;
+    }
+});
+const waitForPaintEnd = async (element, { fullPage = true, captureBeyondViewport } = {}) => {
+    const MAX_WAIT = 15000;
+    const STEP_TIME = 250;
+    const t0 = Date.now();
+    let buf1 = (await element.screenshot(normalizeSreenshotOptions({ fullPage, captureBeyondViewport })));
+    await new Promise((r) => setTimeout(r, STEP_TIME));
+    let buf2 = (await element.screenshot(normalizeSreenshotOptions({ fullPage, captureBeyondViewport })));
+    // buffers are different if compare != 0
+    while (buf1.compare(buf2)) {
+        if (Date.now() - t0 > MAX_WAIT) {
+            throw Error('Paint end timeout');
+        }
+        buf1 = buf2;
+        await new Promise((r) => setTimeout(r, STEP_TIME));
+        buf2 = (await element.screenshot(normalizeSreenshotOptions({ fullPage, captureBeyondViewport })));
+    }
+};
+const normalizeSreenshotOptions = ({ captureBeyondViewport = false, ...options } = {}) => {
+    // Puppeter default for captureBeyondViewport is true, but we think false is a better default.
+    // When this is true, the fixed elements (like fixed footers) are relative to the original page
+    // viewport, not to the full page, so those elements look weird in fullPage screenshots.
+    return { ...options, captureBeyondViewport };
+};
+// Puppeteer already calls scrollIntoViewIfNeeded before clicking an element. But it doesn't work in all situations
+// For example, when there is a fixed footer in the page and the element to click is under it, the browser won't scroll
+// because the element is already in the viewport (the ifNeeded part is important here). By forcing the scroll to the
+// center, we manage to fix these edge cases.
+const scrollIntoView = (el) => el.evaluate((e) => e.scrollIntoView({ block: 'center' }));
+const getPageApi = (page) => {
+    const api = Object.create(page);
+    api.type = async (elementHandle, text, options) => {
+        await scrollIntoView(elementHandle);
+        return elementHandle.type(text, options);
+    };
+    api.click = async (elementHandle, options) => {
+        await scrollIntoView(elementHandle);
+        return elementHandle.click(options);
+    };
+    api.select = async (elementHandle, ...values) => {
+        await scrollIntoView(elementHandle);
+        return elementHandle.select(...values);
+    };
+    api.screenshot = async (options) => {
+        if (!options?.skipNetworkWait) {
+            await page.waitForNetworkIdle();
+        }
+        await waitForPaintEnd(page, options);
+        return page.screenshot(normalizeSreenshotOptions(options));
+    };
+    api.clear = async (elementHandle) => {
+        await elementHandle.click({ clickCount: 3 });
+        await elementHandle.press('Delete');
+    };
+    // For some reason, puppeteer browserContext.overridePermissions doesn't work with newer chrome versions.
+    // This workaround polyfills the browser geolocation api to return the mocked position
+    api.setGeolocation = (position) => page.evaluate((position) => {
+        window.navigator.geolocation.getCurrentPosition = (callback) => {
+            // @ts-expect-error - puppeteer's setGeoLocation does not expect a timestamp to be passed
+            callback({
+                coords: position,
+            });
+        };
+    }, position);
+    return api;
+};
+exports.getPageApi = getPageApi;
+let needsRequestInterception = false;
+let requestHandlers = [];
+const requestInterceptor = async (req) => {
+    const { handler } = requestHandlers.find(({ matcher }) => matcher(req)) ?? { handler: null };
+    if (!handler) {
+        req.continue();
+        return;
+    }
+    const response = await handler(req);
+    req.respond(response);
+};
+const interceptRequest = (matcher) => {
+    needsRequestInterception = true;
+    const spy = jest.fn();
+    requestHandlers.push({ matcher, handler: spy });
+    return spy;
+};
+exports.interceptRequest = interceptRequest;
+const createApiEndpointMock = ({ origin = '*' } = {}) => {
+    const originRegExp = (0, glob_to_regexp_1.default)(origin);
+    (0, exports.interceptRequest)((req) => {
+        const { origin } = new URL(req.url());
+        return req.method() === 'OPTIONS' && !!origin.match(originRegExp);
+    }).mockImplementation(() => ({
+        status: 204,
+        headers: {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'POST,PATCH,PUT,GET,OPTIONS,DELETE',
+            'Access-Control-Allow-Headers': '*',
+        },
+    }));
+    return {
+        spyOn(spiedPath, method = 'GET') {
+            const matcher = (req) => {
+                const { origin, pathname, search } = new URL(req.url());
+                const pathWithParams = pathname + search;
+                return (req.method() === method &&
+                    !!origin.match(originRegExp) &&
+                    (0, utils_1.matchPath)(spiedPath, pathWithParams));
+            };
+            const spy = jest.fn();
+            (0, exports.interceptRequest)(matcher).mockImplementation(async (req) => {
+                const spyResult = await spy(req);
+                const status = spyResult.status ?? 200;
+                const resBody = spyResult.body || spyResult;
+                return {
+                    status,
+                    headers: {
+                        'Access-Control-Allow-Origin': '*',
+                    },
+                    contentType: 'application/json',
+                    body: JSON.stringify(resBody),
+                };
+            });
+            return spy;
+        },
+    };
+};
+exports.createApiEndpointMock = createApiEndpointMock;
+const openPage = async ({ userAgent, isDarkMode, viewport, cookies, ...urlConfig }) => {
+    const url = (() => {
+        if (urlConfig.url !== undefined) {
+            return urlConfig.url;
+        }
+        const { path = '/', port = exports.serverPort, protocol = 'http', hostname = exports.serverHostName } = urlConfig;
+        if (!port) {
+            // Error.captureStackTrace(error, openPage);
+            throw new Error('You must specify a port. You can specify it when calling openPage() or by configuring a dev and ci server in the acceptanceTests config in your package.json');
+        }
+        return `${protocol}://${hostname}:${port}${path}`;
+    })();
+    (0, utils_1.debug)('Opening page:', url);
+    const currentUserAgent = userAgent || (await (0, exports.getGlobalBrowser)().userAgent());
+    const page = (0, exports.getGlobalPage)();
+    await page.bringToFront();
+    if (viewport) {
+        await page.setViewport(viewport);
+    }
+    if (cookies) {
+        await page.setCookie(...cookies);
+    }
+    await page.setUserAgent(`${currentUserAgent} acceptance-test`);
+    await page.emulateMediaFeatures([{ name: 'prefers-color-scheme', value: isDarkMode ? 'dark' : 'light' }]);
+    // A set of styles to make screenshot tests more reliable.
+    await page.evaluateOnNewDocument((viewport) => {
+        const overriddenSafeAreaInsets = !viewport
+            ? []
+            : Object.keys(viewport?.safeAreaInset ?? {}).map((key) => {
+                const position = key;
+                return `--acceptance-test-override-safe-area-inset-${key}: ${viewport?.safeAreaInset?.[position]};`;
+            });
+        const style = document.createElement('style');
+        style.innerHTML = `
+            *, *:after, *:before {
+                transition-delay: 0s !important;
+                transition-duration: 0s !important;
+                animation-delay: -0.0001s !important;
+                animation-duration: 0s !important;
+                animation-play-state: paused !important;
+                caret-color: transparent !important;
+                font-variant-ligatures: none !important;
+            }
+            *::-webkit-scrollbar {
+                display: none !important;
+                width: 0 !important;
+                height: 0 !important;
+            }
+            :root {
+                ${overriddenSafeAreaInsets.join('\n')}
+             }
+        `;
+        window.addEventListener('DOMContentLoaded', () => {
+            document.head.appendChild(style);
+        });
+    }, viewport);
+    if (needsRequestInterception) {
+        await page.setRequestInterception(true);
+        page.on('request', requestInterceptor);
+    }
+    try {
+        await page.goto(url);
+    }
+    catch (e) {
+        if (e.message.includes('net::ERR_CONNECTION_REFUSED')) {
+            const connectionError = new Error(`Could not connect to ${url}. Is the server running?`);
+            Error.captureStackTrace(connectionError, exports.openPage);
+            throw connectionError;
+        }
+        else {
+            throw e;
+        }
+    }
+    await page.waitForFunction('document.fonts.status === "loaded"');
+    return (0, exports.getPageApi)(page);
+};
+exports.openPage = openPage;
+const buildQueryMethods = ({ page, element } = {}) => {
+    const boundQueries = {};
+    for (const [queryName, queryFn] of Object.entries(pptr_testing_library_1.queries)) {
+        boundQueries[queryName] = async (...args) => {
+            const doc = await (0, pptr_testing_library_1.getDocument)(page ?? (0, exports.getGlobalPage)());
+            const body = await doc.$('body');
+            const queryArgs = [...args];
+            if (queryName.startsWith('findBy')) {
+                if (queryArgs.length === 1) {
+                    queryArgs.push(undefined);
+                }
+                queryArgs.push({ timeout: 10000 });
+            }
+            const elementHandle = await queryFn(element ?? body, ...queryArgs);
+            const newElementHandle = Object.create(elementHandle);
+            newElementHandle.screenshot = async (options) => {
+                if (!options?.skipNetworkWait) {
+                    await (page ?? (0, exports.getGlobalPage)()).waitForNetworkIdle();
+                }
+                await waitForPaintEnd(elementHandle, { ...options, fullPage: false });
+                return elementHandle.screenshot(normalizeSreenshotOptions(options));
+            };
+            newElementHandle.click = async (options) => {
+                await scrollIntoView(elementHandle);
+                return elementHandle.click(options);
+            };
+            newElementHandle.type = async (text, options) => {
+                await scrollIntoView(elementHandle);
+                return elementHandle.type(text, options);
+            };
+            newElementHandle.select = async (...values) => {
+                await scrollIntoView(elementHandle);
+                return elementHandle.select(...values);
+            };
+            return newElementHandle;
+        };
+    }
+    return boundQueries;
+};
+const getScreen = (page) => buildQueryMethods({ page });
+exports.getScreen = getScreen;
+exports.screen = buildQueryMethods();
+const within = (element) => buildQueryMethods({ element });
+exports.within = within;
+beforeEach(async () => {
+    await (0, exports.getGlobalPage)().setRequestInterception(false);
+    // by resetting the page we clean up all the evaluateOnNewDocument calls, which are persistent between documents
+    await global.jestPuppeteer.resetPage();
+});
+afterEach(async () => {
+    if (collectCoverage) {
+        await (0, coverage_1.collectFrontendCoverage)({ coveragePath });
+    }
+    try {
+        const page = (0, exports.getGlobalPage)();
+        requestHandlers = [];
+        needsRequestInterception = false;
+        page.off('request', requestInterceptor);
+        // clear tab, this way we clear the DOM and stop js execution or pending requests
+        await page.goto('about:blank');
+    }
+    catch (e) {
+        // ignore, at this point page might be destroyed
+    }
+});
+afterAll(async () => {
+    if (collectCoverage) {
+        await (0, coverage_1.collectBackendCoverage)({ coveragePath, coverageUrls });
+    }
+});
+/**
+ * Returns a new path to the file that can be used by chromium in acceptance tests
+ *
+ * To be able to use `element.uploadFile()` in a dockerized chromium, the file must exist in the
+ * host and the docker, and both sides must use the same path.
+ *
+ * To workaround this bug or limitation, this function prepares the file by copying it to /tmp in
+ * the host and the container.
+ */
+const prepareFile = (filepath) => {
+    const isLocal = !isCi;
+    const isHeadless = !!process.env.HEADLESS;
+    const usesDocker = isLocal && isHeadless;
+    const dockerComposeFile = path_1.default.join(__dirname, '..', 'docker-compose.yaml');
+    if (usesDocker) {
+        const containerId = (0, child_process_1.execSync)(`docker compose -f ${dockerComposeFile} ps -q`).toString().trim();
+        if (!containerId) {
+            throw Error('acceptance-testing container not found');
+        }
+        (0, child_process_1.execSync)(`docker cp ${filepath} ${containerId}:/tmp`);
+        const newPath = path_1.default.join('/tmp', path_1.default.basename(filepath));
+        fs_1.default.copyFileSync(filepath, newPath);
+        return newPath;
+    }
+    else {
+        return filepath;
+    }
+};
+exports.prepareFile = prepareFile;
+/**
+ * A convenience method to defer an expectation
+ */
+const wait = (expectation, timeout = 10000, interval = 50) => {
+    const startTime = Date.now();
+    const startStack = new Error().stack;
+    return new Promise((resolve, reject) => {
+        const rejectOrRerun = (error) => {
+            if (Date.now() - startTime >= timeout) {
+                if (error instanceof Error) {
+                    if (error.message === 'Element not removed') {
+                        error.stack = startStack;
+                    }
+                }
+                reject(error);
+                return;
+            }
+            setTimeout(runExpectation, interval);
+        };
+        const runExpectation = () => {
+            try {
+                Promise.resolve(expectation())
+                    .then((r) => resolve(r))
+                    .catch(rejectOrRerun);
+            }
+            catch (error) {
+                rejectOrRerun(error);
+            }
+        };
+        setTimeout(runExpectation, 0);
+    });
+};
+exports.wait = wait;
+const waitForElementToBeRemoved = (element, timeout = 10000, interval = 100) => {
+    const startStack = new Error().stack;
+    const wait = async () => {
+        const t0 = Date.now();
+        while (Date.now() - t0 < timeout) {
+            // boundingBox returns null when the element is not in the DOM
+            const box = await element.boundingBox();
+            if (!box) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, interval));
+        }
+        throw new Error('Element not removed');
+    };
+    return wait().catch((error) => {
+        if (error.message === 'Element not removed') {
+            error.stack = startStack;
+        }
+        throw error;
+    });
+};
+exports.waitForElementToBeRemoved = waitForElementToBeRemoved;

package/dist/jest-puppeteer.config.d.ts

@@ -0,0 +1 @@
+export {};

package/{jest-puppeteer-config.js → dist/jest-puppeteer.config.js}

@@ -1,89 +1,53 @@
-const path = require('path');
-const fs = require('fs');
-const findRoot = require('find-root');
-const fetch = require('node-fetch');
-const execSync = require('child_process').execSync;
-
-const poll = async (url) => {
-    let tries = 10;
-    while (tries--) {
-        try {
-            return await fetch(url);
-        } catch (e) {
-            await new Promise((r) => setTimeout(r, 500));
-        }
-    }
-    throw Error(`Error fetching ${url}`);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("./config");
 /**
  * CI => everything runs inside a docker
  * Local, headless => connects to a dockerized chromium at port 9223 (see docker-compose.yaml)
  * Local, with UI => launches a local chromium installed by puppetteer
  */
 const getPuppeteerConfig = async () => {
-    const isCi = process.argv.includes('--ci') || process.env.CI;
-    const isLocal = !isCi;
-    const isHeadless = !!process.env.HEADLESS;
-
-    const rootDir = findRoot(process.cwd());
-    const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf-8'));
-    const projectConfig = pkg.acceptanceTests || {};
-
-    const server = (isCi ? projectConfig.ciServer : projectConfig.devServer) || projectConfig.server || {};
-
+    const { isCi, isLocal, isHeadless, server } = (0, config_1.getConfig)();
     const baseConfig = {
         ignoreHTTPSErrors: true,
         headless: isHeadless,
         slowMo: isHeadless ? 0 : 50,
     };
-
     let connect;
-
     if (isLocal && isHeadless) {
         const dockerChromiumUrl = 'http://localhost:9223';
-
         try {
             await fetch(dockerChromiumUrl);
-        } catch (e) {
-            const dockerComposeFile = path.join(__dirname, 'docker-compose.yaml');
-
+        }
+        catch (e) {
+            const dockerComposeFile = path_1.default.join(__dirname, '/../docker-compose.yaml');
             process.on('SIGINT', () => {
                 process.exit(1); // this triggers the 'exit' event handler below when the process is killed with Ctrl+C
             });
-
             process.on('exit', () => {
-                execSync(`docker compose -f ${dockerComposeFile} stop -t 0`, {stdio: 'ignore'});
+                (0, child_process_1.execSync)(`docker compose -f ${dockerComposeFile} stop -t 0`, { stdio: 'ignore' });
             });
-
-            execSync(`docker compose -f ${dockerComposeFile} up -d`, {stdio: 'inherit'});
+            (0, child_process_1.execSync)(`docker compose -f ${dockerComposeFile} up -d`, { stdio: 'inherit' });
             console.log();
-
-            await poll(dockerChromiumUrl);
+            await (0, utils_1.poll)(dockerChromiumUrl);
         }
-
-        const {webSocketDebuggerUrl} = await fetch(`${dockerChromiumUrl}/json/version`).then((r) => r.json());
-
+        const { webSocketDebuggerUrl } = await fetch(`${dockerChromiumUrl}/json/version`).then((r) => r.json());
         connect = {
             ...baseConfig,
             browserWSEndpoint: webSocketDebuggerUrl,
         };
     }
-
-    const defaultServerConfig = {
-        command: 'tail -f /dev/null',
-        host: 'localhost',
-        protocol: server.path ? 'http' : 'tcp',
-        debug: isCi,
-        usedPortAction: isCi ? 'error' : 'ignore', // In dev, if port is already taken, assume server is already running.
-        launchTimeout: 60000,
-    };
-
     return {
         launch: {
             ...baseConfig,
             // Launch chromium installed in docker in CI
-            ...(isCi ? {executablePath: '/usr/bin/chromium'} : {}),
+            ...(isCi ? { executablePath: '/usr/bin/chromium' } : {}),
             env: {
                 ...process.env,
                 TZ: 'UTC',
@@ -112,13 +76,8 @@ const getPuppeteerConfig = async () => {
         },
         connect,
         browserContext: 'incognito',
-        server: server
-            ? {
-                  ...defaultServerConfig,
-                  ...server,
-              }
-            : undefined,
+        server,
+        exitOnPageError: !process.env.ACCEPTANCE_TESTING_IGNORE_PAGE_ERRORS,
     };
 };
-
 module.exports = getPuppeteerConfig();

package/dist/utils.d.ts

@@ -1,8 +1,12 @@
-/**
- * Debug function that logs to the console if the DEBUG_ACCEPTANCE_TESTING environment variable is set
- */
-export declare const debug: (...args: Array<unknown>) => void;
-/**
- * Returns true if the current path matches the spied path, including parameters
- */
-export declare const matchPath: (spiedPath: string, currentPath: string) => boolean;
+/**
+ * Debug function that logs to the console if the ACCEPTANCE_TESTING_DEBUG environment variable is set
+ */
+export declare const debug: (...args: Array<unknown>) => void;
+/**
+ * Returns true if the current path matches the spied path, including parameters
+ */
+export declare const matchPath: (spiedPath: string, currentPath: string) => boolean;
+/**
+ * Polls a URL until it returns a successful response
+ */
+export declare const poll: (url: string) => Promise<Response>;

package/dist/utils.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.poll = exports.matchPath = exports.debug = void 0;
+const path_1 = __importDefault(require("path"));
+const glob_to_regexp_1 = __importDefault(require("glob-to-regexp"));
+const config_1 = require("./config");
+/**
+ * Debug function that logs to the console if the ACCEPTANCE_TESTING_DEBUG environment variable is set
+ */
+const debug = (...args) => {
+    if ((0, config_1.getConfig)().debug) {
+        console.debug('[acceptance-testing]', ...args);
+    }
+};
+exports.debug = debug;
+/**
+ * Returns true if the current path matches the spied path, including parameters
+ */
+const matchPath = (spiedPath, currentPath) => {
+    const normalizedCurrentPath = path_1.default.normalize(currentPath);
+    const pattern = (0, glob_to_regexp_1.default)(spiedPath);
+    return pattern.test(normalizedCurrentPath);
+};
+exports.matchPath = matchPath;
+/**
+ * Polls a URL until it returns a successful response
+ */
+const poll = async (url) => {
+    let tries = 10;
+    while (tries--) {
+        try {
+            return await fetch(url);
+        }
+        catch (e) {
+            await new Promise((r) => setTimeout(r, 500));
+        }
+    }
+    throw Error(`Error fetching ${url}`);
+};
+exports.poll = poll;

package/dist/wsl.d.ts

@@ -0,0 +1,6 @@
+/** Check if running inside WSL */
+export declare const isWsl: () => boolean;
+/** Assumes running inside WSL */
+export declare const isWsl2: () => boolean;
+/** Assumes running inside WSL */
+export declare const getWslHostIp: () => string;

package/dist/wsl.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWslHostIp = exports.isWsl2 = exports.isWsl = void 0;
+const child_process_1 = require("child_process");
+const constants_1 = require("./constants");
+/** Check if running inside WSL */
+const isWsl = () => {
+    if (process.platform !== 'linux') {
+        return false;
+    }
+    try {
+        return (0, child_process_1.execSync)('which wsl.exe').toString().startsWith('/mnt/');
+    }
+    catch (e) {
+        // catched because it throws an error if wsl.exe is not found
+        return false;
+    }
+};
+exports.isWsl = isWsl;
+/** Assumes running inside WSL */
+const isWsl2 = () => {
+    // `wsl.exe -l -v` returns something like:
+    //
+    // NAME                    STATE         VERSION
+    // * Ubuntu-22.04          Running       2
+    //   docker-desktop-data   Running       2
+    //   docker-desktop        Running       2
+    //   Ubuntu-20.04          Stopped       2
+    return ((0, child_process_1.execSync)('wsl.exe -l -v')
+        .toString()
+        // null-bytes are inserted between chars in this command output (UTF-16 output?)
+        .replace(/\0/g, '')
+        .split('\n')
+        .map((line) => line.trim())
+        // matches a line like: "* Ubuntu-22.04    Running       2"
+        .some((line) => !!line.match(/\*\s+\S+\s+Running\s+2/)));
+};
+exports.isWsl2 = isWsl2;
+/** Assumes running inside WSL */
+const getWslHostIp = () => {
+    const ips = (0, child_process_1.execSync)('wsl.exe hostname -I').toString().trim().split(/\s+/);
+    if (ips.includes(constants_1.LINUX_DOCKER_HOST_IP)) {
+        // looks like a docker engine installed inside linux
+        return constants_1.LINUX_DOCKER_HOST_IP;
+    }
+    // assuming docker-desktop installed in windows
+    return ips[0];
+};
+exports.getWslHostIp = getWslHostIp;

package/jest-puppeteer.config.js

@@ -0,0 +1 @@
+module.exports = require('./dist/jest.puppeteer-config.js');