Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/hocuspocus/src/index.test.ts
T

175 lines
6.4 KiB
TypeScript

import { readFileSync } from "node:fs";
import { dirname, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => {
const listen = vi.fn(async () => undefined);
class MockServer {
static instances: MockServer[] = [];
readonly options: unknown;
readonly listen = listen;
constructor(options: unknown) {
this.options = options;
MockServer.instances.push(this);
}
}
class MockLogger {
readonly options: unknown;
constructor(options: unknown) {
this.options = options;
}
}
return {
MockLogger,
MockServer,
authExtension: { name: "auth-extension" },
assertRlsRuntimeReady: vi.fn(async () => undefined),
createAuthExtension: vi.fn(),
createDatabaseExtension: vi.fn(),
databaseExtension: { name: "database-extension" },
dbClient: { collabDoc: {} },
getHocuspocusRuntimeConfig: vi.fn(),
getWriteDbClient: vi.fn(),
hocuspocusLogger: {
error: vi.fn(),
info: vi.fn(),
},
listen,
};
});
vi.mock("@hocuspocus/server", () => ({ Server: mocks.MockServer }));
vi.mock("@hocuspocus/extension-logger", () => ({ Logger: mocks.MockLogger }));
vi.mock("@hivegrid/db/client.server", () => ({ getWriteDbClient: mocks.getWriteDbClient }));
vi.mock("@hivegrid/db/rls-runtime-readiness.server", () => ({ assertRlsRuntimeReady: mocks.assertRlsRuntimeReady }));
vi.mock("./config.js", () => ({ getHocuspocusRuntimeConfig: mocks.getHocuspocusRuntimeConfig }));
vi.mock("./extensions/auth.js", () => ({ createAuthExtension: mocks.createAuthExtension }));
vi.mock("./extensions/database.js", () => ({ createDatabaseExtension: mocks.createDatabaseExtension }));
vi.mock("./logger.js", () => ({ hocuspocusLogger: mocks.hocuspocusLogger }));
const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), "../package.json");
const processExit = vi.spyOn(process, "exit").mockImplementation((() => undefined) as never);
function packageScripts(): Record<string, string> {
return JSON.parse(readFileSync(packageJsonPath, "utf8")).scripts;
}
describe("hocuspocus entrypoint", () => {
beforeEach(() => {
vi.resetModules();
vi.clearAllMocks();
mocks.MockServer.instances.length = 0;
mocks.listen.mockResolvedValue(undefined);
mocks.createAuthExtension.mockReturnValue(mocks.authExtension);
mocks.createDatabaseExtension.mockReturnValue(mocks.databaseExtension);
mocks.assertRlsRuntimeReady.mockResolvedValue(undefined);
mocks.getWriteDbClient.mockReturnValue(mocks.dbClient);
mocks.getHocuspocusRuntimeConfig.mockReturnValue({
authSecret: "collab-secret",
host: "127.0.0.1",
maxPayloadBytes: 4096,
port: 4321,
});
});
afterEach(() => {
vi.unstubAllGlobals();
});
it("production start script runs compiled Node output without tsx", () => {
const scripts = packageScripts();
expect(scripts.start).toBe("node dist/index.js");
expect(scripts.start).not.toContain("tsx");
});
it("boots a standalone Hocuspocus server with auth and database extensions", async () => {
await import("./index.js");
await vi.waitFor(() => expect(mocks.listen).toHaveBeenCalledTimes(1));
expect(mocks.assertRlsRuntimeReady).toHaveBeenCalledWith(
[mocks.dbClient],
expect.objectContaining({ DATABASE_RUNTIME_ROLE: "hivegrid_app" }),
);
expect(mocks.assertRlsRuntimeReady.mock.invocationCallOrder[0]).toBeLessThan(mocks.listen.mock.invocationCallOrder[0] as number);
expect(mocks.createAuthExtension).toHaveBeenCalledWith({ secret: "collab-secret" });
expect(mocks.createDatabaseExtension).toHaveBeenCalledWith({
db: mocks.dbClient,
maxPayloadBytes: 4096,
});
expect(mocks.MockServer.instances).toHaveLength(1);
expect(mocks.MockServer.instances[0]?.options).toMatchObject({
address: "127.0.0.1",
debounce: 2000,
maxDebounce: 10000,
maxPendingDocuments: 2,
maxUnauthenticatedQueueMessages: 8,
maxUnauthenticatedQueueSize: 4096,
name: "hivegrid-hocuspocus",
port: 4321,
quiet: true,
timeout: 30000,
websocketOptions: { maxPayload: 4096 },
});
expect(mocks.MockServer.instances[0]?.listen).toHaveBeenCalledTimes(1);
expect(mocks.hocuspocusLogger.info).toHaveBeenCalledWith({ port: 4321, host: "127.0.0.1" }, "hocuspocus listening");
});
it("wires Hocuspocus extension logs into the app logger", async () => {
await import("./index.js");
await vi.waitFor(() => expect(mocks.listen).toHaveBeenCalledTimes(1));
const options = mocks.MockServer.instances[0]?.options as { extensions: Array<{ options?: { log?: (message: string) => void } }> };
const loggerExtension = options.extensions[0];
loggerExtension?.options?.log?.("connected");
expect(mocks.hocuspocusLogger.info).toHaveBeenCalledWith({ msg: "connected" }, "hocuspocus");
});
it("logs and exits when auth secret is missing", async () => {
mocks.getHocuspocusRuntimeConfig.mockReturnValue({
authSecret: null,
host: "0.0.0.0",
maxPayloadBytes: 1024,
port: 1234,
});
await import("./index.js");
expect(mocks.hocuspocusLogger.error).toHaveBeenCalledWith("HOCUSPOCUS_AUTH_SECRET is not set — refusing to boot");
expect(processExit).toHaveBeenCalledWith(1);
expect(mocks.assertRlsRuntimeReady).not.toHaveBeenCalled();
expect(mocks.listen).not.toHaveBeenCalled();
});
it("refuses to create or listen on the server when app-role RLS readiness fails", async () => {
const error = new Error("RLS runtime readiness failed");
mocks.assertRlsRuntimeReady.mockRejectedValueOnce(error);
await import("./index.js");
await vi.waitFor(() => expect(mocks.hocuspocusLogger.error).toHaveBeenCalledWith({ err: error }, "hocuspocus failed to start"));
expect(mocks.MockServer.instances).toHaveLength(0);
expect(mocks.listen).not.toHaveBeenCalled();
expect(processExit).toHaveBeenCalledWith(1);
});
it("logs startup failures and exits non-zero", async () => {
const error = new Error("listen failed");
mocks.listen.mockRejectedValueOnce(error);
await import("./index.js");
await vi.waitFor(() => expect(mocks.hocuspocusLogger.error).toHaveBeenCalledWith({ err: error }, "hocuspocus failed to start"));
expect(mocks.hocuspocusLogger.error).toHaveBeenCalledWith({ err: error }, "hocuspocus failed to start");
expect(processExit).toHaveBeenCalledWith(1);
});
});