punktfunk-plugin-steam/test/steam.test.ts

// The Steam-specific half — the assembly this plugin adds on top of the kit's parsers (which are
// tested there). The real end-to-end proof is `punktfunk-plugin-steam parity --compare` on a box
// with a real Steam install.
import { describe, expect, test } from "bun:test";
import * as fs from "node:fs";
import * as os from "node:os";
import * as path from "node:path";
import {
	detectFromExe,
	installedApps,
	launcherEntries,
} from "../src/plugin.js";

const tmp = (): string => fs.mkdtempSync(path.join(os.tmpdir(), "pf-steam-"));

/** A `steamapps` dir holding the given `appmanifest_<id>.acf` files. */
const steamapps = (
	manifests: Array<{ appid: number; name: string; installdir?: string }>,
	opts: { makeInstallDirs?: boolean } = {},
): string => {
	const dir = path.join(tmp(), "steamapps");
	fs.mkdirSync(dir, { recursive: true });
	for (const m of manifests) {
		const body = [
			'"AppState"',
			"{",
			`\t"appid"\t\t"${m.appid}"`,
			`\t"name"\t\t"${m.name}"`,
			...(m.installdir ? [`\t"installdir"\t\t"${m.installdir}"`] : []),
			"}",
		].join("\n");
		fs.writeFileSync(path.join(dir, `appmanifest_${m.appid}.acf`), body);
		if (opts.makeInstallDirs && m.installdir) {
			fs.mkdirSync(path.join(dir, "common", m.installdir), { recursive: true });
		}
	}
	return dir;
};

describe("installed apps", () => {
	test("reads every appmanifest and resolves the install dir under common/", () => {
		const dir = steamapps(
			[
				{ appid: 570, name: "Dota 2", installdir: "dota 2 beta" },
				{ appid: 620, name: "Portal 2", installdir: "Portal 2" },
			],
			{ makeInstallDirs: true },
		);
		const apps = installedApps([dir]);
		expect([...apps.keys()].sort((a, b) => a - b)).toEqual([570, 620]);
		expect(apps.get(570)?.name).toBe("Dota 2");
		expect(apps.get(570)?.installDir).toBe(
			path.join(dir, "common", "dota 2 beta"),
		);
	});

	test("an installdir that isn't on disk yields no hint rather than a wrong one", () => {
		// A manifest can name a dir a partial/cancelled install never created. Sending it would
		// bind the session's detection to a path that does not exist.
		const dir = steamapps([{ appid: 1, name: "Ghost", installdir: "Nowhere" }]);
		expect(installedApps([dir]).get(1)?.installDir).toBeUndefined();
	});

	test("the FIRST library wins for an appid present in several", () => {
		// The same appid legitimately appears in two libraries mid-move; the host's scanner took
		// the first, and the parity harness compares ids, so the tie-break has to match.
		const a = steamapps([{ appid: 570, name: "From Library A" }]);
		const b = steamapps([{ appid: 570, name: "From Library B" }]);
		expect(installedApps([a, b]).get(570)?.name).toBe("From Library A");
		expect(installedApps([b, a]).get(570)?.name).toBe("From Library B");
	});

	test("non-manifest files, junk and empty dirs are all skipped quietly", () => {
		const dir = steamapps([{ appid: 570, name: "Dota 2" }]);
		fs.writeFileSync(path.join(dir, "readme.txt"), "not a manifest");
		fs.writeFileSync(
			path.join(dir, "appmanifest_bad.acf"),
			"totally malformed",
		);
		// A manifest with no usable appid+name contributes nothing.
		fs.writeFileSync(
			path.join(dir, "appmanifest_9.acf"),
			'"AppState"\n{\n\t"appid"\t"9"\n}',
		);
		expect([...installedApps([dir]).keys()]).toEqual([570]);
		expect(installedApps([path.join(tmp(), "does-not-exist")]).size).toBe(0);
	});
});

describe("the launcher tiles", () => {
	test("Big Picture is on by default and the desktop client is not", () => {
		// Big Picture IS the couch UI, and reaching it is most of the point of streaming a Steam
		// machine; the desktop window is one more card in front of the games.
		const tiles = launcherEntries({});
		expect(tiles).toHaveLength(1);
		expect(tiles[0]).toMatchObject({
			external_id: "big-picture",
			role: "launcher",
			launch: { kind: "steam_ui", value: "bigpicture" },
		});
	});

	test("both can be published, and both can be turned off", () => {
		const both = launcherEntries({ bigPicture: true, desktopClient: true });
		expect(both.map((t) => t.launch?.value)).toEqual(["bigpicture", "desktop"]);
		// `steam_ui` is the one kind with two values because Steam genuinely has two UIs; the host
		// owns turning each into a command.
		expect(both.every((t) => t.launch?.kind === "steam_ui")).toBe(true);
		expect(
			launcherEntries({ bigPicture: false, desktopClient: false }),
		).toEqual([]);
	});

	test("the tile ids cannot collide with a real appid", () => {
		// The host composes `steam:<external_id>`, and every real appid is digits.
		for (const t of launcherEntries({
			bigPicture: true,
			desktopClient: true,
		})) {
			expect(Number.isNaN(Number(t.external_id))).toBe(true);
		}
	});
});

describe("shortcut detect hints", () => {
	test("unwraps Steam's quoted exe, dropping trailing arguments", () => {
		expect(detectFromExe('"C:\\Games\\game.exe"')).toEqual({
			detect: { exe: "C:\\Games\\game.exe" },
		});
		expect(detectFromExe('"C:\\Games\\game.exe" -windowed -novid')).toEqual({
			detect: { exe: "C:\\Games\\game.exe" },
		});
		// A path with spaces survives, which is the whole reason Steam quotes it.
		expect(detectFromExe('"C:\\Program Files\\My Game\\game.exe"')).toEqual({
			detect: { exe: "C:\\Program Files\\My Game\\game.exe" },
		});
	});

	test("an unquoted target still yields its first token", () => {
		expect(detectFromExe("/usr/bin/retroarch -L core.so")).toEqual({
			detect: { exe: "/usr/bin/retroarch" },
		});
	});

	test("an empty target yields NO hint rather than a wrong one", () => {
		// A bad exe hint is worse than none: it would bind the session to the wrong process.
		expect(detectFromExe("")).toEqual({});
		expect(detectFromExe("   ")).toEqual({});
	});
});