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。

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

import {
  _clearRemotePathVerdictCache,
  peekRemotePathVerdict,
  remotePathVerdictKey,
  subscribeRemotePathVerdictChange,
  verifyRemotePathCached,
} from '@/session/remotePathVerdict';
import type { RemotePathStatResult } from '@/device-link/mobileMakerTransport';

const statOf = (kind: RemotePathStatResult['kind']) =>
  vi.fn(async (absPath: string): Promise<RemotePathStatResult> => ({ kind, resolvedPath: absPath }));

describe('remotePathVerdict', () => {
  beforeEach(() => {
    _clearRemotePathVerdictCache();
  });

  it('dir/file/missing → directory/file/nonfile,并落缓存供 peek 同步读', async () => {
    expect(await verifyRemotePathCached('dev', '/w', '/w/dir', statOf('dir'))).toBe('directory');
    expect(await verifyRemotePathCached('dev', '/w', '/w/a.ts', statOf('file'))).toBe('file');
    expect(await verifyRemotePathCached('dev', '/w', '/w/x', statOf('missing'))).toBe('nonfile');
    expect(peekRemotePathVerdict('dev', '/w', '/w/a.ts')).toBe('file');
    expect(peekRemotePathVerdict('dev', '/w', '/w/x')).toBe('nonfile');
  });

  it('stat 异常(断链等)→ unknown,不 throw', async () => {
    const stat = vi.fn(async () => {
      throw new Error('link down');
    });
    await expect(verifyRemotePathCached('dev', '/w', '/w/a.ts', stat)).resolves.toBe('unknown');
  });

  it('unknown 落短 TTL 负缓存:TTL 内重挂不再发 stat,过期后自愈重验', async () => {
    vi.useFakeTimers();
    try {
      const failing = vi.fn(async (): Promise<RemotePathStatResult> => {
        throw new Error('link down');
      });
      await expect(verifyRemotePathCached('dev', '/w', '/w/x.ts', failing)).resolves.toBe('unknown');
      expect(failing).toHaveBeenCalledTimes(1);
      // 负缓存不进 peek:重挂的 chip 仍走异步验证路径,乐观点亮语义不变。
      expect(peekRemotePathVerdict('dev', '/w', '/w/x.ts')).toBeUndefined();
      // TTL 内重验:同步拿 unknown,不再打 stat(防断续链路下的重验风暴)。
      await expect(verifyRemotePathCached('dev', '/w', '/w/x.ts', failing)).resolves.toBe('unknown');
      expect(failing).toHaveBeenCalledTimes(1);
      // TTL 过期 + 链路恢复:重验拿到确定态并落缓存,自愈不受负缓存影响。
      vi.advanceTimersByTime(30_000 + 1);
      expect(await verifyRemotePathCached('dev', '/w', '/w/x.ts', statOf('missing'))).toBe('nonfile');
      expect(peekRemotePathVerdict('dev', '/w', '/w/x.ts')).toBe('nonfile');
    } finally {
      vi.useRealTimers();
    }
  });

  it('缓存变化按 key 通知:确定态落库与 TTL 到期都要有通道', async () => {
    // 渲染层不自己存结论,只在收到「本 key 变了」时重新派生。两种变化都得通知:
    // 确定态落库(把别处的乐观点亮降级成纯文本)、TTL 到期(该重验了)。
    // 按 key 而非全量广播:一屏几十个 chip,广播会让首屏 N 次 stat 引发 N×N 次重渲染。
    vi.useFakeTimers();
    try {
      const failing = vi.fn(async (): Promise<RemotePathStatResult> => {
        throw new Error('link down');
      });
      const keys: string[] = [];
      const off = subscribeRemotePathVerdictChange((k) => keys.push(k));
      const mine = remotePathVerdictKey('dev', '/w', '/w/a');

      await verifyRemotePathCached('dev', '/w', '/w/a', failing);
      expect(keys, 'unknown 落负缓存没通知').toEqual([mine]);

      await vi.advanceTimersByTimeAsync(30_000 + 1);
      expect(keys, 'TTL 到期没通知 —— 挂载中的 chip 永远等不到重验').toEqual([mine, mine]);

      // 到期后负缓存已清,重验真的重发 stat,并且确定态落库再通知一次。
      expect(await verifyRemotePathCached('dev', '/w', '/w/a', statOf('file'))).toBe('file');
      expect(keys).toEqual([mine, mine, mine]);

      off();
      await vi.advanceTimersByTimeAsync(120_000);
      expect(keys, '退订后仍收到通知').toHaveLength(3);
    } finally {
      vi.useRealTimers();
    }
  });

  it('不同 key 的通知互相区分(订阅方自己过滤)', async () => {
    const failing = vi.fn(async (): Promise<RemotePathStatResult> => {
      throw new Error('link down');
    });
    const keys: string[] = [];
    subscribeRemotePathVerdictChange((k) => keys.push(k));
    await Promise.all([
      verifyRemotePathCached('dev', '/w', '/w/a', failing),
      verifyRemotePathCached('dev', '/w', '/w/b', failing),
    ]);
    expect(new Set(keys).size).toBe(2);
    expect(keys).toContain(remotePathVerdictKey('dev', '/w', '/w/a'));
    expect(keys).toContain(remotePathVerdictKey('dev', '/w', '/w/b'));
  });

  it('确定态不排到期定时器(不轮询)', async () => {
    vi.useFakeTimers();
    try {
      await verifyRemotePathCached('dev', '/w', '/w/a.ts', statOf('file'));
      expect(vi.getTimerCount(), '确定态也排了定时器 —— 那就是在轮询').toBe(0);
    } finally {
      vi.useRealTimers();
    }
  });

  it('不同 key 的 stat 全局限流:最多 3 条在飞,完成一条补位一条', async () => {
    const resolvers: Array<(v: RemotePathStatResult) => void> = [];
    const stat = vi.fn(
      (absPath: string) =>
        new Promise<RemotePathStatResult>((resolve) => {
          resolvers.push((v) => resolve({ ...v, resolvedPath: absPath }));
        }),
    );
    const promises = Array.from({ length: 5 }, (_, i) =>
      verifyRemotePathCached('dev', '/w', `/w/f${i}.ts`, stat),
    );
    await Promise.resolve();
    expect(stat).toHaveBeenCalledTimes(3);
    resolvers[0]({ kind: 'file', resolvedPath: '' });
    await promises[0];
    expect(stat).toHaveBeenCalledTimes(4);
    resolvers[1]({ kind: 'file', resolvedPath: '' });
    await promises[1];
    expect(stat).toHaveBeenCalledTimes(5);
    resolvers[2]({ kind: 'file', resolvedPath: '' });
    resolvers[3]({ kind: 'file', resolvedPath: '' });
    resolvers[4]({ kind: 'file', resolvedPath: '' });
    await expect(Promise.all(promises)).resolves.toEqual(Array(5).fill('file'));
  });

  it('缓存命中不再发 stat', async () => {
    const stat = statOf('file');
    await verifyRemotePathCached('dev', '/w', '/w/a.ts', stat);
    await verifyRemotePathCached('dev', '/w', '/w/a.ts', stat);
    expect(stat).toHaveBeenCalledTimes(1);
  });

  it('并发同 key 去重为一次 stat', async () => {
    let release!: (v: RemotePathStatResult) => void;
    const gate = new Promise<RemotePathStatResult>((resolve) => {
      release = resolve;
    });
    const stat = vi.fn(() => gate);
    const p1 = verifyRemotePathCached('dev', '/w', '/w/a.ts', stat);
    const p2 = verifyRemotePathCached('dev', '/w', '/w/a.ts', stat);
    release({ kind: 'file', resolvedPath: '/w/a.ts' });
    expect(await p1).toBe('file');
    expect(await p2).toBe('file');
    expect(stat).toHaveBeenCalledTimes(1);
  });

  it('不同 deviceId / workdir 互不串缓存', async () => {
    await verifyRemotePathCached('dev1', '/w', '/w/a.ts', statOf('file'));
    expect(peekRemotePathVerdict('dev2', '/w', '/w/a.ts')).toBeUndefined();
    expect(peekRemotePathVerdict('dev1', '/w2', '/w/a.ts')).toBeUndefined();
  });
});