fix(ct): run vite server once on init

Author: DudaGod

src/runner/browser-env/index.ts

@@ -13,7 +13,9 @@ import { plugin as generateIndexHtml } from "./plugins/generate-index-html";
 import { plugin as mockPlugin } from "./plugins/mock";
 import { ManualMock } from "./manual-mock";
 import { Config } from "../../../config";
+import RuntimeConfig from "../../../config/runtime-config";
 import { VITE_DEFAULT_CONFIG_ENV } from "./constants";
+import defaults from "../../../config/defaults";
 
 import type { ViteDevServer, UserConfig, InlineConfig } from "vite";
 import type { BrowserTestRunEnvOptions } from "./types";
@@ -76,6 +78,8 @@ export class ViteServer {
 
         await this._server.listen();
 
+        this._useBaseUrlFromVite();
+
         logger.log(chalk.green(`Vite server started on ${this.baseUrl}`));
     }
 
@@ -115,4 +119,21 @@ export class ViteServer {
     get baseUrl(): string | undefined {
         return this._server?.resolvedUrls!.local[0];
     }
+
+    private _useBaseUrlFromVite(): void {
+        const viteBaseUrl = this.baseUrl!;
+        const defaultBaseUrl = defaults.baseUrl;
+
+        RuntimeConfig.getInstance().extend({ viteBaseUrl });
+
+        if (this._testplaneConfig.baseUrl === defaultBaseUrl) {
+            this._testplaneConfig.baseUrl = viteBaseUrl;
+        }
+
+        for (const broConfig of Object.values(this._testplaneConfig.browsers)) {
+            if (broConfig.baseUrl === defaultBaseUrl) {
+                broConfig.baseUrl = viteBaseUrl;
+            }
+        }
+    }
 }

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

@@ -3,8 +3,7 @@ import _ from "lodash";
 import fs from "fs-extra";
 import { Stats as RunnerStats } from "./stats";
 import { BaseTestplane } from "./base-testplane";
-import type { MainRunner as NodejsEnvRunner } from "./runner";
-import type { MainRunner as BrowserEnvRunner } from "./runner/browser-env";
+import type { MainRunner } from "./runner";
 import RuntimeConfig from "./config/runtime-config";
 import { MasterAsyncEvents, MasterEvents, MasterSyncEvents } from "./events";
 import eventsUtils from "./events/utils";
@@ -19,6 +18,7 @@ import { initDevServer } from "./dev-server";
 import { ConfigInput } from "./config/types";
 import { MasterEventHandler, Test, TestResult } from "./types";
 import { preloadWebdriverIO } from "./utils/preload-utils";
+import { ViteServer } from "./runner/browser-env/vite/server";
 
 interface RunOpts {
     browsers: string[];
@@ -70,14 +70,16 @@ export interface Testplane {
 export class Testplane extends BaseTestplane {
     protected failed: boolean;
     protected failedList: FailedListItem[];
-    protected runner: NodejsEnvRunner | BrowserEnvRunner | null;
+    protected runner: MainRunner | null;
+    protected viteServer: ViteServer | null;
 
     constructor(config?: string | ConfigInput) {
         super(config);
 
         this.failed = false;
         this.failedList = [];
         this.runner = null;
+        this.viteServer = null;
     }
 
     extendCli(parser: Command): void {
@@ -91,6 +93,15 @@ export class Testplane extends BaseTestplane {
             configPath: this._config.configPath,
         });
 
+        if (!isRunInNodeJsEnv(this._config)) {
+            try {
+                this.viteServer = ViteServer.create(this._config);
+                await this.viteServer.start();
+            } catch (err) {
+                throw new Error(`Vite server failed to start: ${(err as Error).message}`);
+            }
+        }
+
         return super._init();
     }
 
@@ -126,9 +137,7 @@ export class Testplane extends BaseTestplane {
             this._config.system.mochaOpts.timeout = 0;
         }
 
-        const RunnerClass = isRunInNodeJsEnv(this._config)
-            ? await import("./runner").then(m => m.MainRunner)
-            : await import("./runner/browser-env").then(m => m.MainRunner);
+        const RunnerClass = await import("./runner").then(m => m.MainRunner);
 
         const runner = RunnerClass.create(this._config, this._interceptors);
         this.runner = runner;
@@ -257,6 +266,10 @@ export class Testplane extends BaseTestplane {
             }, timeout).unref();
         }
 
