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。

11.2 KB
Raw Blame
// @vitest-environment jsdom
import { act, cleanup, renderHook } from '@testing-library/react';
import { afterEach, expect, it, vi } from 'vitest';
import { useRemoteSessionSync } from '../features/cc-agent/hooks/useRemoteSessionSync';

const mocks = vi.hoisted(() => ({ reconcile: vi.fn(async () => true), running: false }));
vi.mock('@/lib/makerChatStore', () => ({
  makerChatStore: {
    reconcileRemoteMessages: mocks.reconcile,
    getSnapshot: () => ({ agentStatus: { isRunning: mocks.running } }),
    subscribe: () => () => {},
    getLastInboundEventAt: () => Date.now(),
  },
}));
vi.mock('@/lib/logger', () => ({
  createLogger: () => ({ info: vi.fn(), debug: vi.fn(), warn: vi.fn() }),
}));
vi.mock('@/lib/makerTransport', () => ({ isSessionTurnRunningFor: async () => true }));
vi.mock('@/features/device-link/remoteProjectsStore', () => ({
  remoteProjectsStore: { getDeviceIds: () => ['host', 'neighbor'], getDeviceName: () => 'host', subscribe: () => () => {} },
}));
vi.mock('@/features/device-link/refreshRemoteSessions', () => ({
  refreshRemoteDeviceSessions: vi.fn(),
}));
afterEach(() => {
  cleanup();
  vi.useRealTimers();
  vi.unstubAllGlobals();
});

function recoveryEvents() {
  function event<T>() {
    const listeners = new Set<(payload: T) => void>();
    return {
      on: (cb: (payload: T) => void) => { listeners.add(cb); return () => { listeners.delete(cb); }; },
      emit: (payload: T) => listeners.forEach((cb) => cb(payload)),
    };
  }
  const status = event<{ status: string }>();
  const presence = event<{ deviceId: string; online: boolean; remoteControlEnabled: boolean }>();
  const responsiveness = event<{ deviceId: string; unresponsive: boolean; recovered: boolean }>();
  const subscribe = vi.fn(async () => {});
  vi.stubGlobal('electronAPI', { deviceLink: {
    subscribe, unsubscribe: async () => {},
    onStatusChanged: status.on,
    onPresenceChanged: presence.on,
    onResponsivenessChanged: responsiveness.on,
  } });
  mocks.running = false;
  mocks.reconcile.mockResolvedValue(true);
  return { status, presence, responsiveness, subscribe };
}

it.each(['focus', 'manual', 'presence', 'relay', 'response'])('allows %s recovery after a terminal reply clears the breaker', async (trigger) => {
  vi.useFakeTimers();
  const events = recoveryEvents();
  const hook = renderHook(() => useRemoteSessionSync('session', 'host'));
  const neighbor = renderHook(() => useRemoteSessionSync('neighbor-session', 'neighbor'));
  await act(async () => {
    events.status.emit({ status: 'online' });
    await vi.advanceTimersByTimeAsync(250);
  });
  expect(hook.result.current.contentState).toBe('ready');
  const callsBeforeClear = events.subscribe.mock.calls.length;
  await act(async () => {
    events.responsiveness.emit({ deviceId: 'host', unresponsive: true, recovered: false });
    events.responsiveness.emit({ deviceId: 'host', unresponsive: false, recovered: false });
    await vi.advanceTimersByTimeAsync(60_000);
  });
  expect(hook.result.current.contentState).toBe('syncing');
  expect(neighbor.result.current.contentState).toBe('ready');
  expect(events.subscribe).toHaveBeenCalledTimes(callsBeforeClear);
  await act(async () => {
    if (trigger === 'focus') window.dispatchEvent(new Event('focus'));
    else if (trigger === 'manual') hook.result.current.resync();
    else if (trigger === 'presence') events.presence.emit({ deviceId: 'host', online: true, remoteControlEnabled: true });
    else if (trigger === 'relay') events.status.emit({ status: 'online' });
    else events.responsiveness.emit({ deviceId: 'host', unresponsive: false, recovered: true });
    await vi.advanceTimersByTimeAsync(250);
  });
  expect(hook.result.current.contentState).toBe('ready');
  expect(neighbor.result.current.contentState).toBe('ready');
  hook.unmount();
  neighbor.unmount();
});

