@trolleroof/tui 0.2.4 → 0.2.6

package/src/recording/recorder.test.ts

@@ -0,0 +1,388 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  GameplayRecorder,
+  recoverActiveRecordings,
+  recoverActiveRecordingsBatched,
+} from "./recorder.js";
+import { RecordingStore } from "./store.js";
+import { FakeTransport } from "./transport.js";
+import { isGameEvent, type IngestAcknowledgment, type RecordedEventChunk } from "./types.js";
+
+const roots: string[] = [];
+afterEach(() => {
+  vi.useRealTimers();
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function setup(overrides: Partial<ConstructorParameters<typeof GameplayRecorder>[0]> = {}) {
+  const root = mkdtempSync(join(tmpdir(), "gamepigeon-recorder-"));
+  roots.push(root);
+  const store = new RecordingStore(root);
+  let wall = 1_000;
+  let monotonic = 500;
+  let id = 0;
+  const recorder = new GameplayRecorder({
+    store,
+    gameType: "2048",
+    gameVersion: "1",
+    seed: 7,
+    initialState: { board: [[2]], score: 0 },
+    applicationVersion: "test",
+    wallTimeMs: () => wall++,
+    monotonicTimeMs: () => monotonic++,
+    createGameId: () => "game_test",
+    createEventId: () => `evt_${++id}`,
+    createChunkId: () => `chk_${++id}`,
+    ...overrides,
+  });
+  return { recorder, store, root };
+}
+
+describe("GameplayRecorder", () => {
+  it("records a complete lifecycle with immutable snapshots and explicit sources", () => {
+    const { recorder, store } = setup();
+    const before = { board: [[2]], score: 0 };
+    const after = { board: [[2]], score: 0 };
+    recorder.recordAction({
+      action: "left",
+      source: "player",
+      stateBefore: before,
+      result: { reward: 0, moved: false, done: false, success: false },
+      stateAfter: after,
+    });
+    before.board[0]![0] = 4096;
+    after.score = 99;
+    recorder.recordAction({
+      action: "tick",
+      source: "environment",
+      stateBefore: { y: 0 },
+      result: {
+        reward: 0,
+        moved: true,
+        done: false,
+        success: false,
+        randomEffects: { queuedPiece: "T" },
+      },
+      stateAfter: { y: 1 },
+    });
+    recorder.endGame({
+      outcome: "abandoned",
+      finalState: { board: [[2]] },
+      finalScore: 0,
+      success: false,
+    });
+
+    const events = store.listCompletedGames()[0]!.events.filter(isGameEvent);
+    expect(events.map((event) => [event.event_sequence, event.event_type, event.source])).toEqual([
+      [1, "game_started", "system"],
+      [2, "action", "player"],
+      [3, "action", "environment"],
+      [4, "game_ended", "system"],
+    ]);
+    expect(events[0]!.monotonic_time_ms).toBe(0);
+    const noop = events[1]!;
+    expect(noop.event_type).toBe("action");
+    if (noop.event_type === "action") {
+      expect(noop.payload.result.moved).toBe(false);
+      expect(noop.payload.state_before).toEqual({ board: [[2]], score: 0 });
+      expect(noop.payload.state_after).toEqual({ board: [[2]], score: 0 });
+    }
+    const tick = events[2]!;
+    if (tick.event_type === "action") {
+      expect(tick.payload.random_effects).toEqual({ queuedPiece: "T" });
+      expect(tick.payload.result).not.toHaveProperty("randomEffects");
+    }
+    const ended = events[3]!;
+    if (ended.event_type === "game_ended") {
+      expect(ended.payload.final_event_sequence).toBe(4);
+    }
+  });
+
+  it("flushes immutable chunks at the configured event-count boundary", () => {
+    const { recorder, store } = setup({ config: { maxEventsPerChunk: 2 } });
+    recorder.recordAction({
+      action: "left",
+      source: "player",
+      stateBefore: {},
+      result: { reward: 0, moved: false, done: false, success: false },
+      stateAfter: {},
+    });
+    const chunks = store.listPending();
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]!.chunk.events.map((event) => event.event_sequence)).toEqual([1, 2]);
+    expect(chunks[0]!.chunk.chunk_sequence).toBe(1);
+  });
+
+  it("flushes when the estimated byte limit is reached", () => {
+    const { recorder, store } = setup({ config: { maxEstimatedChunkBytes: 1 } });
+    expect(store.listPending()).toHaveLength(1);
+    expect(store.listPending()[0]!.chunk.events).toHaveLength(1);
+    recorder.shutdown();
+  });
+
+  it("flushes after the configured interval", async () => {
+    vi.useFakeTimers();
+    const { recorder, store } = setup({ config: { flushIntervalMs: 25 } });
+    expect(store.listPending()).toHaveLength(0);
+    vi.advanceTimersByTime(25);
+    await Promise.resolve();
+    expect(store.listPending()).toHaveLength(1);
+    recorder.shutdown();
+  });
+
+  it("keeps gameplay alive and exposes degraded health after persistence failure", () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-recorder-failure-"));
+    roots.push(root);
+    class FailingStore extends RecordingStore {
+      override appendEvent(): void {
+        throw new Error("disk full");
+      }
+    }
+    const recorder = new GameplayRecorder({
+      store: new FailingStore(root),
+      gameType: "2048",
+      gameVersion: "1",
+      seed: 1,
+      initialState: {},
+    });
+    expect(() => recorder.recordAction({
+      action: "left",
+      source: "player",
+      stateBefore: {},
+      result: { reward: 0, moved: false, done: false, success: false },
+      stateAfter: {},
+    })).not.toThrow();
+    expect(recorder.health()).toEqual({ status: "degraded", last_error: "disk full" });
+    recorder.shutdown();
+  });
+
+  it("does not interrupt gameplay when a state cannot be cloned", () => {
+    const { recorder } = setup();
+    expect(() => recorder.recordAction({
+      action: "left",
+      source: "player",
+      stateBefore: { invalid: () => undefined },
+      result: { reward: 0, moved: false, done: false, success: false },
+      stateAfter: {},
+    })).not.toThrow();
+    expect(recorder.health().status).toBe("degraded");
+    expect(recorder.health().last_error).toContain("cloned");
+    expect(() => recorder.endGame({
+      outcome: "abandoned",
+      finalState: { invalid: () => undefined },
+      finalScore: 0,
+      success: false,
+    })).not.toThrow();
+  });
+
+  it("turns chunk construction failures into degraded health", () => {
+    const { recorder } = setup({
+      createChunkId: () => { throw new Error("id source unavailable"); },
+    });
+    expect(() => recorder.flush()).not.toThrow();
+    expect(recorder.health()).toEqual({
+      status: "degraded", last_error: "id source unavailable",
+    });
+  });
+
+  it("uploads a chunk created while the previous upload is in flight", async () => {
+    let releaseFirst: (() => void) | undefined;
+    const acknowledgment = (chunk: RecordedEventChunk): IngestAcknowledgment => ({
+      accepted: true,
+      duplicate: false,
+      game_id: chunk.game_id,
+      chunk_id: chunk.chunk_id,
+      chunk_sequence: chunk.chunk_sequence,
+      accepted_event_range: {
+        first: chunk.first_event_sequence,
+        last: chunk.last_event_sequence,
+      },
+      queued: true,
+      server_received_at_ms: 2_000,
+    });
+    const transport = new FakeTransport(async (persisted) => {
+      if (transport.requests.length === 1) {
+        await new Promise<void>((resolve) => {
+          releaseFirst = resolve;
+        });
+      }
+      return acknowledgment(persisted.chunk);
+    });
+    const { recorder } = setup({ config: { maxEventsPerChunk: 1 }, transport });
+    recorder.recordAction({
+      action: "left",
+      source: "player",
+      stateBefore: {},
+      result: { reward: 0, moved: false, done: false, success: false },
+      stateAfter: {},
+    });
+    expect(transport.requests).toHaveLength(1);
+    releaseFirst!();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(transport.requests).toHaveLength(2);
+  });
+
+  it("drains the final upload before a normal process exit", async () => {
+    let releaseFirst: (() => void) | undefined;
+    const transport = new FakeTransport(async (persisted) => {
+      if (transport.requests.length === 1) {
+        await new Promise<void>((resolve) => {
+          releaseFirst = resolve;
+        });
+      }
+      return {
+        accepted: true,
+        duplicate: false,
+        game_id: persisted.chunk.game_id,
+        chunk_id: persisted.chunk.chunk_id,
+        chunk_sequence: persisted.chunk.chunk_sequence,
+        accepted_event_range: {
+          first: persisted.chunk.first_event_sequence,
+          last: persisted.chunk.last_event_sequence,
+        },
+        queued: true,
+        server_received_at_ms: 2_000,
+      };
+    });
+    const { recorder, store } = setup({
+      config: { maxEventsPerChunk: 1 },
+      transport,
+    });
+    recorder.endGame({
+      outcome: "abandoned",
+      finalState: {},
+      finalScore: 0,
+      success: false,
+    });
+
+    let drained = false;
+    const draining = recorder.drainUploads().then(() => {
+      drained = true;
+    });
+    await Promise.resolve();
+    expect(drained).toBe(false);
+    expect(store.listPending()).toHaveLength(2);
+
+    releaseFirst!();
+    await draining;
+    expect(transport.requests).toHaveLength(2);
+    expect(store.listPending()).toHaveLength(0);
+  });
+});
+
+describe("recording recovery", () => {
+  it("indexes chunks once and reads each active game once", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-linear-recovery-"));
+    roots.push(root);
+    class CountingStore extends RecordingStore {
+      indexCalls = 0;
+      activeReads = 0;
+
+      override async buildRecoveryChunkIndex(
+        options: Parameters<RecordingStore["buildRecoveryChunkIndex"]>[0],
+      ) {
+        this.indexCalls++;
+        return super.buildRecoveryChunkIndex(options);
+      }
+
+      override readActiveEvents(gameId: string) {
+        this.activeReads++;
+        return super.readActiveEvents(gameId);
+      }
+    }
+    const store = new CountingStore(root);
+    for (let index = 0; index < 20; index++) {
+      store.appendEvent(`game_${index}`, {
+        event_id: `evt_${index}`,
+        event_sequence: 1,
+        event_type: "game_started",
+        event_version: 1,
+        source: "system",
+        client_time_ms: 1,
+        monotonic_time_ms: 1,
+        payload: {
+          game_type: "2048",
+          game_version: "1",
+          seed: index,
+          initial_state: {},
+        },
+      });
+    }
+
+    await recoverActiveRecordingsBatched(store, {
+      batchSize: 4,
+      createChunkId: (() => {
+        let id = 0;
+        return () => `chk_linear_${++id}`;
+      })(),
+    });
+    expect(store.indexCalls).toBe(1);
+    expect(store.activeReads).toBe(20);
+    expect(store.listPending()).toHaveLength(20);
+  });
+
+  it("chunks only events that were not already assigned before restart", () => {
+    const { recorder, store } = setup({ config: { maxEventsPerChunk: 2 } });
+    recorder.recordAction({
+      action: "left",
+      source: "player",
+      stateBefore: {},
+      result: { reward: 0, moved: false, done: false, success: false },
+      stateAfter: {},
+    });
+    recorder.recordAction({
+      action: "right",
+      source: "player",
+      stateBefore: {},
+      result: { reward: 0, moved: true, done: false, success: false },
+      stateAfter: {},
+    });
+
+    const recovered = recoverActiveRecordings(store, {
+      applicationVersion: "test",
+      createChunkId: () => "chk_recovered",
+      wallTimeMs: () => 2_000,
+    });
+    expect(recovered).toEqual({ games: 1, chunks: 1, events: 1 });
+    expect(store.listPending().map((item) =>
+      item.chunk.events.map((event) => event.event_sequence)
+    )).toEqual([[1, 2], [3]]);
+    recorder.shutdown();
+  });
+
+  it("finalizes an ended log whose events were all chunked before a crash", () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-finalize-recovery-"));
+    roots.push(root);
+    class InterruptedStore extends RecordingStore {
+      override finalizeGame(): string | null {
+        throw new Error("simulated crash");
+      }
+    }
+    const interrupted = new InterruptedStore(root);
+    const recorder = new GameplayRecorder({
+      store: interrupted,
+      gameType: "2048",
+      gameVersion: "1",
+      seed: 1,
+      initialState: {},
+      createGameId: () => "game_interrupted",
+    });
+    recorder.endGame({
+      outcome: "abandoned",
+      finalState: {},
+      finalScore: 0,
+      success: false,
+    });
+    expect(interrupted.listActiveGameIds()).toEqual(["game_interrupted"]);
+
+    const recoveredStore = new RecordingStore(root);
+    expect(recoverActiveRecordings(recoveredStore)).toEqual({
+      games: 0, chunks: 0, events: 0,
+    });
+    expect(recoveredStore.listActiveGameIds()).toEqual([]);
+    expect(recoveredStore.listCompletedGames()[0]!.gameId).toBe("game_interrupted");
+  });
+});