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。

10.7 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

const mocks = vi.hoisted(() => ({
  create: vi.fn(),
  prependCreated: vi.fn(),
  removeLocal: vi.fn(),
  purgeSession: vi.fn(),
  preview: vi.fn(),
  previewCleared: vi.fn(),
  discard: vi.fn(async () => ({ discarded: true })),
  commit: vi.fn(async () => ({ committed: true })),
}));

vi.mock('@/lib/sessionService', () => ({ create: mocks.create }));
vi.mock('@/lib/sessionsStore', () => ({
  sessionsStore: { prependCreated: mocks.prependCreated, removeLocal: mocks.removeLocal },
}));
vi.mock('@/lib/makerChatStore', () => ({ makerChatStore: { purgeSession: mocks.purgeSession } }));
vi.mock('@/lib/sessionsBus', () => ({
  emitAutoTitlePreview: mocks.preview,
  emitAutoTitlePreviewCleared: mocks.previewCleared,
}));

import { setDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
import type { Session } from '@/lib/ccAgent.types';
import { groupSessions } from '../lib/projectGrouping';
import { getProvisionalDraftProjectTaskId } from '../lib/provisionalDraftTaskId';

import {
  canOpenProvisionalDraftTask,
  composerDocPlainText,
  discardProvisionalDraftTask,
  ensureProvisionalDraftTask,
  previewProvisionalDraftTitle,
  ProvisionalDraftTaskBusyError,
  provisionalDraftTaskId,
  provisionalDraftTaskIdForCurrentOwner,
  resetProvisionalDraftTaskForTest,
  subscribeProvisionalDraftTask,
  takeProvisionalDraftTask,
  type ProvisionalDraftCreateArgs,
} from '../provisionalDraftTask';

const args = (patch: Partial<ProvisionalDraftCreateArgs> = {}): ProvisionalDraftCreateArgs => ({
  id: 'draft-1',
  agentKind: 'cc',
  model: 'model-a',
  effort: 'high',
  permissionMode: 'auto',
  fastMode: false,
  planModeEnabled: false,
  workingDir: '/repo',
  workspaceKind: 'project',
  extraDirs: [],
  writableDirs: [],
  providerId: null,
  ...patch,
});

describe('provisional draft task', () => {
  beforeEach(() => {
    resetProvisionalDraftTaskForTest();
    vi.clearAllMocks();
    mocks.create.mockImplementation(async (body: { id: string }) => ({ id: body.id, workingDir: '/repo' }));
    (globalThis as { window?: unknown }).window = {
      electronAPI: {
        maker: {
          discardProvisionalSession: mocks.discard,
          commitProvisionalSession: mocks.commit,
        },
      },
    };
  });
  afterEach(() => {
    delete (globalThis as { window?: unknown }).window;
  });

  it('opens one unsent task while typing and reuses it for the same settings', async () => {
    await ensureProvisionalDraftTask(args());
    await ensureProvisionalDraftTask(args());
    expect(mocks.create).toHaveBeenCalledTimes(1);
    expect(mocks.create).toHaveBeenCalledWith(expect.objectContaining({ id: 'draft-1', provisional: true }));
    expect(mocks.prependCreated).toHaveBeenCalledTimes(1);
    expect(provisionalDraftTaskId()).toBe('draft-1');
  });

  it('reopens under the same id when a setting of the task changes', async () => {
    await ensureProvisionalDraftTask(args());
    await ensureProvisionalDraftTask(args({ model: 'model-b' }));
    expect(mocks.discard).toHaveBeenCalledWith('draft-1');
    expect(mocks.removeLocal).toHaveBeenCalledWith('draft-1');
    expect(mocks.create).toHaveBeenCalledTimes(2);
    expect(mocks.create.mock.calls[1]?.[0]).toMatchObject({ id: 'draft-1', model: 'model-b' });
  });

  it('deletes the task when the input is cleared', async () => {
    await ensureProvisionalDraftTask(args());
    previewProvisionalDraftTitle('Fix the login bug');
    await discardProvisionalDraftTask();
    expect(mocks.discard).toHaveBeenCalledWith('draft-1');
    expect(mocks.previewCleared).toHaveBeenCalledWith('draft-1');
    expect(provisionalDraftTaskId()).toBeNull();
  });

  it('hands the task to the send when the settings still match', async () => {
    await ensureProvisionalDraftTask(args());
    const taken = await takeProvisionalDraftTask(args());
    expect(taken?.id).toBe('draft-1');
    expect(mocks.commit).toHaveBeenCalledWith('draft-1');
    expect(mocks.discard).not.toHaveBeenCalled();
    expect(provisionalDraftTaskId()).toBeNull();
  });

  // Unit regression for the 2026-10-23 sidebar jump: the old tests only checked
  // the final handoff, not grouping during commit or when draft identity clears.
  it('keeps the task in its project throughout the asynchronous send handoff', async () => {
    const row = await ensureProvisionalDraftTask(args()) as Session;
    const placements: string[][] = [];
    const observe = () => placements.push(groupSessions([row], {
      provisionalDraftTaskId: getProvisionalDraftProjectTaskId(),
    }).unclassified.map((s) => s.id));
    mocks.commit.mockImplementationOnce(async () => {
      observe();
      await Promise.resolve();
      observe();
      return { committed: true };
    });
    const unsubscribe = subscribeProvisionalDraftTask(observe);
    try {
      await takeProvisionalDraftTask(args());
      observe();
      expect(placements.length).toBeGreaterThan(0);
      expect(placements.every((ids) => ids.length === 0)).toBe(true);
      // Even a late pre-send snapshot stays in the project; navigation must
      // already treat the id as an ordinary task rather than redirect to /new.
      expect(provisionalDraftTaskId()).toBeNull();
      expect(groupSessions([{ ...row, userSendAt: null }], {
        provisionalDraftTaskId: getProvisionalDraftProjectTaskId(),
      }).projects[0]?.sessions[0]?.id).toBe('draft-1');
      await ensureProvisionalDraftTask(args({ id: 'draft-2' }));
      expect(getProvisionalDraftProjectTaskId()).toBe('draft-2');
      await discardProvisionalDraftTask();
      expect(getProvisionalDraftProjectTaskId()).toBeNull();
    } finally {
      unsubscribe();
    }
  });

  // Empty checks wait in the existing serial queue; resumed input must win
  // even if the timeout fired before an in-flight create finished (unit).
  it('rechecks an empty cleanup when its queued operation actually runs', async () => {
    const opening = ensureProvisionalDraftTask(args());
    let empty = true;
    const discarding = discardProvisionalDraftTask(() => empty);
    empty = false;
    await opening;
    await discarding;
    expect(provisionalDraftTaskId()).toBe('draft-1');
    expect(mocks.discard).not.toHaveBeenCalled();
  });

  it('deletes it first when the send uses different settings, so the normal create can reuse the id', async () => {
    await ensureProvisionalDraftTask(args());
    await expect(takeProvisionalDraftTask(args({ effort: 'low' }))).resolves.toBeNull();
    expect(mocks.discard).toHaveBeenCalledWith('draft-1');
    expect(mocks.commit).not.toHaveBeenCalled();
  });

  it('runs operations in order, so a send never races a half-open task', async () => {
    let release: () => void = () => {};
    mocks.create.mockImplementationOnce(
      (body: { id: string }) =>
        new Promise((resolve) => {
          release = () => resolve({ id: body.id, workingDir: '/repo' });
        }),
    );
    const opening = ensureProvisionalDraftTask(args());
    const taking = takeProvisionalDraftTask(args());
    await vi.waitFor(() => expect(mocks.create).toHaveBeenCalled());
    expect(mocks.commit).not.toHaveBeenCalled();
    release();
    await opening;
    await expect(taking).resolves.toMatchObject({ id: 'draft-1' });
    expect(mocks.commit).toHaveBeenCalledWith('draft-1');
  });

  it('keeps tracking the task when it could not be deleted, instead of reopening the same id', async () => {
    await ensureProvisionalDraftTask(args());
    mocks.discard
      .mockResolvedValueOnce({ discarded: false, remaining: true } as never)
      .mockResolvedValueOnce({ discarded: false, remaining: true } as never);
    await discardProvisionalDraftTask();
    expect(provisionalDraftTaskId()).toBe('draft-1');
    expect(mocks.removeLocal).not.toHaveBeenCalled();
    // A settings change cannot reopen over the still-existing row; the next attempt retries the delete.
    await expect(ensureProvisionalDraftTask(args({ model: 'model-b' }))).resolves.toBeNull();
    expect(mocks.create).toHaveBeenCalledTimes(1);
    await ensureProvisionalDraftTask(args({ model: 'model-b' }));
    expect(mocks.create).toHaveBeenCalledTimes(2);
  });

  it('refuses a send that would recreate the same id while the old unsent task still exists', async () => {
    await ensureProvisionalDraftTask(args());
    mocks.discard.mockResolvedValueOnce({ discarded: false, remaining: true } as never);
    await expect(takeProvisionalDraftTask(args({ effort: 'low' }))).rejects.toBeInstanceOf(
      ProvisionalDraftTaskBusyError,
    );
    expect(provisionalDraftTaskId()).toBe('draft-1');
  });

  it('fails the send instead of handing over a task whose account changed while committing', async () => {
    setDataOwnerGeneration('account-a', 1);
    await ensureProvisionalDraftTask(args());
    mocks.commit.mockImplementationOnce(async () => {
      setDataOwnerGeneration('account-b', 2);
      return { committed: false };
    });
    await expect(takeProvisionalDraftTask(args())).rejects.toBeInstanceOf(ProvisionalDraftTaskBusyError);
    setDataOwnerGeneration(null, 0);
  });

  it('never hands another account\'s unsent task to a send after an account switch', async () => {
    setDataOwnerGeneration('account-a', 1);
    await ensureProvisionalDraftTask(args());
    setDataOwnerGeneration('account-b', 2);
    // A new-task page opened in the new account mints its own id instead of reusing this one.
    expect(provisionalDraftTaskIdForCurrentOwner()).toBeNull();
    await expect(takeProvisionalDraftTask(args())).resolves.toBeNull();
    expect(mocks.commit).not.toHaveBeenCalled();
    // Not deleted from the new account's database either.
    expect(mocks.discard).not.toHaveBeenCalled();
    expect(provisionalDraftTaskId()).toBeNull();
    setDataOwnerGeneration(null, 0);
  });

  it('does not open tasks for drafts that run elsewhere or need writable folders', () => {
    expect(canOpenProvisionalDraftTask(args())).toBe(true);
    expect(canOpenProvisionalDraftTask(args({ workspaceKind: 'dialogue', workingDir: undefined }))).toBe(true);
    expect(canOpenProvisionalDraftTask(args({ remoteHostId: 'ssh-1' }))).toBe(false);
    expect(canOpenProvisionalDraftTask(args({ agentDeviceId: 'other' }))).toBe(false);
    expect(canOpenProvisionalDraftTask(args({ writableDirs: ['/out'] }))).toBe(false);
    expect(canOpenProvisionalDraftTask(args({ workingDir: undefined }))).toBe(false);
  });

  it('reads the composer text for the title preview', () => {
    expect(
      composerDocPlainText({
        type: 'doc',
        content: [
          { type: 'paragraph', content: [{ type: 'text', text: 'Fix ' }, { type: 'text', text: 'login' }] },
          { type: 'paragraph', content: [{ type: 'text', text: 'today' }] },
        ],
      }),
    ).toBe('Fix login\ntoday');
    expect(composerDocPlainText(null)).toBe('');
  });
});