@myclaw163/clawclaw-cli 0.6.71 → 0.6.76

package/src/runtime/event-daemon.test.ts

@@ -1,141 +1,209 @@
-import { mkdtempSync, rmSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { buildMeetingStateProjection, EventRuntime } from './event-daemon.js';
-
-const tempDirs: string[] = [];
-
-function makeRuntimeHarness() {
-  const dir = mkdtempSync(join(tmpdir(), 'ccl-event-runtime-'));
-  tempDirs.push(dir);
-  const appended: Record<string, any>[] = [];
-  const stops: string[] = [];
-  const runtime = new EventRuntime({
-    onStop: (stop) => stops.push(stop.reason),
-  });
-  (runtime as any).events = { append: vi.fn((event) => appended.push(event)) };
-  (runtime as any).feedPath = join(dir, 'feed.json');
-  (runtime as any).profileName = 'me';
-  return { runtime, appended, stops };
-}
-
-afterEach(() => {
-  while (tempDirs.length) {
-    const dir = tempDirs.pop();
-    if (dir) rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('buildMeetingStateProjection', () => {
-  it('keeps meeting state fields without historical speech text', () => {
-    expect(buildMeetingStateProjection({
-      caller: 'A',
-      sub_phase: 'speech',
-      first_speaker: 'A',
-      speech_order: ['A', 'B'],
-      current_speaker: 'B',
-      speeches_so_far: { A: 'hello' },
-      speech_skipped: ['C'],
-      votes_submitted: ['A'],
-      alive_players: ['A', 'B'],
-      countdown: 12,
-    })).toEqual({
-      caller: 'A',
-      sub_phase: 'speech',
-      first_speaker: 'A',
-      speech_order: ['A', 'B'],
-      current_speaker: 'B',
-      speech_skipped: ['C'],
-      votes_submitted: ['A'],
-      alive_players: ['A', 'B'],
-    });
-  });
-});
-
-describe('EventRuntime map seat cache', () => {
-  it('keeps opening map seats in the owner snapshot for formatters', async () => {
-    const { runtime } = makeRuntimeHarness();
-    const updateMapCache = vi.fn();
-    (runtime as any).client = {
-      getMap: vi.fn().mockResolvedValue({
-        all_players: [
-          { name: 'me', seat: 6 },
-          { name: '菜逼油条', seat: 8 },
-        ],
-        all_task_locations: [],
-      }),
-    };
-    (runtime as any).playerHistory = { updateMapCache };
-
-    (runtime as any).refreshPlayerHistoryMapCache();
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    expect((runtime as any).currentGame).toMatchObject({
-      all_players: [
-        { name: 'me', seat: 6 },
-        { name: '菜逼油条', seat: 8 },
-      ],
-      all_seats: {
-        me: 6,
-        菜逼油条: 8,
-      },
-    });
-    expect((runtime as any).currentYou.seat).toBe(6);
-    expect((runtime as any).snapshot()?.game?.all_seats?.菜逼油条).toBe(8);
-    expect(updateMapCache).toHaveBeenCalled();
-  });
-});
-
-describe('EventRuntime game over detection', () => {
-  it('stops when a state snapshot phase is game_over even without a game_over event', () => {
-    const { runtime, appended, stops } = makeRuntimeHarness();
-
-    (runtime as any).handleEvent({
-      type: '_state',
-      phase: 'game_over',
-      tick: 12,
-      winner: 'crab',
-      reason: 'all_lobsters_dead',
-    });
-
-    expect(appended).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        type: 'game_over',
-        synthetic: true,
-        source: '_state',
-        tick: 12,
-        winner: 'crab',
-        reason: 'all_lobsters_dead',
-      }),
-      expect.objectContaining({
-        type: 'event_runtime_stopped',
-        reason: 'game_over',
-      }),
-    ]));
-    expect(stops).toEqual(['game_over']);
-  });
-
-  it('stops when state.new_events has already been dispatched as a game_over event', () => {
-    const { runtime, appended, stops } = makeRuntimeHarness();
-
-    (runtime as any).handleEvent({
-      type: 'game_over',
-      tick: 13,
-      winner: 'lobster',
-    });
-
-    expect(appended).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        type: 'game_over',
-        tick: 13,
-        winner: 'lobster',
-      }),
-      expect.objectContaining({
-        type: 'event_runtime_stopped',
-        reason: 'game_over',
-      }),
-    ]));
-    expect(stops).toEqual(['game_over']);
-  });
-});
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { buildMeetingStateProjection, EventRuntime } from './event-daemon.js';
+
+const tempDirs: string[] = [];
+
+function makeRuntimeHarness() {
+  const dir = mkdtempSync(join(tmpdir(), 'ccl-event-runtime-'));
+  tempDirs.push(dir);
+  const appended: Record<string, any>[] = [];
+  const stops: string[] = [];
+  const runtime = new EventRuntime({
+    onStop: (stop) => stops.push(stop.reason),
+  });
+  (runtime as any).events = { append: vi.fn((event) => appended.push(event)) };
+  (runtime as any).feedPath = join(dir, 'feed.json');
+  (runtime as any).profileName = 'me';
+  return { runtime, appended, stops };
+}
+
+afterEach(() => {
+  while (tempDirs.length) {
+    const dir = tempDirs.pop();
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('buildMeetingStateProjection', () => {
+  it('keeps meeting state fields without historical speech text', () => {
+    expect(buildMeetingStateProjection({
+      caller: 'A',
+      sub_phase: 'speech',
+      first_speaker: 'A',
+      speech_order: ['A', 'B'],
+      current_speaker: 'B',
+      speeches_so_far: { A: 'hello' },
+      speech_skipped: ['C'],
+      votes_submitted: ['A'],
+      alive_players: ['A', 'B'],
+      countdown: 12,
+    })).toEqual({
+      caller: 'A',
+      sub_phase: 'speech',
+      first_speaker: 'A',
+      speech_order: ['A', 'B'],
+      current_speaker: 'B',
+      speech_skipped: ['C'],
+      votes_submitted: ['A'],
+      alive_players: ['A', 'B'],
+    });
+  });
+});
+
+describe('EventRuntime map seat cache', () => {
+  it('keeps opening map seats in the owner snapshot for formatters', async () => {
+    const { runtime } = makeRuntimeHarness();
+    const updateMapCache = vi.fn();
+    (runtime as any).client = {
+      getMap: vi.fn().mockResolvedValue({
+        all_players: [
+          { name: 'me', seat: 6 },
+          { name: '菜逼油条', seat: 8 },
+        ],
+        all_task_locations: [],
+      }),
+    };
+    (runtime as any).playerHistory = { updateMapCache };
+
+    (runtime as any).refreshPlayerHistoryMapCache();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect((runtime as any).currentGame).toMatchObject({
+      all_players: [
+        { name: 'me', seat: 6 },
+        { name: '菜逼油条', seat: 8 },
+      ],
+      all_seats: {
+        me: 6,
+        菜逼油条: 8,
+      },
+    });
+    expect((runtime as any).currentYou.seat).toBe(6);
+    expect((runtime as any).snapshot()?.game?.all_seats?.菜逼油条).toBe(8);
+    expect(updateMapCache).toHaveBeenCalled();
+  });
+});
+
+describe('EventRuntime game over detection', () => {
+  it('stops when a state snapshot phase is game_over even without a game_over event', () => {
+    const { runtime, appended, stops } = makeRuntimeHarness();
+
+    (runtime as any).handleEvent({
+      type: '_state',
+      phase: 'game_over',
+      tick: 12,
+      winner: 'crab',
+      reason: 'all_lobsters_dead',
+    });
+
+    expect(appended).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: 'game_over',
+        synthetic: true,
+        source: '_state',
+        tick: 12,
+        winner: 'crab',
+        reason: 'all_lobsters_dead',
+      }),
+      expect.objectContaining({
+        type: 'event_runtime_stopped',
+        reason: 'game_over',
+      }),
+    ]));
+    expect(stops).toEqual(['game_over']);
+  });
+
+  it('stops when state.new_events has already been dispatched as a game_over event', () => {
+    const { runtime, appended, stops } = makeRuntimeHarness();
+
+    (runtime as any).handleEvent({
+      type: 'game_over',
+      tick: 13,
+      winner: 'lobster',
+    });
+
+    expect(appended).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: 'game_over',
+        tick: 13,
+        winner: 'lobster',
+      }),
+      expect.objectContaining({
+        type: 'event_runtime_stopped',
+        reason: 'game_over',
+      }),
+    ]));
+    expect(stops).toEqual(['game_over']);
+  });
+});
+
+describe('EventRuntime user-left-game detection', () => {
+  it('stops after writing user_left_game for a 1000 Left game WS close', () => {
+    const { runtime, appended, stops } = makeRuntimeHarness();
+    (runtime as any).currentPhase = 'wandering';
+    (runtime as any).currentTick = 42;
+    (runtime as any).currentYou = { name: 'me' };
+
+    (runtime as any).handleWsClose({ code: 1000, reason: 'Left game', wasClean: true });
+
+    expect(appended).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: 'user_left_game',
+        synthetic: true,
+        source: 'ws_close',
+        close_code: 1000,
+        close_reason: 'Left game',
+        message: 'The user left the game from the web page. This match has ended; stop playing and do not restart unless the user asks.',
+        phase: 'wandering',
+        tick: 42,
+        player_name: 'me',
+      }),
+      expect.objectContaining({
+        type: 'event_runtime_stopped',
+        reason: 'user_left_game',
+      }),
+    ]));
+    expect(stops).toEqual(['user_left_game']);
+    expect((runtime as any).latestFeed.phase).toBe('user_left_game');
+  });
+
+  it('treats Already left the game close as user_left_game', () => {
+    const { runtime, appended, stops } = makeRuntimeHarness();
+
+    (runtime as any).handleWsClose({ code: 4001, reason: 'Already left the game' });
+
+    expect(appended).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: 'user_left_game',
+        close_code: 4001,
+        close_reason: 'Already left the game',
+        already_left: true,
+      }),
+    ]));
+    expect(stops).toEqual(['user_left_game']);
+  });
+});
+
+describe('EventRuntime event dedup', () => {
+  it('does not append repeated runtime events with the same key', () => {
+    const { runtime, appended } = makeRuntimeHarness();
+
+    (runtime as any).handleEvent({ type: 'game_started', tick: 0, player_count: 10 });
+    (runtime as any).handleEvent({ type: 'game_started', tick: 0, player_count: 10 });
+    (runtime as any).handleEvent({ type: 'role_assigned', tick: 0, role: 'shrimp_generic' });
+    (runtime as any).handleEvent({ type: 'role_assigned', tick: 0, role: 'shrimp_generic' });
+    (runtime as any).handleEvent({ type: 'player_spotted', tick: 7, spotted_name: 'A' });
+    (runtime as any).handleEvent({ type: 'player_spotted', tick: 7, spotted_name: 'A' });
+    (runtime as any).handleEvent({ type: 'player_spotted', tick: 7, spotted_name: 'B' });
+
+    expect(appended.map((event) => [event.type, event.tick, event.spotted_name])).toEqual([
+      ['game_started', 0, undefined],
+      ['role_assigned', 0, undefined],
+      ['player_spotted', 7, 'A'],
+      ['player_spotted', 7, 'B'],
+    ]);
+  });
+});