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。

13.1 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { projectScheduleEvent } from '@cindy/maker-shared/schedule-events';
import type { MobileMakerTransport } from '@/device-link/mobileMakerTransport';
import { markSessionScheduleRunsRead, unreadRunIdFromProjection } from '@/session/scheduleRunRead';
import { remoteScheduleEventStore } from '@/scheduler/remoteScheduleEvents';
import { getScheduleIndexInvalidationVersion, invalidateScheduleIndexForDevice, invalidateScheduleIndexesAfterLinkRecovery, loadSessionScheduleIndex, loadSessionScheduleIndexThrottled, loadSharedSessionScheduleIndex, resetScheduleIndexThrottleForTesting } from '@/session/scheduleIndex';

function makerWith(
  runs: readonly Record<string, unknown>[],
  markRunRead: (runId: string) => Promise<void>,
  listRuns?: (scheduleId: string, limit?: number) => Promise<readonly Record<string, unknown>[]>,
): Pick<MobileMakerTransport, 'schedule'> {
  return {
    schedule: {
      list: async () => [{ id: 'sched-1', name: '日报', status: 'active' }],
      listRuns: listRuns ?? (async () => runs),
      markRunRead,
    },
  } as unknown as Pick<MobileMakerTransport, 'schedule'>;
}

function transientError(message = 'target timed out'): Error & { code: string } {
  return Object.assign(new Error(message), { code: 'INVOKE_TIMEOUT' });
}

