perf: speed up creating sessions

KuznetsovRoman · KuznetsovRoman · commit c30dd643987e · 2025-07-29T17:59:22.000+03:00
diff --git a/src/browser/browser.ts b/src/browser/browser.ts
@@ -25,7 +25,7 @@ const CUSTOM_SESSION_OPTS = [
     "user",
     "key",
     "region",
-];
+] as const;
 
 export type BrowserOpts = {
     id: string;
@@ -122,7 +122,9 @@ export class Browser {
         });
     }
 
-    protected _getSessionOptsFromConfig(optNames = CUSTOM_SESSION_OPTS): Record<string, unknown> {
+    protected _getSessionOptsFromConfig(
+        optNames: ReadonlyArray<(typeof CUSTOM_SESSION_OPTS)[number]> = CUSTOM_SESSION_OPTS,
+    ): Record<string, unknown> {
         return optNames.reduce((options: Record<string, unknown>, optName) => {
             if (optName === "transformRequest") {
                 options[optName] = (req: RequestOptions): RequestOptions => {
diff --git a/src/browser/existing-browser.ts b/src/browser/existing-browser.ts
@@ -19,8 +19,6 @@ import { NEW_ISSUE_LINK } from "../constants/help";
 import type { Options } from "@testplane/wdio-types";
 import { runWithoutHistory } from "./history";
 
-const OPTIONAL_SESSION_OPTS = ["transformRequest", "transformResponse"];
-
 interface SessionOptions {
     sessionId: string;
     sessionCaps?: WebdriverIO.Capabilities;
@@ -232,7 +230,7 @@ export class ExistingBrowser extends Browser {
         const opts: AttachOptions = {
             sessionId,
             ...sessionOpts,
-            ...this._getSessionOptsFromConfig(OPTIONAL_SESSION_OPTS),
+            ...this._getSessionOptsFromConfig(["transformRequest", "transformResponse"]),
             ...detectedSessionEnvFlags,
             ...this._config.sessionEnvFlags,
             options: sessionOpts,
diff --git a/src/browser/new-browser.ts b/src/browser/new-browser.ts
@@ -1,8 +1,10 @@
 import { URLSearchParams } from "url";
 import URI from "urijs";
 import { isBoolean, assign, isEmpty, set } from "lodash";
-import { remote } from "@testplane/webdriverio";
-import type { Capabilities } from "@testplane/wdio-types";
+import { WebDriver } from "@testplane/webdriver";
+import { sessionEnvironmentDetector } from "@testplane/wdio-utils";
+import { attach, remote } from "@testplane/webdriverio";
+import type { Capabilities, Options } from "@testplane/wdio-types";
 
 import { Browser, BrowserOpts } from "./browser";
 import signalHandler from "../signal-handler";
@@ -104,9 +106,62 @@ export class NewBrowser extends Browser {
     }
 
     protected async _createSession(): Promise<WebdriverIO.Browser> {
-        const sessionOpts = await this._getSessionOpts();
+        if (this._isDevtools()) {
+            return this._getSessionOpts().then(remote);
+        }
+
+        let sessionOptsException = null;
+        const sessionOptsPromise = this._getSessionOpts() // starts installing browsers + launching driver process...
+            .catch(exception => {
+                sessionOptsException = exception;
+            });
+
+        const isUsingThirtPartyGrid = typeof this._config.user === "string" && typeof this._config.key === "string";
+        let thirdPartyGridCustomOptions = {};
+
+        if (isUsingThirtPartyGrid && !this._isLocalGridUrl()) {
+            const gridUri = new URI(this._config.gridUrl);
+
+            thirdPartyGridCustomOptions = await import("./third-party-grid").then(m =>
+                m.detectBackend({
+                    port: gridUri.port() ? parseInt(gridUri.port(), 10) : DEFAULT_PORT,
+                    hostname: this._getGridHost(gridUri),
+                    user: this._config.user,
+                    key: this._config.key,
+                    protocol: gridUri.protocol(),
+                    region: this._config.region as Options.SauceRegions | undefined,
+                    path: gridUri.path(),
+                    capabilities: this._config.desiredCapabilities, // we dont need exact caps here
+                }),
+            );
+        }
 
-        return remote(sessionOpts);
+        const sessionOpts = await sessionOptsPromise;
+
+        if (sessionOptsException) {
+            throw sessionOptsException;
+        }
+
+        const fullSessionOpts = Object.assign(sessionOpts!, thirdPartyGridCustomOptions);
+        const session = await WebDriver.newSession(fullSessionOpts).then(res => {
+            return res;
+        });
+
+        const detectedSessionEnvFlags = sessionEnvironmentDetector({
+            capabilities: session.capabilities,
+            requestedCapabilities: fullSessionOpts.capabilities,
+        });
+
+        return attach({
+            sessionId: session.sessionId,
+            ...session.options,
+            ...this._getSessionOptsFromConfig(["transformRequest", "transformResponse"]),
+            ...detectedSessionEnvFlags,
+            ...this._config.sessionEnvFlags,
+            options: session.options,
+            capabilities: session.capabilities,
+            requestedCapabilities: fullSessionOpts.capabilities as WebdriverIO.Capabilities,
+        });
     }
 
     protected async _setPageLoadTimeout(): Promise<void> {
@@ -133,6 +188,10 @@ export class NewBrowser extends Browser {
         return this._config.gridUrl === LOCAL_GRID_URL || getInstance().local;
     }
 
+    protected _isDevtools(): boolean {
+        return this._config.automationProtocol === DEVTOOLS_PROTOCOL || getInstance().devtools;
+    }
+
     protected async _getSessionOpts(): Promise<Capabilities.WebdriverIOConfig> {
         const config = this._config;
 
@@ -150,16 +209,14 @@ export class NewBrowser extends Browser {
 
         const capabilities = await this._extendCapabilities(config);
 
-        const { devtools } = getInstance();
-
         const options = {
             protocol: gridUri.protocol(),
             hostname: this._getGridHost(gridUri),
             port: gridUri.port() ? parseInt(gridUri.port(), 10) : DEFAULT_PORT,
             path: gridUri.path(),
             queryParams: this._getQueryParams(gridUri.query()),
             capabilities,
-            automationProtocol: devtools ? DEVTOOLS_PROTOCOL : config.automationProtocol,
+            automationProtocol: this._isDevtools() ? DEVTOOLS_PROTOCOL : config.automationProtocol,
             connectionRetryTimeout: config.sessionRequestTimeout || config.httpTimeout,
             connectionRetryCount: 3,
             baseUrl: config.baseUrl,
diff --git a/src/browser/third-party-grid.ts b/src/browser/third-party-grid.ts
@@ -0,0 +1,152 @@
+// https://github.com/webdriverio/webdriverio/blob/ed92a6f2abfc55b3c4ae887a222371554a7ada61/packages/webdriverio/src/utils/driver.ts
+import type { Capabilities, Options } from "@testplane/wdio-types";
+
+const DEFAULT_HOSTNAME = "127.0.0.1";
+const DEFAULT_PORT = 4444;
+const DEFAULT_PROTOCOL = "http";
+const DEFAULT_PATH = "/";
+const LEGACY_PATH = "/wd/hub";
+
+const REGION_MAPPING = {
+    us: "us-west-1.", // default endpoint
+    eu: "eu-central-1.",
+    "eu-central-1": "eu-central-1.",
+    "us-east-4": "us-east-4.",
+};
+
+interface BackendConfigurations {
+    port?: number;
+    hostname?: string;
+    user?: string | null;
+    key?: string | null;
+    protocol?: string;
+    region?: Options.SauceRegions | null;
+    path?: string;
+    capabilities?: Capabilities.RequestedStandaloneCapabilities | null;
+}
+
+function getSauceEndpoint(
+    region: keyof typeof REGION_MAPPING,
+    { isRDC, isVisual }: { isRDC?: boolean; isVisual?: boolean } = {},
+): string {
+    const shortRegion = REGION_MAPPING[region] ? region : "us";
+    if (isRDC) {
+        return `${shortRegion}1.appium.testobject.com`;
+    } else if (isVisual) {
+        return "hub.screener.io";
+    }
+
+    return `ondemand.${REGION_MAPPING[shortRegion]}saucelabs.com`;
+}
+
+export function detectBackend({
+    port,
+    hostname,
+    user,
+    key,
+    protocol,
+    region,
+    path,
+    capabilities,
+}: BackendConfigurations = {}): Partial<BackendConfigurations> {
+    /**
+     * browserstack
+     * e.g. zHcv9sZ39ip8ZPsxBVJ2
+     */
+    if (typeof user === "string" && typeof key === "string" && key.length === 20) {
+        return {
+            protocol: protocol || "https",
+            hostname: hostname || "hub-cloud.browserstack.com",
+            port: port || 443,
+            path: path || LEGACY_PATH,
+        };
+    }
+
+    /**
+     * testingbot
+     * e.g. ec337d7b677720a4dde7bd72be0bfc67
+     */
+    if (typeof user === "string" && typeof key === "string" && key.length === 32) {
+        return {
+            protocol: protocol || "https",
+            hostname: hostname || "hub.testingbot.com",
+            port: port || 443,
+            path: path || LEGACY_PATH,
+        };
+    }
+
+    /**
+     * Sauce Labs
+     * e.g. 50aa152c-1932-B2f0-9707-18z46q2n1mb0
+     *
+     * For Sauce Labs Legacy RDC we only need to determine if the sauce option has a `testobject_api_key`.
+     * Same for Sauce Visual where an apiKey can be passed in through the capabilities (soon to be legacy too).
+     */
+    const isVisual = Boolean(
+        !Array.isArray(capabilities) &&
+            capabilities &&
+            (capabilities as WebdriverIO.Capabilities)["sauce:visual"]?.apiKey,
+    );
+    if (
+        (typeof user === "string" && typeof key === "string" && key.length === 36) ||
+        // Or only RDC or visual
+        isVisual
+    ) {
+        const sauceRegion = region as keyof typeof REGION_MAPPING;
+
+        return {
+            protocol: protocol || "https",
+            hostname: hostname || getSauceEndpoint(sauceRegion, { isVisual }),
+            port: port || 443,
+            path: path || LEGACY_PATH,
+        };
+    }
+
+    /**
+     * Lambdatest
+     * e.g. cYAjKrqGwyPjPQv41ICDF4C5OjlxzA9epZsnugVJJxqOReWRWU
+     */
+    if (typeof user === "string" && typeof key === "string" && key.length === 50) {
+        return {
+            protocol: protocol || DEFAULT_PROTOCOL,
+            hostname: hostname || "hub.lambdatest.com",
+            port: port || 80,
+            path: path || LEGACY_PATH,
+        };
+    }
+
+    if (
+        /**
+         * user and key are set in config
+         */
+        (typeof user === "string" || typeof key === "string") &&
+        /**
+         * but no custom WebDriver endpoint was configured
+         */
+        !hostname
+    ) {
+        throw new Error(
+            'A "user" or "key" was provided but could not be connected to a ' +
+                "known cloud service (Sauce Labs, Browerstack, Testingbot or Lambdatest). " +
+                "Please check if given user and key properties are correct!",
+        );
+    }
+
+    /**
+     * default values if on of the WebDriver criticial options is set
+     */
+    if (hostname || port || protocol || path) {
+        return {
+            hostname: hostname || DEFAULT_HOSTNAME,
+            port: port || DEFAULT_PORT,
+            protocol: protocol || DEFAULT_PROTOCOL,
+            path: path || DEFAULT_PATH,
+        };
+    }
+
+    /**
+     * no cloud provider detected, pass on provided params and eventually
+     * fallback to DevTools protocol
+     */
+    return { hostname, port, protocol, path };
+}
diff --git a/src/testplane.ts b/src/testplane.ts
@@ -18,7 +18,7 @@ import { isRunInNodeJsEnv } from "./utils/config";
 import { initDevServer } from "./dev-server";
 import { ConfigInput } from "./config/types";
 import { MasterEventHandler, Test, TestResult } from "./types";
-import { preloadWebdriverIO } from "./utils/preload-utils";
+import { preloadWebdriver, preloadWebdriverIO } from "./utils/preload-utils";
 
 interface RunOpts {
     browsers: string[];
@@ -138,7 +138,7 @@ export class Testplane extends BaseTestplane {
 
         runner.init();
 
-        preloadWebdriverIO();
+        preloadWebdriver().then(preloadWebdriverIO);
 
         await runner.run(
             await this._readTests(testPaths, { browsers, sets, grep, replMode }),
diff --git a/src/utils/preload-utils.ts b/src/utils/preload-utils.ts
@@ -1,5 +1,9 @@
 import { loadEsm } from "load-esm";
 
+export const preloadWebdriver = async (): Promise<void> => {
+    await loadEsm("@testplane/webdriver").catch(() => {});
+};
+
 export const preloadWebdriverIO = async (): Promise<void> => {
     await loadEsm("@testplane/webdriverio").catch(() => {});
 };
diff --git a/test/src/browser/history/index.js b/test/src/browser/history/index.js
@@ -1,6 +1,5 @@
 "use strict";
 
-const webdriver = require("@testplane/webdriver");
 const webdriverio = require("@testplane/webdriverio");
 const proxyquire = require("proxyquire");
 const { Callstack } = require("../../../../src/browser/history/callstack");
@@ -199,21 +198,19 @@ describe("commands-history", () => {
             });
         };
 
-        describe("Browser", () => {
+        describe("ExistingBrowser", () => {
             let browser;
 
             beforeEach(async () => {
-                sandbox.stub(webdriverio, "remote").resolves(mkSessionStub_());
                 sandbox.stub(webdriverio, "attach").resolves(mkSessionStub_());
-                sandbox.stub(webdriver.WebDriver, "newSession").resolves(mkSessionStub_());
                 const ExistingBrowser = proxyquire("src/browser/existing-browser", {
                     "./client-bridge": {
                         build: sandbox.stub().resolves(),
                     },
                 }).ExistingBrowser;
-                browser = mkExistingBrowser_({ saveHistory: true }, void 0, ExistingBrowser);
+                browser = mkExistingBrowser_({ saveHistory: true }, undefined, ExistingBrowser);
 
-                await browser.init({ sessionId: "session-id", sessionCaps: {}, sessionOpts: { capabilities: {} } });
+                await browser.init({ sessionOpts: {}, sessionCaps: {} });
             });
 
             mkTestsSet(() => browser, "addCommand");
diff --git a/test/src/browser/new-browser.js b/test/src/browser/new-browser.js