it.each(['relay', 'peer', 'disabled', 'unresponsive'])('does not resume cleared history while %s is unavailable', async (reason) => {
  vi.useFakeTimers();
  const events = recoveryEvents();
  const hook = renderHook(() => useRemoteSessionSync('session', 'host'));
  await act(async () => { await vi.advanceTimersByTimeAsync(250); });
  const callsBeforeClear = events.subscribe.mock.calls.length;
  await act(async () => {
    events.responsiveness.emit({ deviceId: 'host', unresponsive: true, recovered: false });
    events.responsiveness.emit({ deviceId: 'host', unresponsive: false, recovered: false });
    if (reason === 'relay') events.status.emit({ status: 'offline' });
    else if (reason === 'unresponsive') events.responsiveness.emit({ deviceId: 'host', unresponsive: true, recovered: false });
    else events.presence.emit({ deviceId: 'host', online: reason !== 'peer', remoteControlEnabled: reason !== 'disabled' });
    hook.result.current.resync();
    window.dispatchEvent(new Event('focus'));
    await vi.advanceTimersByTimeAsync(60_000);
  });
  expect(events.subscribe).toHaveBeenCalledTimes(callsBeforeClear);
  expect(hook.result.current.contentState).toBe('syncing');
  await act(async () => {
    if (reason === 'relay') events.status.emit({ status: 'online' });
    else if (reason === 'unresponsive') events.responsiveness.emit({ deviceId: 'host', unresponsive: false, recovered: true });
    else events.presence.emit({ deviceId: 'host', online: true, remoteControlEnabled: true });
    await vi.advanceTimersByTimeAsync(250);
  });
  expect(hook.result.current.contentState).toBe('ready');
  hook.unmount();
});

it('requires a fresh ACK and snapshot after peer-only resets without invalidating neighbors', async () => {
  vi.useFakeTimers();
  const resets = new Set<(payload: { deviceId: string }) => void>();
  const subscribe = vi.fn(async () => {});
  vi.stubGlobal('electronAPI', {
    deviceLink: {
      subscribe,
      unsubscribe: async () => {},
      onStatusChanged: () => () => {},
      onPresenceChanged: () => () => {},
      onResponsivenessChanged: () => () => {},
      onPeerLinkReset: (cb: (payload: { deviceId: string }) => void) => {
        resets.add(cb);
        return () => resets.delete(cb);
      },
    },
  });
  mocks.running = false;
  mocks.reconcile.mockResolvedValue(true);
  const affected = renderHook(() => useRemoteSessionSync('session', 'host'));
  const neighbor = renderHook(() => useRemoteSessionSync('neighbor-session', 'neighbor'));
  await act(async () => {
    await vi.advanceTimersByTimeAsync(0);
  });
  expect(affected.result.current.contentState).toBe('ready');
  expect(mocks.reconcile).toHaveBeenCalledWith('session', { freshHistory: true });
  expect(neighbor.result.current.contentState).toBe('ready');

  let ack!: () => void;
  let oldSnapshot!: (value: boolean) => void;
  let newSnapshot!: (value: boolean) => void;
  subscribe.mockImplementationOnce(
    () =>
      new Promise<void>((resolve) => {
        ack = resolve;
      }),
  );
  mocks.reconcile
    .mockImplementationOnce(
      () =>
        new Promise<boolean>((resolve) => {
          oldSnapshot = resolve;
        }),
    )
    .mockImplementationOnce(
      () =>
        new Promise<boolean>((resolve) => {
          newSnapshot = resolve;
        }),
    );
  const callsBeforeReset = mocks.reconcile.mock.calls.length;
  await act(async () => {
    resets.forEach((cb) => cb({ deviceId: 'host' }));
    await vi.advanceTimersByTimeAsync(0);
  });
  expect(affected.result.current.contentState).toBe('syncing');
  expect(neighbor.result.current.contentState).toBe('ready');
  expect(mocks.reconcile).toHaveBeenCalledTimes(callsBeforeReset);
  await act(async () => {
    ack();
    await vi.advanceTimersByTimeAsync(0);
  });
  expect(affected.result.current.contentState).toBe('syncing');
  await act(async () => {
    resets.forEach((cb) => cb({ deviceId: 'host' }));
    await vi.advanceTimersByTimeAsync(0);
  });
  await act(async () => {
    oldSnapshot(true);
    await vi.advanceTimersByTimeAsync(0);
  });
  expect(affected.result.current.contentState).toBe('syncing');
  expect(neighbor.result.current.contentState).toBe('ready');
  await act(async () => {
    newSnapshot(true);
    await vi.advanceTimersByTimeAsync(0);
  });
  expect(affected.result.current.contentState).toBe('ready');
  affected.unmount();
  neighbor.unmount();
  expect(resets.size).toBe(0);
});

