@serverkgg/bridge 0.0.2 → 0.0.4

package/src/runtime/bridgeDriver.test.ts

@@ -0,0 +1,450 @@
+import { describe, expect, test } from "bun:test";
+import { BridgeKind } from "../core";
+import type { BridgeDriver } from "../modules";
+import {
+	BridgeControl,
+	type BridgeField,
+	BridgeFormTarget,
+	BridgeLayout,
+	type BridgeSectionAction,
+	type BridgeVisibleWhen,
+} from "../panel";
+import { validateDriver } from "./bridgeDriver";
+
+const text = (value: string) => ({
+	ar: value,
+	en: value,
+});
+
+const driverWith = (visibleWhen: BridgeVisibleWhen): BridgeDriver => ({
+	install: {
+		kind: BridgeKind.Install,
+		run: async () => {
+			return;
+		},
+	},
+	lifecycle: {
+		kind: BridgeKind.Lifecycle,
+		command: async () => [
+			"run",
+		],
+	},
+	panel: {
+		tabs: [
+			{
+				id: "version",
+				title: text("Version"),
+				sections: [
+					{
+						layout: BridgeLayout.Form,
+						id: "version",
+						target: BridgeFormTarget.Variables,
+						visibleWhen,
+						fields: [
+							{
+								key: "MC_VERSION",
+								control: BridgeControl.Text,
+								label: text("Version"),
+							},
+						],
+					},
+				],
+			},
+		],
+	},
+});
+
+const field = (key: string): BridgeField => ({
+	key,
+	control: BridgeControl.Text,
+	label: text(key),
+});
+
+const driverWithActions = (actions: BridgeSectionAction[]): BridgeDriver => ({
+	install: {
+		kind: BridgeKind.Install,
+		run: async () => {
+			return;
+		},
+	},
+	lifecycle: {
+		kind: BridgeKind.Lifecycle,
+		command: async () => [
+			"run",
+		],
+	},
+	modules: {
+		broadcast: {
+			kind: BridgeKind.Actions,
+			requiresRunning: true,
+			actions: {
+				say: async () => {
+					return;
+				},
+			},
+		},
+	},
+	panel: {
+		tabs: [
+			{
+				id: "gameplay",
+				title: text("Gameplay"),
+				sections: [
+					{
+						layout: BridgeLayout.Actions,
+						id: "broadcast",
+						title: text("Broadcast"),
+						module: "broadcast",
+						actions,
+					},
+				],
+			},
+		],
+	},
+});
+
+const formSection = (id: string, fields: BridgeField[]) => ({
+	layout: BridgeLayout.Form as const,
+	id,
+	target: BridgeFormTarget.Variables,
+	fields,
+});
+
+const driverWithTabs = (tabs: number, sections: number): BridgeDriver => ({
+	install: {
+		kind: BridgeKind.Install,
+		run: async () => {
+			return;
+		},
+	},
+	lifecycle: {
+		kind: BridgeKind.Lifecycle,
+		command: async () => [
+			"run",
+		],
+	},
+	panel: {
+		tabs: Array.from({
+			length: tabs,
+		}).map((_tab, tabIndex) => ({
+			id: `tab-${tabIndex}`,
+			title: text(`Tab ${tabIndex}`),
+			sections: Array.from({
+				length: sections,
+			}).map((_section, sectionIndex) =>
+				formSection(`section-${sectionIndex}`, [
+					field("MC_VERSION"),
+				]),
+			),
+		})),
+	},
+});
+
+describe("panel caps", () => {
+	test("takes the tab and section counts the agent mirror accepts", () => {
+		expect(() => validateDriver(driverWithTabs(8, 8))).not.toThrow();
+	});
+
+	test("rejects a ninth tab the agent mirror would drop", () => {
+		expect(() => validateDriver(driverWithTabs(9, 1))).toThrow(
+			"the panel declares 9 tabs — the platform takes at most 8",
+		);
+	});
+
+	test("rejects a ninth section the agent mirror would drop", () => {
+		expect(() => validateDriver(driverWithTabs(1, 9))).toThrow(
+			'tab "tab-0" declares 9 sections — the platform takes at most 8',
+		);
+	});
+
+	test("rejects a form carrying more fields than the agent mirror accepts", () => {
+		const driver = driverWithTabs(1, 1);
+		const [tab] = driver.panel?.tabs ?? [];
+		const [section] = tab?.sections ?? [];
+
+		if (section?.layout !== BridgeLayout.Form) {
+			throw new Error("fixture is missing its form section");
+		}
+
+		section.fields = Array.from({
+			length: 33,
+		}).map((_entry, index) => field(`FIELD_${index}`));
+
+		expect(() => validateDriver(driver)).toThrow("declares 33 fields — the platform takes at most 32");
+	});
+
+	test("rejects a table carrying more columns than the agent mirror accepts", () => {
+		const driver = driverWithTabs(1, 1);
+		const [tab] = driver.panel?.tabs ?? [];
+
+		if (!tab) {
+			throw new Error("fixture is missing its tab");
+		}
+
+		tab.sections = [
+			{
+				layout: BridgeLayout.Table,
+				id: "players",
+				module: "players",
+				columns: Array.from({
+					length: 9,
+				}).map((_entry, index) => ({
+					key: `column${index}`,
+					label: text("Column"),
+				})),
+			},
+		];
+
+		driver.modules = {
+			players: {
+				kind: BridgeKind.Collection,
+				list: async () => [],
+			},
+		};
+
+		expect(() => validateDriver(driver)).toThrow("declares 9 columns — the platform takes at most 8");
+	});
+
+	test("rejects a label longer than the agent mirror accepts", () => {
+		const driver = driverWithTabs(1, 1);
+		const [tab] = driver.panel?.tabs ?? [];
+
+		if (!tab) {
+			throw new Error("fixture is missing its tab");
+		}
+
+		tab.title = text("x".repeat(513));
+
+		expect(() => validateDriver(driver)).toThrow(
+			"title arabic text is 513 characters — the platform takes at most 512",
+		);
+	});
+});
+
+describe("actions sections", () => {
+	test("accepts an action the module implements", () => {
+		expect(() =>
+			validateDriver(
+				driverWithActions([
+					{
+						id: "say",
+						label: text("Say"),
+						fields: [
+							field("message"),
+						],
+					},
+				]),
+			),
+		).not.toThrow();
+	});
+
+	test("rejects an action the module does not implement", () => {
+		expect(() =>
+			validateDriver(
+				driverWithActions([
+					{
+						id: "shout",
+						label: text("Shout"),
+					},
+				]),
+			),
+		).toThrow('declares action "shout", which module "broadcast" does not implement');
+	});
+
+	test("rejects a section with no actions", () => {
+		expect(() => validateDriver(driverWithActions([]))).toThrow("declares no actions");
+	});
+
+	test("rejects an action carrying more fields than one prompt fits", () => {
+		expect(() =>
+			validateDriver(
+				driverWithActions([
+					{
+						id: "say",
+						label: text("Say"),
+						fields: [
+							field("one"),
+							field("two"),
+							field("three"),
+							field("four"),
+							field("five"),
+							field("six"),
+						],
+					},
+				]),
+			),
+		).toThrow('action "say" declares 6 fields — at most 5 fit one prompt');
+	});
+
+	test("rejects a section pointing at a module that is not an actions module", () => {
+		const driver = driverWithActions([
+			{
+				id: "say",
+				label: text("Say"),
+			},
+		]);
+
+		driver.modules = {
+			broadcast: {
+				kind: BridgeKind.Settings,
+				read: async () => ({}),
+			},
+		};
+
+		expect(() => validateDriver(driver)).toThrow('references "broadcast", which is not an actions module');
+	});
+
+	test("checks the fields a row action declares", () => {
+		const driver = driverWithActions([
+			{
+				id: "say",
+				label: text("Say"),
+			},
+		]);
+
+		driver.panel = {
+			tabs: [
+				{
+					id: "players",
+					title: text("Players"),
+					sections: [
+						{
+							layout: BridgeLayout.Table,
+							id: "players",
+							module: "players",
+							columns: [
+								{
+									key: "name",
+									label: text("Name"),
+								},
+							],
+							actions: [
+								{
+									id: "xp",
+									label: text("XP"),
+									fields: [
+										{
+											...field("amount"),
+											visibleWhen: {
+												variable: "MODE",
+											},
+										},
+									],
+								},
+							],
+						},
+					],
+				},
+			],
+		};
+
+		driver.modules = {
+			players: {
+				kind: BridgeKind.Collection,
+				list: async () => [],
+				actions: {
+					xp: async () => {
+						return;
+					},
+				},
+			},
+		};
+
+		expect(() => validateDriver(driver)).toThrow('action "xp" field "amount" is visible when "MODE" matches nothing');
+	});
+});
+
+describe("visibleWhen", () => {
+	test("accepts a rule that matches on values", () => {
+		expect(() =>
+			validateDriver(
+				driverWith({
+					variable: "MODPACK",
+					values: [
+						"vanilla",
+					],
+				}),
+			),
+		).not.toThrow();
+	});
+
+	test("accepts a rule that matches on emptiness", () => {
+		expect(() =>
+			validateDriver(
+				driverWith({
+					variable: "MODPACK",
+					empty: true,
+				}),
+			),
+		).not.toThrow();
+
+		expect(() =>
+			validateDriver(
+				driverWith({
+					variable: "MODPACK",
+					empty: false,
+				}),
+			),
+		).not.toThrow();
+	});
+
+	test("accepts a rule that narrows values inside a presence check", () => {
+		expect(() =>
+			validateDriver(
+				driverWith({
+					variable: "MODPACK",
+					empty: false,
+					values: [
+						"modrinth:cobblemon",
+					],
+				}),
+			),
+		).not.toThrow();
+	});
+
+	test("rejects a rule that declares neither values nor empty", () => {
+		expect(() =>
+			validateDriver(
+				driverWith({
+					variable: "MODPACK",
+				}),
+			),
+		).toThrow('is visible when "MODPACK" matches nothing');
+	});
+
+	test("rejects an empty values list", () => {
+		expect(() =>
+			validateDriver(
+				driverWith({
+					variable: "MODPACK",
+					values: [],
+				}),
+			),
+		).toThrow('is visible when "MODPACK" matches nothing');
+	});
+
+	test("checks a field rule as well as a section rule", () => {
+		const driver = driverWith({
+			variable: "MODPACK",
+			empty: true,
+		});
+
+		const [section] = driver.panel?.tabs[0]?.sections ?? [];
+
+		if (!section || section.layout !== BridgeLayout.Form) {
+			throw new Error("fixture is missing its form section");
+		}
+
+		const [field] = section.fields;
+
+		if (!field) {
+			throw new Error("fixture is missing its field");
+		}
+
+		field.visibleWhen = {
+			variable: "SERVER_TYPE",
+		};
+
+		expect(() => validateDriver(driver)).toThrow('field "MC_VERSION" is visible when "SERVER_TYPE" matches nothing');
+	});
+});