146 lines
4.8 KiB
TypeScript
146 lines
4.8 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" },
|
|
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("./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.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");
|
|
|
|
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,
|
|
name: "hivegrid-hocuspocus",
|
|
port: 4321,
|
|
quiet: true,
|
|
timeout: 30000,
|
|
});
|
|
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");
|
|
|
|
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);
|
|
});
|
|
|
|
it("logs startup failures and exits non-zero", async () => {
|
|
const error = new Error("listen failed");
|
|
mocks.listen.mockRejectedValueOnce(error);
|
|
|
|
await import("./index.js");
|
|
|
|
expect(mocks.hocuspocusLogger.error).toHaveBeenCalledWith({ err: error }, "hocuspocus failed to start");
|
|
expect(processExit).toHaveBeenCalledWith(1);
|
|
});
|
|
});
|