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。

12.9 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest';
import { createResumeUpdateChecker, type ResumeUpdateCheckDeps } from './resumeUpdateCheck';

/** 有效的 /latest 记录(runtimeVersion 与当前 '1' 不同 → 有整包更新)。 */
function latestRecord(overrides: Record<string, unknown> = {}) {
  return {
    version: '2.0.0',
    buildNumber: 20,
    runtimeVersion: '2',
    installUrl: 'https://npkg.example/install',
    itmsUrl: 'itms-services://?action=download-manifest&url=https://npkg.example/m.plist',
    ...overrides,
  };
}

function makeDeps(overrides: Partial<ResumeUpdateCheckDeps> = {}) {
  let nowMs = 1_000_000;
  const deps: ResumeUpdateCheckDeps & { advance: (ms: number) => void } = {
    otaEnabled: true,
    checkForUpdateAsync: vi.fn(async () => ({ isAvailable: false })),
    fetchUpdateAsync: vi.fn(async () => ({ isNew: true })),
    bundleCheckEnabled: true,
    fetchLatest: vi.fn(async () => null),
    getCurrentRuntimeVersion: () => '1',
    getCurrentVersion: () => '1.0.0',
    // 真实 callback 是 promptBundleUpdate → enterForcedUpdate(幂等,不需要去重)。
    onForcedUpdate: vi.fn(),
    now: () => nowMs,
    advance: (ms: number) => { nowMs += ms; },
    ...overrides,
  };
  return deps;
}

/** 模拟一次「切后台再回前台」;返回 handleAppStateChange('active') 的结果。 */
function resume(checker: ReturnType<typeof createResumeUpdateChecker>) {
  checker.handleAppStateChange('background');
  return checker.handleAppStateChange('active');
}

describe('createResumeUpdateChecker 触发条件', () => {
  it('创建后立刻 resume:间隔不足 → 不检查(冷启动刚查过)', () => {
    const deps = makeDeps();
    const checker = createResumeUpdateChecker(deps);
    expect(resume(checker)).toBeNull();
    expect(deps.checkForUpdateAsync).not.toHaveBeenCalled();
    expect(deps.fetchLatest).not.toHaveBeenCalled();
  });

  it('间隔满足后 resume → 触发检查', async () => {
    const deps = makeDeps();
    const checker = createResumeUpdateChecker(deps, { minIntervalMs: 1000 });
    deps.advance(1001);
    const result = resume(checker);
    expect(result).not.toBeNull();
    await result;
    expect(deps.checkForUpdateAsync).toHaveBeenCalledOnce();
    expect(deps.fetchLatest).toHaveBeenCalledOnce();
  });

  it('inactive 抖动(未进 background)回 active → 不触发', () => {
    const deps = makeDeps();
    const checker = createResumeUpdateChecker(deps, { minIntervalMs: 0 });
    deps.advance(1);
    checker.handleAppStateChange('inactive');
    expect(checker.handleAppStateChange('active')).toBeNull();
  });

  it('检查在途时再次 resume → 不重入', async () => {
    const deps = makeDeps();
    let release!: () => void;
    deps.checkForUpdateAsync = vi.fn(() => new Promise<{ isAvailable: boolean }>((resolve) => {
      release = () => resolve({ isAvailable: false });
    }));
    const checker = createResumeUpdateChecker(deps, { minIntervalMs: 1000 });
    deps.advance(1001);
    const first = resume(checker);
    expect(first).not.toBeNull();
    deps.advance(1001);
    expect(resume(checker)).toBeNull(); // 在途,拒绝重入
    release();
    await first;
  });

  it('节流:两次 resume 间隔不足只跑一次', async () => {
    const deps = makeDeps();
    const checker = createResumeUpdateChecker(deps, { minIntervalMs: 1000 });
    deps.advance(1001);
    await resume(checker);
    deps.advance(500);
    expect(resume(checker)).toBeNull();
    deps.advance(501);
    expect(resume(checker)).not.toBeNull();
  });
});

