@serverkgg/bridge 0.0.9 → 0.0.11

package/src/runtime/bridgeSetup.test.ts

@@ -0,0 +1,575 @@
+import { describe, expect, test } from "bun:test";
+import { BridgeSetupPromptKind, BridgeSetupStepState } from "../core";
+import type { BridgeSetupRuntime } from "../protocol";
+import { failedSetup, normalizeSetupRuntime, setupSummaryOf, unsupportedSetup } from "./bridgeSetup";
+
+const text = (value: string) => ({
+	ar: value,
+	en: value,
+});
+
+const runtimeWith = (prompt: BridgeSetupRuntime["prompt"]): BridgeSetupRuntime => ({
+	steps: [
+		{
+			id: "sign-in",
+			state: BridgeSetupStepState.Active,
+		},
+		{
+			id: "download",
+			state: BridgeSetupStepState.Pending,
+		},
+	],
+	prompt,
+});
+
+describe("the setup summary", () => {
+	test("has nothing to summarise while the driver reported no runtime", () => {
+		expect(setupSummaryOf(null)).toBeNull();
+	});
+
+	test("names the active driver step", () => {
+		expect(
+			setupSummaryOf(
+				runtimeWith({
+					kind: BridgeSetupPromptKind.Wait,
+					message: text("starting your server"),
+				}),
+			),
+		).toEqual({
+			step: "sign-in",
+			attention: false,
+		});
+	});
+
+	test("names no step once every driver step is done", () => {
+		expect(
+			setupSummaryOf({
+				steps: [
+					{
+						id: "sign-in",
+						state: BridgeSetupStepState.Done,
+					},
+				],
+				prompt: null,
+			}),
+		).toEqual({
+			step: null,
+			attention: false,
+		});
+	});
+
+	test("asks for attention while a link prompt waits on the customer", () => {
+		expect(
+			setupSummaryOf(
+				runtimeWith({
+					kind: BridgeSetupPromptKind.Link,
+					message: text("sign in with your account"),
+					url: "https://hytale.com/device",
+					code: "ABCD-EFGH",
+					expiresAt: null,
+					actions: [],
+				}),
+			)?.attention,
+		).toBe(true);
+	});
+
+	test("asks for attention on an action prompt and on a failed one", () => {
+		expect(
+			setupSummaryOf(
+				runtimeWith({
+					kind: BridgeSetupPromptKind.Action,
+					message: text("get a new code"),
+					actions: [],
+				}),
+			)?.attention,
+		).toBe(true);
+
+		expect(
+			setupSummaryOf(
+				runtimeWith({
+					kind: BridgeSetupPromptKind.Failed,
+					message: text("the sign-in expired"),
+					actions: [],
+				}),
+			)?.attention,
+		).toBe(true);
+	});
+
+	test("waits quietly while a progress prompt runs", () => {
+		expect(
+			setupSummaryOf(
+				runtimeWith({
+					kind: BridgeSetupPromptKind.Progress,
+					message: text("downloading the game"),
+					percent: 10,
+					detail: "146.6 MiB / 1.4 GiB",
+				}),
+			)?.attention,
+		).toBe(false);
+	});
+});
+
+describe("the unsupported sentinel", () => {
+	test("answers a driver that declares no setup", () => {
+		expect(unsupportedSetup()).toEqual({
+			supported: false,
+			runtime: null,
+		});
+	});
+});
+
+describe("a rejected submit", () => {
+	test("turns the user error into a failed prompt keeping the previous actions", () => {
+		const result = failedSetup(
+			runtimeWith({
+				kind: BridgeSetupPromptKind.Link,
+				message: text("sign in with your account"),
+				url: "https://hytale.com/device",
+				code: "ABCD-EFGH",
+				expiresAt: null,
+				actions: [
+					{
+						id: "renew",
+						label: text("Get a new code"),
+					},
+				],
+			}),
+			text("this code cannot be renewed any more"),
+		);
+
+		expect(result).toEqual({
+			supported: true,
+			runtime: {
+				steps: [
+					{
+						id: "sign-in",
+						state: BridgeSetupStepState.Active,
+					},
+					{
+						id: "download",
+						state: BridgeSetupStepState.Pending,
+					},
+				],
+				prompt: {
+					kind: BridgeSetupPromptKind.Failed,
+					message: text("this code cannot be renewed any more"),
+					actions: [
+						{
+							id: "renew",
+							label: text("Get a new code"),
+						},
+					],
+				},
+			},
+		});
+	});
+
+	test("carries no actions over from a prompt that had none", () => {
+		const result = failedSetup(
+			runtimeWith({
+				kind: BridgeSetupPromptKind.Wait,
+				message: text("starting your server"),
+			}),
+			text("the server never came up"),
+		);
+
+		expect(result.runtime?.prompt).toEqual({
+			kind: BridgeSetupPromptKind.Failed,
+			message: text("the server never came up"),
+			actions: [],
+		});
+	});
+
+	test("stays empty when the driver never reported a runtime", () => {
+		expect(failedSetup(null, text("nothing to fail"))).toEqual({
+			supported: true,
+			runtime: null,
+		});
+	});
+});
+
+const declared: ReadonlySet<string> = new Set([
+	"sign-in",
+	"download",
+]);
+
+const normalizing = (runtime: BridgeSetupRuntime | null) => {
+	const reasons: string[] = [];
+
+	const normalized = normalizeSetupRuntime(runtime, {
+		declared,
+		warn: (_message, fields) => {
+			reasons.push(String(fields?.reason));
+		},
+	});
+
+	return {
+		normalized,
+		reasons,
+	};
+};
+
+const withSteps = (steps: BridgeSetupRuntime["steps"]): BridgeSetupRuntime => ({
+	steps,
+	prompt: null,
+});
+
+const link = (
+	prompt: Partial<
+		Extract<
+			BridgeSetupRuntime["prompt"],
+			{
+				kind: BridgeSetupPromptKind.Link;
+			}
+		>
+	>,
+) => {
+	return runtimeWith({
+		kind: BridgeSetupPromptKind.Link,
+		message: text("sign in with your account"),
+		url: "https://hytale.com/device",
+		code: "ABCD-EFGH",
+		expiresAt: null,
+		actions: [],
+		...prompt,
+	});
+};
+
+describe("normalizing a reported runtime", () => {
+	test("has nothing to normalize while the driver reported no runtime", () => {
+		expect(
+			normalizeSetupRuntime(null, {
+				declared,
+				warn: () => {
+					return;
+				},
+			}),
+		).toBeNull();
+	});
+
+	test("drops a step the driver never declared", () => {
+		const { normalized, reasons } = normalizing(
+			withSteps([
+				{
+					id: "sign-in",
+					state: BridgeSetupStepState.Active,
+				},
+				{
+					id: "invent",
+					state: BridgeSetupStepState.Pending,
+				},
+			]),
+		);
+
+		expect(normalized?.steps).toEqual([
+			{
+				id: "sign-in",
+				state: BridgeSetupStepState.Active,
+			},
+		]);
+		expect(reasons).toEqual([
+			"unknown-step",
+		]);
+	});
+
+	test("drops the second report of the same step", () => {
+		const { normalized, reasons } = normalizing(
+			withSteps([
+				{
+					id: "sign-in",
+					state: BridgeSetupStepState.Done,
+				},
+				{
+					id: "sign-in",
+					state: BridgeSetupStepState.Failed,
+				},
+			]),
+		);
+
+		expect(normalized?.steps).toEqual([
+			{
+				id: "sign-in",
+				state: BridgeSetupStepState.Done,
+			},
+		]);
+		expect(reasons).toEqual([
+			"duplicate-step",
+		]);
+	});
+
+	test("keeps the first active step and pends the rest", () => {
+		const { normalized, reasons } = normalizing(
+			withSteps([
+				{
+					id: "sign-in",
+					state: BridgeSetupStepState.Active,
+				},
+				{
+					id: "download",
+					state: BridgeSetupStepState.Active,
+				},
+			]),
+		);
+
+		expect(normalized?.steps).toEqual([
+			{
+				id: "sign-in",
+				state: BridgeSetupStepState.Active,
+			},
+			{
+				id: "download",
+				state: BridgeSetupStepState.Pending,
+			},
+		]);
+		expect(reasons).toEqual([
+			"extra-active-step",
+		]);
+	});
+
+	test("clamps a percent that left the scale", () => {
+		expect(
+			normalizing(
+				runtimeWith({
+					kind: BridgeSetupPromptKind.Progress,
+					message: text("downloading the game"),
+					percent: 140,
+					detail: null,
+				}),
+			),
+		).toEqual({
+			normalized: {
+				steps: [
+					{
+						id: "sign-in",
+						state: BridgeSetupStepState.Active,
+					},
+					{
+						id: "download",
+						state: BridgeSetupStepState.Pending,
+					},
+				],
+				prompt: {
+					kind: BridgeSetupPromptKind.Progress,
+					message: text("downloading the game"),
+					percent: 100,
+					detail: null,
+				},
+			},
+			reasons: [
+				"percent-out-of-range",
+			],
+		});
+	});
+
+	test("drops a percent that is not a number", () => {
+		const { normalized, reasons } = normalizing(
+			runtimeWith({
+				kind: BridgeSetupPromptKind.Progress,
+				message: text("downloading the game"),
+				percent: Number.NaN,
+				detail: null,
+			}),
+		);
+
+		expect(normalized?.prompt).toEqual({
+			kind: BridgeSetupPromptKind.Progress,
+			message: text("downloading the game"),
+			percent: null,
+			detail: null,
+		});
+		expect(reasons).toEqual([
+			"unusable-percent",
+		]);
+	});
+
+	test("cuts a detail line to the length the platform takes", () => {
+		const { normalized, reasons } = normalizing(
+			runtimeWith({
+				kind: BridgeSetupPromptKind.Progress,
+				message: text("downloading the game"),
+				percent: null,
+				detail: "d".repeat(300),
+			}),
+		);
+
+		expect(normalized?.prompt).toEqual({
+			kind: BridgeSetupPromptKind.Progress,
+			message: text("downloading the game"),
+			percent: null,
+			detail: "d".repeat(256),
+		});
+		expect(reasons).toEqual([
+			"long-detail",
+		]);
+	});
+
+	test("drops an empty detail line", () => {
+		const { normalized, reasons } = normalizing(
+			runtimeWith({
+				kind: BridgeSetupPromptKind.Progress,
+				message: text("downloading the game"),
+				percent: null,
+				detail: "",
+			}),
+		);
+
+		expect(normalized?.prompt).toMatchObject({
+			detail: null,
+		});
+		expect(reasons).toEqual([
+			"empty-detail",
+		]);
+	});
+
+	test("drops an action whose id is not kebab-case and the duplicate beside it", () => {
+		const { normalized, reasons } = normalizing(
+			runtimeWith({
+				kind: BridgeSetupPromptKind.Action,
+				message: text("get a new code"),
+				actions: [
+					{
+						id: "renew",
+						label: text("Get a new code"),
+					},
+					{
+						id: "Renew Now",
+						label: text("Get a new code"),
+					},
+					{
+						id: "renew",
+						label: text("Get a new code"),
+					},
+				],
+			}),
+		);
+
+		expect(normalized?.prompt).toEqual({
+			kind: BridgeSetupPromptKind.Action,
+			message: text("get a new code"),
+			actions: [
+				{
+					id: "renew",
+					label: text("Get a new code"),
+				},
+			],
+		});
+		expect(reasons).toEqual([
+			"unknown-action-id",
+			"duplicate-action",
+		]);
+	});
+
+	test("keeps only as many actions as the platform renders", () => {
+		const { normalized, reasons } = normalizing(
+			runtimeWith({
+				kind: BridgeSetupPromptKind.Failed,
+				message: text("the sign-in expired"),
+				actions: Array.from({
+					length: 6,
+				}).map((_entry, index) => ({
+					id: `action-${index}`,
+					label: text(`Action ${index}`),
+				})),
+			}),
+		);
+
+		expect(normalized?.prompt?.kind).toBe(BridgeSetupPromptKind.Failed);
+		expect(normalized?.prompt && "actions" in normalized.prompt ? normalized.prompt.actions.length : 0).toBe(4);
+		expect(reasons).toEqual([
+			"extra-actions",
+		]);
+	});
+
+	test("cuts a long code and drops an empty one", () => {
+		expect(
+			normalizing(
+				link({
+					code: "c".repeat(80),
+				}),
+			).normalized?.prompt,
+		).toMatchObject({
+			code: "c".repeat(64),
+		});
+
+		expect(
+			normalizing(
+				link({
+					code: "",
+				}),
+			).reasons,
+		).toEqual([
+			"empty-code",
+		]);
+	});
+
+	test("re-emits an expiry as an iso stamp and drops one it cannot read", () => {
+		expect(
+			normalizing(
+				link({
+					expiresAt: "2026-09-04T10:00:00+03:00",
+				}),
+			).normalized?.prompt,
+		).toMatchObject({
+			expiresAt: "2026-09-04T07:00:00.000Z",
+		});
+
+		expect(
+			normalizing(
+				link({
+					expiresAt: "soon",
+				}),
+			).reasons,
+		).toEqual([
+			"unusable-expiry",
+		]);
+	});
+
+	test("turns a link the browser cannot open into a failed prompt keeping its actions", () => {
+		const { normalized, reasons } = normalizing(
+			link({
+				url: "javascript:alert(1)",
+				actions: [
+					{
+						id: "renew",
+						label: text("Get a new code"),
+					},
+				],
+			}),
+		);
+
+		expect(normalized?.prompt).toEqual({
+			kind: BridgeSetupPromptKind.Failed,
+			message: {
+				ar: "اللعبة رجّعت رابط دخول ما يشتغل. جرّب مرة ثانية.",
+				en: "The game reported a broken sign-in link. Try again.",
+			},
+			actions: [
+				{
+					id: "renew",
+					label: text("Get a new code"),
+				},
+			],
+		});
+		expect(reasons).toEqual([
+			"unusable-link",
+		]);
+	});
+
+	test("turns a url it cannot parse into a failed prompt", () => {
+		expect(
+			normalizing(
+				link({
+					url: "not a url",
+				}),
+			).normalized?.prompt?.kind,
+		).toBe(BridgeSetupPromptKind.Failed);
+	});
+
+	test("leaves a healthy runtime exactly as the driver reported it", () => {
+		const source = link({});
+		const { normalized, reasons } = normalizing(source);
+
+		expect(normalized).toEqual(source);
+		expect(reasons).toEqual([]);
+	});
+});