@gravity-ui/playwright-tools 0.4.1

package/har/types.d.ts

@@ -0,0 +1,175 @@
+export type HARFile = {
+    log: Log;
+};
+export type Log = {
+    version: string;
+    creator: Creator;
+    browser?: Browser;
+    pages?: Page[];
+    entries: Entry[];
+    comment?: string;
+};
+export type Creator = {
+    name: string;
+    version: string;
+    comment?: string;
+};
+export type Browser = {
+    name: string;
+    version: string;
+    comment?: string;
+};
+export type Page = {
+    startedDateTime: Date;
+    id: string;
+    title: string;
+    pageTimings: PageTimings;
+    comment?: string;
+};
+export type PageTimings = {
+    onContentLoad?: number;
+    onLoad?: number;
+    comment?: string;
+};
+export type Entry = {
+    pageref?: string;
+    startedDateTime: Date;
+    time: number;
+    request: Request;
+    response: Response;
+    cache: Cache;
+    timings: Timings;
+    serverIPAddress?: string;
+    connection?: string;
+    _frameref?: string;
+    _monotonicTime?: number;
+    _serverPort?: number;
+    _securityDetails?: SecurityDetails;
+};
+export type Request = {
+    method: string;
+    url: string;
+    httpVersion: string;
+    cookies: Cookie[];
+    headers: Header[];
+    queryString: QueryParameter[];
+    postData?: PostData;
+    headersSize: number;
+    bodySize: number;
+    comment?: string;
+};
+export type Response = {
+    status: number;
+    statusText: string;
+    httpVersion: string;
+    cookies: Cookie[];
+    headers: Header[];
+    content: Content;
+    redirectURL: string;
+    headersSize: number;
+    bodySize: number;
+    comment?: string;
+    _transferSize?: number;
+    _failureText?: string;
+};
+export type Cookie = {
+    name: string;
+    value: string;
+    path?: string;
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: string;
+    comment?: string;
+};
+export type Header = {
+    name: string;
+    value: string;
+    comment?: string;
+};
+export type QueryParameter = {
+    name: string;
+    value: string;
+    comment?: string;
+};
+export type PostData = {
+    mimeType: string;
+    params: Param[];
+    text: string;
+    comment?: string;
+    _sha1?: string;
+    _file?: string;
+};
+export type Param = {
+    name: string;
+    value?: string;
+    fileName?: string;
+    contentType?: string;
+    comment?: string;
+};
+export type Content = {
+    size: number;
+    compression?: number;
+    mimeType: string;
+    text?: string;
+    encoding?: string;
+    comment?: string;
+    _sha1?: string;
+    _file?: string;
+};
+export type Cache = {
+    beforeRequest?: CacheState | null;
+    afterRequest?: CacheState | null;
+    comment?: string;
+};
+export type CacheState = {
+    expires?: string;
+    lastAccess: string;
+    eTag: string;
+    hitCount: number;
+    comment?: string;
+};
+export type Timings = {
+    blocked?: number;
+    dns?: number;
+    connect?: number;
+    send: number;
+    wait: number;
+    receive: number;
+    ssl?: number;
+    comment?: string;
+};
+export type SecurityDetails = {
+    protocol?: string;
+    subjectName?: string;
+    issuer?: string;
+    validFrom?: number;
+    validTo?: number;
+};
+export type Metadata = {
+    location?: {
+        file: string;
+        line?: number;
+        column?: number;
+    };
+    apiName?: string;
+    internal?: boolean;
+    wallTime?: number;
+};
+export type LocalUtilsHarLookupParams = {
+    harId: string;
+    url: string;
+    method: string;
+    headers: Header[];
+    postData?: Buffer;
+    isNavigationRequest: boolean;
+};
+export type LocalUtilsHarLookupResult = {
+    action: 'error' | 'redirect' | 'fulfill' | 'noentry';
+    message?: string;
+    redirectURL?: string;
+    status?: number;
+    headers?: Header[];
+    body?: Buffer;
+};

