@serverkgg/bridge 0.1.1 → 0.1.3

package/src/runtime/bridgeServer.test.ts

@@ -1,8 +1,9 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 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<{
@@ -129,7 +162,7 @@ describe("pending dispatch", () => {
 		rejected: null,
 	};
 
-	test("answers pendingList with what the driver lists", async () => {
+	it("answers pendingList with what the driver lists", async () => {
 		const server = createServer({
 			...baseOptions(socket),
 			onPendingList: async () => listed,
@@ -150,7 +183,7 @@ describe("pending dispatch", () => {
 		});
 	});
 
-	test("answers pendingList with the unsupported sentinel when the driver declares no pending module", async () => {
+	it("answers pendingList with the unsupported sentinel when the driver declares no pending module", async () => {
 		const server = createServer({
 			...baseOptions(socket),
 			onPendingList: async () => ({
@@ -183,7 +216,7 @@ describe("pending dispatch", () => {
 		});
 	});
 
-	test("passes the uploaded path to pendingAdd and answers with the refreshed list", async () => {
+	it("passes the uploaded path to pendingAdd and answers with the refreshed list", async () => {
 		const received: string[] = [];
 
 		const server = createServer({
@@ -214,7 +247,7 @@ describe("pending dispatch", () => {
 		});
 	});
 
-	test("refuses a pendingAdd carrying no path", async () => {
+	it("refuses a pendingAdd carrying no path", async () => {
 		const server = createServer({
 			...baseOptions(socket),
 			onPendingAdd: unreachable("pendingAdd"),
@@ -235,7 +268,7 @@ describe("pending dispatch", () => {
 		});
 	});
 
-	test("answers pendingAdd with the rejection the driver reported beside the refreshed list", async () => {
+	it("answers pendingAdd with the rejection the driver reported beside the refreshed list", async () => {
 		const rejected: BridgePendingResult = {
 			...listed,
 			rejected: {
@@ -266,7 +299,7 @@ describe("pending dispatch", () => {
 		});
 	});
 
-	test("names an unknown method so an older agent can degrade", async () => {
+	it("names an unknown method so an older agent can degrade", async () => {
 		const server = createServer(baseOptions(socket));
 
 		const response = await call(socket, {
@@ -334,7 +367,7 @@ describe("setup dispatch", () => {
 		runtime,
 	};
 
-	test("answers setupStatus with what the driver reported", async () => {
+	it("answers setupStatus with what the driver reported", async () => {
 		const server = createServer({
 			...baseOptions(socket),
 			onSetupStatus: () => reported,
@@ -355,7 +388,7 @@ describe("setup dispatch", () => {
 		});
 	});
 
-	test("answers setupStatus with the unsupported sentinel when the driver declares no setup", async () => {
+	it("answers setupStatus with the unsupported sentinel when the driver declares no setup", async () => {
 		const server = createServer({
 			...baseOptions(socket),
 			onSetupStatus: () => unsupportedSetup(),
@@ -379,7 +412,7 @@ describe("setup dispatch", () => {
 		});
 	});
 
-	test("passes the step, action and args of a setupSubmit to the driver", async () => {
+	it("passes the step, action and args of a setupSubmit to the driver", async () => {
 		const received: {
 			step: string;
 			action: string;
@@ -395,7 +428,10 @@ describe("setup dispatch", () => {
 					args,
 				});
 
-				return reported;
+				return {
+					result: reported,
+					activity: [],
+				};
 			},
 		});
 
@@ -425,10 +461,11 @@ describe("setup dispatch", () => {
 			id: 3,
 			ok: true,
 			result: reported,
+			activity: [],
 		});
 	});
 
-	test("refuses a setupSubmit carrying no step id", async () => {
+	it("refuses a setupSubmit carrying no step id", async () => {
 		const server = createServer({
 			...baseOptions(socket),
 			onSetupSubmit: unreachable("setupSubmit"),
@@ -450,14 +487,16 @@ describe("setup dispatch", () => {
 		});
 	});
 
-	test("answers a rejected setupSubmit with a failed prompt instead of a failed call", async () => {
+	it("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 () => {
+	it("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: [],
 		});
 	});
 });
@@ -561,7 +605,7 @@ describe("error serialisation", () => {
 		return response;
 	};
 
-	test("carries the localized text of a user error beside the message", async () => {
+	it("carries the localized text of a user error beside the message", async () => {
 		expect(
 			await thrown(
 				new BridgeUserError({
@@ -580,7 +624,7 @@ describe("error serialisation", () => {
 		});
 	});
 
-	test("carries the failure code of a failure error and no text", async () => {
+	it("carries the failure code of a failure error and no text", async () => {
 		expect(await thrown(new BridgeFailureError(BridgeFailureCode.CatalogRestricted, "the author blocked it"))).toEqual({
 			id: 1,
 			ok: false,
@@ -589,7 +633,36 @@ describe("error serialisation", () => {
 		});
 	});
 
-	test("carries the message alone for an ordinary error", async () => {
+	it("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",
+			},
+		});
+	});
+
+	it("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,
+		});
+	});
+
+	it("carries the message alone for an ordinary error", async () => {
 		expect(await thrown(new Error("the file could not be read"))).toEqual({
 			id: 1,
 			ok: false,
@@ -609,7 +682,7 @@ describe("backup ownership dispatch", () => {
 			recursive: true,
 		});
 	});
-	test("carries the lease token through renew and release frames", async () => {
+	it("carries the lease token through renew and release frames", async () => {
 		const socket = join(dir, "bridge.sock");
 		const renewals: (string | undefined)[] = [];
 		const releases: (string | undefined)[] = [];
@@ -673,7 +746,7 @@ describe("error replies", () => {
 		});
 	});
 
-	test("hide a secret value from the error and the customer text", async () => {
+	it("hide a secret value from the error and the customer text", async () => {
 		const server = createServer({
 			...baseOptions(socket),
 			redact: (value) => value.split(SECRET).join("••••"),
@@ -757,7 +830,7 @@ describe("failure logging", () => {
 		return lines;
 	};
 
-	test("logs a refused action as a refusal with its message and no stack", async () => {
+	it("logs a refused action as a refusal with its message and no stack", async () => {
 		expect(
 			await logged(
 				new BridgeUserError({
@@ -776,11 +849,338 @@ describe("failure logging", () => {
 		]);
 	});
 
-	test("logs an ordinary error as a failure with its stack", async () => {
+	it("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");
 	});
+
+	it("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",
+	};
+
+	it("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,
+			],
+		});
+	});
+
+	it("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,
+			],
+		});
+	});
+
+	it("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: [],
+		});
+	});
+
+	it("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",
+	};
+
+	it("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,
+			],
+		]);
+	});
+
+	it("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([]);
+	});
+
+	it("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,
+		});
+	});
+
+	it("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",
+			},
+		});
+	});
 });