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。

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

import {
  createReconcileBackoff,
  createRemoteReconcilePresence,
  nextArchivedSessionRetryDelay,
  nextSessionListTokenRetryDelay,
  resolveIneligibleRemoteProjectAction,
  startRemoteSessionsReconciler,
  startSessionListTokenRefresh,
} from '@/features/device-link/useDeviceLinkRemoteProjects';

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

describe('session-list owner token retry backoff', () => {
  it('从 2s 指数退避到 30s 后仍持续恢复,cleanup 停旧循环,新账号从 2s 重启', async () => {
    vi.useFakeTimers();
    const refresh = vi.fn(async () => undefined);
    const stop = startSessionListTokenRefresh(refresh, () => false);
    await vi.advanceTimersByTimeAsync(0); // 首次立即补读
    expect(refresh).toHaveBeenCalledTimes(1);

    // 实际循环的间隔序列:2s → 4s → 8s → 16s → 30s → 30s,封顶后不停止。
    for (const [index, delay] of [2_000, 4_000, 8_000, 16_000, 30_000, 30_000].entries()) {
      await vi.advanceTimersByTimeAsync(delay - 1);
      expect(refresh).toHaveBeenCalledTimes(index + 1);
      await vi.advanceTimersByTimeAsync(1);
      expect(refresh).toHaveBeenCalledTimes(index + 2);
    }

    stop();
    await vi.advanceTimersByTimeAsync(60_000);
    expect(refresh).toHaveBeenCalledTimes(7); // 旧账号 timer 已取消

    // effect 在新账号边界重建启动器:立即补读一次,首次重试重新回到 2s(不是继承 30s)。
    const stopNextOwner = startSessionListTokenRefresh(refresh, () => false);
    await vi.advanceTimersByTimeAsync(0);
    expect(refresh).toHaveBeenCalledTimes(8);
    await vi.advanceTimersByTimeAsync(1_999);
    expect(refresh).toHaveBeenCalledTimes(8);
    await vi.advanceTimersByTimeAsync(1);
    expect(refresh).toHaveBeenCalledTimes(9);
    stopNextOwner();
  });

  it('readiness 就位后不再排后续补读', async () => {
    vi.useFakeTimers();
    let ready = false;
    const refresh = vi.fn(async () => {
      ready = true;
    });
    const stop = startSessionListTokenRefresh(refresh, () => ready);
    await vi.advanceTimersByTimeAsync(0);
    await vi.advanceTimersByTimeAsync(60_000);
    expect(refresh).toHaveBeenCalledTimes(1);
    stop();
  });

  it('纯延迟函数保持 2s 到 30s 封顶', () => {
    const delays: number[] = [];
    let previous = 0;
    for (let i = 0; i < 7; i += 1) {
      previous = nextSessionListTokenRetryDelay(previous);
      delays.push(previous);
    }
    expect(delays).toEqual([2_000, 4_000, 8_000, 16_000, 30_000, 30_000, 30_000]);
  });
});

describe('archived session retry backoff', () => {
  it('从 2s 指数退避到 30s,并在成功或生命周期清理后可从首档重启', () => {
    const delays: number[] = [];
    let previous = 0;
    for (let i = 0; i < 7; i += 1) {
      previous = nextArchivedSessionRetryDelay(previous);
      delays.push(previous);
    }
    expect(delays).toEqual([2_000, 4_000, 8_000, 16_000, 30_000, 30_000, 30_000]);
    expect(nextArchivedSessionRetryDelay(0)).toBe(2_000);
  });
});

