Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { describe, expect, it, vi } from 'vitest';
import { rehydrateDeviceLinkPeer, rehydrateDeviceLinkTopics } from '@/device-link/rehydrate';
import type { DeviceLinkRehydrateDeps } from '@/device-link/rehydrate';
function deps() {
const calls: string[] = [];
let nextCohort = 0;
const harness: DeviceLinkRehydrateDeps = {
capturePresenceEpoch: vi.fn(() => 0),
captureResponseEvidenceEpoch: vi.fn(() => 0),
isPresenceEpochCurrent: vi.fn(() => true),
isResponseEvidenceEpochCurrent: vi.fn(() => true),
createDeviceSendCohort: vi.fn(() => ++nextCohort),
openLink: vi.fn((deviceId: string) => {
calls.push(`open:${deviceId}`);
return {
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.resolve(),
};
}),
subscribe: vi.fn(async (deviceId: string, topics) => {
calls.push(`subscribe:${deviceId}:${topics.join(',')}`);
}),
requestSessionsReseed: vi.fn((deviceId: string) => {
calls.push(`reseed:${deviceId}`);
}),
rebuildSessionSnapshot: vi.fn(async (deviceId: string, sessionId: string) => {
calls.push(`rebuild:${deviceId}:${sessionId}`);
}),
};
return { calls, harness };
}
describe('rehydrateDeviceLinkTopics', () => {
it('restores the visible task before a list registered earlier, without starting background reads while it waits', async () => {
const { calls, harness } = deps();
let finish!: () => void;
vi.mocked(harness.rebuildSessionSnapshot).mockImplementationOnce(async () => {
calls.push('snapshot');
await new Promise<void>((resolve) => { finish = resolve; });
});
const result = rehydrateDeviceLinkPeer({ deviceId: 'a', openLink: false, topics: ['sessions', 'session:active'] }, harness);
for (let i = 0; i < 5; i++) await Promise.resolve();
expect(calls).toEqual(['subscribe:a:sessions,session:active', 'snapshot']);
expect(harness.requestSessionsReseed).not.toHaveBeenCalled();
finish();
await result;
expect(calls.at(-1)).toBe('reseed:a');
});
it.each(['open', 'subscribe', 'snapshot'])('stops fan-out after a %s timeout without delaying another peer', async (stage) => {
const { harness } = deps();
const error = Object.assign(new Error('request timed out'), { code: 'INVOKE_TIMEOUT' });
if (stage === 'open') vi.mocked(harness.openLink).mockReturnValueOnce({
capturedPresenceEpoch: 0, capturedResponseEvidenceEpoch: 0, request: Promise.reject(error),
});
if (stage === 'subscribe') vi.mocked(harness.subscribe).mockRejectedValueOnce(error);
if (stage === 'snapshot') vi.mocked(harness.rebuildSessionSnapshot).mockRejectedValueOnce(error);
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'a', openLink: true, topics: ['sessions', 'session:a1', 'session:a2'] },
{ deviceId: 'b', openLink: true, topics: ['sessions', 'session:b1'] },
], harness);
expect(result.transientFailures).toBe(1);
expect(harness.requestSessionsReseed).toHaveBeenCalledExactlyOnceWith('b');
expect(harness.rebuildSessionSnapshot).not.toHaveBeenCalledWith('a', 'a2', expect.anything());
expect(harness.rebuildSessionSnapshot).toHaveBeenCalledWith('b', 'b1', expect.anything());
});
it('replays open links, subscriptions, and host-authoritative snapshots in order', async () => {
const { calls, harness } = deps();
await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['session:s1', 'sessions'] },
{ deviceId: 'dev-2', openLink: false, topics: ['session:s2'] },
], harness);
expect(calls).toEqual([
'open:dev-1',
'subscribe:dev-1:session:s1,sessions',
'rebuild:dev-1:s1',
'reseed:dev-1',
'subscribe:dev-2:session:s2',
'rebuild:dev-2:s2',
]);
});
it('does not open a listing-only peer while replaying its subscription', async () => {
const { calls, harness } = deps();
const result = await rehydrateDeviceLinkPeer(
{ deviceId: 'dev-topic-only', openLink: false, topics: ['sessions'] },
harness,
);
expect(calls).toEqual([
'subscribe:dev-topic-only:sessions',
'reseed:dev-topic-only',
]);
expect(harness.openLink).not.toHaveBeenCalled();
expect(result.linkOpened).toBe(false);
});
it('opens a listing peer only when the recovery plan asks for a control link', async () => {
const { calls, harness } = deps();
const result = await rehydrateDeviceLinkPeer(
{ deviceId: 'dev-forced', openLink: true, topics: ['sessions'] },
harness,
);
expect(calls).toEqual([
'open:dev-forced',
'subscribe:dev-forced:sessions',
'reseed:dev-forced',
]);
expect(result.linkOpened).toBe(true);
});
it('reports whether the peer link-open step actually succeeded', async () => {
const { harness } = deps();
const success = await rehydrateDeviceLinkPeer(
{ deviceId: 'dev-ok', openLink: true, topics: [] },
harness,
);
expect(success.transientFailures).toBe(0);
expect(success.linkOpened).toBe(true);
vi.mocked(harness.openLink).mockReturnValueOnce({
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.reject(Object.assign(new Error('offline'), { code: 'DEVICE_OFFLINE' })),
});
const failed = await rehydrateDeviceLinkPeer(
{ deviceId: 'dev-failed', openLink: true, topics: [] },
harness,
);
expect(failed.linkOpened).toBe(false);
});
it('stops the remaining sweep when background release cancels it', async () => {
const { calls, harness } = deps();
let cancelled = false;
harness.isCancelled = vi.fn(() => cancelled);
vi.mocked(harness.openLink).mockImplementationOnce((deviceId: string) => {
calls.push(`open:${deviceId}`);
cancelled = true;
return {
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.resolve(),
};
});
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['session:s1'] },
{ deviceId: 'dev-2', openLink: true, topics: ['session:s2'] },
], harness);
expect(calls).toEqual(['open:dev-1']);
expect(harness.subscribe).not.toHaveBeenCalled();
expect(harness.rebuildSessionSnapshot).not.toHaveBeenCalled();
expect(result.transientFailures).toBe(0);
});
it('uses independent cohorts for each concurrent snapshot batch', async () => {
const { harness } = deps();
await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['session:s1', 'session:s2'] },
{ deviceId: 'dev-2', openLink: true, topics: ['session:s3'] },
], harness);
expect(harness.createDeviceSendCohort).toHaveBeenCalledWith('dev-1');
expect(harness.createDeviceSendCohort).toHaveBeenCalledWith('dev-2');
expect(harness.createDeviceSendCohort).toHaveBeenCalledTimes(3);
expect(vi.mocked(harness.openLink).mock.calls[0]).toEqual(['dev-1']);
expect(vi.mocked(harness.subscribe).mock.calls[0]).toEqual([
'dev-1',
['session:s1', 'session:s2'],
]);
const dev1First = vi.mocked(harness.rebuildSessionSnapshot).mock.calls[0][2]?.responsivenessCohort;
const dev1Second = vi.mocked(harness.rebuildSessionSnapshot).mock.calls[1][2]?.responsivenessCohort;
const dev2 = vi.mocked(harness.rebuildSessionSnapshot).mock.calls[2][2]?.responsivenessCohort;
expect(dev1First).toBeDefined();
expect(dev1Second).not.toBe(dev1First);
expect(dev2).not.toBe(dev1First);
expect(dev2).not.toBe(dev1Second);
});
it('reports a successful remote step as reachable so stale cleanup can be cancelled', async () => {
const { harness } = deps();
const onDeviceReachable = vi.fn();
harness.onDeviceReachable = onDeviceReachable;
await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['sessions'] },
], harness);
expect(onDeviceReachable).toHaveBeenCalledWith('dev-1');
});
it('ignores stale reachable evidence after a newer offline presence delta', async () => {
const { harness } = deps();
const onDeviceReachable = vi.fn();
harness.onDeviceReachable = onDeviceReachable;
vi.mocked(harness.isPresenceEpochCurrent).mockReturnValue(false);
await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: [] },
], harness);
expect(onDeviceReachable).not.toHaveBeenCalled();
});
it('restores unavailable state after an authoritative offline failure', async () => {
const { harness } = deps();
const onDeviceUnavailable = vi.fn();
harness.onDeviceUnavailable = onDeviceUnavailable;
vi.mocked(harness.openLink).mockReturnValueOnce({
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.reject(
Object.assign(new Error('target offline'), { code: 'DEVICE_OFFLINE' }),
),
});
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: [] },
], harness);
expect(harness.subscribe).not.toHaveBeenCalled();
expect(harness.rebuildSessionSnapshot).not.toHaveBeenCalled();
expect(onDeviceUnavailable).toHaveBeenCalledOnce();
expect(onDeviceUnavailable).toHaveBeenCalledWith('dev-1');
expect(result.transientFailures).toBe(0);
});
it('stops the current device plan when a snapshot confirms it is offline', async () => {
const { harness } = deps();
const onDeviceUnavailable = vi.fn();
harness.onDeviceUnavailable = onDeviceUnavailable;
vi.mocked(harness.rebuildSessionSnapshot).mockRejectedValueOnce(
Object.assign(new Error('target offline'), { code: 'DEVICE_OFFLINE' }),
);
await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: false, topics: ['session:s1', 'session:s2'] },
], harness);
expect(harness.rebuildSessionSnapshot).toHaveBeenCalledTimes(1);
expect(onDeviceUnavailable).toHaveBeenCalledWith('dev-1');
});
it('ignores a stale offline verdict after a newer presence delta', async () => {
const { harness } = deps();
const onDeviceUnavailable = vi.fn();
harness.onDeviceUnavailable = onDeviceUnavailable;
vi.mocked(harness.isPresenceEpochCurrent).mockReturnValue(false);
vi.mocked(harness.openLink).mockReturnValueOnce({
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.reject(
Object.assign(new Error('target offline'), { code: 'DEVICE_OFFLINE' }),
),
});
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['sessions'] },
], harness);
expect(onDeviceUnavailable).not.toHaveBeenCalled();
expect(harness.subscribe).toHaveBeenCalledOnce();
expect(result.transientFailures).toBe(1);
});
it('downgrades offline after a concurrent send proves the device reachable', async () => {
const { harness } = deps();
const onDeviceUnavailable = vi.fn();
harness.onDeviceUnavailable = onDeviceUnavailable;
vi.mocked(harness.isResponseEvidenceEpochCurrent).mockReturnValue(false);
vi.mocked(harness.openLink).mockReturnValueOnce({
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.reject(
Object.assign(new Error('target offline'), { code: 'DEVICE_OFFLINE' }),
),
});
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['sessions'] },
], harness);
expect(onDeviceUnavailable).not.toHaveBeenCalled();
expect(harness.subscribe).toHaveBeenCalledOnce();
expect(result.transientFailures).toBe(1);
});
it('downgrades remote-disabled after a concurrent send proves reachability', async () => {
const { harness } = deps();
const onDeviceRemoteDisabled = vi.fn();
harness.onDeviceRemoteDisabled = onDeviceRemoteDisabled;
vi.mocked(harness.isResponseEvidenceEpochCurrent).mockReturnValue(false);
vi.mocked(harness.openLink).mockReturnValueOnce({
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.reject(
Object.assign(new Error('disabled'), { code: 'REMOTE_DISABLED' }),
),
});
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['sessions'] },
], harness);
expect(onDeviceRemoteDisabled).not.toHaveBeenCalled();
expect(harness.subscribe).toHaveBeenCalledOnce();
expect(result.transientFailures).toBe(1);
});
it('does not treat transport failures as an unavailable presence verdict', async () => {
const { harness } = deps();
const onDeviceUnavailable = vi.fn();
harness.onDeviceUnavailable = onDeviceUnavailable;
vi.mocked(harness.subscribe).mockRejectedValueOnce(
Object.assign(new Error('not connected'), { code: 'NOT_CONNECTED' }),
);
await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: false, topics: ['sessions'] },
], harness);
expect(onDeviceUnavailable).not.toHaveBeenCalled();
});
it('continues rebuilding other devices and sessions when one replay step fails', async () => {
const { calls, harness } = deps();
vi.mocked(harness.openLink).mockReturnValueOnce({
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.reject(new Error('open failed')),
});
vi.mocked(harness.subscribe).mockRejectedValueOnce(new Error('subscribe failed'));
vi.mocked(harness.rebuildSessionSnapshot).mockRejectedValueOnce(new Error('rebuild failed'));
await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['session:s1', 'session:s2'] },
{ deviceId: 'dev-2', openLink: true, topics: ['sessions'] },
], harness);
expect(calls).toEqual([
'rebuild:dev-1:s2',
'open:dev-2',
'subscribe:dev-2:sessions',
'reseed:dev-2',
]);
expect(harness.openLink).toHaveBeenCalledTimes(2);
expect(harness.subscribe).toHaveBeenCalledTimes(2);
expect(harness.rebuildSessionSnapshot).toHaveBeenCalledTimes(2);
});
it('counts transient failures so the caller can schedule a backoff re-run', async () => {
const { harness } = deps();
vi.mocked(harness.subscribe).mockRejectedValueOnce(
Object.assign(new Error('not connected'), { code: 'NOT_CONNECTED' }),
);
vi.mocked(harness.rebuildSessionSnapshot).mockRejectedValueOnce(
Object.assign(new Error('timeout'), { code: 'INVOKE_TIMEOUT' }),
);
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: false, topics: ['session:s1'] },
{ deviceId: 'dev-2', openLink: false, topics: ['session:s2'] },
], harness);
expect(result.transientFailures).toBe(2);
});
it('treats remote-disabled as authoritative and stops the device plan', async () => {
const { harness } = deps();
const onDeviceRemoteDisabled = vi.fn();
harness.onDeviceRemoteDisabled = onDeviceRemoteDisabled;
vi.mocked(harness.openLink).mockReturnValueOnce({
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.reject(
Object.assign(new Error('disabled'), { code: 'REMOTE_DISABLED' }),
),
});
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['session:s1'] },
], harness);
expect(onDeviceRemoteDisabled).toHaveBeenCalledWith('dev-1');
expect(harness.subscribe).not.toHaveBeenCalled();
expect(harness.rebuildSessionSnapshot).not.toHaveBeenCalled();
expect(result.transientFailures).toBe(0);
});
it('ignores stale remote-disabled after a newer presence delta', async () => {
const { harness } = deps();
const onDeviceRemoteDisabled = vi.fn();
harness.onDeviceRemoteDisabled = onDeviceRemoteDisabled;
vi.mocked(harness.isPresenceEpochCurrent).mockReturnValue(false);
vi.mocked(harness.openLink).mockReturnValueOnce({
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.reject(
Object.assign(new Error('disabled'), { code: 'REMOTE_DISABLED' }),
),
});
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['sessions'] },
], harness);
expect(onDeviceRemoteDisabled).not.toHaveBeenCalled();
expect(harness.subscribe).toHaveBeenCalledOnce();
expect(result.transientFailures).toBe(1);
});
it('does not count other permanent failures (retrying them is pointless)', async () => {
const { harness } = deps();
vi.mocked(harness.openLink).mockReturnValueOnce({
capturedPresenceEpoch: 0,
capturedResponseEvidenceEpoch: 0,
request: Promise.reject(
Object.assign(new Error('unsupported'), { code: 'CHANNEL_NOT_ALLOWED' }),
),
});
vi.mocked(harness.rebuildSessionSnapshot).mockRejectedValueOnce(new Error('unexpected'));
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['session:s1'] },
], harness);
expect(result.transientFailures).toBe(0);
});
it('reports a clean pass with zero transient failures', async () => {
const { harness } = deps();
const result = await rehydrateDeviceLinkTopics([
{ deviceId: 'dev-1', openLink: true, topics: ['session:s1'] },
], harness);
expect(result.transientFailures).toBe(0);
});
});