it('does not reset a recovered mounted task on its first busy presence update', async () => {
  vi.useFakeTimers();
  let presence!: (snapshot: {
    deviceId: string;
    online: boolean;
    remoteControlEnabled: boolean;
    busy: boolean;
  }) => void;
  vi.stubGlobal('electronAPI', undefined);
  Object.defineProperty(window, 'electronAPI', {
    configurable: true,
    value: {
      deviceLink: {
        subscribe: async () => {},
        unsubscribe: async () => {},
        onStatusChanged: () => () => {},
        onPresenceChanged: (cb: typeof presence) => {
          presence = cb;
          return () => {};
        },
        onResponsivenessChanged: () => () => {},
      },
    },
  });
  mocks.running = false;
  mocks.reconcile.mockResolvedValue(true);
  const hook = renderHook(() => useRemoteSessionSync('session', 'host'));
  await act(async () => {
    await vi.advanceTimersByTimeAsync(0);
  });
  expect(hook.result.current.contentState).toBe('ready');
  mocks.running = true;
  mocks.reconcile.mockResolvedValue(false);
  act(() => presence({ deviceId: 'host', online: true, remoteControlEnabled: true, busy: true }));
  await act(async () => {
    await vi.advanceTimersByTimeAsync(250);
  });
  expect(hook.result.current.contentState).toBe('ready');
  act(() => presence({ deviceId: 'host', online: false, remoteControlEnabled: true, busy: true }));
  expect(hook.result.current.contentState).toBe('syncing');
  act(() => presence({ deviceId: 'host', online: true, remoteControlEnabled: true, busy: true }));
  await act(async () => {
    await vi.advanceTimersByTimeAsync(250);
  });
  expect(hook.result.current.contentState).toBe('syncing');
  hook.unmount();
});

it.each(['relay', 'peer', 'disabled', 'unresponsive'])('releases the local topic on offline unmount (%s)', async (reason) => {
  vi.useFakeTimers();
  const unsubscribe = vi.fn(async () => {});
  let status!: (value: { status: string }) => void;
  let presence!: (value: { deviceId: string; online: boolean; remoteControlEnabled: boolean }) => void;
  let responsiveness!: (value: { deviceId: string; unresponsive: boolean }) => void;
  vi.stubGlobal('electronAPI', {
    deviceLink: {
      subscribe: vi.fn(async () => {}), unsubscribe,
      onStatusChanged: (cb: typeof status) => { status = cb; return () => {}; },
      onPresenceChanged: (cb: typeof presence) => { presence = cb; return () => {}; },
      onResponsivenessChanged: (cb: typeof responsiveness) => { responsiveness = cb; return () => {}; },
    },
  });
  mocks.running = false;
  mocks.reconcile.mockResolvedValue(true);
  const hook = renderHook(() => useRemoteSessionSync('session', 'host'));
  await act(async () => { await vi.advanceTimersByTimeAsync(0); });
  act(() => {
    if (reason === 'relay') status({ status: 'offline' });
    else if (reason === 'unresponsive') responsiveness({ deviceId: 'host', unresponsive: true });
    else presence({ deviceId: 'host', online: reason !== 'peer', remoteControlEnabled: reason !== 'disabled' });
  });
  hook.unmount();
  expect(unsubscribe).toHaveBeenCalledExactlyOnceWith('host', ['session:session']);
});