@roster-lock/match-agent 0.1.0

package/tests/integration/piece-download-and-list.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { join as pathJoin } from "node:path";
+import { startTestServer, TestServer, errorBody } from "./helpers/server";
+import {
+  makeEngine, makePiece, makeTempFolder, seedCompletePiece, cleanupFolder, TEST_PIECE_TYPE,
+} from "./helpers/piece";
+import { prepareDatabase } from "../../src/handle-room/version-1/globals/FolderDB/SQLFolderDB/schema";
+import { RosterLockPiece, RosterLockV1Config } from "@roster-lock/types";
+
+type ListedPiece = Pick<RosterLockPiece, "version" | "pathVariables">;
+
+describe("PUT /v1/piece", () => {
+  let server: TestServer;
+  let folder: string;
+
+  beforeEach(async () => {
+    folder = await makeTempFolder();
+    server = await startTestServer(folder);
+  });
+  afterEach(async () => {
+    await server.close();
+    await cleanupFolder(folder);
+  });
+
+  const engine = makeEngine();
+  const piece = makePiece();
+
+  function put(path: string, body: unknown) {
+    return fetch(`${server.httpUrl}/v1${path}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${server.authCode}`,
+      },
+      body: JSON.stringify(body),
+    });
+  }
+
+  it("400s on a malformed body", async () => {
+    const res = await put("/piece", {});
+    expect(res.status).toBe(400);
+    expect((await errorBody(res)).error).toBe("Bad Form");
+  });
+
+  // A real download requires a resolvable dl-protocol plugin under
+  // DEFAULT_PLUGIN_DIR (~/roster-lock/plugins), which isn't part of this
+  // package's test setup - only the request-shape validation is covered here.
+  it("400s when the piece fails the piece schema", async () => {
+    const res = await put("/piece", {
+      engine, pieceType: TEST_PIECE_TYPE, piece: { ...piece, id: undefined },
+    });
+    expect(res.status).toBe(400);
+    expect((await errorBody(res)).error).toBe("Bad Form");
+  });
+
+  // ensurePieceExists (SQLite3FolderDB) short-circuits to the existing folder
+  // when the DB already has the piece marked complete, without touching the
+  // download pipeline - so this is reachable without a real dl-protocol
+  // plugin, unlike the two tests above.
+  it("returns the existing folder when the piece is already downloaded", async () => {
+    const downloaded = makePiece({
+      id: "already-downloaded",
+      version: { logic: "already-downloaded-1.0.0", media: "1.0.0", docs: "1.0.0" },
+    });
+    const expectedFolder = await seedCompletePiece({
+      folder, engine, pieceType: TEST_PIECE_TYPE, piece: downloaded, folderName: "already-downloaded-folder", files: {},
+    });
+
+    const res = await put("/piece", { engine, pieceType: TEST_PIECE_TYPE, piece: downloaded });
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({
+      pieceType: TEST_PIECE_TYPE,
+      pieceId: downloaded.id,
+      pieceVersions: { logic: downloaded.version.logic, media: downloaded.version.media },
+      folder: expectedFolder,
+    });
+  });
+});
+
+describe("QUERY /v1/piece/list-downloaded", () => {
+  let server: TestServer;
+  let folder: string;
+
+  beforeEach(async () => {
+    folder = await makeTempFolder();
+    server = await startTestServer(folder);
+  });
+  afterEach(async () => {
+    await server.close();
+    await cleanupFolder(folder);
+  });
+
+  const engine = makeEngine();
+
+  function query(path: string, body: unknown, params: Record<string, string> = {}) {
+    const url = new URL(`${server.httpUrl}/v1${path}`);
+    for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
+    return fetch(url, {
+      method: "QUERY",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${server.authCode}`,
+      },
+      body: JSON.stringify(body),
+    });
+  }
+
+  // seedCompletePiece always stamps completed_at via unixepoch() (second
+  // resolution), which is too coarse to assert ordering across pieces
+  // seeded within the same test - so pagination/ordering tests set it
+  // directly on the row.
+  async function setCompletedAt(
+    engineConfig: RosterLockV1Config["engine"], pieceType: string, piece: RosterLockPiece, completedAt: number,
+  ) {
+    const db = prepareDatabase(pathJoin(folder, "rosterlock.sqlite3.db"));
+    try {
+      db.db.prepare(
+        `UPDATE pieces SET completed_at = @completedAt
+         WHERE engine_name = @engineName AND piece_type = @pieceType
+           AND logic_hash = @logic AND media_hash = @media`
+      ).run({
+        engineName: engineConfig.name,
+        pieceType,
+        logic: piece.version.logic,
+        media: piece.version.media,
+        completedAt,
+      });
+    } finally {
+      db.close();
+    }
+  }
+
+  describe("/piece/list-downloaded/direct", () => {
+    it("400s on a malformed body", async () => {
+      const res = await query("/piece/list-downloaded/direct", {});
+      expect(res.status).toBe(400);
+      expect((await errorBody(res)).error).toBe("Bad Form");
+    });
+
+    it("returns [] without touching the DB when logicIds is empty", async () => {
+      const res = await query("/piece/list-downloaded/direct", {
+        engineName: engine.name, pieceType: TEST_PIECE_TYPE, logicIds: [],
+      });
+      expect(res.status).toBe(200);
+      expect(await res.json()).toEqual([]);
+    });
+
+    it("only returns complete pieces whose logic hash was requested", async () => {
+      const matching = makePiece({ id: "match", version: { logic: "1.0.0", media: "1.0.0", docs: "1.0.0" } });
+      const unrequestedLogic = makePiece({ id: "unrequested", version: { logic: "9.9.9", media: "1.0.0", docs: "1.0.0" } });
+      const stillPending = makePiece({ id: "pending", version: { logic: "2.0.0", media: "1.0.0", docs: "1.0.0" } });
+
+      await seedCompletePiece({ folder, engine, pieceType: TEST_PIECE_TYPE, piece: matching, folderName: "a", files: {} });
+      await seedCompletePiece({ folder, engine, pieceType: TEST_PIECE_TYPE, piece: unrequestedLogic, folderName: "b", files: {} });
+      await seedCompletePiece({
+        folder, engine, pieceType: TEST_PIECE_TYPE, piece: stillPending, folderName: "c", files: {}, complete: false,
+      });
+
+      const res = await query("/piece/list-downloaded/direct", {
+        engineName: engine.name, pieceType: TEST_PIECE_TYPE, logicIds: ["1.0.0", "2.0.0"],
+      });
+      expect(res.status).toBe(200);
+      const body = await res.json() as ListedPiece[];
+      expect(body).toHaveLength(1);
+      expect(body[0].version.logic).toBe("1.0.0");
+    });
+
+    it("paginates results ordered by completion time ascending", async () => {
+      const pieces = ["1.0.0", "2.0.0", "3.0.0"].map((logic, i) => (
+        makePiece({ id: `piece-${i}`, version: { logic, media: "1.0.0", docs: "1.0.0" } })
+      ));
+      for (const [i, p] of pieces.entries()) {
+        await seedCompletePiece({ folder, engine, pieceType: TEST_PIECE_TYPE, piece: p, folderName: `folder-${i}`, files: {} });
+        // Seed in reverse completion order so a correct ORDER BY is actually exercised.
+        await setCompletedAt(engine, TEST_PIECE_TYPE, p, 3000 - i);
+      }
+      const logicIds = pieces.map((p) => p.version.logic);
+
+      const page0 = await query(
+        "/piece/list-downloaded/direct",
+        { engineName: engine.name, pieceType: TEST_PIECE_TYPE, logicIds },
+        { page: "0", limit: "2" },
+      );
+      expect((await page0.json() as ListedPiece[]).map((p) => p.version.logic)).toEqual(["3.0.0", "2.0.0"]);
+
+      const page1 = await query(
+        "/piece/list-downloaded/direct",
+        { engineName: engine.name, pieceType: TEST_PIECE_TYPE, logicIds },
+        { page: "1", limit: "2" },
+      );
+      expect((await page1.json() as ListedPiece[]).map((p) => p.version.logic)).toEqual(["1.0.0"]);
+    });
+  });
+});

package/tests/integration/piece-ensure-ws.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from "vitest";
+import { once } from "node:events";
+import { createServer, Server } from "node:http";
+import { mkdtemp, rm, writeFile, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { AddressInfo } from "node:net";
+import { WebSocket } from "ws";
+import { MessageBridge } from "@roster-lock/utils";
+import { startTestServer, TestServer } from "./helpers/server";
+import {
+  makeEngine, makePiece, makeTempFolder, cleanupFolder, seedCompletePiece, TEST_PIECE_TYPE,
+} from "./helpers/piece";
+import { createFixturePluginDir } from "./helpers/plugin-dir";
+import { makeTarGz } from "./helpers/make-tar-gz";
+import { getDownloadSourceVersion } from "../../src/handle-room/version-1/globals/FolderDB/SQLFolderDB/getVersions";
+
+describe("WS /v1/piece/ensure", () => {
+  let server: TestServer;
+  let folder: string;
+  beforeAll(async () => { folder = await makeTempFolder(); server = await startTestServer(folder); });
+  afterAll(async () => { await server.close(); await cleanupFolder(folder); });
+
+  const engine = makeEngine();
+  const piece = makePiece();
+
+  // Opens an authenticated connection and waits for "ready", mirroring the
+  // handshake every other test here needs before it can send a request.
+  async function connectReady() {
+    const ws = new WebSocket(`${server.wsUrl}/v1/piece/ensure`, {
+      headers: { Authorization: `Bearer ${server.authCode}` },
+    });
+    const bridge = new MessageBridge((message) => ws.send(JSON.stringify(message)));
+    const readyPromise = new Promise<void>((resolve) => bridge.onEvent("ready", () => resolve()));
+    ws.on("message", (data) => bridge.handleMessage(JSON.parse(data.toString())));
+
+    await once(ws, "open");
+    await readyPromise;
+    return { ws, bridge };
+  }
+
+  it("terminates the connection with no auth, without ever sending a ready event", async () => {
+    const ws = new WebSocket(`${server.wsUrl}/v1/piece/ensure`);
+    let receivedMessage = false;
+    ws.on("message", () => { receivedMessage = true; });
+    ws.on("error", () => {}); // abrupt terminate() can surface as ECONNRESET - not the point of this test
+
+    await once(ws, "close");
+    expect(receivedMessage).toBe(false);
+  });
+
+  it("sends a ready event once authenticated, and rejects an invalid ensure-piece request", async () => {
+    const { ws, bridge } = await connectReady();
+    try {
+      await expect(bridge.sendRequest("ensure-piece", { not: "a valid ensure-piece request" }))
+        .rejects.toMatch(/^Bad Form/);
+    } finally {
+      ws.close();
+    }
+  });
+
+  // A real download requires a resolvable dl-protocol plugin under
+  // DEFAULT_PLUGIN_DIR (~/roster-lock/plugins), which isn't part of this
+  // package's test setup - only the request-shape validation is covered here
+  // (mirrors the same limitation noted in piece-download-and-list.test.ts).
+  it("surfaces a download failure over the bridge rather than hanging", async () => {
+    const { ws, bridge } = await connectReady();
+    try {
+      await expect(bridge.sendRequest("ensure-piece", { engine, pieceType: TEST_PIECE_TYPE, piece }))
+        .rejects.toBeTruthy();
+    } finally {
+      ws.close();
+    }
+  });
+
+  // ensurePieceExists (SQLite3FolderDB) short-circuits to the existing folder
+  // when the DB already has the piece marked complete, without touching the
+  // download pipeline - so this is reachable without a real dl-protocol
+  // plugin, unlike the failure-path test above.
+  it("resolves with the existing folder and emits no progress when the piece is already downloaded", async () => {
+    const downloaded = makePiece({
+      id: "already-downloaded",
+      version: { logic: "already-downloaded-1.0.0", media: "1.0.0", docs: "1.0.0" },
+    });
+    const expectedFolder = await seedCompletePiece({
+      folder, engine, pieceType: TEST_PIECE_TYPE, piece: downloaded, folderName: "already-downloaded-folder", files: {},
+    });
+
+    const { ws, bridge } = await connectReady();
+    try {
+      const progressEvents: unknown[] = [];
+      bridge.onEvent("download-progress", (update) => progressEvents.push(update));
+
+      const result = await bridge.sendRequest(
+        "ensure-piece", { engine, pieceType: TEST_PIECE_TYPE, piece: downloaded },
+      );
+
+      expect(result).toEqual({
+        pieceType: TEST_PIECE_TYPE,
+        pieceId: downloaded.id,
+        pieceVersions: { logic: downloaded.version.logic, media: downloaded.version.media },
+        folder: expectedFolder,
+      });
+      expect(progressEvents).toEqual([]);
+    } finally {
+      ws.close();
+    }
+  });
+});
+
+describe("WS /v1/piece/ensure - first-time download", () => {
+  const cleanups: Array<() => Promise<void> | void> = [];
+  afterEach(async () => {
+    while (cleanups.length) await cleanups.pop()!();
+  });
+
+  const engine = makeEngine();
+  const spriteContent = "not actually a png, just fixture bytes\n";
+
+  async function connectReady(server: TestServer) {
+    const ws = new WebSocket(`${server.wsUrl}/v1/piece/ensure`, {
+      headers: { Authorization: `Bearer ${server.authCode}` },
+    });
+    const bridge = new MessageBridge((message) => ws.send(JSON.stringify(message)));
+    const readyPromise = new Promise<void>((resolve) => bridge.onEvent("ready", () => resolve()));
+    ws.on("message", (data) => bridge.handleMessage(JSON.parse(data.toString())));
+
+    await once(ws, "open");
+    await readyPromise;
+    return { ws, bridge };
+  }
+
+  function startArchiveServer(archive: Buffer): Promise<Server> {
+    return new Promise((resolve) => {
+      const server = createServer((_req, res) => {
+        res.writeHead(200, { "content-length": String(archive.length) });
+        res.end(archive);
+      });
+      server.listen(0, "localhost", () => resolve(server));
+    });
+  }
+
+  // Exercises the real download path end to end (http fetch -> gzip decompress
+  // -> tar extract -> hash validation) instead of the DB short-circuit the
+  // other tests in this file use, since that's the only way to see
+  // "download-progress" events actually stream and a first-time download
+  // land on disk. Requires a real plugin dir - see helpers/plugin-dir.ts.
+  it("streams download-progress events and resolves once the archive is extracted and validated", async () => {
+    const sourceDir = await mkdtemp(join(tmpdir(), "match-agent-source-"));
+    cleanups.push(() => rm(sourceDir, { recursive: true, force: true }));
+    await writeFile(join(sourceDir, "sprite.png"), spriteContent);
+    const version = await getDownloadSourceVersion(sourceDir, {}, engine.pieceDefinitions[TEST_PIECE_TYPE]);
+
+    const archive = makeTarGz([{ path: "sprite.png", content: spriteContent }]);
+    const archiveServer = await startArchiveServer(archive);
+    cleanups.push(() => new Promise((resolve) => archiveServer.close(() => resolve(undefined))));
+    const port = (archiveServer.address() as AddressInfo).port;
+
+    const fixture = await createFixturePluginDir([
+      "@roster-lock/dl-protocol-http", "@roster-lock/dl-compression-gzip", "@roster-lock/dl-archive-tar",
+    ]);
+    cleanups.push(fixture.cleanup);
+
+    const folder = await makeTempFolder();
+    cleanups.push(() => cleanupFolder(folder));
+    const server = await startTestServer(folder, undefined, fixture.pluginDir);
+    cleanups.push(() => server.close());
+
+    const piece = makePiece({
+      version,
+      downloadSources: [`http://localhost:${port}/archive.tar.gz`],
+    });
+
+    const { ws, bridge } = await connectReady(server);
+    try {
+      const progressEvents: Array<{ type: string }> = [];
+      bridge.onEvent("download-progress", (update) => progressEvents.push(update as { type: string }));
+
+      const result = await bridge.sendRequest("ensure-piece", { engine, pieceType: TEST_PIECE_TYPE, piece });
+
+      expect(result).toMatchObject({
+        pieceType: TEST_PIECE_TYPE,
+        pieceId: piece.id,
+        pieceVersions: { logic: version.logic, media: version.media },
+      });
+      expect(progressEvents.some((e) => e.type === "download-progress")).toBe(true);
+      expect(progressEvents.at(-1)).toMatchObject({ type: "download-validation" });
+
+      const downloadedFile = await readFile(join((result as { folder: string }).folder, "sprite.png"), "utf-8");
+      expect(downloadedFile).toBe(spriteContent);
+    } finally {
+      ws.close();
+    }
+  });
+
+  // Second ensure-piece call for the same piece should hit the DB
+  // short-circuit and emit no further progress or network traffic - this is
+  // the "second match reuses the cache" behavior already covered against a
+  // seeded DB in the test above this describe block; here it's proven
+  // end-to-end against a piece that was actually downloaded moments ago.
+  it("reuses the cached download on a second ensure-piece call, without re-downloading", async () => {
+    const sourceDir = await mkdtemp(join(tmpdir(), "match-agent-source-"));
+    cleanups.push(() => rm(sourceDir, { recursive: true, force: true }));
+    await writeFile(join(sourceDir, "sprite.png"), spriteContent);
+    const version = await getDownloadSourceVersion(sourceDir, {}, engine.pieceDefinitions[TEST_PIECE_TYPE]);
+
+    const archive = makeTarGz([{ path: "sprite.png", content: spriteContent }]);
+    let requestCount = 0;
+    const archiveServer = await new Promise<Server>((resolve) => {
+      const s = createServer((_req, res) => {
+        requestCount += 1;
+        res.writeHead(200, { "content-length": String(archive.length) });
+        res.end(archive);
+      });
+      s.listen(0, "localhost", () => resolve(s));
+    });
+    cleanups.push(() => new Promise((resolve) => archiveServer.close(() => resolve(undefined))));
+    const port = (archiveServer.address() as AddressInfo).port;
+
+    const fixture = await createFixturePluginDir([
+      "@roster-lock/dl-protocol-http", "@roster-lock/dl-compression-gzip", "@roster-lock/dl-archive-tar",
+    ]);
+    cleanups.push(fixture.cleanup);
+
+    const folder = await makeTempFolder();
+    cleanups.push(() => cleanupFolder(folder));
+    const server = await startTestServer(folder, undefined, fixture.pluginDir);
+    cleanups.push(() => server.close());
+
+    const piece = makePiece({
+      version,
+      downloadSources: [`http://localhost:${port}/archive.tar.gz`],
+    });
+
+    const first = await connectReady(server);
+    try {
+      await first.bridge.sendRequest("ensure-piece", { engine, pieceType: TEST_PIECE_TYPE, piece });
+    } finally {
+      first.ws.close();
+    }
+    expect(requestCount).toBe(1);
+
+    const second = await connectReady(server);
+    try {
+      const progressEvents: unknown[] = [];
+      second.bridge.onEvent("download-progress", (update) => progressEvents.push(update));
+      const result = await second.bridge.sendRequest("ensure-piece", { engine, pieceType: TEST_PIECE_TYPE, piece });
+
+      expect(result).toMatchObject({ pieceType: TEST_PIECE_TYPE, pieceId: piece.id });
+      expect(progressEvents).toEqual([]);
+      expect(requestCount).toBe(1);
+    } finally {
+      second.ws.close();
+    }
+  });
+});