describe('markSessionScheduleRunsRead', () => {
  beforeEach(resetScheduleIndexThrottleForTesting);
  it('applies the read locally so Home reconciles badges even when the host sends no broadcast', async () => {
    // Already read elsewhere: the host's markRunRead is a no-op and broadcasts nothing.
    remoteScheduleEventStore.clearDevice('dev-echo');
    const maker = makerWith(
      [{ id: 'run-1', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 1 }],
      async () => undefined,
    );
    const before = remoteScheduleEventStore.getSnapshot('dev-echo').sessionIndexVersion;
    await expect(markSessionScheduleRunsRead(maker, 'session-1', 'dev-echo')).resolves.toEqual(['run-1']);
    const after = remoteScheduleEventStore.getSnapshot('dev-echo');
    expect(after.sessionIndexVersion).toBe(before + 1);
    expect(after.lastProjection?.runPatch.status).toBe('read');
    expect(getScheduleIndexInvalidationVersion('dev-echo')).toBeGreaterThan(0);

    // Nothing to mark: no local event.
    await expect(markSessionScheduleRunsRead(makerWith([], async () => undefined), 'session-2', 'dev-echo')).resolves.toEqual([]);
    expect(remoteScheduleEventStore.getSnapshot('dev-echo').sessionIndexVersion).toBe(before + 1);
    remoteScheduleEventStore.clearDevice('dev-echo');
  });
  it('finds runs completed while disconnected even when the old success cache is still fresh', async () => {
    const mark = vi.fn(async () => undefined);
    const listRuns = vi.fn().mockResolvedValueOnce([]).mockResolvedValue([
      { id: 'run-offline', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 1 },
    ]);
    const maker = makerWith([], mark, listRuns);
    await loadSharedSessionScheduleIndex('dev-1', maker);
    // No completed push arrives during disconnection. Recovery alone must refresh.
    invalidateScheduleIndexesAfterLinkRecovery();
    const home = loadSharedSessionScheduleIndex('dev-1', maker);
    await expect(markSessionScheduleRunsRead(maker, 'session-1', 'dev-1')).resolves.toEqual(['run-offline']);
    await home;
    expect(listRuns).toHaveBeenCalledTimes(2);
    expect(mark).toHaveBeenCalledExactlyOnceWith('run-offline');
  });
  it('retries a transient scan inside the shared load before caching failure', async () => {
    const mark = vi.fn(async () => undefined);
    const listRuns = vi.fn().mockRejectedValueOnce(transientError()).mockResolvedValue([
      { id: 'run-1', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 1 },
    ]);
    const maker = makerWith([], mark, listRuns);
    const home = loadSharedSessionScheduleIndex('dev-1', maker);
    const task = markSessionScheduleRunsRead(maker, 'session-1', 'dev-1');
    await home;
    await expect(task).resolves.toEqual(['run-1']);
    expect(listRuns).toHaveBeenCalledTimes(2);
  });

  it('abandons a queued refresh after blur without poisoning the next visible consumer', async () => {
    let finish!: (index: Map<string, never>) => void;
    const old = loadSessionScheduleIndexThrottled('dev-1', () => new Promise((resolve) => { finish = resolve; }));
    invalidateScheduleIndexForDevice('dev-1');
    let active = true;
    const listRuns = vi.fn(async () => []);
    const maker = makerWith([], vi.fn(async () => undefined), listRuns);
    const task = markSessionScheduleRunsRead(maker, 'session-1', 'dev-1', () => active);
    const assertion = expect(task).rejects.toThrow('consumer inactive');
    active = false;
    finish(new Map<string, never>());
    await old;
    await assertion;
    expect(listRuns).not.toHaveBeenCalled();
    await markSessionScheduleRunsRead(maker, 'session-1', 'dev-1');
    expect(listRuns).toHaveBeenCalledTimes(1);
  });
  it('marks only the target session unread runs as read', async () => {
    const markRunRead = vi.fn(async () => undefined);
    const maker = makerWith([
      { id: 'run-mine-unread', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 1 },
      { id: 'run-mine-read', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 2, readAt: 3 },
      { id: 'run-other-session', scheduleId: 'sched-1', sessionId: 'session-2', status: 'success', firedAt: 4 },
      { id: 'run-still-running', scheduleId: 'sched-1', sessionId: 'session-1', status: 'running', firedAt: 5 },
    ], markRunRead);

    const marked = await markSessionScheduleRunsRead(maker, 'session-1', 'dev-1');

    expect(marked).toEqual(['run-mine-unread']);
    expect(markRunRead).toHaveBeenCalledTimes(1);
    expect(markRunRead).toHaveBeenCalledWith('run-mine-unread');
  });

  it('returns empty without invoking markRunRead when the session has no unread runs', async () => {
    const markRunRead = vi.fn(async () => undefined);
    const maker = makerWith([
      { id: 'run-read', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 1, readAt: 2 },
    ], markRunRead);

    await expect(markSessionScheduleRunsRead(maker, 'session-1', 'dev-1')).resolves.toEqual([]);
    await expect(markSessionScheduleRunsRead(maker, '', 'dev-1')).resolves.toEqual([]);
    expect(markRunRead).not.toHaveBeenCalled();
  });

  it('keeps marking the remaining runs when one markRunRead call fails', async () => {
    const markRunRead = vi.fn(async (runId: string) => {
      if (runId === 'run-a') throw new Error('device offline');
    });
    const maker = makerWith([
      { id: 'run-a', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 1 },
      { id: 'run-b', scheduleId: 'sched-1', sessionId: 'session-1', status: 'failed', firedAt: 2 },
    ], markRunRead);

    const marked = await markSessionScheduleRunsRead(maker, 'session-1', 'dev-1');

    expect(marked).toEqual(['run-b']);
    expect(markRunRead).toHaveBeenCalledTimes(2);
  });

  it('rejects after the shared transient scan retry is exhausted', async () => {
    vi.useFakeTimers();
    const error = transientError();
    const markRunRead = vi.fn(async () => undefined);
    const maker = makerWith([], markRunRead, async () => {
      throw error;
    });

    try {
      const assertion = expect(markSessionScheduleRunsRead(maker, 'session-1', 'dev-1')).rejects.toBe(error);
      await vi.runAllTimersAsync();
      await assertion;
      expect(markRunRead).not.toHaveBeenCalled();
    } finally { vi.useRealTimers(); }
  });

  it('rejects on transient markRunRead failures so the caller retry wrapper can rerun the mark', async () => {
    const error = transientError('device offline');
    const markRunRead = vi.fn(async (runId: string) => {
      if (runId === 'run-a') throw error;
    });
    const maker = makerWith([
      { id: 'run-a', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 1 },
      { id: 'run-b', scheduleId: 'sched-1', sessionId: 'session-1', status: 'failed', firedAt: 2 },
    ], markRunRead);

    await expect(markSessionScheduleRunsRead(maker, 'session-1', 'dev-1')).rejects.toBe(error);
    expect(markRunRead).toHaveBeenCalledTimes(2);
  });

  it('returns marked run ids in the original unread order regardless of resolution timing', async () => {
    const markRunRead = vi.fn((runId: string) => new Promise<void>((resolve) => {
      // run-a 比 run-b 晚 resolve,返回值仍应保持 unreadRunIds 原序。
      setTimeout(resolve, runId === 'run-a' ? 20 : 0);
    }));
    const maker = makerWith([
      { id: 'run-a', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 1 },
      { id: 'run-b', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 2 },
    ], markRunRead);

    await expect(markSessionScheduleRunsRead(maker, 'session-1', 'dev-1')).resolves.toEqual(['run-a', 'run-b']);
  });

  it('reuses the home scan across ordinary task visits without losing bound task receipts', async () => {
    const listRuns = vi.fn(async () => [
      { id: 'run-1', scheduleId: 'sched-1', sessionId: 'bound-task', status: 'success', firedAt: 1 },
    ]);
    const mark = vi.fn(async () => undefined);
    const maker = makerWith([], mark, listRuns);
    await loadSessionScheduleIndexThrottled('dev-1', () => loadSessionScheduleIndex(maker));
    await markSessionScheduleRunsRead(maker, 'ordinary-1', 'dev-1');
    await markSessionScheduleRunsRead(maker, 'ordinary-2', 'dev-1');
    await markSessionScheduleRunsRead(maker, 'bound-task', 'dev-1');
    expect(listRuns).toHaveBeenCalledTimes(1);
    expect(mark).toHaveBeenCalledExactlyOnceWith('run-1');
  });

  it('does not start a scan when inactive or mark receipts after leaving during a shared scan', async () => {
    let finish!: (runs: Record<string, unknown>[]) => void;
    const listRuns = vi.fn(() => new Promise<Record<string, unknown>[]>((resolve) => { finish = resolve; }));
    const mark = vi.fn(async () => undefined);
    const maker = makerWith([], mark, listRuns);
    await markSessionScheduleRunsRead(maker, 'session-1', 'dev-1', () => false);
    expect(listRuns).not.toHaveBeenCalled();
    let active = true;
    const pending = markSessionScheduleRunsRead(maker, 'session-1', 'dev-1', () => active);
    await vi.waitFor(() => expect(listRuns).toHaveBeenCalledTimes(1));
    active = false;
    finish([{ id: 'run-1', scheduleId: 'sched-1', sessionId: 'session-1', status: 'success', firedAt: 1 }]);
    await expect(pending).resolves.toEqual([]);
    expect(mark).not.toHaveBeenCalled();
  });
});

