Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

17.6 KB
Raw Blame
// @vitest-environment jsdom

/**
 * userMessageEditBox.test.ts
 * ---------------------------------------------------------------------------
 * edit-last-message: 编辑框「发送时中断 → 等 idle 接力提交 → 超时兜底 →
 * 取消零副作用」状态机的组件级契约。提交编排本身(rewind/重发/草稿兜底)
 * 由 editLastUserMessage.test.ts 覆盖,这里 mock 掉,只测组件时序。
 */

import { act, cleanup, fireEvent, render, waitFor } from '@testing-library/react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { createElement } from 'react';

vi.mock('react-i18next', () => ({
  useTranslation: () => ({ t: (key: string) => key }),
}));

vi.mock('@/lib/toast', () => ({
  toast: { error: vi.fn() },
}));

vi.mock('@/lib/httpClient', () => ({
  ApiError: class ApiError extends Error {
    code: string;
    constructor(code: string, _status: number, message: string) {
      super(message);
      this.code = code;
    }
  },
}));

vi.mock('@/lib/sessionService', () => ({
  rewindPreview: vi.fn(async () => ({
    canRewind: true,
    filesChanged: [] as string[],
    insertions: 0,
    deletions: 0,
  })),
}));

vi.mock('@/lib/editLastUserMessage', () => ({
  commitEditAndResendWithRunningRetry: vi.fn(async () => true),
}));

import { toast } from '@/lib/toast';
import { rewindPreview } from '@/lib/sessionService';
import { commitEditAndResendWithRunningRetry } from '@/lib/editLastUserMessage';
import {
  readFollowLatestRequestKey,
  bumpSendFollowCancelGeneration,
} from '../components/chat/autoFollowIntent';
import { UserMessageEditBox } from '../components/chat/UserMessageEditBox';

const commitMock = commitEditAndResendWithRunningRetry as unknown as ReturnType<typeof vi.fn>;
const previewMock = rewindPreview as unknown as ReturnType<typeof vi.fn>;

function renderBox(overrides: Partial<Parameters<typeof UserMessageEditBox>[0]> = {}) {
  const props = {
    sessionId: 'sess-1',
    messageClientId: 'msg-1',
    initialText: 'original text',
    workingDir: '/repo',
    sessionRunning: false,
    onRequestStop: vi.fn(),
    onCancel: vi.fn(),
    onSent: vi.fn(),
    ...overrides,
  };
  const utils = render(createElement(UserMessageEditBox, props));
  const textarea = utils.container.querySelector('textarea') as HTMLTextAreaElement;
  const buttons = [...utils.container.querySelectorAll('button')];
  const cancelBtn = buttons.find((b) => b.textContent === 'chat.userMessage.editCancel') as HTMLButtonElement;
  const sendBtn = buttons.find((b) => b.textContent?.includes('chat.userMessage.editSend')) as HTMLButtonElement;
  return { ...utils, props, textarea, cancelBtn, sendBtn };
}

beforeEach(() => {
  vi.clearAllMocks();
});

afterEach(() => {
  cleanup();
  vi.useRealTimers();
});

