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「以被控端为准」)。
* 守住:远程走隧道 maker:provider:list、按 deviceId 隔离、inflight 去重、缓存命中不重拉、
* evict 只清该设备、evict 在途结果丢弃不复活 —— 与 useAgentCapabilities 同范式。
* 模块级缓存:每个用例 vi.resetModules() + 动态 import 拿干净模块。
*/
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import {
connectedProvidersForAgent,
visibleModelUnion,
type ProviderView,
} from '@cindy/model-providers';
beforeEach(() => {
vi.resetModules();
});
it('expires only subscription share snapshots and preserves ordinary API discovery cache semantics', async () => {
const login = { ...provider('subscription'), subscriptionFastPolicy: { allowFast: true, groupAllowsFast: true } };
const api = provider('openai');
const invoke = vi.fn(async (device: string) => ({ providers: [device === 'share:subscription' ? login : api] }));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('share:subscription');
await mod.prefetchDeviceProviders('share:api');
expect(mod.isSubscriptionShareCatalogStale('share:subscription')).toBe(false);
const later = Date.now() + 61_000;
expect(mod.isSubscriptionShareCatalogStale('share:subscription', later)).toBe(true);
expect(mod.isSubscriptionShareCatalogStale('share:api', later)).toBe(false);
expect(mod.isSubscriptionShareCatalogStale('same-account-computer', later)).toBe(false);
mod.evictDeviceProviders('share:subscription');
expect(mod.isSubscriptionShareCatalogStale('share:subscription', later)).toBe(false);
await mod.prefetchDeviceProviders('share:api');
expect(invoke.mock.calls.filter(([device]) => device === 'share:api')).toHaveLength(1);
});
// A failed policy refresh evicts the authoritative cache. Its subscription
// identity must survive that soft eviction so the next membership poll retries;
// account/disconnect eviction must still discard the hint and any late result.
it('retains subscription freshness after a failed soft refresh and clears it at the owner boundary', async () => {
const login = { ...provider('subscription'), subscriptionFastPolicy: { allowFast: true, groupAllowsFast: true } };
const invoke = vi.fn().mockResolvedValueOnce({ providers: [login] }).mockRejectedValueOnce(Error('temporary disconnect'));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('share:subscription');
const later = Date.now() + 61_000;
mod.evictDeviceProviders('share:subscription', { retainDisplaySnapshot: true });
await mod.prefetchDeviceProviders('share:subscription');
expect(mod.getCachedDeviceProviders('share:subscription')).toBeNull();
expect(mod.isSubscriptionShareCatalogStale('share:subscription', later)).toBe(true);
mod.evictAllDeviceProviders();
expect(mod.isSubscriptionShareCatalogStale('share:subscription', later)).toBe(false);
});
type Providers = {
providers: ProviderView[];
modelVisibilityOverrides?: Record<string, boolean>;
};
const provider = (id: string): ProviderView => ({
id,
name: id,
source: 'builtin',
agents: ['claude-code'],
auth: { method: 'none' },
routing: {
'claude-code': { upstream: 'https://example.invalid', authStrategy: 'none' },
},
models: { 'claude-code': [] },
connected: true,
});
const result = (deviceId: string): Providers => ({ providers: [provider(`${deviceId}-xd`)] });
const providerWithModel = (id: string) => ({
...provider(id),
models: {
'claude-code': [
{
id: `${id}-model`,
name: `${id} Model`,
contextWindow: 200_000,
efforts: ['medium'],
defaultEffort: 'medium',
},
],
},
});
/** stub window.electronAPI.deviceLink.invoke,返回 spy。 */
function stubDeviceLink() {
const invoke = vi.fn(async (deviceId: string) => result(deviceId));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
return invoke;
}
describe('useDeviceProviders deviceId-aware cache', () => {
it('远程路径:prefetch 命中 deviceLink.invoke(maker:provider:list, [])', async () => {
const invoke = stubDeviceLink();
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('dev-1');
expect(invoke).toHaveBeenCalledWith('dev-1', 'maker:provider:list', [
{
capabilities: ['provider-logo-kinds-v2'],
},
]);
});
it('非法 provider 响应进入 error,不得把 null 当成权威空列表', async () => {
const invoke = vi.fn(async () => null);
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
const listener = vi.fn();
mod.subscribeDeviceProviders('dev-invalid', listener);
await mod.prefetchDeviceProviders('dev-invalid');
expect(listener).toHaveBeenCalledWith({
status: 'error',
error: 'Invalid provider list response',
unsupported: false,
});
expect(mod.getCachedDeviceProviders('dev-invalid')).toBeNull();
});
it('provider 数组混入非法元素时丢掉坏项,保留合法供应商', async () => {
const invoke = vi.fn(async () => ({ providers: [provider('valid'), null] }));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
const listener = vi.fn();
mod.subscribeDeviceProviders('dev-invalid-item', listener);
await mod.prefetchDeviceProviders('dev-invalid-item');
expect(mod.getCachedDeviceProviders('dev-invalid-item')?.providers.map((row) => row.id)).toEqual([
'valid',
]);
expect(listener).toHaveBeenCalledWith(
expect.objectContaining({
status: 'ready',
providers: [expect.objectContaining({ id: 'valid' })],
}),
);
});
it('接受不含执行字段的安全投影 provider', async () => {
const projected = {
id: 'projected',
name: 'Projected',
agents: ['claude-code'],
models: {
'claude-code': [
{
id: 'projected-model',
name: 'Projected Model',
contextWindow: 200_000,
efforts: ['medium'],
defaultEffort: 'medium',
},
],
},
connected: true,
};
const invoke = vi.fn(async () => ({ providers: [projected] }));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('dev-projected');
const cached = mod.getCachedDeviceProviders('dev-projected');
expect(cached).toEqual({
providers: [{ ...projected, routing: { 'claude-code': {} } }],
});
expect(connectedProvidersForAgent(cached?.providers ?? [], 'claude-code')).toHaveLength(1);
expect(
visibleModelUnion(cached?.providers ?? [], 'claude-code', () => true).map((m) => m.id),
).toEqual(['projected-model']);
});
it('补齐 agents 声明但缺失的远程 routing entry,保留已有 disabled 标记', async () => {
const projected = {
...providerWithModel('partial-routing'),
agents: ['claude-code', 'codex'],
routing: { codex: { disabled: true } },
};
const invoke = vi.fn(async () => ({ providers: [projected] }));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('dev-partial-routing');
const cached = mod.getCachedDeviceProviders('dev-partial-routing');
expect(cached?.providers[0]?.routing).toEqual({
codex: { disabled: true },
'claude-code': {},
});
expect(connectedProvidersForAgent(cached?.providers ?? [], 'claude-code')).toHaveLength(1);
expect(connectedProvidersForAgent(cached?.providers ?? [], 'codex')).toEqual([]);
});
it('嵌套模型损坏时丢掉坏模型,保留供应商', async () => {
const malformed = {
...provider('malformed-model'),
models: {
'claude-code': [
null,
{
id: 'kept',
name: 'Kept',
contextWindow: 200_000,
efforts: ['medium'],
defaultEffort: 'medium',
},
],
},
};
const invoke = vi.fn(async () => ({ providers: [malformed] }));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('dev-malformed-model');
expect(
mod.getCachedDeviceProviders('dev-malformed-model')?.providers[0]?.models['claude-code'],
).toEqual([
expect.objectContaining({ id: 'kept' }),
]);
});
it('缺默认思考深度的远程模型保留,并按实际支持档位补默认', async () => {
const invoke = vi.fn(async () => ({
providers: [
{
...provider('openai'),
models: {
'claude-code': [
{
id: 'gpt-5.6-luna',
name: 'GPT-5.6-Luna',
contextWindow: 1_050_000,
efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
},
{
id: 'claude-opus-5',
name: 'Claude Opus 5',
contextWindow: 200_000,
efforts: ['high'],
defaultEffort: 'high',
},
],
},
},
],
}));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('dev-luna');
expect(
mod.getCachedDeviceProviders('dev-luna')?.providers[0]?.models['claude-code']?.map((m) => m.id),
).toEqual(['gpt-5.6-luna', 'claude-opus-5']);
expect(mod.getCachedDeviceProviders('dev-luna')?.providers[0]?.models['claude-code']?.[0]?.defaultEffort).toBe('medium');
});
it.each([undefined, true, false])('preserves provider effort capability marker %s without inferring legacy emptiness', async (effortsUnknown) => {
const mod = await import('@/hooks/useDeviceProviders');
const base = providerWithModel('remote');
const model = {
...base.models['claude-code'][0],
efforts: [],
defaultEffort: null,
...(effortsUnknown === undefined ? {} : { effortsUnknown }),
};
const result = mod.parseDeviceProvidersPayload({ providers: [{
...base, models: { 'claude-code': [model] },
}] });
expect(result.providers[0]?.models['claude-code']?.[0]?.effortsUnknown).toBe(effortsUnknown);
});
it('preserves explicit no-thinking and rejects malformed remote defaults', async () => {
const mod = await import('@/hooks/useDeviceProviders');
const base = providerWithModel('remote');
const model = base.models['claude-code'][0];
const result = mod.parseDeviceProvidersPayload({ providers: [{ ...base, models: {
'claude-code': [
{ ...model, id: 'empty', efforts: [], defaultEffort: undefined },
{ ...model, id: 'explicit-null', defaultEffort: null },
{ ...model, id: 'invalid', defaultEffort: { value: 'medium' } },
],
} }] });
expect(result.providers[0]?.models['claude-code']?.map(m => [m.id, m.defaultEffort])).toEqual([
['empty', null], ['explicit-null', null],
]);
});
it.each([
['provider.suspended', { ...provider('bad-suspended'), suspended: 'true' }],
[
'routing.disabled',
{
...provider('bad-route-disabled'),
routing: { 'claude-code': { disabled: 'true' } },
},
],
[
'routing.wireProtocol',
{
...provider('bad-wire-protocol'),
routing: { 'claude-code': { wireProtocol: 'future-protocol' } },
},
],
])('%s 类型损坏时整份 provider 响应失败', async (field, malformed) => {
const deviceId = `dev-invalid-${field}`;
const invoke = vi.fn(async () => ({ providers: [malformed] }));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
const listener = vi.fn();
mod.subscribeDeviceProviders(deviceId, listener);
await mod.prefetchDeviceProviders(deviceId);
expect(listener).toHaveBeenCalledWith({
status: 'error',
error: 'Invalid provider list response',
unsupported: false,
});
expect(mod.getCachedDeviceProviders(deviceId)).toBeNull();
});
it.each([
['model.disabled', 'true'],
['model.supportsFastMode', 'true'],
['model.defaultEnabled', 'false'],
])('%s 类型损坏时丢掉该模型,不整表失败', async (field, badValue) => {
const key = field.split('.')[1] as 'disabled' | 'supportsFastMode' | 'defaultEnabled';
const invoke = vi.fn(async () => ({
providers: [
{
...providerWithModel('kept-provider'),
models: {
'claude-code': [
{
...providerWithModel('kept-provider').models['claude-code'][0],
[key]: badValue,
},
{
id: 'good',
name: 'Good',
contextWindow: 200_000,
efforts: ['medium'],
defaultEffort: 'medium',
},
],
},
},
],
}));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders(`dev-drop-${key}`);
expect(
mod
.getCachedDeviceProviders(`dev-drop-${key}`)
?.providers[0]?.models['claude-code']?.map((model) => model.id),
).toEqual(['good']);
});
it('模型可见性 override 含非布尔值时不得缓存', async () => {
const invoke = vi.fn(async () => ({
providers: [provider('invalid-override')],
modelVisibilityOverrides: { 'claude-code:invalid-override:model': 'hidden' },
}));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
const listener = vi.fn();
mod.subscribeDeviceProviders('dev-invalid-override', listener);
await mod.prefetchDeviceProviders('dev-invalid-override');
expect(listener).toHaveBeenCalledWith({
status: 'error',
error: 'Invalid provider visibility response',
unsupported: false,
});
expect(mod.getCachedDeviceProviders('dev-invalid-override')).toBeNull();
});
it('缓存命中:同设备二次 prefetch 不再发请求', async () => {
const invoke = stubDeviceLink();
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('dev-1');
await mod.prefetchDeviceProviders('dev-1');
expect(invoke).toHaveBeenCalledTimes(1);
});
it('缓存并通知被控端的模型可见性 override 快照', async () => {
const overrides = { 'codex:openai:hidden-model': false };
const invoke = vi.fn(async () => ({
...result('dev-1'),
modelVisibilityOverrides: overrides,
}));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
const listener = vi.fn();
mod.subscribeDeviceProviders('dev-1', listener);
await mod.prefetchDeviceProviders('dev-1');
expect(mod.getCachedDeviceProviders('dev-1')).toEqual({
providers: [provider('dev-1-xd')],
modelVisibilityOverrides: overrides,
});
expect(listener).toHaveBeenCalledWith({
status: 'ready',
providers: [provider('dev-1-xd')],
modelVisibilityOverrides: overrides,
});
});
it('inflight 去重:同设备并发只发一次', async () => {
const invoke = stubDeviceLink();
const mod = await import('@/hooks/useDeviceProviders');
await Promise.all([mod.prefetchDeviceProviders('dev-1'), mod.prefetchDeviceProviders('dev-1')]);
expect(invoke).toHaveBeenCalledTimes(1);
});
it('key 隔离:dev-1 / dev-2 各拉各的,互不影响', async () => {
const invoke = stubDeviceLink();
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('dev-1');
await mod.prefetchDeviceProviders('dev-2');
expect(invoke).toHaveBeenCalledWith('dev-1', 'maker:provider:list', [
{
capabilities: ['provider-logo-kinds-v2'],
},
]);
expect(invoke).toHaveBeenCalledWith('dev-2', 'maker:provider:list', [
{
capabilities: ['provider-logo-kinds-v2'],
},
]);
expect(invoke).toHaveBeenCalledTimes(2);
// dev-2 已缓存:再 prefetch 不重拉(隔离 + 命中)。
await mod.prefetchDeviceProviders('dev-2');
expect(invoke).toHaveBeenCalledTimes(2);
});
it('驱逐:evict 后同设备重新拉取;只清该设备(dev-2 仍命中缓存)', async () => {
const invoke = stubDeviceLink();
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('dev-1');
await mod.prefetchDeviceProviders('dev-2');
expect(invoke).toHaveBeenCalledTimes(2);
mod.evictDeviceProviders('dev-1');
await mod.prefetchDeviceProviders('dev-1'); // 缓存已清 → 重拉(+1)
await mod.prefetchDeviceProviders('dev-2'); // 未清 → 命中(+0)
expect(invoke).toHaveBeenCalledTimes(3);
});
it('evict 在途 prefetch → 结果丢弃,不复活缓存(重连/升级目标端后串旧)', async () => {
const resolvers: Array<(v: Providers) => void> = [];
const invoke = vi.fn(() => new Promise<Providers>((r) => resolvers.push(r)));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
const p = mod.prefetchDeviceProviders('dev-1'); // 在途(invoke 未 resolve)
mod.evictDeviceProviders('dev-1'); // 设备下线 → 驱逐(代际自增)
resolvers.forEach((r) => r(result('dev-1-stale'))); // 在途请求随后才回来
await p;
// 被驱逐的在途结果不得回写缓存 → 再 prefetch 必须重新发请求(总计 2 次)。
const p2 = mod.prefetchDeviceProviders('dev-1');
resolvers.forEach((r) => r(result('dev-1-fresh'))); // resolve 第二轮(含已 resolve 的第一轮,no-op)
await p2;
expect(invoke).toHaveBeenCalledTimes(2);
});
it('reject(旧版被控端不识别通道)→ 不缓存,下次重试', async () => {
let call = 0;
const invoke = vi.fn(async () => {
call += 1;
throw new Error(
"[DEVICE_LINK_CHANNEL_NOT_ALLOWED] channel 'maker:provider:list' not allowed remotely",
);
});
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('dev-old'); // swallow
await mod.prefetchDeviceProviders('dev-old'); // 上次失败未缓存 → 再发
expect(call).toBe(2);
});
it('错误事件区分旧端不支持与真实连接失败', async () => {
const unsupported = new Error('[DEVICE_LINK_CHANNEL_NOT_ALLOWED] channel not allowed remotely');
const policyFailure = new Error('proxy policy: request not allowed remotely');
const invoke = vi
.fn()
.mockRejectedValueOnce(unsupported)
.mockRejectedValueOnce(new Error('[DEVICE_LINK_TIMEOUT] timed out'))
.mockRejectedValueOnce(policyFailure);
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
const oldDeviceListener = vi.fn();
const offlineListener = vi.fn();
const policyFailureListener = vi.fn();
mod.subscribeDeviceProviders('dev-old', oldDeviceListener);
mod.subscribeDeviceProviders('dev-offline', offlineListener);
mod.subscribeDeviceProviders('dev-policy-failure', policyFailureListener);
await mod.prefetchDeviceProviders('dev-old');
await mod.prefetchDeviceProviders('dev-offline');
await mod.prefetchDeviceProviders('dev-policy-failure');
expect(mod.isDeviceProvidersUnsupportedError(unsupported)).toBe(true);
expect(mod.isDeviceProvidersUnsupportedError(policyFailure)).toBe(false);
expect(oldDeviceListener).toHaveBeenCalledWith({
status: 'error',
error: unsupported.message,
unsupported: true,
});
expect(offlineListener).toHaveBeenCalledWith({
status: 'error',
error: '[DEVICE_LINK_TIMEOUT] timed out',
unsupported: false,
});
expect(policyFailureListener).toHaveBeenCalledWith({
status: 'error',
error: policyFailure.message,
unsupported: false,
});
});
it('新快照只通知对应 deviceId 的已挂载订阅者', async () => {
const invoke = stubDeviceLink();
const mod = await import('@/hooks/useDeviceProviders');
const dev1 = vi.fn();
const dev2 = vi.fn();
const off1 = mod.subscribeDeviceProviders('dev-1', dev1);
const off2 = mod.subscribeDeviceProviders('dev-2', dev2);
await mod.prefetchDeviceProviders('dev-1');
expect(dev1).toHaveBeenCalledWith({
status: 'ready',
providers: [provider('dev-1-xd')],
});
expect(dev2).not.toHaveBeenCalled();
off1();
off2();
expect(invoke).toHaveBeenCalledTimes(1);
});
it('revision 后新请求先完成、旧请求后完成时只通知新快照', async () => {
const resolvers: Array<(value: Providers) => void> = [];
const invoke = vi.fn(() => new Promise<Providers>((resolve) => resolvers.push(resolve)));
vi.stubGlobal('window', { electronAPI: { deviceLink: { invoke } } });
const mod = await import('@/hooks/useDeviceProviders');
const listener = vi.fn();
mod.subscribeDeviceProviders('dev-1', listener);
const stale = mod.prefetchDeviceProviders('dev-1');
mod.evictDeviceProviders('dev-1');
const fresh = mod.prefetchDeviceProviders('dev-1');
resolvers[1](result('fresh'));
await fresh;
resolvers[0](result('stale'));
await stale;
expect(listener).toHaveBeenNthCalledWith(1, { status: 'loading' });
expect(listener).toHaveBeenNthCalledWith(2, {
status: 'ready',
providers: [provider('fresh-xd')],
});
});
});
describe('provider visibility readiness retry', () => {
afterEach(() => { vi.useRealTimers(); vi.unstubAllGlobals(); });
it('retries a serialized typed readiness error, deduplicates callers, then retains hidden switches', async () => {
vi.useFakeTimers();
const invoke = stubDeviceLink();
invoke.mockRejectedValueOnce(new Error('[MODEL_VISIBILITY_NOT_READY] waiting'));
invoke.mockResolvedValue({ ...result('host'), modelVisibilityOverrides: { 'codex:xd:hidden': false } });
const mod = await import('@/hooks/useDeviceProviders');
const listener = vi.fn();
mod.subscribeDeviceProviders('host', listener);
const requests = [mod.prefetchDeviceProviders('host'), mod.prefetchDeviceProviders('host')];
await vi.runAllTimersAsync();
await Promise.all(requests);
expect(invoke).toHaveBeenCalledTimes(2);
expect(listener).toHaveBeenCalledTimes(1);
expect(listener).toHaveBeenCalledWith(expect.objectContaining({ status: 'ready', modelVisibilityOverrides: { 'codex:xd:hidden': false } }));
});
it('stops after three not-ready attempts and reports a real error without legacy fallback', async () => {
vi.useFakeTimers();
const invoke = stubDeviceLink().mockRejectedValue(new Error('[MODEL_VISIBILITY_NOT_READY] waiting'));
const mod = await import('@/hooks/useDeviceProviders');
const listener = vi.fn();
mod.subscribeDeviceProviders('host', listener);
const pending = mod.prefetchDeviceProviders('host');
await vi.runAllTimersAsync();
await pending;
expect(invoke).toHaveBeenCalledTimes(3);
expect(listener).toHaveBeenCalledWith(expect.objectContaining({ status: 'error', unsupported: false }));
expect(mod.getCachedDeviceProviders('host')).toBeNull();
});
it.each(['[INTERNAL] failed', 'MODEL_VISIBILITY_NOT_READY: untyped'])('does not retry other errors: %s', async (message) => {
const invoke = stubDeviceLink().mockRejectedValue(new Error(message));
const mod = await import('@/hooks/useDeviceProviders');
await mod.prefetchDeviceProviders('host');
expect(invoke).toHaveBeenCalledTimes(1);
expect(mod.isDeviceProvidersUnsupportedError(new Error(message))).toBe(false);
});
it('eviction cancels delayed retries without disturbing another device', async () => {
vi.useFakeTimers();
const invoke = stubDeviceLink();
invoke.mockRejectedValueOnce(new Error('[MODEL_VISIBILITY_NOT_READY] waiting'));
const mod = await import('@/hooks/useDeviceProviders');
const pending = mod.prefetchDeviceProviders('retired');
await vi.advanceTimersByTimeAsync(0);
mod.evictDeviceProviders('retired');
await mod.prefetchDeviceProviders('healthy');
await vi.runAllTimersAsync();
await pending;
expect(invoke).toHaveBeenCalledTimes(2);
expect(mod.getCachedDeviceProviders('retired')).toBeNull();
expect(mod.getCachedDeviceProviders('healthy')).toEqual(result('healthy'));
});
});