Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
// @vitest-environment jsdom
/**
* useRemoteDeviceUsage / remoteDeviceUsageMirror / useRemoteClaudeSessionRoute 单测。
*
* 镜像工厂与 useRemoteClaudeSubscriptionUsage 同语义(owner 栅栏 / CHANNEL_NOT_ALLOWED
* TTL 已在该 hook 的测试覆盖同款路径),这里覆盖:
* - 工厂 push 整帧替换 / null 清空 / invokeArgs 透传 / push-only 镜像不发 invoke;
* - selectRemoteCodexAccountUsage 的选槽 / 选桶口径(与本机 useAccountUsage 一致:
* bridge → web 槽;app-server 按模型匹配桶,匹配不到不显示;空桶表回退顶层);
* - 路由镜像的观察值应用与 push 更新(按 deviceId+sessionId 过滤)。
*/
import { act, cleanup, renderHook } from '@testing-library/react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { setDataOwnerGeneration } from '../contexts/dataOwnerGeneration';
import { createRemoteDeviceUsageMirror } from '../hooks/remoteDeviceUsageMirror';
import {
selectRemoteCodexAccountUsage,
useRemoteCodexAccountUsage,
useRemoteClaudeAccountUsage,
useRemoteXaiRateLimit,
resetRemoteDeviceUsageMirrorsForTest,
} from '../hooks/useRemoteDeviceUsage';
import {
resetRemoteClaudeSessionRouteCacheForTest,
useRemoteClaudeSessionRoute,
} from '../hooks/useRemoteClaudeSessionRoute';
type PushListener = (
push: { deviceId: string; channel: string; payload: unknown },
localOwnerStamp?: unknown,
) => void;
const mocks = vi.hoisted(() => ({
invoke: vi.fn<(deviceId: string, channel: string, args: unknown[]) => Promise<unknown>>(),
pushListeners: [] as PushListener[],
reopenedListeners: [] as Array<(value: { deviceId: string }) => void>,
peerResetListeners: [] as Array<(value: { deviceId: string }) => void>,
statusListeners: [] as Array<(value: { status: 'online' | 'connecting' | 'stopped' }) => void>,
presenceListeners: [] as Array<(value: { deviceId: string; online: boolean }) => void>,
}));
function emitPush(push: { deviceId: string; channel: string; payload: unknown }): void {
for (const cb of [...mocks.pushListeners]) cb(push);
}
async function flushMicrotasks(): Promise<void> {
await act(async () => {
await Promise.resolve();
await Promise.resolve();
});
}
beforeEach(() => {
vi.useFakeTimers();
vi.setSystemTime(1_788_300_000_000);
setDataOwnerGeneration('owner-a');
resetRemoteDeviceUsageMirrorsForTest();
resetRemoteClaudeSessionRouteCacheForTest();
mocks.invoke.mockReset();
mocks.pushListeners.length = 0;
mocks.presenceListeners.length = 0;
mocks.statusListeners.length = 0;
mocks.peerResetListeners.length = 0;
mocks.reopenedListeners.length = 0;
Object.defineProperty(window, 'electronAPI', {
configurable: true,
value: {
deviceLink: {
invoke: mocks.invoke,
onPeerLinkReopened: (listener: (value: { deviceId: string }) => void) => {
mocks.reopenedListeners.push(listener);
return () => { mocks.reopenedListeners = mocks.reopenedListeners.filter(item => item !== listener); };
},
onPeerLinkReset: (listener: (value: { deviceId: string }) => void) => {
mocks.peerResetListeners.push(listener);
return () => { mocks.peerResetListeners = mocks.peerResetListeners.filter(item => item !== listener); };
},
onPresenceChanged: (listener: (value: { deviceId: string; online: boolean }) => void) => {
mocks.presenceListeners.push(listener);
return () => { mocks.presenceListeners = mocks.presenceListeners.filter(item => item !== listener); };
},
onStatusChanged: (listener: (value: { status: 'online' | 'connecting' | 'stopped' }) => void) => {
mocks.statusListeners.push(listener);
return () => { mocks.statusListeners = mocks.statusListeners.filter(item => item !== listener); };
},
onRemotePush: (cb: PushListener) => {
mocks.pushListeners.push(cb);
return () => {
const i = mocks.pushListeners.indexOf(cb);
if (i >= 0) mocks.pushListeners.splice(i, 1);
};
},
},
},
});
});
afterEach(() => {
cleanup();
vi.clearAllTimers();
vi.useRealTimers();
});
describe('createRemoteDeviceUsageMirror', () => {
it('push 整帧替换、null 清空,push-only 镜像不发 invoke', async () => {
const pushOnly = createRemoteDeviceUsageMirror<{ v?: number }>({
invokeChannel: null,
pushChannel: 'test:push-only-changed',
});
const { result } = renderHook(() => pushOnly.useMirror('device-1'));
await flushMicrotasks();
expect(mocks.invoke).not.toHaveBeenCalled();
act(() => emitPush({ deviceId: 'device-1', channel: 'test:push-only-changed', payload: { v: 1 } }));
expect(result.current).toEqual({ v: 1 });
act(() => emitPush({ deviceId: 'device-1', channel: 'test:push-only-changed', payload: null }));
expect(result.current).toBeNull();
// 异常形状保留现值。
act(() => emitPush({ deviceId: 'device-1', channel: 'test:push-only-changed', payload: { v: 2 } }));
act(() => emitPush({ deviceId: 'device-1', channel: 'test:push-only-changed', payload: 'junk' }));
expect(result.current).toEqual({ v: 2 });
pushOnly.resetForTest();
});
it('useRemoteCodexAccountUsage 经 maker:usage:account 携带 agentKind 参数', async () => {
mocks.invoke.mockResolvedValue({ primary: { usedPercent: 3 } });
const { result } = renderHook(() => useRemoteCodexAccountUsage('device-1'));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledWith('device-1', 'maker:usage:account', ['codex']);
expect(result.current).toMatchObject({ primary: { usedPercent: 3 } });
});
it('shares one device read between concurrent consumers of the same account', async () => {
mocks.invoke.mockImplementation(async (_deviceId, _channel, args) => ({
providerId: args[1],
primary: { usedPercent: 3 },
}));
const chip = renderHook(() => useRemoteCodexAccountUsage('device-1', 'account-2'));
await flushMicrotasks();
// A second consumer (model picker) mounting beside a live consumer reuses its fresh snapshot.
vi.advanceTimersByTime(59_000);
const picker = renderHook(() => useRemoteCodexAccountUsage('device-1', 'account-2'));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledTimes(1);
expect(picker.result.current).toMatchObject({ primary: { usedPercent: 3 } });
act(() =>
emitPush({
deviceId: 'device-1',
channel: 'usage:codex-provider-account-changed',
payload: { providerId: 'account-2', snapshot: { primary: { usedPercent: 7 } } },
}),
);
expect(chip.result.current).toMatchObject({ primary: { usedPercent: 7 } });
expect(picker.result.current).toMatchObject({ primary: { usedPercent: 7 } });
// Other accounts on the same device keep their own entry and read.
renderHook(() => useRemoteCodexAccountUsage('device-1', 'account-3'));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledTimes(2);
});
it('re-reads beside a live consumer once its snapshot is older than the reuse window', async () => {
// Pushes are lost while the link is down; a long-lived chip must not pin a stale snapshot.
mocks.invoke.mockResolvedValue({ primary: { usedPercent: 3 } });
renderHook(() => useRemoteCodexAccountUsage('device-1'));
await flushMicrotasks();
vi.advanceTimersByTime(61_000);
mocks.invoke.mockResolvedValue({ primary: { usedPercent: 9 } });
const picker = renderHook(() => useRemoteCodexAccountUsage('device-1'));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledTimes(2);
expect(picker.result.current).toMatchObject({ primary: { usedPercent: 9 } });
});
it('always re-reads on mount when no consumer was listening for pushes', async () => {
// A logout/account-switch clear pushed while nobody listened must not leave the old quota.
mocks.invoke.mockResolvedValue({ primary: { usedPercent: 3 } });
renderHook(() => useRemoteCodexAccountUsage('device-1')).unmount();
await flushMicrotasks();
mocks.invoke.mockResolvedValue(null);
const reopened = renderHook(() => useRemoteCodexAccountUsage('device-1'));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledTimes(2);
expect(reopened.result.current).toBeNull();
});
it('keeps retrying mounts after a failed read', async () => {
mocks.invoke.mockRejectedValueOnce(new Error('offline'));
const first = renderHook(() => useRemoteCodexAccountUsage('device-1'));
await flushMicrotasks();
first.unmount();
mocks.invoke.mockResolvedValue({ primary: { usedPercent: 3 } });
const second = renderHook(() => useRemoteCodexAccountUsage('device-1'));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledTimes(2);
expect(second.result.current).toMatchObject({ primary: { usedPercent: 3 } });
});
});
describe('selectRemoteCodexAccountUsage', () => {
const bucketA = {
limitId: 'codex',
primary: { usedPercent: 12, windowMinutes: 300 },
};
const bucketSpark = {
limitId: 'codex_bengalfox',
limitName: 'GPT-5.3-Codex-Spark',
primary: { usedPercent: 1, windowMinutes: 11_520 },
};
it('bridge 形态取 web 槽', () => {
const web = { source: 'openai-web', primary: { usedPercent: 9 } };
expect(
selectRemoteCodexAccountUsage(
{ webSnapshot: web, appServerBuckets: { codex: bucketA } },
'openai-web',
'chatgpt/gpt-5.6',
),
).toMatchObject({ primary: { usedPercent: 9 } });
});
it('app-server 形态按模型匹配桶,通用模型不显示模型专属促销桶', () => {
const selected = selectRemoteCodexAccountUsage(
{
...bucketA,
webSnapshot: null,
appServerBuckets: { codex: bucketA, codex_bengalfox: bucketSpark },
},
'app-server',
'gpt-5.6-sol',
);
expect(selected?.limitId).toBe('codex');
});
it('桶表为空(旧被控端)回退顶层兼容位;payload 为 null 返回 null', () => {
expect(
selectRemoteCodexAccountUsage(
{ ...bucketA, webSnapshot: null, appServerBuckets: null },
'app-server',
'gpt-5.6-sol',
)?.primary?.usedPercent,
).toBe(12);
expect(selectRemoteCodexAccountUsage(null, 'app-server', 'gpt-5.6-sol')).toBeNull();
});
});
describe('useRemoteClaudeSessionRoute', () => {
it('应用被控端观察值,并按 deviceId+sessionId 过滤 push 更新', async () => {
mocks.invoke.mockResolvedValue(null);
const { result } = renderHook(() => useRemoteClaudeSessionRoute('device-1', 'sess-1'));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledWith('device-1', 'maker:claude-session-route:get', ['sess-1']);
expect(result.current).toBeNull();
// 其它会话 / 其它设备的 push 不影响本会话。
act(() => emitPush({
deviceId: 'device-1',
channel: 'maker:claude-session-route-changed',
payload: { sessionId: 'sess-other', route: 'gateway' },
}));
expect(result.current).toBeNull();
act(() => emitPush({
deviceId: 'device-1',
channel: 'maker:claude-session-route-changed',
payload: { sessionId: 'sess-1', route: 'subscription' },
}));
expect(result.current).toBe('subscription');
});
it('warm-start 观察值直接生效', async () => {
mocks.invoke.mockResolvedValue('gateway');
const { result } = renderHook(() => useRemoteClaudeSessionRoute('device-1', 'sess-2'));
await flushMicrotasks();
expect(result.current).toBe('gateway');
});
// MagicLizi P1 (#3789): a warm-start GET that resolves after a newer push must not win.
it.each([null, 'gateway'])('迟到的 warm-start GET(%s)不覆盖在途期间到达的 push', async (late) => {
let resolveGet: (v: unknown) => void = () => {};
mocks.invoke.mockImplementation(() => new Promise((resolve) => { resolveGet = resolve; }));
const { result } = renderHook(() => useRemoteClaudeSessionRoute('device-1', 'sess-3'));
await flushMicrotasks();
expect(result.current).toBeNull();
act(() => emitPush({
deviceId: 'device-1',
channel: 'maker:claude-session-route-changed',
payload: { sessionId: 'sess-3', route: 'subscription' },
}));
expect(result.current).toBe('subscription');
await act(async () => { resolveGet(late); await flushMicrotasks(); });
expect(result.current).toBe('subscription');
});
it('无 push 时 warm-start GET 正常生效(revision 未变)', async () => {
let resolveGet: (v: unknown) => void = () => {};
mocks.invoke.mockImplementation(() => new Promise((resolve) => { resolveGet = resolve; }));
const { result } = renderHook(() => useRemoteClaudeSessionRoute('device-1', 'sess-4'));
await flushMicrotasks();
await act(async () => { resolveGet('gateway'); await flushMicrotasks(); });
expect(result.current).toBe('gateway');
});
});
describe('remote account parity', () => {
it('keeps builtin and named provider reads, pushes and clears separate on one device', async () => {
mocks.invoke.mockImplementation(async (_device, _channel, args) => args[1]
? { providerId: args[1], primary: { usedPercent: 70 } }
: { primary: { usedPercent: 10 } });
const builtin = renderHook(() => useRemoteCodexAccountUsage('device-1'));
const named = renderHook(() => useRemoteCodexAccountUsage('device-1', 'account-2'));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledWith('device-1', 'maker:usage:account', ['codex', 'account-2']);
expect(builtin.result.current?.primary?.usedPercent).toBe(10);
expect(named.result.current?.primary?.usedPercent).toBe(70);
act(() => emitPush({ deviceId: 'device-1', channel: 'usage:codex-provider-account-changed',
payload: { providerId: 'account-2', snapshot: { primary: { usedPercent: 80 } } } }));
expect(named.result.current?.primary?.usedPercent).toBe(80);
expect(builtin.result.current?.primary?.usedPercent).toBe(10);
act(() => emitPush({ deviceId: 'device-1', channel: 'usage:codex-account-changed', payload: null }));
expect(builtin.result.current).toBeNull();
expect(named.result.current?.primary?.usedPercent).toBe(80);
act(() => emitPush({ deviceId: 'device-1', channel: 'usage:codex-provider-account-changed',
payload: { providerId: 'account-2', snapshot: null } }));
expect(named.result.current).toBeNull();
});
// MagicLizi P1 (#3789): xAI rate-limit mirrors are account-scoped too. An independent
// account's record must not land in the builtin mirror and its clear must not empty it.
it('keeps builtin and independent xAI rate-limit mirrors separate on one device', () => {
const builtin = renderHook(() => useRemoteXaiRateLimit('device-1'));
const named = renderHook(() => useRemoteXaiRateLimit('device-1', 'xai-second'));
expect(mocks.invoke).not.toHaveBeenCalled();
act(() => emitPush({ deviceId: 'device-1', channel: 'usage:xai-rate-limit-changed',
payload: { updatedAt: 1, remainingRequests: 5 } }));
expect(builtin.result.current?.remainingRequests).toBe(5);
expect(named.result.current).toBeNull();
act(() => emitPush({ deviceId: 'device-1', channel: 'usage:xai-provider-rate-limit-changed',
payload: { providerId: 'xai-second', snapshot: { updatedAt: 2, remainingRequests: 9 } } }));
expect(named.result.current?.remainingRequests).toBe(9);
expect(builtin.result.current?.remainingRequests).toBe(5);
// Independent account clear leaves the still-logged-in builtin account untouched.
act(() => emitPush({ deviceId: 'device-1', channel: 'usage:xai-provider-rate-limit-changed',
payload: { providerId: 'xai-second', snapshot: null } }));
expect(named.result.current).toBeNull();
expect(builtin.result.current?.remainingRequests).toBe(5);
});
it('rejects a legacy host builtin response when a named account was requested', async () => {
mocks.invoke.mockResolvedValue({ primary: { usedPercent: 10 } });
const { result } = renderHook(() => useRemoteCodexAccountUsage('device-1', 'account-2'));
await flushMicrotasks();
expect(result.current).toBeNull();
});
it('does not let a late initial read overwrite a newer usage push', async () => {
let finish!: (value: unknown) => void;
mocks.invoke.mockReturnValue(new Promise(resolve => { finish = resolve; }));
const { result } = renderHook(() => useRemoteCodexAccountUsage('device-1'));
act(() => emitPush({ deviceId: 'device-1', channel: 'usage:codex-account-changed',
payload: { primary: { usedPercent: 80 } } }));
await act(async () => finish({ primary: { usedPercent: 10 } }));
expect(result.current?.primary?.usedPercent).toBe(80);
});
it('does not expose another device snapshot during a device switch', async () => {
mocks.invoke.mockResolvedValueOnce({ primary: { usedPercent: 10 } });
const seen: unknown[] = [];
const { rerender } = renderHook(({ device }) => {
const snapshot = useRemoteCodexAccountUsage(device);
seen.push(snapshot);
return snapshot;
}, { initialProps: { device: 'device-1' } });
await flushMicrotasks();
mocks.invoke.mockReturnValue(new Promise(() => {}));
seen.length = 0;
rerender({ device: 'device-2' });
expect(seen).toEqual([null]);
});
});
// Unit: the remote mirror must retain the daily-limit switch on reads and pushes,
// including a switch-off update without dropping the monthly quota.
it('mirrors enterprise daily-limit changes through device-link', async () => {
const quota = { spend: 12, maxBudget: 100, currency: 'CNY', todaySpend: 1, fetchedAt: 1, dailyLimitEnabled: true };
mocks.invoke.mockResolvedValue(quota);
const view = renderHook(() => useRemoteClaudeAccountUsage('daily-switch'));
await flushMicrotasks();
expect(view.result.current).toEqual(quota);
const disabled = { ...quota, todaySpend: null, dailyLimitEnabled: false };
act(() => emitPush({ deviceId: 'daily-switch', channel: 'usage:claude-account-changed', payload: disabled }));
expect(view.result.current).toEqual(disabled);
});
it.each(['unlimited', 'invalidated'])('retains remote quota on unavailable reads but replays a missed %s clear', async (quotaState) => {
const quota = { spend: 12, maxBudget: 100, currency: 'CNY', todaySpend: null, fetchedAt: 1 };
mocks.invoke.mockResolvedValue(quota);
const first = renderHook(() => useRemoteClaudeAccountUsage('device-quota'));
await flushMicrotasks();
expect(first.result.current).toEqual(quota);
first.unmount();
mocks.invoke.mockResolvedValue(null);
const unavailable = renderHook(() => useRemoteClaudeAccountUsage('device-quota'));
await flushMicrotasks();
expect(unavailable.result.current).toEqual(quota);
unavailable.unmount();
mocks.invoke.mockResolvedValue({ quotaState });
const cleared = renderHook(() => useRemoteClaudeAccountUsage('device-quota'));
await flushMicrotasks();
expect(cleared.result.current).toBeNull();
});
it('rereads only the recovered quota peer while consumers remain mounted', async () => {
const quota = { spend: 12, maxBudget: 100, currency: 'CNY', todaySpend: null, fetchedAt: 1 };
mocks.invoke.mockResolvedValue(quota);
const a = renderHook(() => useRemoteClaudeAccountUsage('peer-a'));
const b = renderHook(() => useRemoteClaudeAccountUsage('peer-b'));
await flushMicrotasks();
mocks.invoke.mockClear();
mocks.invoke.mockResolvedValue({ quotaState: 'unlimited' });
act(() => mocks.presenceListeners.forEach(cb => cb({ deviceId: 'peer-a', online: false })));
act(() => mocks.presenceListeners.forEach(cb => cb({ deviceId: 'peer-a', online: true })));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledTimes(1);
expect(mocks.invoke.mock.calls[0]?.[0]).toBe('peer-a');
expect(a.result.current).toBeNull();
expect(b.result.current).toEqual(quota);
});
it('queues a recovery read when a previous quota request is still in flight', async () => {
let finish!: (value: unknown) => void;
mocks.invoke.mockImplementationOnce(() => new Promise(resolve => { finish = resolve; }));
mocks.invoke.mockResolvedValue({ quotaState: 'unlimited' });
const a = renderHook(() => useRemoteClaudeAccountUsage('peer-pending'));
act(() => mocks.presenceListeners.forEach(cb => cb({ deviceId: 'peer-pending', online: true })));
await act(async () => finish(null));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledTimes(2);
expect(a.result.current).toBeNull();
});
it('rereads when the target comes online after an early relay recovery read fails', async () => {
const quota = { spend: 12, maxBudget: 100, currency: 'CNY', todaySpend: null, fetchedAt: 1 };
mocks.invoke.mockResolvedValue(quota);
const view = renderHook(() => useRemoteClaudeAccountUsage('peer-late'));
await flushMicrotasks();
act(() => mocks.statusListeners.forEach(cb => cb({ status: 'online' })));
act(() => mocks.presenceListeners.forEach(cb => cb({ deviceId: 'peer-late', online: true })));
await flushMicrotasks();
mocks.invoke.mockRejectedValue(new Error('target offline'));
act(() => mocks.statusListeners.forEach(cb => cb({ status: 'connecting' })));
act(() => mocks.statusListeners.forEach(cb => cb({ status: 'online' })));
await flushMicrotasks();
expect(view.result.current).toEqual(quota);
mocks.invoke.mockClear();
mocks.invoke.mockResolvedValue({ quotaState: 'unlimited' });
act(() => mocks.presenceListeners.forEach(cb => cb({ deviceId: 'peer-late', online: true })));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledTimes(1);
expect(view.result.current).toBeNull();
});
it('rereads only the reset peer without needing relay or presence changes', async () => {
const quota = { spend: 12, maxBudget: 100, currency: 'CNY', todaySpend: null, fetchedAt: 1 };
mocks.invoke.mockResolvedValue(quota);
const a = renderHook(() => useRemoteClaudeAccountUsage('reset-a'));
const b = renderHook(() => useRemoteClaudeAccountUsage('reset-b'));
await flushMicrotasks();
mocks.invoke.mockClear();
mocks.invoke.mockResolvedValue({ quotaState: 'unlimited' });
act(() => mocks.peerResetListeners.forEach(cb => cb({ deviceId: 'reset-a' })));
await flushMicrotasks();
expect(mocks.invoke).toHaveBeenCalledTimes(1);
expect(mocks.invoke.mock.calls[0]?.[0]).toBe('reset-a');
expect(a.result.current).toBeNull();
expect(b.result.current).toEqual(quota);
a.unmount();
b.unmount();
expect(mocks.peerResetListeners).toHaveLength(0);
});
it('rereads the recovered peer after the initial reset read failed, leaving its neighbor untouched', async () => {
const finite = { spend: 1, maxBudget: 10, currency: 'CNY', fetchedAt: 1 };
mocks.invoke.mockResolvedValue(finite);
const a = renderHook(() => useRemoteClaudeAccountUsage('retry-a'));
const b = renderHook(() => useRemoteClaudeAccountUsage('retry-b'));
await flushMicrotasks();
mocks.invoke.mockRejectedValueOnce(new Error('first open failed'));
act(() => mocks.peerResetListeners.forEach(cb => cb({ deviceId: 'retry-a' })));
await flushMicrotasks();
expect(a.result.current).toEqual(finite);
mocks.invoke.mockClear();
mocks.invoke.mockResolvedValue({ quotaState: 'invalidated' });
act(() => mocks.reopenedListeners.forEach(cb => cb({ deviceId: 'retry-a' })));
await flushMicrotasks();
expect(a.result.current).toBeNull();
expect(b.result.current).toEqual(finite);
expect(mocks.invoke).toHaveBeenCalledTimes(1);
expect(mocks.invoke.mock.calls[0]?.[0]).toBe('retry-a');
a.unmount(); b.unmount();
expect(mocks.reopenedListeners).toHaveLength(0);
});