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

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

import { usePromptPolish } from '../src/features/project-workspace/usePromptPolish';

afterEach(cleanup);

function renderPolish({
  requestPolish,
  applyPrompt = vi.fn(),
  normalizeResult,
}: {
  requestPolish: (
    prompt: string,
    context: string | null,
  ) => Promise<string | null>;
  applyPrompt?: (text: string) => void;
  normalizeResult?: (polished: string) => {
    text: string;
    notice?: string | null;
  };
}) {
  return renderHook(() =>
    usePromptPolish({
      readPrompt: () => '原始需求',
      applyPrompt,
      requestPolish,
      normalizeResult,
    }),
  );
}

describe('usePromptPolish', () => {
  test('注入的 requestPolish 拒绝时收敛成失败提示，不产生未处理拒绝', async () => {
    const applyPrompt = vi.fn();
    const { result } = renderPolish({
      requestPolish: vi.fn(async () => {
        throw new Error('platform llm unavailable');
      }),
      applyPrompt,
    });

    let returned: string | null = 'sentinel';
    await act(async () => {
      returned = await result.current.polish();
    });

    // 默认 `requestChatPromptPolish` 自己吞掉失败；注入实现可以拒绝，此时必须
    // 变成用户可见的失败提示，而不是把 promise 变成未处理拒绝、界面上什么都没有。
    expect(returned).toBeNull();
    expect(result.current.error).toBe('AI 润色失败，可重试');
    expect(result.current.polishing).toBe(false);
    expect(applyPrompt).not.toHaveBeenCalled();
  });

  test('notice 文案覆盖本次失败，并且回填前的抛错同样被接住', async () => {
    const applyPrompt = vi.fn(() => {
      throw new Error('composer write failed');
    });
    const { result } = renderPolish({
      requestPolish: async () => '润色结果',
      applyPrompt,
    });

    await act(async () => {
      await result.current.polish({ failureMessage: '润色失败，可直接发送' });
    });

    expect(result.current.error).toBe('润色失败，可直接发送');
    expect(result.current.polishing).toBe(false);
  });

  test('reset 之后的在飞润色结果不再回填宿主草稿', async () => {
    let resolvePolish: (value: string) => void = () => {};
    const applyPrompt = vi.fn();
    const { result } = renderPolish({
      requestPolish: vi.fn(
        () =>
          new Promise<string>((resolve) => {
            resolvePolish = resolve;
          }),
      ),
      applyPrompt,
    });

    let pending: Promise<string | null> | null = null;
    await act(async () => {
      pending = result.current.polish();
    });
    // 宿主清空草稿 / 换资源：在飞请求必须被作废，迟到的结果不许写进新草稿。
    await act(async () => {
      result.current.reset();
    });
    await act(async () => {
      resolvePolish('迟到的润色结果');
      await pending;
    });

    expect(applyPrompt).not.toHaveBeenCalled();
    expect(result.current.originalText).toBeNull();
    expect(result.current.notice).toBeNull();
    expect(result.current.error).toBeNull();
  });

  test('没有 reset 时在飞结果照旧回填（对照）', async () => {
    let resolvePolish: (value: string) => void = () => {};
    const applyPrompt = vi.fn();
    const { result } = renderPolish({
      requestPolish: () =>
        new Promise<string>((resolve) => {
          resolvePolish = resolve;
        }),
      applyPrompt,
    });

    let pending: Promise<string | null> | null = null;
    await act(async () => {
      pending = result.current.polish();
    });
    await act(async () => {
      resolvePolish('润色后的需求');
      await pending;
    });

    expect(applyPrompt).toHaveBeenCalledWith('润色后的需求');
    expect(result.current.originalText).toBe('原始需求');
  });
});