describe('UserMessageEditBox — idle 发送', () => {
  it('idle 时点发送:直接提交(不触发 onRequestStop),成功后 onSent', async () => {
    const { props, textarea, sendBtn } = renderBox();
    fireEvent.change(textarea, { target: { value: 'edited' } });
    fireEvent.click(sendBtn);

    await waitFor(() => expect(props.onSent).toHaveBeenCalledTimes(1));
    expect(commitMock).toHaveBeenCalledTimes(1);
    expect(commitMock.mock.calls[0][0]).toMatchObject({
      sessionId: 'sess-1',
      clientId: 'msg-1',
      text: 'edited',
      fallbackWorkingDir: '/repo',
    });
    expect(props.onRequestStop).not.toHaveBeenCalled();
  });

  it('编辑重发在派发时就请求跟底,不等受理,等待期间上翻也不撤票', async () => {
    const acceptedId = `edit-follow-ok-${Date.now()}`;
    commitMock.mockResolvedValueOnce(true);
    const accepted = renderBox({ sessionId: acceptedId });
    fireEvent.click(accepted.sendBtn);
    await waitFor(() => expect(accepted.props.onSent).toHaveBeenCalledTimes(1));
    expect(readFollowLatestRequestKey(acceptedId)).toBe(1);
    accepted.unmount();
    vi.clearAllMocks();

    const failedId = `edit-follow-fail-${Date.now()}`;
    commitMock.mockResolvedValueOnce(false);
    const failed = renderBox({ sessionId: failedId });
    fireEvent.click(failed.sendBtn);
    await waitFor(() => expect(failed.props.onSent).toHaveBeenCalledTimes(1));
    expect(readFollowLatestRequestKey(failedId)).toBe(1);
    failed.unmount();
    vi.clearAllMocks();

    const dispatchedId = `edit-follow-dispatch-${Date.now()}`;
    let release: (value: boolean) => void = () => {};
    commitMock.mockImplementationOnce(
      () => new Promise<boolean>((resolve) => { release = resolve; }),
    );
    const dispatched = renderBox({ sessionId: dispatchedId });
    fireEvent.click(dispatched.sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    expect(readFollowLatestRequestKey(dispatchedId)).toBe(1);
    bumpSendFollowCancelGeneration(dispatchedId);
    await act(async () => { release(true); });
    await waitFor(() => expect(dispatched.props.onSent).toHaveBeenCalledTimes(1));
    expect(readFollowLatestRequestKey(dispatchedId)).toBe(1);
  });

  it('被拦消息重发成功后请求跟底', async () => {
    const sessionId = `blocked-follow-${Date.now()}`;
    const override = vi.fn(async () => {});
    const box = renderBox({ sessionId, onCommitOverride: override });
    fireEvent.click(box.sendBtn);
    await waitFor(() => expect(box.props.onSent).toHaveBeenCalledTimes(1));
    expect(override).toHaveBeenCalledTimes(1);
    expect(readFollowLatestRequestKey(sessionId)).toBe(1);
  });


  it('引用编辑框隐藏 marker,未修改时仍提交保序原文,修改后只提交可见文本', async () => {
    const encoded = '> <!-- cindy-composer-quote -->\n> quoted\n\nreply';
    const visible = '> quoted\n\nreply';
    const first = renderBox({ initialText: visible, initialSubmitText: encoded, quotesEncoded: true });
    expect(first.textarea.value).toBe(visible);
    expect(first.textarea.value).not.toContain('cindy-composer-quote');
    fireEvent.click(first.sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    expect(commitMock.mock.calls[0][0].text).toBe(encoded);
    expect(commitMock.mock.calls[0][0].quotesEncoded).toBe(true);
    first.unmount();

    vi.clearAllMocks();
    const second = renderBox({ initialText: visible, initialSubmitText: encoded, quotesEncoded: true });
    fireEvent.change(second.textarea, { target: { value: 'edited reply' } });
    fireEvent.click(second.sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    expect(commitMock.mock.calls[0][0].text).toBe('edited reply');
    expect(commitMock.mock.calls[0][0].quotesEncoded).toBeUndefined();
  });

  it('被拦消息覆盖重发仅在引用正文未修改时透传 quote metadata', async () => {
    const encoded = '> <!-- cindy-composer-quote -->\n> quoted\n\nreply';
    const visible = '> quoted\n\nreply';
    const firstOverride = vi.fn(async () => {});
    const first = renderBox({
      initialText: visible,
      initialSubmitText: encoded,
      quotesEncoded: true,
      onCommitOverride: firstOverride,
    });
    fireEvent.click(first.sendBtn);
    await waitFor(() => expect(firstOverride).toHaveBeenCalledWith({
      text: encoded,
      quotesEncoded: true,
    }));
    first.unmount();

    const editedOverride = vi.fn(async () => {});
    const second = renderBox({
      initialText: visible,
      initialSubmitText: encoded,
      quotesEncoded: true,
      onCommitOverride: editedOverride,
    });
    fireEvent.change(second.textarea, { target: { value: 'edited reply' } });
    fireEvent.click(second.sendBtn);
    await waitFor(() => expect(editedOverride).toHaveBeenCalledWith({ text: 'edited reply' }));
  });

  it('文本未修改时保留语义引用与 chip ranges,文本修改后丢弃', async () => {
    const agentReferences = [{
      kind: 'session' as const,
      start: 0,
      end: 13,
      href: 'cindy://session/source',
      sessionId: 'source',
    }];
    const ranges = {
      agentReferences,
      pastedTextRanges: [{ start: 0, end: 13, display: 'Pasted text (1 line)' }],
      slashCommandRanges: [] as [],
    };
    const first = renderBox({ initialText: 'original text', ...ranges });
    fireEvent.click(first.sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    expect(commitMock.mock.calls[0][0]).toMatchObject({
      text: 'original text',
      agentReferences,
      pastedTextRanges: ranges.pastedTextRanges,
      slashCommandRanges: [],
    });
    first.unmount();

    vi.clearAllMocks();
    const second = renderBox({ initialText: 'original text', ...ranges });
    fireEvent.change(second.textarea, { target: { value: 'edited text' } });
    fireEvent.click(second.sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    expect(commitMock.mock.calls[0][0].agentReferences).toBeUndefined();
    expect(commitMock.mock.calls[0][0].pastedTextRanges).toBeUndefined();
    expect(commitMock.mock.calls[0][0].slashCommandRanges).toBeUndefined();
  });

  it('未确认的 /skill: 散文被用户删掉前缀后不再静默改回 runtime 名', async () => {
    const box = renderBox({
      initialText: '/skill:unknown is prose',
      slashCommandRanges: [],
    });
    fireEvent.change(box.textarea, { target: { value: '/unknown is prose' } });
    fireEvent.click(box.sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    expect(commitMock.mock.calls[0][0].text).toBe('/unknown is prose');
    expect(commitMock.mock.calls[0][0].slashCommandRanges).toBeUndefined();
  });

  it('后文已确认的命令 range 不会让首行未确认的 /skill: 散文被改回', async () => {
    const original = '/skill:unknown\n/help later';
    const helpStart = original.indexOf('/help');
    const box = renderBox({
      initialText: original,
      initialSubmitText: original,
      slashCommandRanges: [{ start: helpStart, end: helpStart + 5 }],
    });
    fireEvent.change(box.textarea, { target: { value: '/unknown\n/help later' } });
    fireEvent.click(box.sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    expect(commitMock.mock.calls[0][0].text).toBe('/unknown\n/help later');
    expect(commitMock.mock.calls[0][0].slashCommandRanges).toBeUndefined();
  });

  it('已确认 range 覆盖的 Pi skill 编辑后仍恢复 runtime 名', async () => {
    const box = renderBox({
      initialText: '/git please',
      initialSubmitText: '/skill:git please',
      slashCommandRanges: [{ start: 0, end: 10 }],
    });
    fireEvent.change(box.textarea, { target: { value: '/git review' } });
    fireEvent.click(box.sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    expect(commitMock.mock.calls[0][0].text).toBe('/skill:git review');
    expect(commitMock.mock.calls[0][0].slashCommandRanges).toEqual([{ start: 0, end: 10 }]);
  });

  it('引用 marker 落库坐标仍能恢复可见 /git',
    async () => {
    const wire = [
      '> <!-- cindy-composer-quote -->',
      '> quoted',
      '',
      '/skill:git follow-up',
    ].join('\n');
    const skillStart = wire.indexOf('/skill:git');
    const box = renderBox({
      initialText: 'quoted\n\n/git follow-up',
      initialSubmitText: wire,
      quotesEncoded: true,
      slashCommandRanges: [{ start: skillStart, end: skillStart + 10 }],
    });
    fireEvent.change(box.textarea, { target: { value: 'quoted\n\n/git please' } });
    fireEvent.click(box.sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    expect(commitMock.mock.calls[0][0].text).toBe('quoted\n\n/skill:git please');
  });

  it('被拦消息覆盖重发在文本未修改时透传语义引用与 chip ranges', async () => {
    const override = vi.fn(async () => {});
    const agentReferences = [{
      kind: 'session' as const,
      start: 0,
      end: 13,
      href: 'cindy://session/source',
      sessionId: 'source',
    }];
    const ranges = {
      agentReferences,
      pastedTextRanges: [{ start: 0, end: 13, display: 'Pasted text (1 line)' }],
      slashCommandRanges: [] as [],
    };
    const box = renderBox({
      initialText: 'original text',
      onCommitOverride: override,
      ...ranges,
    });
    fireEvent.click(box.sendBtn);
    await waitFor(() =>
      expect(override).toHaveBeenCalledWith({
        text: 'original text',
        agentReferences,
        pastedTextRanges: ranges.pastedTextRanges,
        slashCommandRanges: [],
      }),
    );
  });

  it('提交挂起期间重复点发送不会二次提交(同步 ref 防重入)', async () => {
    let release: () => void = () => {};
    commitMock.mockImplementationOnce(
      () => new Promise<void>((r) => { release = r; }),
    );
    const { props, sendBtn } = renderBox();
    fireEvent.click(sendBtn);
    fireEvent.click(sendBtn);
    fireEvent.click(sendBtn);
    expect(commitMock).toHaveBeenCalledTimes(1);
    await act(async () => release());
    await waitFor(() => expect(props.onSent).toHaveBeenCalledTimes(1));
  });

  it('空文本(无附件)发送按钮禁用', () => {
    const { textarea, sendBtn } = renderBox();
    fireEvent.change(textarea, { target: { value: '   ' } });
    expect(sendBtn.disabled).toBe(true);
    expect(commitMock).not.toHaveBeenCalled();
  });

  it('提交失败:toast 报错、保持编辑态(不 onSent),可重试', async () => {
    commitMock.mockRejectedValueOnce(new Error('boom'));
    const { props, sendBtn } = renderBox();
    fireEvent.click(sendBtn);
    await waitFor(() =>
      expect(toast.error).toHaveBeenCalledWith('chat.userMessage.editFailed'),
    );
    expect(props.onSent).not.toHaveBeenCalled();
    // 失败后守卫复位,可再次发送
    fireEvent.click(sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(2));
  });
});

describe('UserMessageEditBox — 运行中发送(停止时机在发送时刻)', () => {
  it('running 时点发送:先 onRequestStop,不提交;sessionRunning 翻 false 后接力提交', async () => {
    const { props, sendBtn, rerender } = renderBox({ sessionRunning: true });
    fireEvent.click(sendBtn);

    expect(props.onRequestStop).toHaveBeenCalledTimes(1);
    expect(commitMock).not.toHaveBeenCalled();

    // stop 完成 → renderer 观察到 idle → effect 接力提交
    rerender(createElement(UserMessageEditBox, { ...props, sessionRunning: false }));
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    await waitFor(() => expect(props.onSent).toHaveBeenCalledTimes(1));
  });

  it('等待停止超时(15s):toast 报错、退回编辑态、不提交', async () => {
    vi.useFakeTimers();
    const { props, sendBtn } = renderBox({ sessionRunning: true });
    fireEvent.click(sendBtn);
    expect(props.onRequestStop).toHaveBeenCalledTimes(1);

    act(() => {
      vi.advanceTimersByTime(15_000);
    });
    expect(toast.error).toHaveBeenCalledWith('chat.userMessage.editStopTimeout');
    expect(commitMock).not.toHaveBeenCalled();
    expect(props.onSent).not.toHaveBeenCalled();
    // 兜底后守卫复位:发送按钮回到可用态
    expect(sendBtn.disabled).toBe(false);
  });

  it('running 时进入编辑不触发 preview;翻 false 后重跑 preview 补提示', async () => {
    const { props, rerender } = renderBox({ sessionRunning: true });
    expect(previewMock).not.toHaveBeenCalled();

    rerender(createElement(UserMessageEditBox, { ...props, sessionRunning: false }));
    await waitFor(() => expect(previewMock).toHaveBeenCalledTimes(1));
  });
});

describe('UserMessageEditBox — 取消与键盘', () => {
  it('取消不产生额外副作用:onCancel 触发,不再 stop、不提交(点铅笔时的中断由 UserMessage 负责,取消后 AI 不恢复是既定语义)', () => {
    const { props, cancelBtn } = renderBox({ sessionRunning: true });
    fireEvent.click(cancelBtn);
    expect(props.onCancel).toHaveBeenCalledTimes(1);
    expect(props.onRequestStop).not.toHaveBeenCalled();
    expect(commitMock).not.toHaveBeenCalled();
  });


  it('Enter 提交,Shift+Enter 不提交,IME 组合中的 Enter 不提交,Esc 取消', async () => {
    const { props, textarea } = renderBox();
    fireEvent.keyDown(textarea, { key: 'Enter', shiftKey: true });
    expect(commitMock).not.toHaveBeenCalled();

    fireEvent.keyDown(textarea, { key: 'Enter', isComposing: true });
    expect(commitMock).not.toHaveBeenCalled();

    fireEvent.keyDown(textarea, { key: 'Escape' });
    expect(props.onCancel).toHaveBeenCalledTimes(1);

    fireEvent.keyDown(textarea, { key: 'Enter' });
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
  });

  it('preview 报告文件改动时渲染回滚提示', async () => {
    previewMock.mockResolvedValueOnce({
      canRewind: true,
      filesChanged: ['a.ts', 'b.ts'],
      insertions: 3,
      deletions: 1,
    });
    const { findByText } = renderBox();
    expect(await findByText('chat.userMessage.editRollbackHint')).toBeTruthy();
  });

  it('preview 为 conversation-only 时明确提示文件不会恢复', async () => {
    previewMock.mockResolvedValueOnce({
      canRewind: true,
      conversationOnly: true,
      filesChanged: [],
      insertions: 0,
      deletions: 0,
    });
    const { findByText } = renderBox();
    expect(await findByText('chat.userMessage.editConversationOnlyHint')).toBeTruthy();
  });

  it('conversation-only 发送把 allowFileRestore=false 传到 rewind commit', async () => {
    previewMock.mockResolvedValueOnce({
      canRewind: true,
      conversationOnly: true,
      filesChanged: [],
      insertions: 0,
      deletions: 0,
    });
    const { findByText, sendBtn } = renderBox();
    await findByText('chat.userMessage.editConversationOnlyHint');
    fireEvent.click(sendBtn);
    await waitFor(() => expect(commitMock).toHaveBeenCalledTimes(1));
    expect(commitMock.mock.calls[0][0]).toMatchObject({
      allowFileRestore: false,
    });
  });
});