package/tests/integration/piece-files.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { startTestServer, TestServer, errorBody } from "./helpers/server";
+import {
+  makeEngine, makePiece, makeTempFolder, seedCompletePiece, cleanupFolder, TEST_PIECE_TYPE,
+} from "./helpers/piece";
+
+describe("/v1/piece/asset-files and /v1/piece/file-contents", () => {
+  let server: TestServer;
+  let folder: string;
+
+  beforeEach(async () => {
+    folder = await makeTempFolder();
+    server = await startTestServer(folder);
+  });
+  afterEach(async () => {
+    await server.close();
+    await cleanupFolder(folder);
+  });
+
+  const engine = makeEngine();
+  const piece = makePiece();
+
+  function post(path: string, body: unknown) {
+    return fetch(`${server.httpUrl}/v1${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${server.authCode}`,
+      },
+      body: JSON.stringify(body),
+    });
+  }
+
+  describe("POST /v1/piece/asset-files", () => {
+    it("400s on a malformed body", async () => {
+      const res = await post("/piece/asset-files", {});
+      expect(res.status).toBe(400);
+      expect((await errorBody(res)).error).toBe("Bad Form");
+    });
+
+    it("404s when the piece has never been seen", async () => {
+      const res = await post("/piece/asset-files", {
+        engine, pieceType: TEST_PIECE_TYPE, piece, assetName: "sprite",
+      });
+      expect(res.status).toBe(404);
+      expect((await errorBody(res)).error).toBe("Piece Doesn't exist");
+    });
+
+    it("409s when the piece exists but hasn't finished downloading", async () => {
+      await seedCompletePiece({
+        folder, engine, pieceType: TEST_PIECE_TYPE, piece,
+        folderName: "pending-folder", files: {}, complete: false,
+      });
+      const res = await post("/piece/asset-files", {
+        engine, pieceType: TEST_PIECE_TYPE, piece, assetName: "sprite",
+      });
+      expect(res.status).toBe(409);
+      expect((await errorBody(res)).error).toBe("Piece not finished");
+    });
+
+    it("200s with matching files for a completed piece", async () => {
+      await seedCompletePiece({
+        folder, engine, pieceType: TEST_PIECE_TYPE, piece,
+        folderName: "complete-folder",
+        files: { "sprite.png": "fake-png-bytes", "unrelated.txt": "not an asset" },
+      });
+      const res = await post("/piece/asset-files", {
+        engine, pieceType: TEST_PIECE_TYPE, piece, assetName: "sprite",
+      });
+      expect(res.status).toBe(200);
+      expect(await res.json()).toEqual(["sprite.png"]);
+    });
+  });
+
+  describe("POST /v1/piece/file-contents", () => {
+    it("400s on a malformed body", async () => {
+      const res = await post("/piece/file-contents", {});
+      expect(res.status).toBe(400);
+      expect((await errorBody(res)).error).toBe("Bad Form");
+    });
+
+    it("404s when the piece has never been seen", async () => {
+      const res = await post("/piece/file-contents", {
+        engine, pieceType: TEST_PIECE_TYPE, piece, filePath: "sprite.png",
+      });
+      expect(res.status).toBe(404);
+      expect((await errorBody(res)).error).toBe("Piece doesn't exist");
+    });
+
+    it("409s when the piece exists but hasn't finished downloading", async () => {
+      await seedCompletePiece({
+        folder, engine, pieceType: TEST_PIECE_TYPE, piece,
+        folderName: "pending-folder", files: {}, complete: false,
+      });
+      const res = await post("/piece/file-contents", {
+        engine, pieceType: TEST_PIECE_TYPE, piece, filePath: "sprite.png",
+      });
+      expect(res.status).toBe(409);
+      expect((await errorBody(res)).error).toBe("Piece not finished");
+    });
+
+    it("400s on a path-traversal attempt", async () => {
+      await seedCompletePiece({
+        folder, engine, pieceType: TEST_PIECE_TYPE, piece,
+        folderName: "complete-folder", files: { "sprite.png": "fake-png-bytes" },
+      });
+      const res = await post("/piece/file-contents", {
+        engine, pieceType: TEST_PIECE_TYPE, piece, filePath: "../../etc/passwd",
+      });
+      expect(res.status).toBe(400);
+      expect((await errorBody(res)).error).toBe("Can't back out of folder");
+    });
+
+    it("404s when the requested file isn't on disk", async () => {
+      await seedCompletePiece({
+        folder, engine, pieceType: TEST_PIECE_TYPE, piece,
+        folderName: "complete-folder", files: { "sprite.png": "fake-png-bytes" },
+      });
+      const res = await post("/piece/file-contents", {
+        engine, pieceType: TEST_PIECE_TYPE, piece, filePath: "missing.png",
+      });
+      expect(res.status).toBe(404);
+      expect((await errorBody(res)).error).toBe("File doesn't exist");
+    });
+
+    it("200s and streams the file contents with the right content type", async () => {
+      await seedCompletePiece({
+        folder, engine, pieceType: TEST_PIECE_TYPE, piece,
+        folderName: "complete-folder", files: { "sprite.png": "fake-png-bytes" },
+      });
+      const res = await post("/piece/file-contents", {
+        engine, pieceType: TEST_PIECE_TYPE, piece, filePath: "sprite.png",
+      });
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toBe("image/png");
+      await expect(res.text()).resolves.toBe("fake-png-bytes");
+    });
+  });
+});