@serverkgg/bridge 0.0.21 → 0.1.2

package/src/runtime/bridgeServer.test.ts

@@ -3,6 +3,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
+	type BridgeActivity,
 	BridgeDesired,
 	BridgeFailureCode,
 	BridgeFailureError,
@@ -12,6 +13,7 @@ import {
 	BridgeUserError,
 } from "../core";
 import {
+	BridgeEventName,
 	BridgeMethod,
 	type BridgePendingResult,
 	type BridgeResponse,
@@ -19,6 +21,7 @@ import {
 	type BridgeSetupRuntime,
 	type BridgeValues,
 } from "../protocol";
+import { BridgeRefusalError } from "./bridgeRefusalError";
 import { createServer, type ServerOptions } from "./bridgeServer";
 import { failedSetup, unsupportedSetup } from "./bridgeSetup";
 
@@ -61,11 +64,41 @@ const baseOptions = (socket: string): ServerOptions => ({
 	onPendingAdd: unreachable("pendingAdd"),
 	onSetupStatus: unreachable("setupStatus"),
 	onSetupSubmit: unreachable("setupSubmit"),
+	onUndelivered: unreachable("undelivered"),
 	onLog: () => {
 		return;
 	},
 });
 
+const abandon = async (socket: string, frame: Record<string, unknown>) => {
+	await new Promise<void>((resolve, reject) => {
+		void Bun.connect({
+			unix: socket,
+			socket: {
+				open(connection) {
+					connection.write(`${JSON.stringify(frame)}\n`);
+					connection.end();
+				},
+				close() {
+					resolve();
+				},
+				data() {
+					return;
+				},
+				error(_connection, error) {
+					reject(error);
+				},
+			},
+		}).catch(reject);
+	});
+};
+
+const until = async (check: () => boolean) => {
+	for (let attempt = 0; attempt < 100 && !check(); attempt++) {
+		await Bun.sleep(10);
+	}
+};
+
 const call = async (socket: string, frame: Record<string, unknown>): Promise<BridgeResponse> => {
 	return await new Promise<BridgeResponse>((resolve, reject) => {
 		void Bun.connect<{
@@ -395,7 +428,10 @@ describe("setup dispatch", () => {
 					args,
 				});
 
-				return reported;
+				return {
+					result: reported,
+					activity: [],
+				};
 			},
 		});
 
@@ -425,6 +461,7 @@ describe("setup dispatch", () => {
 			id: 3,
 			ok: true,
 			result: reported,
+			activity: [],
 		});
 	});
 
@@ -453,11 +490,13 @@ describe("setup dispatch", () => {
 	test("answers a rejected setupSubmit with a failed prompt instead of a failed call", async () => {
 		const server = createServer({
 			...baseOptions(socket),
-			onSetupSubmit: async () =>
-				failedSetup(runtime, {
+			onSetupSubmit: async () => ({
+				result: failedSetup(runtime, {
 					ar: "الكود ما عاد ينفع",
 					en: "this code cannot be renewed any more",
 				}),
+				activity: [],
+			}),
 		});
 
 		const response = await call(socket, {
@@ -495,13 +534,17 @@ describe("setup dispatch", () => {
 					},
 				},
 			},
+			activity: [],
 		});
 	});
 
 	test("answers setupSubmit with the unsupported sentinel when the driver implements no submit", async () => {
 		const server = createServer({
 			...baseOptions(socket),
-			onSetupSubmit: async () => unsupportedSetup(),
+			onSetupSubmit: async () => ({
+				result: unsupportedSetup(),
+				activity: [],
+			}),
 		});
 
 		const response = await call(socket, {
@@ -521,6 +564,7 @@ describe("setup dispatch", () => {
 				supported: false,
 				runtime: null,
 			},
+			activity: [],
 		});
 	});
 });
@@ -589,6 +633,35 @@ describe("error serialisation", () => {
 		});
 	});
 