describe('startRemoteSessionsReconciler', () => {
  it('keeps a healthy third peer independent of two stalled peers and stops cleanly', async () => {
    vi.useFakeTimers();
    const refresh = vi.fn((id: string) => id === 'healthy' ? Promise.resolve('ok') : new Promise<string>(() => {}));
    const { wake, stop } = startRemoteSessionsReconciler(
      () => new Map([['a', 'A'], ['b', 'B'], ['healthy', 'C']]), refresh, 1000,
    );
    wake();
    expect(refresh.mock.calls.map(([id]) => id)).toEqual(['a', 'b', 'healthy']);
    await vi.advanceTimersByTimeAsync(1000);
    expect(refresh.mock.calls.map(([id]) => id)).toEqual(['a', 'b', 'healthy', 'healthy']);
    stop();
    wake();
    await vi.advanceTimersByTimeAsync(1000);
    expect(refresh).toHaveBeenCalledTimes(4);
  });
  it('preserves failure backoff while a window is hidden', async () => {
    vi.useFakeTimers();
    let visible = true;
    const refresh = vi.fn(async () => 'gave-up');
    const backoff = createReconcileBackoff({ baseMs: 10_000, jitter: (ms) => ms });
    const { stop } = startRemoteSessionsReconciler(
      () => new Map([['dev-a', 'Mac A']]),
      refresh,
      1_000,
      backoff,
      () => visible,
    );
    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh).toHaveBeenCalledTimes(1);
    visible = false;
    await vi.advanceTimersByTimeAsync(2_000);
    visible = true;
    await vi.advanceTimersByTimeAsync(7_000);
    expect(refresh).toHaveBeenCalledTimes(1);
    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh).toHaveBeenCalledTimes(2);
    await vi.advanceTimersByTimeAsync(19_000);
    expect(refresh).toHaveBeenCalledTimes(2);
    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh).toHaveBeenCalledTimes(3);
    stop();
  });

  it('wakes immediately after idle instead of waiting for the next interval', async () => {
    vi.useFakeTimers();
    let visible = false;
    const refresh = vi.fn(async () => 'ok');
    const { stop, wake } = startRemoteSessionsReconciler(
      () => new Map([['dev-a', 'Mac A']]),
      refresh,
      10_000,
      undefined,
      () => visible,
    );
    await vi.advanceTimersByTimeAsync(30_000);
    expect(refresh).not.toHaveBeenCalled();
    visible = true;
    wake();
    expect(refresh).toHaveBeenCalledTimes(1);
    await vi.advanceTimersByTimeAsync(9_000);
    expect(refresh).toHaveBeenCalledTimes(1);
    stop();
  });

  it('wake bypasses failure backoff so returning to the computer is not delayed', async () => {
    vi.useFakeTimers();
    const refresh = vi.fn(async () => 'gave-up');
    const backoff = createReconcileBackoff({
      baseMs: 10_000,
      maxMs: 120_000,
      jitter: (ms) => ms,
      now: () => Date.now(),
    });
    const { stop, wake } = startRemoteSessionsReconciler(
      () => new Map([['dev-a', 'Mac A']]),
      refresh,
      1_000,
      backoff,
    );
    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh).toHaveBeenCalledTimes(1);
    await vi.advanceTimersByTimeAsync(0);
    expect(refresh).toHaveBeenCalledTimes(1);
    wake();
    expect(refresh).toHaveBeenCalledTimes(2);
    stop();
  });

  it('pauses hidden window polling without duplicating pending requests on resume', async () => {
    vi.useFakeTimers();
    let visible = false;
    let finish!: (result: string) => void;
    const refresh = vi.fn(
      () =>
        new Promise<string>((resolve) => {
          finish = resolve;
        }),
    );
    const { stop } = startRemoteSessionsReconciler(
      () => new Map([['dev-a', 'Mac A']]),
      refresh,
      1_000,
      undefined,
      () => visible,
    );
    await vi.advanceTimersByTimeAsync(10_000);
    expect(refresh).not.toHaveBeenCalled();
    visible = true;
    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh).toHaveBeenCalledTimes(1);
    visible = false;
    await vi.advanceTimersByTimeAsync(10_000);
    visible = true;
    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh).toHaveBeenCalledTimes(1);
    finish('ok');
    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh).toHaveBeenCalledTimes(2);
    stop();
    finish('ok');
    await vi.advanceTimersByTimeAsync(10_000);
    expect(refresh).toHaveBeenCalledTimes(2);
  });

  it('periodically refreshes every eligible device and stops cleanly', async () => {
    vi.useFakeTimers();
    const eligible = new Map([
      ['dev-a', 'Mac A'],
      ['dev-b', 'Mac B'],
    ]);
    const refresh = vi.fn(async () => 'ok');
    const { stop } = startRemoteSessionsReconciler(() => eligible, refresh, 1_000);

    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh.mock.calls).toEqual([
      ['dev-a', 'Mac A'],
      ['dev-b', 'Mac B'],
    ]);

    eligible.delete('dev-a');
    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh).toHaveBeenLastCalledWith('dev-b', 'Mac B');
    expect(refresh).toHaveBeenCalledTimes(3);

    stop();
    await vi.advanceTimersByTimeAsync(2_000);
    expect(refresh).toHaveBeenCalledTimes(3);
  });

  // 测试价值:startRemoteSessionsReconciler 的 cadence 把有 push 的设备全量对账从每拍放宽到
  // 间隔一次(实测 3 台 peer 每 10s 三连 sessions:list + 自动化读取),但 sessions 订阅缺口
  // 的设备没有 push 兜底,必须仍每拍补订;wake 不受间隔约束。unit,fake timers。
  it('reconciles subscribed peers once per interval but subscription gaps every tick', async () => {
    vi.useFakeTimers();
    const gaps = new Set(['gap']);
    const refresh = vi.fn(async (_id: string) => 'ok');
    const { stop, wake } = startRemoteSessionsReconciler(
      () => new Map([['healthy', 'A'], ['gap', 'B']]),
      refresh,
      60_000,
      createReconcileBackoff({ baseMs: 10_000, jitter: (ms) => ms }),
      () => true,
      { tickMs: 10_000, needsEveryTick: (id) => gaps.has(id) },
    );
    const callsFor = (id: string) => refresh.mock.calls.filter(([device]) => device === id).length;
    // The first sighting follows bootstrap, so the interval starts there (10s tick).
    await vi.advanceTimersByTimeAsync(60_000);
    expect(callsFor('healthy')).toBe(0);
    expect(callsFor('gap')).toBe(6);
    await vi.advanceTimersByTimeAsync(10_000);
    expect(callsFor('healthy')).toBe(1);
    gaps.clear();
    await vi.advanceTimersByTimeAsync(50_000);
    expect(callsFor('healthy')).toBe(1);
    expect(callsFor('gap')).toBe(7);
    wake();
    expect(callsFor('healthy')).toBe(2);
    expect(callsFor('gap')).toBe(8);
    stop();
  });

  it('counts one coalesced refresh failure once when periodic ticks overlap', async () => {
    vi.useFakeTimers();
    const eligible = new Map([['dev-a', 'Mac A']]);
    let rejectRefresh!: (error: Error) => void;
    const pending = new Promise<unknown>((_, reject) => {
      rejectRefresh = reject;
    });
    const refresh = vi.fn(() => pending);
    const backoff = createReconcileBackoff({
      baseMs: 1_000,
      maxMs: 8_000,
      jitter: (delay) => delay,
      now: () => Date.now(),
    });
    const { stop } = startRemoteSessionsReconciler(() => eligible, refresh, 1_000, backoff);

    await vi.advanceTimersByTimeAsync(1_000);
    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh).toHaveBeenCalledTimes(1);

    rejectRefresh(new Error('timeout'));
    await vi.advanceTimersByTimeAsync(0);
    await vi.advanceTimersByTimeAsync(1_000);
    expect(refresh).toHaveBeenCalledTimes(2);

    stop();
  });

  it('连续 gave-up 的设备按指数退避放慢,成功后复位;其它设备不受影响', async () => {
    vi.useFakeTimers();
    const eligible = new Map([
      ['dev-bad', 'Mac Bad'],
      ['dev-good', 'Mac Good'],
    ]);
    let badResult: string = 'gave-up';
    const refresh = vi.fn(async (deviceId: string) => (deviceId === 'dev-bad' ? badResult : 'ok'));
    // 无抖动 + 假时钟,退避序列确定:失败 1 次后推迟 1s(=base),2 次后 2s,3 次后 4s…
    const backoff = createReconcileBackoff({
      baseMs: 1_000,
      maxMs: 8_000,
      jitter: (d) => d,
      now: () => Date.now(),
    });
    const { stop } = startRemoteSessionsReconciler(() => eligible, refresh, 1_000, backoff);

    const badCalls = () => refresh.mock.calls.filter(([id]) => id === 'dev-bad').length;
    const goodCalls = () => refresh.mock.calls.filter(([id]) => id === 'dev-good').length;

    // tick1: bad 尝试并失败(退避 1s) → tick2(t=2s)已过退避,再试(失败,退避 2s)
    // → tick3(t=3s)在退避中跳过,tick4(t=4s)再试(失败,退避 4s)→ t=5s/6s/7s 跳过,t=8s 再试
    await vi.advanceTimersByTimeAsync(1_000);
    expect(badCalls()).toBe(1);
    await vi.advanceTimersByTimeAsync(1_000);
    expect(badCalls()).toBe(2);
    await vi.advanceTimersByTimeAsync(1_000);
    expect(badCalls()).toBe(2); // 退避中
    await vi.advanceTimersByTimeAsync(1_000);
    expect(badCalls()).toBe(3);
    await vi.advanceTimersByTimeAsync(3_000);
    expect(badCalls()).toBe(3); // 退避 4s 中
    await vi.advanceTimersByTimeAsync(1_000);
    expect(badCalls()).toBe(4);

    // good 设备每个 tick 照常对账,不被 bad 的退避拖累
    expect(goodCalls()).toBe(8);

    // bad 恢复:下一次尝试成功后退避复位,恢复逐 tick 对账
    badResult = 'ok';
    await vi.advanceTimersByTimeAsync(8_000);
    const afterRecovery = badCalls();
    await vi.advanceTimersByTimeAsync(2_000);
    expect(badCalls()).toBe(afterRecovery + 2);

    stop();
  });

  it('单次刷新横跨多个 tick 时只发一次、只记账一次(在途合并不重复累计退避)', async () => {
    vi.useFakeTimers();
    const eligible = new Map([['dev-slow', 'Mac Slow']]);
    let settle: ((r: string) => void) | null = null;
    const refresh = vi.fn(
      () =>
        new Promise<string>((resolve) => {
          settle = resolve;
        }),
    );
    const failures: string[] = [];
    const backoff = createReconcileBackoff({ baseMs: 1_000, maxMs: 8_000, jitter: (d) => d });
    const origReport = backoff.report.bind(backoff);
    backoff.report = (deviceId, outcome) => {
      if (outcome === 'failure') failures.push(deviceId);
      origReport(deviceId, outcome);
    };
    const { stop } = startRemoteSessionsReconciler(() => eligible, refresh, 1_000, backoff);

    // 三个 tick 过去,刷新仍在途:不再重复发起,也没有任何记账
    await vi.advanceTimersByTimeAsync(3_000);
    expect(refresh).toHaveBeenCalledTimes(1);
    expect(failures).toEqual([]);

    // 在途请求最终 gave-up:恰好记一次失败
    settle!('gave-up');
    await vi.advanceTimersByTimeAsync(0);
    expect(failures).toEqual(['dev-slow']);
    stop();
  });

  it('抖动结果被 clamp 在 maxMs 内(封顶是硬上限,+15% 不得越过)', () => {
    let at = 0;
    const backoff = createReconcileBackoff({
      baseMs: 1_000,
      maxMs: 8_000,
      jitter: (d) => d * 1.15, // 模拟上向抖动
      now: () => at,
    });
    for (let i = 0; i < 10; i++) backoff.report('dev-a', 'failure');
    at = 8_000; // 恰到封顶值:若 jitter 越过 maxMs,这里仍会是退避中
    expect(backoff.shouldAttempt('dev-a')).toBe(true);
    // 负值抖动防御:不会把 nextEligibleAt 推到过去之前(行为上等价于立即可试)
    const negBackoff = createReconcileBackoff({
      baseMs: 1_000,
      maxMs: 8_000,
      jitter: () => -5_000,
      now: () => 100,
    });
    negBackoff.report('dev-b', 'failure');
    expect(negBackoff.shouldAttempt('dev-b')).toBe(true);
  });

  it('设备移出合格集后退避账本随之清理,重新合格时从零开始', () => {
    let at = 0;
    const backoff = createReconcileBackoff({
      baseMs: 1_000,
      maxMs: 8_000,
      jitter: (d) => d,
      now: () => at,
    });
    backoff.report('dev-a', 'failure');
    backoff.report('dev-a', 'failure');
    expect(backoff.shouldAttempt('dev-a')).toBe(false);
    backoff.retainOnly(new Set(['dev-b']));
    expect(backoff.shouldAttempt('dev-a')).toBe(true);
    // neutral 不改变账本
    backoff.report('dev-b', 'neutral');
    expect(backoff.shouldAttempt('dev-b')).toBe(true);
    // 封顶:多次失败后延迟不超过 maxMs
    for (let i = 0; i < 10; i++) backoff.report('dev-b', 'failure');
    at = 7_999;
    expect(backoff.shouldAttempt('dev-b')).toBe(false);
    at = 8_000;
    expect(backoff.shouldAttempt('dev-b')).toBe(true);
  });
});

