test.build/core/factories/server.factory.test.ts

test.build/core/factories/server.factory.test.ts is a file in Codebase Testing. 78 lines of code and 0 definitions.

import { describe, expect, it, vi } from "vitest";
import { devServers, releaseServer, withModuleServer } from "@banes-lab/build-scripts/core/factories/server.factory.ts";
import { type ViteDevServer, createServer } from "vite";
import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { DEV_ARGV } from "@banes-lab/build-scripts/configuration/constants/server.constants.ts";
import { join } from "node:path";
import { tmpdir } from "node:os";

const SITE_PORT = 4202;
const SOCIAL_PORT = 4203;
const MODULE_FILE = "probe.ts";
const MODULE_URL = `/${MODULE_FILE}`;

vi.mock("@ssot/secrets", () => ({ portOf: (key: string) => (key === "SITE_DEV_PORT" ? SITE_PORT : SOCIAL_PORT) }));

const transformsOf = function transformsOf(server: ViteDevServer): readonly unknown[] {
    return [...server.environments.ssr.moduleGraph.idToModuleMap.values()].map((node) => node.transformResult);
};

describe("withModuleServer", () => {
    it("runs the work on a middleware-mode server at the root, then drops every transform and closes it", async () => {
        const root = mkdtempSync(join(tmpdir(), "module-server-"));
        writeFileSync(join(root, MODULE_FILE), "export const PROBE: number = 1;\n");
        try {
            let held: ViteDevServer | null = null;
            const during = await withModuleServer(root, async (server) => {
                held = server;
                expect(server.config.root.split("\\").join("/")).toBe(root.split("\\").join("/"));
                expect(server.config.server.middlewareMode).toBe(true);
                await server.environments.ssr.transformRequest(MODULE_URL);
                return transformsOf(server);
            });
            expect(during.length).toBe(1);
            expect(during.every((result) => result !== null)).toBe(true);
            expect(held).not.toBeNull();
            if (held !== null) {
                expect(transformsOf(held).every((result) => result === null)).toBe(true);
            }
        } finally {
            rmSync(root, { force: true, recursive: true });
        }
    });

    it("releases the server when the work fails, and passes the failure on", async () => {
        const root = mkdtempSync(join(tmpdir(), "module-server-"));
        try {
            await expect(
                withModuleServer(root, async () => {
                    await Promise.resolve();
                    throw new Error("work failed");
                }),
            ).rejects.toThrow("work failed");
        } finally {
            rmSync(root, { force: true, recursive: true });
        }
    });
});

describe("releaseServer", () => {
    it("drops every transform a server holds and closes it", async () => {
        const root = mkdtempSync(join(tmpdir(), "module-server-"));
        writeFileSync(join(root, MODULE_FILE), "export const PROBE: number = 1;\n");
        const server = await createServer({ appType: "custom", configFile: false, logLevel: "error", root });
        try {
            await server.environments.ssr.transformRequest(MODULE_URL);
            expect(transformsOf(server).every((result) => result !== null)).toBe(true);
            await releaseServer(server);
            expect(transformsOf(server).every((result) => result === null)).toBe(true);
        } finally {
            rmSync(root, { force: true, recursive: true });
        }
    });
});

describe("devServers", () => {
    it("runs the site on the port the environment declares with --host, and the social share on its own", () => {
        const servers = devServers();
        expect(servers.map((server) => [server.label, server.port, server.args])).toStrictEqual([
            ["site", SITE_PORT, ["--host"]],
            ["social", SOCIAL_PORT, []],
        ]);
        expect(servers.every((server) => server.config.endsWith("vite.config.ts"))).toBe(true);
        expect(DEV_ARGV.flags).toStrictEqual([]);
    });
});