describe('createResumeUpdateChecker OTA 静默路径', () => {
  async function runOnce(deps: ReturnType<typeof makeDeps>, opts: Parameters<typeof createResumeUpdateChecker>[1] = {}) {
    const checker = createResumeUpdateChecker(deps, { minIntervalMs: 0, ...opts });
    deps.advance(1);
    const result = resume(checker);
    expect(result).not.toBeNull();
    return result!;
  }

  it('otaEnabled=false → skipped,不调 expo-updates', async () => {
    const deps = makeDeps({ otaEnabled: false });
    const { ota } = await runOnce(deps);
    expect(ota).toBe('skipped');
    expect(deps.checkForUpdateAsync).not.toHaveBeenCalled();
  });

  it('不再依赖 analytics consent,走正常 OTA 检查', async () => {
    const deps = makeDeps();
    const { ota } = await runOnce(deps);
    expect(ota).toBe('up-to-date');
    expect(deps.checkForUpdateAsync).toHaveBeenCalledOnce();
  });

  it('check 期间账号切换 → 下载前跳过,不 fetch', async () => {
    let current = true;
    const deps = makeDeps({
      isCurrent: () => current,
      checkForUpdateAsync: vi.fn(async () => {
        current = false;
        return { isAvailable: true };
      }),
    });
    const { ota } = await runOnce(deps);
    expect(ota).toBe('skipped');
    expect(deps.checkForUpdateAsync).toHaveBeenCalledOnce();
    expect(deps.fetchUpdateAsync).not.toHaveBeenCalled();
  });

  it('排队等待包装器期间账号切换 → 请求前跳过,不访问旧 channel', async () => {
    let current = true;
    let releaseQueue!: () => void;
    const wrappedCheck = vi.fn(async () => ({ isAvailable: false }));
    const withOtaClient: NonNullable<ResumeUpdateCheckDeps['withOtaClient']> =
      vi.fn(async (operation) => {
        await new Promise<void>((resolve) => { releaseQueue = resolve; });
        return operation({
          checkForUpdateAsync: wrappedCheck,
          fetchUpdateAsync: vi.fn(async () => ({ isNew: false })),
        });
      });
    const deps = makeDeps({
      withOtaClient,
      isCurrent: () => current,
    });

    const pending = runOnce(deps);
    await vi.waitFor(() => expect(withOtaClient).toHaveBeenCalledOnce());
    current = false;
    releaseQueue();

    await expect(pending).resolves.toMatchObject({ ota: 'skipped' });
    expect(wrappedCheck).not.toHaveBeenCalled();
    expect(deps.checkForUpdateAsync).not.toHaveBeenCalled();
  });

  it('用同一个包装器覆盖完整 check → fetch 事务', async () => {
    const wrappedCheck = vi.fn(async () => ({ isAvailable: true }));
    const wrappedFetch = vi.fn(async () => ({ isNew: true }));
    const withOtaClient: NonNullable<ResumeUpdateCheckDeps['withOtaClient']> =
      vi.fn(async (operation) => operation({
        checkForUpdateAsync: wrappedCheck,
        fetchUpdateAsync: wrappedFetch,
      }));
    const deps = makeDeps({ withOtaClient });

    const { ota } = await runOnce(deps);

    expect(ota).toBe('fetched');
    expect(withOtaClient).toHaveBeenCalledOnce();
    expect(wrappedCheck).toHaveBeenCalledOnce();
    expect(wrappedFetch).toHaveBeenCalledOnce();
    expect(deps.checkForUpdateAsync).not.toHaveBeenCalled();
    expect(deps.fetchUpdateAsync).not.toHaveBeenCalled();
  });

  it('无可用更新 → up-to-date,不 fetch', async () => {
    const deps = makeDeps();
    const { ota } = await runOnce(deps);
    expect(ota).toBe('up-to-date');
    expect(deps.fetchUpdateAsync).not.toHaveBeenCalled();
  });

  it('有更新 → 静默 fetch,返回 fetched(无 reload 依赖,构造上不可能重启)', async () => {
    const deps = makeDeps({ checkForUpdateAsync: vi.fn(async () => ({ isAvailable: true })) });
    const { ota } = await runOnce(deps);
    expect(ota).toBe('fetched');
    expect(deps.fetchUpdateAsync).toHaveBeenCalledOnce();
  });

  it('check 抛错 → error(fail-open),不影响整包检查', async () => {
    const deps = makeDeps({ checkForUpdateAsync: vi.fn(async () => { throw new Error('offline'); }) });
    const { ota, bundle } = await runOnce(deps);
    expect(ota).toBe('error');
    expect(bundle).toBe('up-to-date');
  });

  it('check 超时 → error(fail-open)', async () => {
    const deps = makeDeps({
      checkForUpdateAsync: vi.fn((): Promise<{ isAvailable: boolean }> => new Promise(() => {})),
    });
    const { ota } = await runOnce(deps, { checkTimeoutMs: 20 });
    expect(ota).toBe('error');
  });
});

