@roster-lock/match-agent 0.1.0 → 0.2.0

package/tests/integration/game-launcher-settings.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { startTestServer, TestServer, errorBody } from "./helpers/server";
+import { makeTempFolder, cleanupFolder } from "./helpers/piece";
+import { createFixturePluginDir } from "./helpers/plugin-dir";
+
+const PLUGIN_NAME = "@roster-lock/game-launcher-ikemen-go";
+
+// Mirrors plugins/game-launcher/ikemen-go/src/binaryLocation.ts's own mapping -
+// duplicated here rather than imported since this test is about match-agent
+// resolving binaryLocation before the plugin ever sees it, not about the
+// plugin's own resolution logic.
+const IKEMEN_EXECUTABLE_NAME = (
+  process.platform === "win32" ? "Ikemen_GO.exe" : process.platform === "darwin" ? "Ikemen_GO_MacOS" : "Ikemen_GO_Linux"
+);
+
+describe("game-launcher local settings/version/update routes", () => {
+  const cleanups: Array<() => Promise<void> | void> = [];
+  afterEach(async () => {
+    while (cleanups.length) await cleanups.pop()!();
+  });
+
+  async function setup(): Promise<{ server: TestServer, pluginDir: string }> {
+    const fixture = await createFixturePluginDir([PLUGIN_NAME]);
+    cleanups.push(fixture.cleanup);
+    const folder = await makeTempFolder();
+    cleanups.push(() => cleanupFolder(folder));
+    const server = await startTestServer(folder, undefined, fixture.pluginDir);
+    cleanups.push(() => server.close());
+    return { server, pluginDir: fixture.pluginDir };
+  }
+
+  function auth(server: TestServer): HeadersInit {
+    return { Authorization: `Bearer ${server.authCode}` };
+  }
+
+  it("GET settings returns {} before anything has been saved", async () => {
+    const { server } = await setup();
+    const res = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/settings`, { headers: auth(server) });
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({});
+  });
+
+  it("PUT settings round-trips through GET", async () => {
+    const { server } = await setup();
+    const putRes = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/settings`, {
+      method: "PUT",
+      headers: { ...auth(server), "Content-Type": "application/json" },
+      body: JSON.stringify({ binaryLocation: "/opt/ikemen/Ikemen_GO" }),
+    });
+    expect(putRes.status).toBe(200);
+
+    const getRes = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/settings`, { headers: auth(server) });
+    expect(await getRes.json()).toEqual({ binaryLocation: "/opt/ikemen/Ikemen_GO" });
+  });
+
+  it("PUT settings rejects unknown fields", async () => {
+    const { server } = await setup();
+    const res = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/settings`, {
+      method: "PUT",
+      headers: { ...auth(server), "Content-Type": "application/json" },
+      body: JSON.stringify({ binaryLocation: "/x", extra: true }),
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it("GET version 400s when no binaryLocation has been configured", async () => {
+    const { server } = await setup();
+    const res = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/version`, { headers: auth(server) });
+    expect(res.status).toBe(400);
+    expect((await errorBody(res)).error).toMatch(/binaryLocation/);
+  });
+
+  it("resolves a relative binaryLocation against pluginDir (docs/v2/binary-location.md)", async () => {
+    const { server, pluginDir } = await setup();
+
+    // "engine" here plays the role of wherever a USB-hosted setup would keep
+    // its binaries relative to --plugin-folder - pluginDir moves with the
+    // USB, so a relative binaryLocation should too, rather than needing to
+    // be an absolute path that goes stale once the USB remounts elsewhere.
+    const engineDir = join(pluginDir, "engine");
+    await mkdir(engineDir, { recursive: true });
+    await writeFile(join(engineDir, IKEMEN_EXECUTABLE_NAME), "not a real binary, just needs to exist", {
+      mode: 0o755,
+    });
+
+    await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/settings`, {
+      method: "PUT",
+      headers: { ...auth(server), "Content-Type": "application/json" },
+      body: JSON.stringify({ binaryLocation: "engine" }),
+    });
+
+    const res = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/validate`, {
+      headers: auth(server),
+    });
+    expect(res.status).toBe(200);
+    // If "engine" had been treated literally (e.g. resolved against the
+    // process's own cwd instead of pluginDir) this would come back invalid,
+    // since nothing exists at a literal relative "engine" from wherever
+    // vitest happens to run.
+    expect(await res.json()).toEqual({ valid: true });
+  });
+
+  it("POST update 400s when the plugin has no updateBinary (ikemen-go doesn't declare one)", async () => {
+    const { server } = await setup();
+    await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/settings`, {
+      method: "PUT",
+      headers: { ...auth(server), "Content-Type": "application/json" },
+      body: JSON.stringify({ binaryLocation: "/opt/ikemen/Ikemen_GO" }),
+    });
+
+    const res = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/update`, {
+      method: "POST",
+      headers: auth(server),
+    });
+    expect(res.status).toBe(400);
+    expect((await errorBody(res)).error).toMatch(/in-app updates/);
+  });
+
+  it("GET process/:handleId 404s for an unknown handle", async () => {
+    const { server } = await setup();
+    const res = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/process/not-a-real-handle`, {
+      headers: auth(server),
+    });
+    expect(res.status).toBe(404);
+  });
+
+  it("POST install 400s with the underlying error for a package that can't be installed", async () => {
+    const { server } = await setup();
+    const res = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent("not-a-real-package")}/install`, {
+      method: "POST",
+      headers: auth(server),
+    });
+    expect(res.status).toBe(400);
+    expect((await errorBody(res)).error).toBeTruthy();
+  });
+});

package/tests/integration/game-launcher-start.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { startTestServer, TestServer, errorBody } from "./helpers/server";
+import { makeTempFolder, cleanupFolder } from "./helpers/piece";
+import { createFixturePluginDir } from "./helpers/plugin-dir";
+
+const PLUGIN_NAME = "@roster-lock/game-launcher-ikemen-go";
+
+describe("POST /v1/game-launcher/:pluginName/start", () => {
+  const cleanups: Array<() => Promise<void> | void> = [];
+  afterEach(async () => {
+    while (cleanups.length) await cleanups.pop()!();
+  });
+
+  async function setup(): Promise<TestServer> {
+    const fixture = await createFixturePluginDir([PLUGIN_NAME]);
+    cleanups.push(fixture.cleanup);
+    const folder = await makeTempFolder();
+    cleanups.push(() => cleanupFolder(folder));
+    const server = await startTestServer(folder, undefined, fixture.pluginDir);
+    cleanups.push(() => server.close());
+    return server;
+  }
+
+  function auth(server: TestServer): HeadersInit {
+    return { Authorization: `Bearer ${server.authCode}` };
+  }
+
+  async function configureBinaryLocation(server: TestServer) {
+    await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/settings`, {
+      method: "PUT",
+      headers: { ...auth(server), "Content-Type": "application/json" },
+      body: JSON.stringify({ binaryLocation: "/opt/ikemen/Ikemen_GO" }),
+    });
+  }
+
+  it("400s when the plugin has no binaryLocation configured yet", async () => {
+    const server = await setup();
+    const res = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/start`, {
+      method: "POST",
+      headers: { ...auth(server), "Content-Type": "application/json" },
+    });
+    expect(res.status).toBe(400);
+    expect((await errorBody(res)).error).toMatch(/binaryLocation/);
+  });
+
+  it("400s on a connectionConfig the type doesn't allow (e.g. an unknown type)", async () => {
+    const server = await setup();
+    await configureBinaryLocation(server);
+
+    const res = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/start`, {
+      method: "POST",
+      headers: { ...auth(server), "Content-Type": "application/json" },
+      body: JSON.stringify({
+        connectionConfig: { type: "carrier-pigeon" },
+        currentMachine: { machineId: "m1", publicKey: "pk", privateKey: "sk" },
+        allMachines: [],
+        selectionResult: {},
+        rosterConfig: {},
+        gameConfig: {},
+        relayRoomId: "room-1",
+      }),
+    });
+    expect(res.status).toBe(400);
+    expect((await errorBody(res)).error).toBe("Bad Form");
+  });
+
+  it("400s when required top-level fields are missing", async () => {
+    const server = await setup();
+    await configureBinaryLocation(server);
+
+    const res = await fetch(`${server.httpUrl}/v1/game-launcher/${encodeURIComponent(PLUGIN_NAME)}/start`, {
+      method: "POST",
+      headers: { ...auth(server), "Content-Type": "application/json" },
+      body: JSON.stringify({
+        connectionConfig: { type: "direct-tcp", party: "host", port: 7000 },
+      }),
+    });
+    expect(res.status).toBe(400);
+    expect((await errorBody(res)).error).toBe("Bad Form");
+  });
+});