+        if (this.viteServer) {
+            this.viteServer.close();
+        }
+
         if (this.runner) {
             this.runner.cancel();
         }

src/testplane.ts

@@ -1,6 +1,5 @@
 import type { Events } from "../events";
-import type { MainRunner as NodejsEnvRunner } from "../runner";
-import type { MainRunner as BrowserEnvRunner } from "../runner/browser-env/index";
+import type { MainRunner } from "../runner";
 import type { TestCollection } from "../test-collection";
 import type { Test } from "../test-reader/test-object/test";
 import type { Suite } from "../test-reader/test-object/suite";
@@ -219,7 +218,7 @@ export interface SnapshotsData {
 
 export type MasterEventHandler<T extends BaseTestplane> = {
     (event: Events["INIT"], callback: () => Promise<void> | void): T;
-    (event: Events["RUNNER_START"], callback: (runner: NodejsEnvRunner | BrowserEnvRunner) => Promise<void> | void): T;
+    (event: Events["RUNNER_START"], callback: (runner: MainRunner) => Promise<void> | void): T;
     (event: Events["RUNNER_END"], callback: (result: StatsResult) => Promise<void> | void): T;
     (event: Events["SESSION_START"], callback: AsyncSessionEventCallback): T;
     (event: Events["SESSION_END"], callback: AsyncSessionEventCallback): T;

src/types/index.ts

@@ -7,10 +7,12 @@ import { ViteServer } from "../../../../../src/runner/browser-env/vite/server";
 import { ManualMock } from "../../../../../src/runner/browser-env/vite/manual-mock";
 import { makeConfigStub } from "../../../../utils";
 import { BROWSER_TEST_RUN_ENV } from "../../../../../src/constants/config";
+import defaults from "../../../../../src/config/defaults";
+import { promiseDelay } from "../../../../../src/utils/promise";
+import RuntimeConfig from "../../../../../src/config/runtime-config";
 
 import type { Config } from "../../../../../src/config";
 import type { BrowserTestRunEnvOptions } from "../../../../../src/runner/browser-env/vite/types";
-import { promiseDelay } from "../../../../../src/utils/promise";
 
 describe("runner/browser-env/vite/server", () => {
     const sandbox = sinon.createSandbox();
@@ -54,6 +56,8 @@ describe("runner/browser-env/vite/server", () => {
         mockPlugin = sandbox.stub().returns([{ name: "default-plugin-2" }]);
         sandbox.stub(ManualMock, "create").resolves(sinon.stub() as unknown as ManualMock);
 
+        sandbox.stub(RuntimeConfig, "getInstance").returns({ extend: sandbox.stub() });
+
         ({ ViteServer: ViteServerStub } = proxyquire("../../../../../src/runner/browser-env/vite/server", {
             "get-port": getPortStub,
             "./socket": { createSocketServer },
@@ -222,6 +226,45 @@ describe("runner/browser-env/vite/server", () => {
             assert.callOrder(createSocketServer, viteServer.listen as SinonStub);
         });
 
+        it("should save vite base url to runtime config", async () => {
+            const viteBaseUrl = "http://localhost:4444";
+            const viteServer = mkViteServer_({
+                resolvedUrls: {
+                    local: [viteBaseUrl],
+                    network: [],
+                },
+            });
+            (Vite.createServer as SinonStub).resolves(viteServer);
+
+            await ViteServerStub.create(mkConfig_()).start();
+
+            assert.calledWith((RuntimeConfig.getInstance as SinonStub).lastCall.returnValue.extend, {
+                viteBaseUrl,
+            });
+        });
+
+        it("should use base url from vite", async () => {
+            const viteBaseUrl = "http://localhost:4444";
+            const viteServer = mkViteServer_({
+                resolvedUrls: {
+                    local: [viteBaseUrl],
+                    network: [],
+                },
+            });
+            (Vite.createServer as SinonStub).resolves(viteServer);
+
+            const config = makeConfigStub({
+                baseUrl: defaults.baseUrl,
+                browsers: ["b1", "b2"],
+            }) as Config;
+
+            await ViteServerStub.create(config).start();
+
+            assert.equal(config.baseUrl, viteBaseUrl);
+            assert.equal(config.browsers.b1.baseUrl, viteBaseUrl);
+            assert.equal(config.browsers.b2.baseUrl, viteBaseUrl);
+        });
+
         it("should inform on which address vite server started", async () => {
             const viteServer = mkViteServer_({
                 resolvedUrls: {