package/har/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// End of channels types

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@gravity-ui/playwright-tools",
+  "version": "0.4.1",
+  "description": "Tools for Playwright Test",
+  "keywords": [
+    "playwright",
+    "e2e",
+    "test",
+    "tests",
+    "integration"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gravity-ui/playwright-tools"
+  },
+  "license": "MIT",
+  "author": "@Avol-V",
+  "files": [
+    "/actions/**/*.*(js|d.ts)",
+    "/auth/**/*.*(js|d.ts)",
+    "/config/**/*.*(js|d.ts)",
+    "/data/**/*.*(js|d.ts)",
+    "/fixtures/**/*.*(js|d.ts)",
+    "/har/**/*.*(js|d.ts)",
+    "/utils/**/*.*(js|d.ts)",
+    "!/**/__tests__"
+  ],
+  "exports": [
+    "./actions/**/*.*(js|d.ts)",
+    "./auth/**/*.*(js|d.ts)",
+    "./config/**/*.*(js|d.ts)",
+    "./data/**/*.*(js|d.ts)",
+    "./fixtures/**/*.*(js|d.ts)",
+    "./har/**/*.*(js|d.ts)",
+    "./utils/**/*.*(js|d.ts)"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "find actions auth config data fixtures har utils -type f ! -name '.eslintrc.js' \\( -name '*.js' -o -name '*.d.ts' \\) -delete",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint --ext .ts ./",
+    "test": "jest --colors --config=jest.config.js",
+    "prepublishOnly": "npm run clean && npm run lint && npm run build"
+  },
+  "dependencies": {
+    "escape-string-regexp": "^4.0.0",
+    "minimatch": "^10.0.1",
+    "otplib": "^12.0.1",
+    "timekeeper": "^2.3.1"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.6.1",
+    "@commitlint/config-conventional": "^19.6.0",
+    "@gravity-ui/eslint-config": "^3.3.0",
+    "@gravity-ui/prettier-config": "^1.1.0",
+    "@jest/globals": "^29.7.0",
+    "@playwright/test": "^1.49.0",
+    "@swc/core": "^1.11.5",
+    "@swc/jest": "^0.2.37",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.17.9",
+    "eslint": "^8.57.1",
+    "jest": "^29.7.0",
+    "prettier": "^3.4.2",
+    "ts-jest": "^29.3.1",
+    "typescript": "^5.7.2"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.22"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/utils/NeverError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Unreachable statement Error
+ */
+export declare class NeverError extends Error {
+    constructor(value: never);
+}

package/utils/NeverError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeverError = void 0;
+/**
+ * Unreachable statement Error
+ */
+class NeverError extends Error {
+    constructor(value) {
+        super(`Unreachable statement: ${value}`);
+    }
+}
+exports.NeverError = NeverError;

package/utils/deleteCache.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Remove file from cache
+ *
+ * @param path cache path
+ * @param name cache name (without extension)
+ */
+export declare function deleteCache(path: string, name: string): Promise<void>;

package/utils/deleteCache.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteCache = deleteCache;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+/**
+ * Remove file from cache
+ *
+ * @param path cache path
+ * @param name cache name (without extension)
+ */
+function deleteCache(path, name) {
+    const fullPath = (0, path_1.resolve)(path, name + '.json');
+    return (0, promises_1.unlink)(fullPath).catch(() => { });
+}

package/utils/extractTestSlug.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Retrieves a test ID for use in the test artifact path.
+ *
+ * It is assumed that the identifier is written at the end of the test name in square brackets:
+ * `'My test title [my-test]'`
+ * Otherwise, it is formed from the name, excluding all special characters, for example:
+ * `'My test title 1 @test @tag'` -> `'my-test-title-1-test-tag'`
+ *
+ * @param title test name
+ * @param allowToUseTitle Requires the slug to be specified in a specific way in the title (otherwise the title itself will be used)
+ */
+export declare function extractTestSlug(title: string, allowToUseTitle?: boolean): string;

package/utils/extractTestSlug.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTestSlug = extractTestSlug;
+/**
+ * Retrieves a test ID for use in the test artifact path.
+ *
+ * It is assumed that the identifier is written at the end of the test name in square brackets:
+ * `'My test title [my-test]'`
+ * Otherwise, it is formed from the name, excluding all special characters, for example:
+ * `'My test title 1 @test @tag'` -> `'my-test-title-1-test-tag'`
+ *
+ * @param title test name
+ * @param allowToUseTitle Requires the slug to be specified in a specific way in the title (otherwise the title itself will be used)
+ */
+function extractTestSlug(title, allowToUseTitle = true) {
+    const matches = /\[([^[\]]+)\]$/.exec(title);
+    if (matches) {
+        return matches[1];
+    }
+    if (allowToUseTitle) {
+        return title.match(/\w+/g)?.join('-').toLocaleLowerCase() || '';
+    }
+    return '';
+}

package/utils/fetchWithoutRejectUnauthorized.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Native fetch with certificate verification disabled
+ */
+export declare const fetchWithoutRejectUnauthorized: typeof fetch;

package/utils/fetchWithoutRejectUnauthorized.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWithoutRejectUnauthorized = void 0;
+const unidiciGlobalDispatcherSymbol = Symbol.for('undici.globalDispatcher.1');
+let dispatcherWithoutRejectUnauthorized;
+/**
+ * Native fetch with certificate verification disabled
+ */
+const fetchWithoutRejectUnauthorized = async (input, init) => {
+    if (!dispatcherWithoutRejectUnauthorized) {
+        // Initialize fetch globals
+        await fetch('data:text/plain,');
+        // Getting the dispatcher from global is considered a public API
+        // https://github.com/nodejs/undici/discussions/2167#discussioncomment-6265039
+        const undiciGlobalDispatcher = global[unidiciGlobalDispatcherSymbol];
+        dispatcherWithoutRejectUnauthorized = new undiciGlobalDispatcher.constructor({
+            connect: {
+                rejectUnauthorized: false,
+            },
+        });
+    }
+    const fetchOptions = {
+        dispatcher: dispatcherWithoutRejectUnauthorized,
+        ...init,
+    };
+    return fetch(input, fetchOptions);
+};
+exports.fetchWithoutRejectUnauthorized = fetchWithoutRejectUnauthorized;

package/utils/getCookieDomain.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns the domain for cookies based on the baseURL from the config
+ */
+export declare function getCookieDomain(baseURL: string): string;

package/utils/getCookieDomain.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCookieDomain = getCookieDomain;
+const url_1 = require("url");
+/**
+ * Returns the domain for cookies based on the baseURL from the config
+ */
+function getCookieDomain(baseURL) {
+    const parsedBaseUrl = new url_1.URL(baseURL);
+    const baseHost = parsedBaseUrl.hostname.replace(/:\d+$/, '');
+    const domain = '.' + baseHost.split('.').slice(-2).join('.');
+    return domain;
+}

package/utils/index.d.ts

@@ -0,0 +1,9 @@
+export { deleteCache } from './deleteCache';
+export { extractTestSlug } from './extractTestSlug';
+export { fetchWithoutRejectUnauthorized } from './fetchWithoutRejectUnauthorized';
+export { getCookieDomain } from './getCookieDomain';
+export { NeverError } from './NeverError';
+export { readCache } from './readCache';
+export { waitForResolve } from './waitForResolve';
+export { waitHttpService } from './waitHttpService';
+export { writeCache } from './writeCache';

package/utils/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeCache = exports.waitHttpService = exports.waitForResolve = exports.readCache = exports.NeverError = exports.getCookieDomain = exports.fetchWithoutRejectUnauthorized = exports.extractTestSlug = exports.deleteCache = void 0;
+var deleteCache_1 = require("./deleteCache");
+Object.defineProperty(exports, "deleteCache", { enumerable: true, get: function () { return deleteCache_1.deleteCache; } });
+var extractTestSlug_1 = require("./extractTestSlug");
+Object.defineProperty(exports, "extractTestSlug", { enumerable: true, get: function () { return extractTestSlug_1.extractTestSlug; } });
+var fetchWithoutRejectUnauthorized_1 = require("./fetchWithoutRejectUnauthorized");
+Object.defineProperty(exports, "fetchWithoutRejectUnauthorized", { enumerable: true, get: function () { return fetchWithoutRejectUnauthorized_1.fetchWithoutRejectUnauthorized; } });
+var getCookieDomain_1 = require("./getCookieDomain");
+Object.defineProperty(exports, "getCookieDomain", { enumerable: true, get: function () { return getCookieDomain_1.getCookieDomain; } });
+var NeverError_1 = require("./NeverError");
+Object.defineProperty(exports, "NeverError", { enumerable: true, get: function () { return NeverError_1.NeverError; } });
+var readCache_1 = require("./readCache");
+Object.defineProperty(exports, "readCache", { enumerable: true, get: function () { return readCache_1.readCache; } });
+var waitForResolve_1 = require("./waitForResolve");
+Object.defineProperty(exports, "waitForResolve", { enumerable: true, get: function () { return waitForResolve_1.waitForResolve; } });
+var waitHttpService_1 = require("./waitHttpService");
+Object.defineProperty(exports, "waitHttpService", { enumerable: true, get: function () { return waitHttpService_1.waitHttpService; } });
+var writeCache_1 = require("./writeCache");
+Object.defineProperty(exports, "writeCache", { enumerable: true, get: function () { return writeCache_1.writeCache; } });

package/utils/readCache.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the contents of the cache file
+ *
+ * @param path Path to the directory with cache
+ * @param name cache name (without extension)
+ * @param ttl Cache Lifetime (ms)
+ */
+export declare function readCache<TData = unknown>(path: string, name: string, ttl: number): Promise<TData | undefined>;

package/utils/readCache.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCache = readCache;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const checkedPaths = new Set();
+/**
+ * Returns the contents of the cache file
+ *
+ * @param path Path to the directory with cache
+ * @param name cache name (without extension)
+ * @param ttl Cache Lifetime (ms)
+ */
+async function readCache(path, name, ttl) {
+    const fullPath = (0, path_1.resolve)(path, name + '.json');
+    if (checkedPaths.has(fullPath)) {
+        return undefined;
+    }
+    checkedPaths.add(fullPath);
+    try {
+        const { mtimeMs } = await (0, promises_1.stat)(fullPath);
+        if (mtimeMs + ttl < Date.now()) {
+            return undefined;
+        }
+        const json = await (0, promises_1.readFile)(fullPath, 'utf8');
+        const data = JSON.parse(json);
+        return data;
+    }
+    catch {
+        return undefined;
+    }
+}

package/utils/waitForResolve.d.ts

@@ -0,0 +1,24 @@
+export type WaitForResolveOptions = {
+    /**
+     * Interval between checks (ms)
+     * @defaultValue `100`
+     */
+    interval?: number;
+    /**
+     * Timeout after which checks are aborted (ms)
+     * `0` — without limitation
+     * @defaultValue `5000`
+     */
+    timeout?: number;
+};
+/**
+ * Waits for the check function to return `true`
+ *
+ * The checking function is launched at a given interval and its value is checked.
+ * If it returned `true`, then it succeeds, otherwise we wait further.
+ * If there is a timeout or an error in the checking function, it fails.
+ *
+ * @param solver resolving function
+ * @param options Options
+ */
+export declare function waitForResolve(solver: () => boolean | PromiseLike<boolean>, { interval, timeout, }?: WaitForResolveOptions): Promise<void>;

package/utils/waitForResolve.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForResolve = waitForResolve;
+const globalSettings_1 = require("../data/globalSettings");
+/**
+ * Waits for the check function to return `true`
+ *
+ * The checking function is launched at a given interval and its value is checked.
+ * If it returned `true`, then it succeeds, otherwise we wait further.
+ * If there is a timeout or an error in the checking function, it fails.
+ *
+ * @param solver resolving function
+ * @param options Options
+ */
+function waitForResolve(solver, { interval = globalSettings_1.globalSettings.waitForResolve.interval, timeout = globalSettings_1.globalSettings.waitForResolve.timeout, } = {}) {
+    const until = timeout === 0 ? 0 : Date.now() + timeout;
+    let resolveResult;
+    let rejectResult;
+    const resultPromise = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+    });
+    const timer = setInterval(async () => {
+        try {
+            if (await solver()) {
+                clearInterval(timer);
+                resolveResult();
+                return;
+            }
+            if (until && Date.now() > until) {
+                clearInterval(timer);
+                rejectResult(new Error('waitForResolve timeout'));
+            }
+        }
+        catch (error) {
+            rejectResult(error);
+        }
+    }, interval);
+    return resultPromise;
+}

