Merge branch 'master' into feat/add-dtl

Author: talkenson

.github/workflows/collect-deps.yml

@@ -13,7 +13,7 @@ jobs:
 
         strategy:
             matrix:
-                os: [ubuntu-20.04, ubuntu-22.04, ubuntu-24.04]
+                os: [ubuntu-22.04, ubuntu-24.04]
         steps:
             - name: Checkout repository
               uses: actions/checkout@v2

package-lock.json

@@ -75,7 +75,6 @@
     "@testplane/wdio-utils": "9.5.3",
     "@testplane/webdriverio": "9.5.20",
     "@vitest/spy": "2.1.4",
-    "bluebird": "3.5.1",
     "chalk": "2.4.2",
     "clear-require": "1.0.1",
     "cli-progress": "3.12.0",
@@ -129,7 +128,6 @@
     "@testplane/wdio-types": "9.5.2",
     "@types/babel__code-frame": "7.0.6",
     "@types/babel__core": "7.20.5",
-    "@types/bluebird": "3.5.38",
     "@types/browserify": "12.0.40",
     "@types/chai": "4.3.4",
     "@types/chai-as-promised": "7.1.5",

package.json

@@ -40,6 +40,7 @@
             "136",
             "137",
             "138",
+            "139",
             "73",
             "74",
             "75",
@@ -109,6 +110,7 @@
             "136",
             "137",
             "138",
+            "139",
             "57",
             "58",
             "59",

src/browser-installer/ubuntu-packages/collect-dependencies/cache/autogenerated/processed-browsers-linux.json

@@ -1,6 +1,5 @@
 "use strict";
 
-const Promise = require("bluebird");
 const { ImageDiffError } = require("../errors/image-diff-error");
 const { NoRefImageError } = require("../errors/no-ref-image-error");
 const { InvalidRefImageError } = require("../errors/invalid-ref-image-error");

src/browser/commands/assert-view/capture-processors/assert-refs.js

@@ -3,7 +3,6 @@
 const fs = require("fs-extra");
 const path = require("path");
 const _ = require("lodash");
-const Promise = require("bluebird");
 const { pngValidator: validatePng } = require("png-validator");
 const { Image } = require("../../../image");
 const ScreenShooter = require("../../screen-shooter");
