fix(ct): correctly work in headless mode

Author: DudaGod

src/runner/browser-env/vite/browser-modules/types.ts

@@ -80,10 +80,11 @@ export interface WorkerRunRunnablePayload {
     fullTitle: string;
 }
 
+export type WorkerInitializeCb = (err: null | Error) => void;
 export type WorkerRunRunnableCb = (...args: [null | ViteError[]]) => void;
 
 export interface WorkerViteEvents {
-    [WorkerEventNames.initialize]: (payload: WorkerInitializePayload) => void;
+    [WorkerEventNames.initialize]: (payload: WorkerInitializePayload, cb: WorkerInitializeCb) => void;
     [WorkerEventNames.finalize]: () => void;
     [WorkerEventNames.runRunnable]: (payload: WorkerRunRunnablePayload, cb: WorkerRunRunnableCb) => void;
 }

src/runner/browser-env/vite/socket.ts

@@ -66,11 +66,17 @@ function handleWorkerEvents(
     socket: Socket<ClientViteEvents, ViteClientEvents>,
     io: Server<ClientViteEvents, ViteClientEvents>,
 ): void {
-    socket.on(WorkerEventNames.initialize, payload => {
-        const { runUuid } = socket.handshake.auth;
-        socket.join(runUuid);
+    socket.on(WorkerEventNames.initialize, (payload, cb) => {
+        try {
+            const { runUuid } = socket.handshake.auth;
+            socket.join(runUuid);
 
-        WORKER_ENV_BY_RUN_UUID.set(runUuid, payload);
+            WORKER_ENV_BY_RUN_UUID.set(runUuid, payload);
+
+            cb(null);
+        } catch (err) {
+            cb(prepareError(err as Error));
+        }
     });
 
     socket.on(WorkerEventNames.finalize, () => {

src/worker/browser-env/runner/test-runner/index.ts

@@ -13,7 +13,7 @@ import {
     BRO_INIT_TIMEOUT_ON_RECONNECT,
     BRO_INIT_INTERVAL_ON_RECONNECT,
 } from "./constants";
-import { VITE_RUN_UUID_ROUTE } from "../../../../runner/browser-env/vite/constants";
+import { SOCKET_MAX_TIMEOUT, VITE_RUN_UUID_ROUTE } from "../../../../runner/browser-env/vite/constants";
 import * as logger from "../../../../utils/logger";
 import RuntimeConfig from "../../../../config/runtime-config";
 import { AbortOnReconnectError } from "../../../../errors/abort-on-reconnect-error";
@@ -191,7 +191,7 @@ export class TestRunner extends NodejsEnvTestRunner {
                     this._handleRunExpectMatcher(browser, expectMatchers),
                 );
 
-                this._socket.emit(WorkerEventNames.initialize, {
+                const err = (await this._socket.timeout(SOCKET_MAX_TIMEOUT).emitWithAck(WorkerEventNames.initialize, {
                     file: this._file,
                     sessionId: this._runOpts.sessionId,
                     capabilities: this._runOpts.sessionCaps,
@@ -201,7 +201,11 @@ export class TestRunner extends NodejsEnvTestRunner {
                     customCommands: browser.customCommands,
                     config: this._config as BrowserConfig,
                     expectMatchers: Object.getOwnPropertyNames(expectMatchers),
-                });
+                })) as null | Error;
+
+                if (err) {
+                    throw err;
+                }
 
                 await history.runGroup(
                     {

test/src/worker/browser-env/runner/test-runner/index.ts

@@ -152,7 +152,8 @@ describe("worker/browser-env/runner/test-runner", () => {
 
     const mkSocket_ = (): WorkerViteSocket => {
         const socket = new EventEmitter() as unknown as WorkerViteSocket;
-        socket.emitWithAck = sandbox.stub().resolves([null]);
+        socket.emitWithAck = sandbox.stub().onFirstCall().resolves(null).onSecondCall().resolves([null]);
+
         socket.timeout = sandbox.stub().returnsThis();
 
         sinon.spy(socket, "on");
@@ -362,7 +363,7 @@ describe("worker/browser-env/runner/test-runner", () => {
                     ...runOpts,
                 });
 
-                assert.calledWith(socket.emit as SinonStub, WorkerEventNames.initialize, {
+                assert.calledWith(socket.emitWithAck as SinonStub, WorkerEventNames.initialize, {
                     file,
                     sessionId: runOpts.sessionId,
                     capabilities: runOpts.sessionCaps,
@@ -373,6 +374,19 @@ describe("worker/browser-env/runner/test-runner", () => {
                 });
             });
 
+            it("should throw if master return error", async () => {
+                const socket = mkSocket_();
+                const err = new Error("o.O");
+                (socket.emitWithAck as SinonStub).onFirstCall().resolves(err);
+                socketClientStub.returns(socket);
+
+                const runner = mkRunner_({ file: "/some/file" });
+                const browser = mkBrowser_();
+                (BrowserAgent.prototype.getBrowser as SinonStub).resolves(browser);
+
+                await assert.isRejected(run_({ runner }), /o.O/);
+            });
+
             it(`should emit before open url`, async () => {
                 const socket = mkSocket_();
                 socketClientStub.returns(socket);
@@ -386,7 +400,7 @@ describe("worker/browser-env/runner/test-runner", () => {
                 await runWithEmitBrowserInit(socket, { runner });
 
                 assert.callOrder(
-                    (socket.emit as SinonStub).withArgs(WorkerEventNames.initialize, sinon.match.any),
+                    (socket.emitWithAck as SinonStub).withArgs(WorkerEventNames.initialize, sinon.match.any),
                     browser.publicAPI.url as SinonStub,
                 );
             });
@@ -425,8 +439,6 @@ describe("worker/browser-env/runner/test-runner", () => {
                     const promise = run_();
                     await clock.tickAsync(1);
                     socket.emit(BrowserEventNames.initialize, []);
-
-                    await clock.tickAsync(1);
                     socket.emit(BrowserEventNames.reconnect);
 
                     await clock.runToLastAsync();
@@ -447,8 +459,6 @@ describe("worker/browser-env/runner/test-runner", () => {
                     const promise = run_();
                     await clock.tickAsync(1);
                     socket.emit(BrowserEventNames.initialize, []);
-
-                    await clock.tickAsync(1);
                     socket.emit(BrowserEventNames.reconnect);
                     socket.emit(BrowserEventNames.initialize, [error]);