describe('unreadRunIdFromProjection', () => {
  it('returns the runId for a completed run bound to this session', () => {
    const projection = projectScheduleEvent({
      type: 'completed',
      scheduleId: 'sched-1',
      runId: 'run-1',
      sessionId: 'session-1',
    });
    expect(unreadRunIdFromProjection(projection, 'session-1')).toBe('run-1');
  });

  it('ignores events for other sessions and non-terminal statuses', () => {
    const completedElsewhere = projectScheduleEvent({
      type: 'completed',
      scheduleId: 'sched-1',
      runId: 'run-1',
      sessionId: 'session-2',
    });
    const bound = projectScheduleEvent({
      type: 'session-bound',
      scheduleId: 'sched-1',
      runId: 'run-1',
      sessionId: 'session-1',
    });
    expect(unreadRunIdFromProjection(completedElsewhere, 'session-1')).toBeNull();
    expect(unreadRunIdFromProjection(bound, 'session-1')).toBeNull();
    expect(unreadRunIdFromProjection(null, 'session-1')).toBeNull();
  });

  it('does not re-trigger on the read event broadcast after marking', () => {
    const readEvent = projectScheduleEvent({ type: 'read', scheduleId: 'sched-1' });
    expect(unreadRunIdFromProjection(readEvent, 'session-1')).toBeNull();
  });

  it('returns null for failed events: they carry no sessionId and are handled by the index probe path', () => {
    const failedEvent = projectScheduleEvent({
      type: 'failed',
      scheduleId: 'sched-1',
      runId: 'run-1',
      error: 'agent crashed',
    });
    expect(unreadRunIdFromProjection(failedEvent, 'session-1')).toBeNull();
  });
});

it('shares the cached index with the notice and ignores a late result after leaving', async () => {
  resetScheduleIndexThrottleForTesting();
  const markRunRead = vi.fn(async () => undefined);
  const runs = [{ id: 'r', scheduleId: 'sched-1', sessionId: 'session-1', status: 'failed', firedAt: 1 }];
  let finish!: (value: typeof runs) => void;
  const rows = new Promise<typeof runs>((resolve) => { finish = resolve; });
  const maker = makerWith([], markRunRead, () => rows);
  const onIndex = vi.fn();
  let active = true;
  const pending = markSessionScheduleRunsRead(maker, 'session-1', 'notice-device', () => active, { onIndex });
  active = false; finish(runs); await pending;
  expect(onIndex).not.toHaveBeenCalled(); expect(markRunRead).not.toHaveBeenCalled();
  await markSessionScheduleRunsRead(maker, 'session-1', 'notice-device', () => true, { onIndex });
  expect(onIndex.mock.calls[0][0].get('session-1')).toMatchObject({ latestFailedRun: { runId: 'r', firedAt: 1 } });
  expect(markRunRead).toHaveBeenCalledWith('r');
});