Genarrative/apps/ai-game-creator-shell/tests/homeWebPreflight.test.tsx

// @vitest-environment jsdom
import { act, cleanup, renderHook } from '@testing-library/react';
import { afterEach, expect, it, vi } from 'vitest';

import { createGameCreationAppManifest } from '../../../packages/shared/src/contracts/gameCreationApp';
import { HOME_WEB_PREFLIGHT_FAILURE } from '../src/features/app-shell/homeWebPreflight';
import { useHomeProjectCreation } from '../src/features/app-shell/useHomeProjectCreation';

afterEach(() => {
  cleanup();
  delete window.__TAURI__;
});

function mount(preflight: () => Promise<unknown>) {
  const calls: string[] = [];
  const invoke = vi.fn(async (command: string) => {
    if (command !== 'capture_analytics_context') calls.push(command);
    if (command === 'preflight_web_game_creation') return preflight();
    if (command === 'suggest_automatic_project_name') return '预检项目';
    if (command === 'create_automatic_local_game_project')
      return {
        projectPath: 'C:/test/preflight-game',
        manifestPath: 'C:/test/preflight-game/.agent/manifest.json',
        manifest: createGameCreationAppManifest('preflight-game', '预检项目'),
      };
    if (command === 'get_local_game_project_revision') return { revision: 1 };
    if (command === 'set_design_agent_runtime_mode')
      return { activeRuntime: 'design' };
    return null;
  });
  window.__TAURI__ = { core: { invoke } } as unknown as typeof window.__TAURI__;
  const hook = renderHook(() =>
    useHomeProjectCreation({
      setStatus: vi.fn(),
      showTransientNotice: vi.fn(),
      setLauncherView: vi.fn(),
      setAgentChatProjectPath: vi.fn(),
      rememberRecentWorkspace: vi.fn(),
    }),
  );
  return { ...hook, calls, invoke };
}

it('awaits the real home preflight before naming or creating a game', async () => {
  let ready!: (value: unknown) => void;
  const pending = new Promise((resolve) => {
    ready = resolve;
  });
  const { result, calls } = mount(() => pending);
  let creation!: Promise<string>;
  await act(async () => {
    creation = result.current.createHomeDraftAutomatically(
      { creationType: 'game', prompt: '做一个小游戏', attachments: [] },
      'direct-build',
    );
  });
  expect(calls).toEqual(['preflight_web_game_creation']);
  await act(async () => {
    ready({ status: 'ready' });
    await creation;
  });
  expect(calls.slice(0, 3)).toEqual([
    'preflight_web_game_creation',
    'suggest_automatic_project_name',
    'create_automatic_local_game_project',
  ]);
  expect(result.current.currentProjectContext?.creationType).toBe('game');
});

it.each([false, true])(
  'blocks naming, creation, and first generation when preflight fails (throws=%s)',
  async (throws) => {
    const { result, calls } = mount(async () => {
      if (throws) throw new Error('private host path');
      return { status: 'blocked' };
    });
    let status = '';
    await act(async () => {
      status = await result.current.createHomeDraftAutomatically(
        { creationType: 'game', prompt: '做一个小游戏', attachments: [] },
        'direct-build',
      );
    });
    expect(status).toBe(HOME_WEB_PREFLIGHT_FAILURE);
    expect(calls).toEqual(['preflight_web_game_creation']);
    expect(result.current.currentProjectContext).toBeNull();
    expect(status).not.toContain('private');
  },
);

it.each(['game', 'doc'] as const)(
  'does not require the Web preflight for %s planning',
  async (creationType) => {
    const { result, calls } = mount(async () => {
      throw new Error('must not run');
    });
    await act(async () => {
      await result.current.createHomeDraftAutomatically(
        { creationType, prompt: '策划需求', attachments: [] },
        'planning',
      );
    });
    expect(calls).not.toContain('preflight_web_game_creation');
    expect(calls).not.toContain('suggest_automatic_project_name');
    expect(calls).toContain('create_automatic_local_game_project');
  },
);