+	test("marks a runtime refusal unchanged and carries its text", async () => {
+		expect(
+			await thrown(
+				new BridgeRefusalError('module "worlds" cannot run "delete" right now', {
+					ar: "ما تقدر تحذف العالم الشغّال",
+					en: "You cannot delete the active world",
+				}),
+			),
+		).toEqual({
+			id: 1,
+			ok: false,
+			error: 'module "worlds" cannot run "delete" right now',
+			unchanged: true,
+			text: {
+				ar: "ما تقدر تحذف العالم الشغّال",
+				en: "You cannot delete the active world",
+			},
+		});
+	});
+
+	test("marks a runtime refusal without text unchanged and sends no text", async () => {
+		expect(await thrown(new BridgeRefusalError('no module named "worlds"'))).toEqual({
+			id: 1,
+			ok: false,
+			error: 'no module named "worlds"',
+			unchanged: true,
+		});
+	});
+
 	test("carries the message alone for an ordinary error", async () => {
 		expect(await thrown(new Error("the file could not be read"))).toEqual({
 			id: 1,
@@ -654,3 +727,460 @@ describe("backup ownership dispatch", () => {
 		}
 	});
 });
+
+describe("error replies", () => {
+	const SECRET = "tok-1234567890-secret";
+
+	let dir = "";
+	let socket = "";
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "bridge-server-"));
+		socket = join(dir, "bridge.sock");
+	});
+
+	afterEach(async () => {
+		await rm(dir, {
+			force: true,
+			recursive: true,
+		});
+	});
+
+	test("hide a secret value from the error and the customer text", async () => {
+		const server = createServer({
+			...baseOptions(socket),
+			redact: (value) => value.split(SECRET).join("••••"),
+			onInvoke: async () => {
+				throw new BridgeUserError({
+					ar: `رفض ${SECRET}`,
+					en: `refused ${SECRET}`,
+				});
+			},
+		});
+
+		const response = await call(socket, {
+			id: 9,
+			token: TOKEN,
+			method: BridgeMethod.Invoke,
+			module: "botDeploy",
+			action: "redeploy",
+			args: {},
+		});
+
+		server.stop(true);
+
+		expect(response).toEqual({
+			id: 9,
+			ok: false,
+			error: "refused ••••",
+			text: {
+				ar: "رفض ••••",
+				en: "refused ••••",
+			},
+		});
+	});
+});
+
+describe("failure logging", () => {
+	let dir = "";
+	let socket = "";
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "bridge-server-"));
+		socket = join(dir, "bridge.sock");
+	});
+
+	afterEach(async () => {
+		await rm(dir, {
+			force: true,
+			recursive: true,
+		});
+	});
+
+	const logged = async (error: unknown) => {
+		const lines: {
+			message: string;
+			fields: Record<string, unknown>;
+		}[] = [];
+
+		const server = createServer({
+			...baseOptions(socket),
+			onLog: (message, fields = {}) => {
+				lines.push({
+					message,
+					fields,
+				});
+			},
+			onInvoke: async () => {
+				throw error;
+			},
+		});
+
+		await call(socket, {
+			id: 3,
+			token: TOKEN,
+			method: BridgeMethod.Invoke,
+			module: "botDeploy",
+			action: "redeploy",
+			args: {},
+		});
+
+		server.stop(true);
+
+		return lines;
+	};
+
+	test("logs a refused action as a refusal with its message and no stack", async () => {
+		expect(
+			await logged(
+				new BridgeUserError({
+					ar: "فيه نشر شغّال الحين",
+					en: "a deploy is already running",
+				}),
+			),
+		).toEqual([
+			{
+				message: "bridge call refused",
+				fields: {
+					method: BridgeMethod.Invoke,
+					error: "a deploy is already running",
+				},
+			},
+		]);
+	});
+
+	test("logs an ordinary error as a failure with its stack", async () => {
+		const [line] = await logged(new Error("the marker could not be written"));
+
+		expect(line?.message).toBe("bridge call failed");
+		expect(line?.fields.error).toBe("the marker could not be written");
+		expect(String(line?.fields.stack)).toContain("the marker could not be written");
+	});
+
+	test("logs a refusal with the cause the driver attached", async () => {
+		expect(
+			await logged(
+				new BridgeUserError(
+					{
+						ar: "المصدر رفض التنزيل",
+						en: "the source refused the download",
+					},
+					{
+						cause: new Error("cdn.modrinth.com answered 403"),
+					},
+				),
+			),
+		).toEqual([
+			{
+				message: "bridge call refused",
+				fields: {
+					method: BridgeMethod.Invoke,
+					error: "the source refused the download — cdn.modrinth.com answered 403",
+				},
+			},
+		]);
+	});
+});
+
+describe("activity on the answer frame", () => {
+	let dir = "";
+	let socket = "";
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "bridge-server-"));
+		socket = join(dir, "bridge.sock");
+	});
+
+	afterEach(async () => {
+		await rm(dir, {
+			force: true,
+			recursive: true,
+		});
+	});
+
+	const entry: BridgeActivity = {
+		name: BridgeEventName.AccessGranted,
+		text: {
+			ar: "أضفت Steve للقائمة البيضاء",
+			en: "Added Steve to the whitelist",
+		},
+		subject: "Steve",
+	};
+
+	test("carries the entries an invoke reported beside its result", async () => {
+		const server = createServer({
+			...baseOptions(socket),
+			onInvoke: async () => ({
+				result: null,
+				activity: [
+					entry,
+				],
+			}),
+		});
+
+		const response = await call(socket, {
+			id: 11,
+			token: TOKEN,
+			method: BridgeMethod.Invoke,
+			module: "whitelist",
+			action: "add",
+			args: {
+				input: "Steve",
+			},
+		});
+
+		server.stop(true);
+
+		expect(response).toEqual({
+			id: 11,
+			ok: true,
+			result: null,
+			activity: [
+				entry,
+			],
+		});
+	});
+
+	test("carries the entries a setup submit reported beside its result", async () => {
+		const server = createServer({
+			...baseOptions(socket),
+			onSetupSubmit: async () => ({
+				result: unsupportedSetup(),
+				activity: [
+					entry,
+				],
+			}),
+		});
+
+		const response = await call(socket, {
+			id: 12,
+			token: TOKEN,
+			method: BridgeMethod.SetupSubmit,
+			module: "sign-in",
+			action: "renew",
+		});
+
+		server.stop(true);
+
+		expect(response).toMatchObject({
+			ok: true,
+			activity: [
+				entry,
+			],
+		});
+	});
+
+	test("carries an empty list when nothing was reported, so the platform knows the runtime reports", async () => {
+		const server = createServer({
+			...baseOptions(socket),
+			onInvoke: async () => ({
+				result: "done",
+				activity: [],
+			}),
+		});
+
+		const response = await call(socket, {
+			id: 13,
+			token: TOKEN,
+			method: BridgeMethod.Invoke,
+			module: "whitelist",
+			action: "add",
+		});
+
+		server.stop(true);
+
+		expect(response).toEqual({
+			id: 13,
+			ok: true,
+			result: "done",
+			activity: [],
+		});
+	});
+
+	test("leaves the field off the answers of methods that report no activity", async () => {
+		const server = createServer(baseOptions(socket));
+
+		const response = await call(socket, {
+			id: 14,
+			token: TOKEN,
+			method: BridgeMethod.Status,
+		});
+
+		server.stop(true);
+
+		expect(response.ok).toBe(true);
+		expect("activity" in response).toBe(false);
+	});
+
+	const invokeFrame = {
+		id: 21,
+		token: TOKEN,
+		method: BridgeMethod.Invoke,
+		module: "whitelist",
+		action: "add",
+	};
+
+	test("sends the entries to the events ring once when the caller left before the answer", async () => {
+		const ring: BridgeActivity[][] = [];
+
+		let finish: () => void = () => undefined;
+		let started = false;
+		let answered = false;
+
+		const server = createServer({
+			...baseOptions(socket),
+			onInvoke: async () => {
+				started = true;
+
+				await new Promise<void>((resolve) => {
+					finish = resolve;
+				});
+
+				answered = true;
+
+				return {
+					result: null,
+					activity: [
+						entry,
+					],
+				};
+			},
+			onUndelivered: (activity) => {
+				ring.push(activity);
+			},
+		});
+
+		await abandon(socket, invokeFrame);
+		await until(() => started);
+		await Bun.sleep(20);
+
+		finish();
+
+		await until(() => answered && ring.length > 0);
+		await Bun.sleep(20);
+
+		server.stop(true);
+
+		expect(ring).toEqual([
+			[
+				entry,
+			],
+		]);
+	});
+
+	test("sends nothing to the ring when the answer reached the caller", async () => {
+		const ring: BridgeActivity[][] = [];
+
+		const server = createServer({
+			...baseOptions(socket),
+			onInvoke: async () => ({
+				result: null,
+				activity: [
+					entry,
+				],
+			}),
+			onUndelivered: (activity) => {
+				ring.push(activity);
+			},
+		});
+
+		const response = await call(socket, invokeFrame);
+
+		await Bun.sleep(20);
+
+		server.stop(true);
+
+		expect(response).toMatchObject({
+			ok: true,
+			activity: [
+				entry,
+			],
+		});
+		expect(ring).toEqual([]);
+	});
+
+	test("sends the entries to the ring when the answer cannot be written", async () => {
+		const ring: BridgeActivity[][] = [];
+
+		const server = createServer({
+			...baseOptions(socket),
+			onInvoke: async () => ({
+				result: BigInt(1),
+				activity: [
+					entry,
+				],
+			}),
+			onUndelivered: (activity) => {
+				ring.push(activity);
+			},
+		});
+
+		const response = await call(socket, invokeFrame);
+
+		server.stop(true);
+
+		expect(response.ok).toBe(false);
+		expect(ring).toEqual([
+			[
+				entry,
+			],
+		]);
+	});
+});
+
+describe("failure frames", () => {
+	let dir = "";
+	let socket = "";
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "bridge-server-"));
+		socket = join(dir, "bridge.sock");
+	});
+
+	afterEach(async () => {
+		await rm(dir, {
+			force: true,
+			recursive: true,
+		});
+	});
+
+	test("carry the cause in the staff error and keep the customer text friendly", async () => {
+		const SECRET = "tok-1234567890-secret";
+
+		const server = createServer({
+			...baseOptions(socket),
+			redact: (value) => value.split(SECRET).join("••••"),
+			onInvoke: async () => {
+				throw new BridgeUserError(
+					{
+						ar: "المصدر رفض التنزيل",
+						en: "the source refused the download",
+					},
+					{
+						cause: new Error(`cdn.modrinth.com answered 403 for ${SECRET}`),
+					},
+				);
+			},
+		});
+
+		const response = await call(socket, {
+			id: 31,
+			token: TOKEN,
+			method: BridgeMethod.Invoke,
+			module: "mods",
+			action: "install",
+		});
+
+		server.stop(true);
+
+		expect(response).toEqual({
+			id: 31,
+			ok: false,
+			error: "the source refused the download — cdn.modrinth.com answered 403 for ••••",
+			text: {
+				ar: "المصدر رفض التنزيل",
+				en: "the source refused the download",
+			},
+		});
+	});
+});