package/tests/integration/helpers/fakePluginRuntime.ts

@@ -1,8 +1,9 @@
-import { IPluginManager, IPieceSort } from "@roster-lock/plugin-runtime";
+import { IPluginManager, IPieceSort, IGameLauncher } from "@roster-lock/plugin-runtime";
 
 export class FakePluginManager implements IPluginManager {
   readonly pluginDir = "hello-world";
   pieceSort = new FakePieceSort()
+  gameLauncher = new FakeGameLauncher()
   uninstallPlugin(): ReturnType<IPluginManager["uninstallPlugin"]>{
     throw new Error("Not implemented");
   }
@@ -43,4 +44,28 @@ class FakePieceSort implements IPieceSort {
   handleGameComplete(): ReturnType<IPieceSort["handleGameComplete"]>{
     throw new Error("Not Implmented")
   }
+}
+
+class FakeGameLauncher implements IGameLauncher {
+  listAvailable(): ReturnType<IGameLauncher["listAvailable"]>{
+    throw new Error("Not Implemented");
+  }
+  getLocalSettings(): ReturnType<IGameLauncher["getLocalSettings"]>{
+    throw new Error("Not Implemented");
+  }
+  setLocalSettings(): ReturnType<IGameLauncher["setLocalSettings"]>{
+    throw new Error("Not Implemented");
+  }
+  getLocalVersion(): ReturnType<IGameLauncher["getLocalVersion"]>{
+    throw new Error("Not Implemented");
+  }
+  getSupportedVersion(): ReturnType<IGameLauncher["getSupportedVersion"]>{
+    throw new Error("Not Implemented");
+  }
+  updateBinary(): ReturnType<IGameLauncher["updateBinary"]>{
+    throw new Error("Not Implemented");
+  }
+  startGame(): ReturnType<IGameLauncher["startGame"]>{
+    throw new Error("Not Implemented");
+  }
 }

package/tests/integration/helpers/server.ts

@@ -22,14 +22,20 @@ export async function startTestServer(folder: string, authCode: string = randomU
 
   const pluginRuntime = await PluginManager.create(pluginDir ?? folder);
   const fileDB = getSQLite3FolderDB(folder, pluginRuntime);
-  const { httpRouter: v1HttpRouter, wsRouter: v1WsRouter } = createV1Routers(fileDB, pluginRuntime);
+  // port isn't known until the ephemeral listen() below resolves - getPort()
+  // is only ever called from a request handler, by which point `port` has
+  // already been assigned.
+  let port = 0;
+  const { httpRouter: v1HttpRouter, wsRouter: v1WsRouter } = createV1Routers(
+    fileDB, pluginRuntime, { authCode, getPort: () => port }
+  );
   server.httpRouter.use("/v1", authMiddleware(authCode), v1HttpRouter);
   server.wsRouter.use("/v1", authMiddleware(authCode), v1WsRouter);
   server.httpRouter.use("/editor/v1", authMiddleware(authCode), createEditorV1Router(pluginRuntime, fileDB));
 
   const nodeServer = server.listen(0);
   await once(nodeServer, "listening");
-  const { port } = nodeServer.address() as AddressInfo;
+  ({ port } = nodeServer.address() as AddressInfo);
 
   return {
     authCode,

package/src/index.old.ts

@@ -1,71 +0,0 @@
-
-import {
-  MatchLockRestrictionConfig,
-  MatchLockSelectionConfig,
-  GamePiece
-} from "@match-lock/shared";
-import { PublicKeyMap, validateSignedSelection } from "./validateSelection";
-
-import { handleConnection } from "./handleConnection";
-
-
-export function prepareGame(){
-  
-  return new MatchLockPrepare();
-}
-
-class MatchLockPrepare extends Promise<boolean> {
-  constructor(
-    public pieceFolder: string,
-    public roomClient: RoomClient,
-    public restrictionConfig: MatchLockRestrictionConfig,
-    public userSelection: MatchLockSelectionConfig
-  ) {
-    super((res, rej)=>{
-      Promise.resolve().then(async ()=>{
-        const { publicKeys } = await roomClient.getUsers();
-
-      }).then(()=>{
-        res(true);
-      }, rej)
-    });
-  }
-}
-
-import { ISimpleEventEmitter } from "@match-lock/shared";
-
-interface RoomClient {
-  getUsers(): Promise<{ publicKeys: PublicKeyMap }>
-  sendSelection(selection: MatchLockSelectionConfig): Promise<boolean>
-  recieveSelection: ISimpleEventEmitter<[MatchLockSelectionConfig]>
-  onDestroy: ISimpleEventEmitter<[MatchLockSelectionConfig]>
-}
-
-interface ClientConnection{
-  handlePrivateKey(): Promise<string>
-  handleSelection(): Promise<MatchLockSelectionConfig>
-  onPiece: ISimpleEventEmitter<[GamePiece]>
-  sendPieceProgress(pieceId: string, part: "logic" | "media", progress: number): Promise<void>
-  onFinished(): Promise<void>
-
-  onClose: ISimpleEventEmitter<[reason?: string]>
-
-  connect(): void
-}
-
-
-interface DownloadProgress {
-  onProgress: ISimpleEventEmitter<[number]>
-  onFinished: ISimpleEventEmitter<[]>
-}
-
-function downloadPiece(restriction: MatchLockRestrictionConfig, peice: GamePiece): DownloadProgress {
-  
-
-
-}
-
-function resolveDownloadable(url: string){
-
-
-}