@@ -159,16 +158,18 @@ module.exports.default = browser => {
     };
 
     const waitSelectorsForExist = async (browser, selectors) => {
-        await Promise.map([].concat(selectors), async selector => {
-            await browser
-                .$(selector)
-                .then(el => el.waitForExist())
-                .catch(() => {
-                    throw new Error(
-                        `element ("${selector}") still not existing after ${browser.options.waitforTimeout} ms`,
-                    );
-                });
-        });
+        await Promise.all(
+            [].concat(selectors).map(selector =>
+                browser
+                    .$(selector)
+                    .then(el => el.waitForExist())
+                    .catch(() => {
+                        throw new Error(
+                            `element ("${selector}") still not existing after ${browser.options.waitforTimeout} ms`,
+                        );
+                    }),
+            ),
+        );
     };
 
     const assertViewBySelector = async (browser, state, selectors, opts) => {

src/browser/commands/assert-view/index.js

@@ -1,12 +1,10 @@
 import { EventEmitter } from "events";
-import BluebirdPromise from "bluebird";
+import { promiseMethod } from "../../utils/promise";
 
 export class AsyncEmitter extends EventEmitter {
     async emitAndWait(event: string | symbol, ...args: unknown[]): Promise<unknown[]> {
         const results = await Promise.allSettled(
-            this.listeners(event).map(l =>
-                BluebirdPromise.method(l as (...args: unknown[]) => unknown).apply(this, args as []),
-            ),
+            this.listeners(event).map(l => promiseMethod(l as (...args: unknown[]) => unknown).apply(this, args as [])),
         );
 
         const rejected = results.find(({ status }) => status === "rejected");

src/events/async-emitter/index.ts

@@ -0,0 +1,66 @@
+export function promiseMethod<T, ThisArg = unknown, Args extends unknown[] = unknown[]>(
+    fn: (this: ThisArg, ...args: Args) => T,
+): (this: ThisArg, ...args: Args) => Promise<T> {
+    return function (this: ThisArg, ...args: Args): Promise<T> {
+        try {
+            const result = fn.apply(this, args);
+            return Promise.resolve(result);
+        } catch (err) {
+            return Promise.reject(err);
+        }
+    };
+}
+
+export function promiseTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
+    let timeoutId: NodeJS.Timeout;
+    let isCancelled = false;
+
+    const timeoutPromise = new Promise<never>((_, reject) => {
+        timeoutId = setTimeout(() => {
+            if (!isCancelled) {
+                reject(new Error(message));
+            }
+        }, ms);
+
+        if (timeoutId.unref) {
+            timeoutId.unref();
+        }
+    });
+
+    const wrappedPromise = new Promise<T>((resolve, reject) => {
+        promise.then(
+            value => {
+                if (!isCancelled) {
+                    resolve(value);
+                }
+            },
+            error => {
+                if (!isCancelled) {
+                    reject(error);
+                }
+            },
+        );
+    });
+
+    return Promise.race([wrappedPromise, timeoutPromise]).finally(() => {
+        isCancelled = true;
+        clearTimeout(timeoutId);
+    });
+}
+
+export function promiseDelay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export async function promiseMapSeries<T, R>(
+    items: T[],
+    mapper: (item: T, index: number) => Promise<R> | R,
+): Promise<R[]> {
+    const results: R[] = [];
+
+    for (let i = 0; i < items.length; i++) {
+        results.push(await Promise.resolve(mapper(items[i], i)));
+    }
+
+    return results;
+}

src/utils/promise.ts

@@ -2,7 +2,7 @@
 
 const { EventEmitter } = require("events");
 const workerFarm = require("worker-farm");
-const Promise = require("bluebird");
+const { promisify } = require("util");
 const _ = require("lodash");
 const { MasterEvents } = require("../events");
 const RuntimeConfig = require("../config/runtime-config");
@@ -39,7 +39,7 @@ module.exports = class WorkersRegistry extends EventEmitter {
 
     async end() {
         this._ended = true;
-        await Promise.promisify(workerFarm.end)(this._workerFarm);
+        await promisify(workerFarm.end)(this._workerFarm);
     }
 
     isEnded() {
@@ -55,7 +55,7 @@ module.exports = class WorkersRegistry extends EventEmitter {
                 if (this._ended) {
                     return Promise.reject(new Error(`Can't execute method '${methodName}' because worker farm ended.`));
                 }
-                return Promise.promisify(this._workerFarm)(workerFilepath, methodName, args);
+                return promisify(this._workerFarm)(workerFilepath, methodName, args);
             };
         }
 

src/utils/workers-registry.js

@@ -1,9 +1,9 @@
 import crypto from "node:crypto";
-import P from "bluebird";
 import _ from "lodash";
 import { io } from "socket.io-client";
 import urljoin from "url-join";
 
+import { promiseTimeout } from "../../../../utils/promise";
 import NodejsEnvTestRunner from "../../../runner/test-runner";
 import { wrapExecutionThread } from "./execution-thread";
 import { WorkerEventNames } from "./types";
@@ -143,34 +143,33 @@ export class TestRunner extends NodejsEnvTestRunner {
     private _waitBroInitOnReconnect(): Promise<void> {
         let intervalId: NodeJS.Timeout | null = null;
 
-        return new P((resolve, reject) => {
-            intervalId = setInterval(() => {
-                if (_.isNull(this._broInitResOnReconnect)) {
-                    return;
-                }
+        return promiseTimeout(
+            new Promise<void>((resolve, reject) => {
+                intervalId = setInterval(() => {
+                    if (_.isNull(this._broInitResOnReconnect)) {
+                        return;
+                    }
 
-                if (intervalId) {
-                    clearInterval(intervalId);
-                }
+                    if (intervalId) {
+                        clearInterval(intervalId);
+                    }
 
-                if (_.isEmpty(this._broInitResOnReconnect)) {
-                    resolve();
-                } else {
-                    reject(this._broInitResOnReconnect[0]);
-                }
-            }, BRO_INIT_INTERVAL_ON_RECONNECT).unref();
-        })
-            .timeout(
-                BRO_INIT_TIMEOUT_ON_RECONNECT,
-                `Browser didn't connect to the Vite server after reconnect in ${BRO_INIT_TIMEOUT_ON_RECONNECT}ms`,
-            )
-            .catch(err => {
-                if (intervalId) {
-                    clearInterval(intervalId);
-                }
+                    if (_.isEmpty(this._broInitResOnReconnect)) {
+                        resolve();
+                    } else {
+                        reject(this._broInitResOnReconnect[0]);
+                    }
+                }, BRO_INIT_INTERVAL_ON_RECONNECT).unref();
+            }),
+            BRO_INIT_TIMEOUT_ON_RECONNECT,
+            `Browser didn't connect to the Vite server after reconnect in ${BRO_INIT_TIMEOUT_ON_RECONNECT}ms`,
+        ).catch(err => {
+            if (intervalId) {
+                clearInterval(intervalId);
+            }
 
-                throw err;
-            });
+            throw err;
+        });
     }
 
     _getPreparePageActions(browser: Browser, history: BrowserHistory): (() => Promise<void>)[] {
@@ -298,7 +297,7 @@ export class TestRunner extends NodejsEnvTestRunner {
     }
 
     private async _openViteUrl(browser: Browser): Promise<void> {
-        const browserInitialize = new P((resolve, reject) => {
+        const browserInitialize = new Promise<void>((resolve, reject) => {
             this._socket.once(BrowserEventNames.initialize, errors => {
                 _.isEmpty(errors) ? resolve() : reject(errors[0]);
             });
@@ -308,7 +307,7 @@ export class TestRunner extends NodejsEnvTestRunner {
         const uri = urljoin(this._config.baseUrl, VITE_RUN_UUID_ROUTE, this._runUuid);
 
         await Promise.all([
-            browserInitialize.timeout(timeout, `Browser didn't connect to the Vite server in ${timeout}ms`),
+            promiseTimeout(browserInitialize, timeout, `Browser didn't connect to the Vite server in ${timeout}ms`),
             browser.publicAPI.url(uri),
         ]);
     }