Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* useDeviceProviders 的 deviceId-aware 缓存单测(device-link「以被控端为准」)。
* 守住:按 deviceId 隔离、inflight 去重、缓存命中不重拉、evict 只清该设备、evict 在途结果
* 丢弃不复活、reject 不缓存下次重试 —— 对齐桌面 deviceProvidersCache.test。
* 模块级缓存:每个用例 vi.resetModules() + 动态 import 拿干净模块。fetcher 注入,无需 stub 全局。
*/
import { readFileSync } from 'node:fs';
import { resolve } from 'node:path';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import type { ProviderView } from '@cindy/model-providers/registry';
const readTextLf = (path: string, encoding: BufferEncoding): string =>
readFileSync(path, encoding).toString().replace(/\r\n/g, '\n');
beforeEach(() => {
vi.resetModules();
});
type Providers = { providers: ProviderView[] };
const result = (deviceId: string): Providers =>
({ providers: [{ id: `${deviceId}-xd` } as ProviderView] });
describe('useDeviceProviders deviceId-aware cache', () => {
it('unsupported refresh retires only that device cache without publishing an empty success', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
await mod.fetchDeviceProviders('dev-1', async () => result('dev-1'));
await mod.fetchDeviceProviders('dev-2', async () => result('dev-2'));
const otherGen = mod.getDeviceProvidersGen('dev-2');
const readyListener = vi.fn();
mod.subscribeDeviceProviders('dev-1', readyListener);
await expect(mod.fetchDeviceProvidersFresh('dev-1', async () => {
throw new Error('[CHANNEL_NOT_ALLOWED] unavailable');
})).rejects.toThrow('CHANNEL_NOT_ALLOWED');
expect(mod.getCachedDeviceProviders('dev-1')).toBeUndefined();
expect(readyListener).not.toHaveBeenCalled();
expect(mod.getCachedDeviceProviders('dev-2')).toEqual(result('dev-2'));
expect(mod.getDeviceProvidersGen('dev-2')).toBe(otherGen);
});
it('首次 fetch 调用注入的 fetcher', async () => {
const fetcher = vi.fn(async () => result('dev-1'));
const mod = await import('@/device-link/deviceProvidersCache');
const providers = await mod.fetchDeviceProviders('dev-1', fetcher);
expect(fetcher).toHaveBeenCalledTimes(1);
expect(providers).toEqual({ providers: [{ id: 'dev-1-xd' }] });
});
it('被控端回传 modelVisibilityOverrides 时原样入缓存(手机据此过滤模型列表)', async () => {
const overrides = { 'codex:xd:gpt-5.4': false };
const fetcher = vi.fn(async () => ({ ...result('dev-1'), modelVisibilityOverrides: overrides }));
const mod = await import('@/device-link/deviceProvidersCache');
const payload = await mod.fetchDeviceProviders('dev-1', fetcher);
expect(payload.modelVisibilityOverrides).toEqual(overrides);
expect(mod.getCachedDeviceProviders('dev-1')?.modelVisibilityOverrides).toEqual(overrides);
});
it('缓存命中:同设备二次 fetch 不再发请求', async () => {
const fetcher = vi.fn(async () => result('dev-1'));
const mod = await import('@/device-link/deviceProvidersCache');
await mod.fetchDeviceProviders('dev-1', fetcher);
await mod.fetchDeviceProviders('dev-1', fetcher);
expect(fetcher).toHaveBeenCalledTimes(1);
});
it('fetchDeviceProvidersFresh:缓存命中也执行 fetcher 访问工作站,成功后回写缓存(codex P2)', async () => {
const fetcher = vi.fn(async () => result('dev-1-new'));
const mod = await import('@/device-link/deviceProvidersCache');
// 先普通读取填缓存(缓存命中不再发请求)
await mod.fetchDeviceProviders('dev-1', vi.fn(async () => result('dev-1-old')));
expect(mod.getCachedDeviceProviders('dev-1')).toEqual({ providers: [{ id: 'dev-1-old-xd' }] });
// 强制刷新:即使缓存仍在,也必须访问工作站
const fresh = await mod.fetchDeviceProvidersFresh('dev-1', fetcher);
expect(fetcher).toHaveBeenCalledTimes(1);
expect(fresh).toEqual({ providers: [{ id: 'dev-1-new-xd' }] });
// 成功后回写缓存(后续普通读取拿新目录)
expect(mod.getCachedDeviceProviders('dev-1')).toEqual({ providers: [{ id: 'dev-1-new-xd' }] });
});
it('fetchDeviceProvidersFresh 失败:不覆盖缓存,抛错由调用方回退', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
await mod.fetchDeviceProviders('dev-1', vi.fn(async () => result('dev-1-old')));
await expect(mod.fetchDeviceProvidersFresh('dev-1', () => Promise.reject(new Error('down'))))
.rejects.toThrow('down');
expect(mod.getCachedDeviceProviders('dev-1')).toEqual({ providers: [{ id: 'dev-1-old-xd' }] });
});
it('fresh failure invalidates the pending read and reports the error without retrying other failures', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
let release!: (v: Providers) => void;
const ordinary = mod.fetchDeviceProviders('dev-1', () => new Promise<Providers>((r) => { release = r; }));
const error = new Error('transient down');
const listener = vi.fn();
mod.subscribeDeviceProvidersError('dev-1', listener);
const freshFetcher = vi.fn().mockRejectedValue(error);
await expect(mod.fetchDeviceProvidersFresh('dev-1', freshFetcher)).rejects.toThrow('transient down');
expect(freshFetcher).toHaveBeenCalledTimes(1);
expect(listener).toHaveBeenCalledWith(error);
release(result('obsolete'));
await ordinary;
expect(mod.getCachedDeviceProviders('dev-1')).toBeUndefined();
await mod.fetchDeviceProviders('dev-1', async () => result('recovered'));
expect(mod.getCachedDeviceProviders('dev-1')).toEqual(result('recovered'));
});
it('fetchDeviceProvidersFresh 无普通在途时不推进代际:守卫 genAt 校验可直接采信(codex P2)', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const genBefore = mod.getDeviceProvidersGen('dev-1');
const fetcher = vi.fn(async () => result('dev-1'));
await mod.fetchDeviceProvidersFresh('dev-1', fetcher);
// 无普通在途 → 不得自推进代际(否则守卫把 fresh 自推进误判为外部驱逐而丢结果)
expect(mod.getDeviceProvidersGen('dev-1')).toBe(genBefore);
});
it('fetchDeviceProvidersFresh 有普通在途时推进代际:旧普通请求后返回不回写覆盖 fresh(greptile P1)', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
// 普通请求挂起(发起时目录为 A)
const ordinaryResolvers: Array<(v: Providers) => void> = [];
const ordinary = vi.fn(() => new Promise<Providers>((r) => ordinaryResolvers.push(r)));
const ordinaryP = mod.fetchDeviceProviders('dev-1', ordinary);
// fresh 在普通请求在途时发起(强制访问工作站,拿到 B)
const freshResolvers: Array<(v: Providers) => void> = [];
const freshFetcher = vi.fn(() => new Promise<Providers>((r) => freshResolvers.push(r)));
const freshP = mod.fetchDeviceProvidersFresh('dev-1', freshFetcher);
expect(freshFetcher).toHaveBeenCalledTimes(1);
freshResolvers.forEach((r) => r(result('dev-1-fresh')));
await freshP;
expect(mod.getCachedDeviceProviders('dev-1')).toEqual({ providers: [{ id: 'dev-1-fresh-xd' }] });
// 旧普通请求随后返回 A → 代际已变,不得回写覆盖 fresh
ordinaryResolvers.forEach((r) => r(result('dev-1-stale')));
await ordinaryP;
expect(mod.getCachedDeviceProviders('dev-1')).toEqual({ providers: [{ id: 'dev-1-fresh-xd' }] });
});
it('clearAll 纳入 fresh-only 在途设备:登出后 fresh 响应不回写跨账号残留(greptile/copilot P1)', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const freshResolvers: Array<(v: Providers) => void> = [];
const freshFetcher = vi.fn(() => new Promise<Providers>((r) => freshResolvers.push(r)));
// 无普通缓存/在途,只有 fresh 在途(提交终检触发)
const freshP = mod.fetchDeviceProvidersFresh('dev-1', freshFetcher);
mod.clearAllDeviceProviders(); // 登出 → fresh-only 设备也要代际作废
freshResolvers.forEach((r) => r(result('dev-1-old-account')));
await freshP;
// 旧账号 fresh 响应不得回写缓存(代际已变)
expect(mod.getCachedDeviceProviders('dev-1')).toBeUndefined();
});
it('clearAll:不向 payload 订阅者推送空载荷(防误标就绪),仅代际失效(codex review P2)', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const f1 = vi.fn(async () => result('dev-1'));
await mod.fetchDeviceProviders('dev-1', f1);
const subscriber = vi.fn();
const unsub = mod.subscribeDeviceProviders('dev-1', subscriber);
mod.clearAllDeviceProviders();
// payload 订阅是「确认快照」通道:推送空载荷会把 readyFor 误置为就绪。
// 清空展示与未就绪改由 gen 失效订阅承担(hook 侧),此处不得再推送。
expect(subscriber).not.toHaveBeenCalled();
unsub();
});
it('inflight 去重:同设备并发只发一次', async () => {
const fetcher = vi.fn(async () => result('dev-1'));
const mod = await import('@/device-link/deviceProvidersCache');
await Promise.all([
mod.fetchDeviceProviders('dev-1', fetcher),
mod.fetchDeviceProviders('dev-1', fetcher),
]);
expect(fetcher).toHaveBeenCalledTimes(1);
});
it('key 隔离:dev-1 / dev-2 各拉各的,互不影响', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const f1 = vi.fn(async () => result('dev-1'));
const f2 = vi.fn(async () => result('dev-2'));
await mod.fetchDeviceProviders('dev-1', f1);
await mod.fetchDeviceProviders('dev-2', f2);
expect(f1).toHaveBeenCalledTimes(1);
expect(f2).toHaveBeenCalledTimes(1);
// dev-2 已缓存:再 fetch 不重拉(隔离 + 命中)。
await mod.fetchDeviceProviders('dev-2', f2);
expect(f2).toHaveBeenCalledTimes(1);
});
it('缓存所属连接代际持久化到模块级:组件卸载不丢,旧设备仍判重连(codex P1)', async () => {
// reconnected 判定必须按 deviceId 记录「缓存写入时的连接代际」,且存模块级
// (组件本地 ref 会随卸载丢失)——重连时 hook 未挂载,旧设备再打开若被当首次
// 挂载会采信断线前缓存,断线期间改过的供应商永远不被刷新(codex review P1)。
const src = readTextLf(resolve(process.cwd(), 'src/device-link/useDeviceProviders.ts'), 'utf8');
const cacheSrc = readTextLf(resolve(process.cwd(), 'src/device-link/deviceProvidersCache.ts'), 'utf8');
const ctxSrc = readTextLf(resolve(process.cwd(), 'src/device-link/DeviceLinkContext.tsx'), 'utf8');
// hook 从模块级缓存读取/标记代际(不持有组件本地 ref)
expect(src).toContain('const prevEpoch = getDeviceFetchEpoch(deviceId);');
expect(src).toContain('const reconnected = prevEpoch !== undefined && prevEpoch !== connectionEpoch;');
expect(src).toContain('markDeviceFetchEpoch(deviceId, connectionEpoch);');
// 首帧 readyFor 初始化同步核对连接代际(codex P2):重连后 hook 重挂载,缓存属
// 旧 epoch 时首帧保持未就绪,避免外层 auto-default 按旧目录首行写草稿。
expect(src).toContain('const cachedAtEpoch = getDeviceFetchEpoch(deviceId);');
expect(src).toContain('cachedAtEpoch !== undefined && cachedAtEpoch !== connectionEpoch) return null;');
// mark 只在成功路径:effect 开头(reconnected 判定后)不得无条件 mark——否则
// refresh 失败后同 epoch 重挂载会把断线前旧缓存判「未重连」直接就绪且不重试
const reconnectedBlock = src.slice(
src.indexOf('const prevEpoch = getDeviceFetchEpoch(deviceId);'),
src.indexOf('const prevEpoch = getDeviceFetchEpoch(deviceId);') + 300,
);
expect(reconnectedBlock).not.toContain('markDeviceFetchEpoch');
// 无挂载 hook 的后台缓存写入路径(DeviceLinkContext provider:changed)也必须
// mark epoch——否则断线前旧目录被当「首次挂载缓存命中」采信、永不刷新
// (codex review P1)。捕获 epoch 在 fetch 前、mark 在成功后(失败不 mark)。
expect(ctxSrc).toContain('connectionEpoch: () => connectionEpochRef.current');
const ctxBlock = ctxSrc.slice(
ctxSrc.indexOf('onProviderChanged: (deviceId) => {'),
ctxSrc.indexOf('onProviderChanged: (deviceId) => {') + 1400,
);
expect(ctxBlock).toContain('catalogRefresh.notify(deviceId);');
// 模块级 Map + 导出存取(跨组件卸载存活)
expect(cacheSrc).toContain('const deviceFetchEpoch = new Map<string, number>();');
expect(cacheSrc).toContain('export function markDeviceFetchEpoch(deviceId: string, epoch: number): void');
expect(cacheSrc).toContain('export function getDeviceFetchEpoch(deviceId: string): number | undefined');
// 不再有组件本地单值/Map ref 判定
expect(src).not.toMatch(/prevEpochRef|prevEpochsRef/);
});
it('多 peer 故障隔离:dev-1 fresh 拉取失败,dev-2 缓存零感知(fault-radius 三问)', async () => {
// 故障半径三问的多 peer 用例:恢复路径改动必须带「≥2 控制端共享同一被控端,
// 一个 peer 静默/失败,其它 peer 零感知」——dev-1 fresh 失败只作用于 dev-1
// 自身(不覆盖缓存、不推进代际),dev-2 的缓存命中与代际不受波及。
const mod = await import('@/device-link/deviceProvidersCache');
const dev2Fetcher = vi.fn(async () => result('dev-2'));
await mod.fetchDeviceProviders('dev-2', dev2Fetcher);
const dev2Gen = mod.getDeviceProvidersGen('dev-2');
// dev-1 fresh 拉取失败(网络/工作站问题):不覆盖 dev-1 缓存,抛错由调用方回退
await expect(mod.fetchDeviceProvidersFresh('dev-1', vi.fn(async () => {
throw new Error('NETWORK_DOWN');
}))).rejects.toThrow('NETWORK_DOWN');
// dev-2 零感知:缓存仍命中(不发新请求)、代际未被 dev-1 的失败推进
await mod.fetchDeviceProviders('dev-2', vi.fn(async () => result('dev-2-should-not-be-used')));
expect(dev2Fetcher).toHaveBeenCalledTimes(1);
expect(mod.getCachedDeviceProviders('dev-2')).toEqual({ providers: [{ id: 'dev-2-xd' }] });
expect(mod.getDeviceProvidersGen('dev-2')).toBe(dev2Gen);
});
it('驱逐:evict 后同设备重新拉取;只清该设备(dev-2 仍命中缓存)', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const f1 = vi.fn(async () => result('dev-1'));
const f2 = vi.fn(async () => result('dev-2'));
await mod.fetchDeviceProviders('dev-1', f1);
await mod.fetchDeviceProviders('dev-2', f2);
mod.evictDeviceProviders('dev-1');
await mod.fetchDeviceProviders('dev-1', f1); // 缓存已清 → 重拉(+1)
await mod.fetchDeviceProviders('dev-2', f2); // 未清 → 命中(+0)
expect(f1).toHaveBeenCalledTimes(2);
expect(f2).toHaveBeenCalledTimes(1);
});
it('evict 在途 fetch → 结果丢弃,不复活缓存', async () => {
const resolvers: Array<(v: Providers) => void> = [];
const fetcher = vi.fn(() => new Promise<Providers>((r) => resolvers.push(r)));
const mod = await import('@/device-link/deviceProvidersCache');
const p = mod.fetchDeviceProviders('dev-1', fetcher); // 在途(未 resolve)
mod.evictDeviceProviders('dev-1'); // 设备切换 → 驱逐(代际自增)
resolvers.forEach((r) => r(result('dev-1-stale'))); // 在途请求随后才回来
await p;
// 被驱逐的在途结果不得回写缓存 → 再 fetch 必须重新发请求(总计 2 次)。
const p2 = mod.fetchDeviceProviders('dev-1', fetcher);
resolvers.forEach((r) => r(result('dev-1-fresh')));
await p2;
expect(fetcher).toHaveBeenCalledTimes(2);
});
it('reject(旧版被控端不识别通道)→ 不缓存,下次重试', async () => {
const fetcher = vi.fn(async () => {
throw new Error("channel 'maker:provider:list' not allowed remotely");
});
const mod = await import('@/device-link/deviceProvidersCache');
await expect(mod.fetchDeviceProviders('dev-old', fetcher)).rejects.toThrow();
await expect(mod.fetchDeviceProviders('dev-old', fetcher)).rejects.toThrow();
expect(fetcher).toHaveBeenCalledTimes(2);
});
it('clearAll:登出后全部设备缓存清空,各自重拉(防跨账号串数据)', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const f1 = vi.fn(async () => result('dev-1'));
const f2 = vi.fn(async () => result('dev-2'));
await mod.fetchDeviceProviders('dev-1', f1);
await mod.fetchDeviceProviders('dev-2', f2);
expect(mod.getCachedDeviceProviders('dev-1')).toEqual({ providers: [{ id: 'dev-1-xd' }] });
mod.clearAllDeviceProviders();
expect(mod.getCachedDeviceProviders('dev-1')).toBeUndefined();
expect(mod.getCachedDeviceProviders('dev-2')).toBeUndefined();
await mod.fetchDeviceProviders('dev-1', f1); // 缓存已清 → 重拉
await mod.fetchDeviceProviders('dev-2', f2);
expect(f1).toHaveBeenCalledTimes(2);
expect(f2).toHaveBeenCalledTimes(2);
});
it('clearAll 在途 fetch → 结果丢弃,不复活缓存(代际作废)', async () => {
const resolvers: Array<(v: Providers) => void> = [];
const fetcher = vi.fn(() => new Promise<Providers>((r) => resolvers.push(r)));
const mod = await import('@/device-link/deviceProvidersCache');
const p = mod.fetchDeviceProviders('dev-1', fetcher); // 在途(未 resolve)
mod.clearAllDeviceProviders(); // 登出 → 全清 + 代际自增
resolvers.forEach((r) => r(result('dev-1-stale'))); // 在途请求随后才回来
await p;
expect(mod.getCachedDeviceProviders('dev-1')).toBeUndefined();
const p2 = mod.fetchDeviceProviders('dev-1', fetcher);
resolvers.forEach((r) => r(result('dev-1-fresh')));
await p2;
expect(fetcher).toHaveBeenCalledTimes(2);
});
it('新快照只通知对应 deviceId 的已挂载订阅者', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const dev1 = vi.fn();
const dev2 = vi.fn();
const off1 = mod.subscribeDeviceProviders('dev-1', dev1);
const off2 = mod.subscribeDeviceProviders('dev-2', dev2);
await mod.fetchDeviceProviders('dev-1', async () => result('dev-1'));
expect(dev1).toHaveBeenCalledWith({ providers: [{ id: 'dev-1-xd' }] });
expect(dev2).not.toHaveBeenCalled();
off1();
off2();
});
it('revision 后新请求先完成、旧请求后完成时只通知新快照', async () => {
const resolvers: Array<(value: Providers) => void> = [];
const fetcher = vi.fn(() => new Promise<Providers>((resolve) => resolvers.push(resolve)));
const mod = await import('@/device-link/deviceProvidersCache');
const listener = vi.fn();
mod.subscribeDeviceProviders('dev-1', listener);
const stale = mod.fetchDeviceProviders('dev-1', fetcher);
mod.evictDeviceProviders('dev-1');
const fresh = mod.fetchDeviceProviders('dev-1', fetcher);
resolvers[1](result('fresh'));
await fresh;
resolvers[0](result('stale'));
await stale;
expect(listener).toHaveBeenCalledTimes(1);
expect(listener).toHaveBeenLastCalledWith({ providers: [{ id: 'fresh-xd' }] });
expect(mod.getCachedDeviceProviders('dev-1')).toEqual({ providers: [{ id: 'fresh-xd' }] });
});
it('getDeviceProvidersGen:evict / clearAll 自增代际,其他设备不受影响(codex P2 ready 代际)', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const gen0 = mod.getDeviceProvidersGen('dev-1');
mod.evictDeviceProviders('dev-1');
expect(mod.getDeviceProvidersGen('dev-1')).toBe(gen0 + 1);
// 重拉完成不进一步提升代际(代际只随驱逐前进,置位时记录即稳定)
await mod.fetchDeviceProviders('dev-1', async () => result('dev-1'));
expect(mod.getDeviceProvidersGen('dev-1')).toBe(gen0 + 1);
mod.evictDeviceProviders('dev-1');
expect(mod.getDeviceProvidersGen('dev-1')).toBe(gen0 + 2);
// clearAll 只自增代际表内设备;从未有缓存活动的设备不受影响
const gen2 = mod.getDeviceProvidersGen('dev-2');
mod.clearAllDeviceProviders();
expect(mod.getDeviceProvidersGen('dev-1')).toBe(gen0 + 3);
expect(mod.getDeviceProvidersGen('dev-2')).toBe(gen2);
});
it('subscribeDeviceProvidersGen:evict/clearAll 主动通知,fetch 完成不通知(codex P2)', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const dev1 = vi.fn();
const dev2 = vi.fn();
const off1 = mod.subscribeDeviceProvidersGen('dev-1', dev1);
const off2 = mod.subscribeDeviceProvidersGen('dev-2', dev2);
// fetch 完成(写缓存 + payload 通知)不触发代际通知
await mod.fetchDeviceProviders('dev-1', async () => result('dev-1'));
expect(dev1).not.toHaveBeenCalled();
// evict 触发对应设备的代际通知(原因 evict),不影响其他设备
mod.evictDeviceProviders('dev-1');
expect(dev1).toHaveBeenCalledWith('evict');
expect(dev2).not.toHaveBeenCalled();
// clearAll 通知代际表内所有设备(原因 evict),且发生在缓存清空之后
mod.evictDeviceProviders('dev-2');
dev1.mockClear();
dev2.mockClear();
const cacheAtNotify: unknown[] = [];
const offProbe = mod.subscribeDeviceProvidersGen('dev-1', () => {
cacheAtNotify.push(mod.getCachedDeviceProviders('dev-1'));
});
mod.clearAllDeviceProviders();
expect(dev1).toHaveBeenCalledWith('evict');
expect(dev2).toHaveBeenCalledWith('evict');
// 通知时缓存已清空(hook 收到后重拉不会命中旧账号缓存——codex review P2)
expect(cacheAtNotify).toContain(undefined);
offProbe();
// 退订后不再通知
off1();
off2();
mod.evictDeviceProviders('dev-1');
expect(dev1).toHaveBeenCalledTimes(1);
});
it('fresh 作废普通在途:代际通知原因 fresh-invalidate(fresh 自身恢复,hook 不得重拉)', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const listener = vi.fn();
const off = mod.subscribeDeviceProvidersGen('dev-1', listener);
// 普通请求在途时启动 fresh → 作废普通在途,通知原因 fresh-invalidate
const resolvers: Array<(v: Providers) => void> = [];
const fetcher = vi.fn(() => new Promise<Providers>((r) => resolvers.push(r)));
const freshResolvers: Array<(v: Providers) => void> = [];
const freshFetcher = vi.fn(() => new Promise<Providers>((r) => freshResolvers.push(r)));
void mod.fetchDeviceProviders('dev-1', fetcher); // 普通在途
void mod.fetchDeviceProvidersFresh('dev-1', freshFetcher); // fresh 作废普通
expect(listener).toHaveBeenCalledWith('fresh-invalidate');
// 完成两条请求后,缓存最终为 fresh 结果(普通被作废不回写)
freshResolvers.forEach((r) => r(result('dev-1-fresh')));
await new Promise((r) => setTimeout(r, 0));
resolvers.forEach((r) => r(result('dev-1-stale')));
await new Promise((r) => setTimeout(r, 0));
expect(mod.getCachedDeviceProviders('dev-1')?.providers[0]?.id).toBe('dev-1-fresh-xd');
off();
});
});
describe('provider catalog error classification', () => {
it.each([
[new Error('[MODEL_VISIBILITY_NOT_READY] waiting'), false],
[new Error('[INTERNAL] mentions CHANNEL_NOT_ALLOWED'), false],
[new Error('MODEL_VISIBILITY_NOT_READY: raw error'), false],
[new Error('[CHANNEL_NOT_ALLOWED] unavailable'), true],
[Object.assign(new Error('unavailable'), { code: 'CHANNEL_NOT_ALLOWED' }), true],
])('allows legacy fallback only for a typed unsupported error: %s', async (error, expected) => {
const mod = await import('@/device-link/deviceProvidersCache');
expect(mod.isDeviceProvidersUnsupportedError(error)).toBe(expected);
});
});
it('uses host display order in cached and fresh reads without mutating the wire catalog', async () => {
const mod = await import('@/device-link/deviceProvidersCache');
const providers = ['a','b','c'].map(id => ({id})) as ProviderView[];
const first = await mod.fetchDeviceProviders('order-host', async()=>({providers,providerOrder:['b','missing','b','a']}));
expect(first.providers.map(p=>p.id)).toEqual(['b','a','c']);
expect(providers.map(p=>p.id)).toEqual(['a','b','c']);
const fresh = await mod.fetchDeviceProvidersFresh('order-host', async()=>({providers,providerOrder:['c']}));
expect(fresh.providers.map(p=>p.id)).toEqual(['c','a','b']);
expect(mod.getCachedDeviceProviders('order-host')?.providers.map(p=>p.id)).toEqual(['c','a','b']);
});