Build your personal knowledge base with Trilium Notes
TypeScript electronelectron-appknowledge-baseknowledge-graphknowledge-managementknowledge-management-graphlocal-firstnote-managmentnote-takernote-takingnotebooknotesnotes-apppersonal-knowledge-basepersonal-wikiscriptableself-hostedself-hostingwiki
import type { WebSocketMessage } from "@triliumnext/commons";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
const OPEN = 1;
const CLOSED = 3;
type Handler = (...args: any[]) => void;
const { state, getLogMock, configMock, randomStringMock, WebSocketServerMock } = vi.hoisted(() => {
const state: { instances: any[] } = { instances: [] };
class WebSocketServerMock {
options: any;
clients = new Set<any>();
handlers: Record<string, (...a: any[]) => void> = {};
closed = false;
constructor(options: any) {
this.options = options;
state.instances.push(this);
}
on(event: string, cb: (...a: any[]) => void) {
this.handlers[event] = cb;
return this;
}
emit(event: string, ...args: any[]) {
return this.handlers[event]?.(...args);
}
close() {
this.closed = true;
}
}
return {
state,
WebSocketServerMock,
getLogMock: { error: vi.fn(), info: vi.fn() },
configMock: { General: { noAuthentication: false } as { noAuthentication: boolean } | undefined },
randomStringMock: vi.fn(() => "client-id")
};
});
vi.mock("ws", () => ({
WebSocketServer: WebSocketServerMock,
WebSocket: { OPEN: 1 } // keep in sync with the module-level OPEN constant
}));
vi.mock("./config.js", () => ({ default: configMock }));
vi.mock("./utils.js", () => ({ randomString: randomStringMock }));
vi.mock("@triliumnext/core", async () => {
// use the real shouldLogMessage so the suppression tests cover the actual filter
const { shouldLogMessage } = await vi.importActual<typeof import("@triliumnext/core/src/services/messaging/index.js")>(
"@triliumnext/core/src/services/messaging/index.js"
);
return { getLog: () => getLogMock, shouldLogMessage };
});
import WebSocketMessagingProvider, { isHttpAttachableMessagingProvider } from "./ws_messaging_provider.js";
function makeSocket(readyState = OPEN) {
const handlers: Record<string, Handler> = {};
return {
readyState,
sent: [] as string[],
handlers,
on(event: string, cb: Handler) {
handlers[event] = cb;
return this;
},
send(data: string) {
this.sent.push(data);
},
closed: false,
close() {
this.closed = true;
},
emit(event: string, ...args: any[]) {
return handlers[event]?.(...args);
}
};
}
describe("WebSocketMessagingProvider", () => {
let provider: WebSocketMessagingProvider;
beforeEach(() => {
provider = new WebSocketMessagingProvider();
state.instances = [];
getLogMock.error.mockClear();
getLogMock.info.mockClear();
configMock.General = { noAuthentication: false };
randomStringMock.mockReturnValue("client-id");
vi.spyOn(console, "log").mockImplementation(() => {});
});
afterEach(() => {
vi.restoreAllMocks();
});
it("is recognised as HTTP-attachable (the capability www.ts gates the WS server on)", () => {
expect(isHttpAttachableMessagingProvider(provider)).toBe(true);
// A plain IPC-style provider without attachToHttpServer must not qualify.
expect(isHttpAttachableMessagingProvider({
sendMessageToAllClients() {},
sendMessageToClient: () => false,
setClientMessageHandler() {}
})).toBe(false);
});
function init() {
const httpServer = {} as any;
const sessionParser = vi.fn((_req: any, _params: any, cb: () => void) => cb());
provider.attachToHttpServer(httpServer, sessionParser as any);
return { server: state.instances[0], sessionParser };
}
describe("init / verifyClient", () => {
it("allows a logged-in session", () => {
const { server } = init();
const done = vi.fn();
server.options.verifyClient({ req: { session: { loggedIn: true } } }, done);
expect(done).toHaveBeenCalledWith(true);
expect(getLogMock.error).not.toHaveBeenCalled();
});
it("allows when authentication is disabled", () => {
configMock.General = { noAuthentication: true };
const { server } = init();
const done = vi.fn();
server.options.verifyClient({ req: { session: { loggedIn: false } } }, done);
expect(done).toHaveBeenCalledWith(true);
});
it("rejects and logs when not logged in and auth is required", () => {
const { server } = init();
const done = vi.fn();
server.options.verifyClient({ req: { session: { loggedIn: false } } }, done);
expect(done).toHaveBeenCalledWith(false);
expect(getLogMock.error).toHaveBeenCalled();
});
it("rejects when the config has no General section", () => {
configMock.General = undefined;
const { server } = init();
const done = vi.fn();
server.options.verifyClient({ req: { session: { loggedIn: false } } }, done);
// `config.General && config.General.noAuthentication` short-circuits to a
// falsy value, so the connection is not allowed.
expect(done.mock.calls[0][0]).toBeFalsy();
});
});
describe("connection lifecycle", () => {
it("tracks a connected client, dispatches messages, and untracks on close", async () => {
const { server } = init();
const handler = vi.fn();
provider.setClientMessageHandler(handler);
const ws = makeSocket();
server.emit("connection", ws, {});
expect(provider.getClientCount()).toBe(0); // server.clients still empty (we manage map)
expect(provider.sendMessageToClient("client-id", { type: "ping" } as any)).toBe(true);
await Promise.resolve(ws.emit("message", JSON.stringify({ type: "hello" })));
expect(handler).toHaveBeenCalledWith("client-id", { type: "hello" });
ws.emit("close");
expect(provider.sendMessageToClient("client-id", { type: "ping" } as any)).toBe(false);
});
it("ignores incoming messages when no handler is registered", async () => {
const { server } = init();
const ws = makeSocket();
server.emit("connection", ws, {});
// With no handler registered the message listener parses the payload
// and returns (undefined) without dispatching — emitting must not throw.
expect(ws.emit("message", JSON.stringify({ type: "x" }))).toBeUndefined();
await Promise.resolve(); // let the fire-and-forget async body settle
});
it("logs server errors via the error handler", () => {
const { server } = init();
expect(() => server.emit("error", new Error("ws boom"))).not.toThrow();
});
it("handles a per-connection error without throwing and untracks the client", () => {
// A protocol error on a single socket (e.g. WS_ERR_INVALID_CLOSE_CODE) must not
// bubble up as an uncaught exception that crashes the process. See issue #9598.
const { server } = init();
const ws = makeSocket();
server.emit("connection", ws, {});
expect(provider.sendMessageToClient("client-id", { type: "ping" } as any)).toBe(true);
expect(() => ws.emit("error", new Error("WS_ERR_INVALID_CLOSE_CODE"))).not.toThrow();
expect(provider.sendMessageToClient("client-id", { type: "ping" } as any)).toBe(false);
});
});
describe("sendMessageToAllClients", () => {
it("sends to OPEN clients and logs non-suppressed message types", () => {
const { server } = init();
const open = makeSocket(OPEN);
const closed = makeSocket(CLOSED);
server.clients.add(open);
server.clients.add(closed);
provider.sendMessageToAllClients({ type: "sync-finished" } as WebSocketMessage);
expect(open.sent).toHaveLength(1);
expect(closed.sent).toHaveLength(0);
expect(getLogMock.info).toHaveBeenCalled();
});
it("does not log for suppressed message types", () => {
const { server } = init();
const open = makeSocket(OPEN);
server.clients.add(open);
provider.sendMessageToAllClients({ type: "frontend-update" } as WebSocketMessage);
provider.sendMessageToAllClients({ type: "sync-failed" } as WebSocketMessage);
provider.sendMessageToAllClients({ type: "api-log-messages" } as WebSocketMessage);
expect(getLogMock.info).not.toHaveBeenCalled();
// suppressing the log must not suppress delivery
expect(open.sent).toHaveLength(3);
});
it("is a no-op when the server is not initialized", () => {
expect(() =>
provider.sendMessageToAllClients({ type: "frontend-update" } as WebSocketMessage)
).not.toThrow();
expect(getLogMock.info).not.toHaveBeenCalled();
});
});
describe("disconnectAllClients", () => {
it("asks every open client to reload, then closes every connection", () => {
const { server } = init();
const open = makeSocket(OPEN);
const closed = makeSocket(CLOSED);
server.clients.add(open);
server.clients.add(closed);
provider.disconnectAllClients("password changed");
expect(open.sent.map((data) => JSON.parse(data))).toEqual([
{ type: "reload-frontend", reason: "password changed" }
]);
expect(closed.sent).toHaveLength(0);
expect(open.closed).toBe(true);
expect(closed.closed).toBe(true);
});
it("is a no-op when the server is not initialized", () => {
expect(() => provider.disconnectAllClients("password changed")).not.toThrow();
});
});
describe("sendMessageToClient", () => {
it("returns false for an unknown client", () => {
init();
expect(provider.sendMessageToClient("missing", { type: "ping" } as any)).toBe(false);
});
it("returns false for a client that is not OPEN", () => {
const { server } = init();
const ws = makeSocket(CLOSED);
server.emit("connection", ws, {});
expect(provider.sendMessageToClient("client-id", { type: "ping" } as any)).toBe(false);
});
it("sends and returns true for an OPEN client", () => {
const { server } = init();
const ws = makeSocket(OPEN);
server.emit("connection", ws, {});
expect(provider.sendMessageToClient("client-id", { type: "ping" } as any)).toBe(true);
expect(ws.sent).toHaveLength(1);
});
});
describe("getClientCount", () => {
it("returns the server's client set size", () => {
const { server } = init();
server.clients.add(makeSocket());
server.clients.add(makeSocket());
expect(provider.getClientCount()).toBe(2);
});
it("returns 0 when the server is not initialized", () => {
expect(provider.getClientCount()).toBe(0);
});
});
describe("dispose", () => {
it("closes the server and clears the client map", () => {
const { server } = init();
const ws = makeSocket(OPEN);
server.emit("connection", ws, {});
provider.dispose();
expect(server.closed).toBe(true);
// After dispose, server is still referenced but map is cleared.
expect(provider.sendMessageToClient("client-id", { type: "ping" } as any)).toBe(false);
});
it("is safe to call before init", () => {
expect(() => provider.dispose()).not.toThrow();
});
});
});