describe('createResumeUpdateChecker 整包路径', () => {
  async function runOnce(deps: ReturnType<typeof makeDeps>) {
    const checker = createResumeUpdateChecker(deps, { minIntervalMs: 0 });
    deps.advance(1);
    const result = resume(checker);
    expect(result).not.toBeNull();
    return result!;
  }

  it('bundleCheckEnabled=false → skipped,不拉 /latest', async () => {
    const deps = makeDeps({ bundleCheckEnabled: false });
    const { ota, bundle } = await runOnce(deps);
    expect(ota).toBe('up-to-date');
    expect(bundle).toBe('skipped');
    expect(deps.checkForUpdateAsync).toHaveBeenCalledOnce();
    expect(deps.fetchLatest).not.toHaveBeenCalled();
  });

  it('/latest 无记录 → up-to-date', async () => {
    const deps = makeDeps({ fetchLatest: vi.fn(async () => null) });
    const { bundle } = await runOnce(deps);
    expect(bundle).toBe('up-to-date');
  });

  // Unit: resume used to discard ordinary APK releases, so long-running Android
  // apps could not prepare a new package. The public checker now forwards them.
  it('非强更整包更新交给自动下载出口,不进入强更闸门', async () => {
    const onAvailableUpdate = vi.fn();
    const deps = makeDeps({ fetchLatest: vi.fn(async () => latestRecord()), onAvailableUpdate });
    const { bundle } = await runOnce(deps);
    expect(bundle).toBe('update-available');
    expect(deps.onForcedUpdate).not.toHaveBeenCalled();
    expect(onAvailableUpdate).toHaveBeenCalledWith(expect.objectContaining({
      forced: false, target: expect.objectContaining({ version: '2.0.0' }),
    }));
  });

  it.each(['0.1.4', '0.1.5'])('整包 version=%s 不高于本机 → 忽略整包,OTA 仍正常下载', async (version) => {
    const deps = makeDeps({
      getCurrentVersion: () => '0.1.5',
      fetchLatest: vi.fn(async () => latestRecord({ version })),
      checkForUpdateAsync: vi.fn(async () => ({ isAvailable: true })),
    });
    await expect(runOnce(deps)).resolves.toEqual({ ota: 'fetched', bundle: 'up-to-date' });
    expect(deps.fetchUpdateAsync).toHaveBeenCalledOnce();
    expect(deps.onForcedUpdate).not.toHaveBeenCalled();
  });

  it('强更(minVersion)→ forced 且回调一次', async () => {
    const deps = makeDeps({ fetchLatest: vi.fn(async () => latestRecord({ minVersion: '2.0.0' })) });
    const { bundle } = await runOnce(deps);
    expect(bundle).toBe('forced');
    expect(deps.onForcedUpdate).toHaveBeenCalledOnce();
  });

  it('同一强更目标多次 resume → 每次都上报(阻断态幂等,本层不去重)', async () => {
    // 去重曾是必需的(强更是一次性 Alert);改成阻断态后 enterForcedUpdate 幂等,
    // 本层不再持有"已提示过"状态 —— 也就不会因为一次未展示而让强更永久失声。
    const deps = makeDeps({ fetchLatest: vi.fn(async () => latestRecord({ minVersion: '2.0.0' })) });
    const checker = createResumeUpdateChecker(deps, { minIntervalMs: 0 });
    deps.advance(1);
    await resume(checker);
    deps.advance(1);
    await resume(checker);
    expect(deps.onForcedUpdate).toHaveBeenCalledTimes(2);
  });

  it('同 runtimeVersion 但低于 minVersion → 依旧上报强更', async () => {
    // 服务端事后给某个已发布版本下发门槛时,装机 runtimeVersion 与 /latest 相同,
    // 但 version 低于门槛 —— 不能因为"指纹没变"就放过。
    const deps = makeDeps({
      fetchLatest: vi.fn(async () => latestRecord({ runtimeVersion: '1', minVersion: '2.0.0' })),
    });
    const { bundle } = await runOnce(deps);
    expect(bundle).toBe('forced');
    expect(deps.onForcedUpdate).toHaveBeenCalledOnce();
  });

  it('/latest 拉取失败 → error(fail-open),不影响 OTA 结果', async () => {
    const deps = makeDeps({ fetchLatest: vi.fn(async () => { throw new Error('http 500'); }) });
    const { ota, bundle } = await runOnce(deps);
    expect(bundle).toBe('error');
    expect(ota).toBe('up-to-date');
  });

  it('/latest 挂起 → withTimeout backstop 触发 error(fail-open),不影响 OTA', async () => {
    // 注入一个永不 resolve 的 fetchLatest:模拟注入实现无内部超时时纯逻辑层的兜底。
    const deps = makeDeps({ fetchLatest: vi.fn((): Promise<unknown> => new Promise(() => {})) });
    const checker = createResumeUpdateChecker(deps, { minIntervalMs: 0, latestTimeoutMs: 20 });
    deps.advance(1);
    const result = resume(checker);
    expect(result).not.toBeNull();
    const { ota, bundle } = await result!;
    expect(bundle).toBe('error');
    expect(ota).toBe('up-to-date');
  });

  it('channel 切换后旧检查迟到不再触发强更提示', async () => {
    let current = true;
    let release!: (value: unknown) => void;
    const deps = makeDeps({
      fetchLatest: vi.fn(() => new Promise((resolve) => { release = resolve; })),
      isCurrent: () => current,
    });
    const checker = createResumeUpdateChecker(deps, { minIntervalMs: 0 });
    deps.advance(1);
    const pending = resume(checker);
    expect(pending).not.toBeNull();
    current = false;
    release(latestRecord({ minVersion: '2.0.0' }));
    const result = await pending!;
    expect(result.bundle).toBe('skipped');
    expect(deps.onForcedUpdate).not.toHaveBeenCalled();
  });
});