describe('resolveIneligibleRemoteProjectAction', () => {
  it('keeps the cached shard when an eligible device goes offline even if the offline row reports remoteControlEnabled=false', () => {
    expect(
      resolveIneligibleRemoteProjectAction({
        wasEligible: true,
        hasCachedShard: true,
        isSelf: false,
        online: false,
        remoteControlEnabled: false,
        disabledControl: false,
      }),
    ).toBe('disconnect');
  });

  it('removes an already disconnected cached shard when control is explicitly disabled later', () => {
    expect(
      resolveIneligibleRemoteProjectAction({
        wasEligible: false,
        hasCachedShard: true,
        isSelf: false,
        online: true,
        remoteControlEnabled: false,
        disabledControl: false,
      }),
    ).toBe('remove');

    expect(
      resolveIneligibleRemoteProjectAction({
        wasEligible: false,
        hasCachedShard: true,
        isSelf: false,
        online: false,
        remoteControlEnabled: false,
        disabledControl: true,
      }),
    ).toBe('remove');
  });
});

describe('createRemoteReconcilePresence', () => {
  it('pauses polling after idle while keeping a visible window reconnectable', () => {
    let now = 1_000;
    const gate = createRemoteReconcilePresence({ idleMs: 5_000, now: () => now });
    expect(gate.isActive()).toBe(true);
    now = 6_000;
    expect(gate.isActive()).toBe(false);
    expect(gate.noteActivity()).toBe(true);
    expect(gate.isActive()).toBe(true);
    expect(gate.noteActivity()).toBe(false);
    expect(gate.setVisible(false)).toBe(false);
    expect(gate.isActive()).toBe(false);
    now = 20_000;
    expect(gate.setVisible(true)).toBe(true);
    expect(gate.isActive()).toBe(true);
  });
});