package/utils/waitHttpService.d.ts

@@ -0,0 +1,28 @@
+export type WaitHttpServiceOptions = {
+    /** URL to check */
+    url: string;
+    /**
+     * Request Method
+     * @default 'HEAD'
+     */
+    method?: string;
+    /**
+     * Expected response status
+     * @default 200
+     */
+    expectedStatus?: number;
+    /**
+     * Interval between requests
+     * @default 1000
+     */
+    interval?: number;
+    /**
+     * Waiting time
+     * @default Infinity
+     */
+    timeout?: number;
+};
+/**
+ * Waits for a response with the required status at the given URL
+ */
+export declare function waitHttpService({ url, method, expectedStatus, interval, timeout, }: WaitHttpServiceOptions): Promise<void>;

package/utils/waitHttpService.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitHttpService = waitHttpService;
+const promises_1 = require("node:timers/promises");
+const fetchWithoutRejectUnauthorized_1 = require("./fetchWithoutRejectUnauthorized");
+/**
+ * Waits for a response with the required status at the given URL
+ */
+async function waitHttpService({ url, method = 'HEAD', expectedStatus = 200, interval = 1000, timeout = Infinity, }) {
+    const until = Date.now() + timeout;
+    let success = false;
+    do {
+        const response = await (0, fetchWithoutRejectUnauthorized_1.fetchWithoutRejectUnauthorized)(url, {
+            method,
+        }).catch(() => null);
+        if (response?.status === expectedStatus) {
+            success = true;
+            return;
+        }
+        await (0, promises_1.setTimeout)(interval);
+        if (Date.now() > until) {
+            throw new Error('Timed out waiting for ' + url);
+        }
+    } while (!success);
+}

package/utils/writeCache.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Writes data to the cache file
+ *
+ * @param path Path to the directory with cache
+ * @param name Cache name (without extension)
+ * @param data Data to write to cache
+ */
+export declare function writeCache(path: string, name: string, data: unknown): Promise<void>;

package/utils/writeCache.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeCache = writeCache;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+/**
+ * Writes data to the cache file
+ *
+ * @param path Path to the directory with cache
+ * @param name Cache name (without extension)
+ * @param data Data to write to cache
+ */
+async function writeCache(path, name, data) {
+    const fullPath = (0, path_1.resolve)(path, name + '.json');
+    const json = JSON.stringify(data);
+    await (0, promises_1.mkdir)(path, { recursive: true }).catch(() => { });
+    await (0, promises_1.writeFile)(fullPath, json, 'utf8');
+}