From b9f9f2a8cb91f6ee542ab658a7e1f96a4e00c9f5 Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 15:01:58 +0800 Subject: [PATCH] Import packages/plugin/tests/native-stream-recovery.test.ts --- .../tests/native-stream-recovery.test.ts | 123 ++++++++++++++++++ 1 file changed, 123 insertions(+) create mode 100644 packages/plugin/tests/native-stream-recovery.test.ts diff --git a/packages/plugin/tests/native-stream-recovery.test.ts b/packages/plugin/tests/native-stream-recovery.test.ts new file mode 100644 index 0000000..e2eeab1 --- /dev/null +++ b/packages/plugin/tests/native-stream-recovery.test.ts @@ -0,0 +1,123 @@ +import { RemoteSnapshotStream, RemoteStream, RemoteStreamCarrierError } from '@deepseek-ai/dsh-api-gateway/client' +import { RemoteClientError, type RemoteClientCore } from '@dsh-remote/client-core' +import type { EventPayload } from '@dsh-remote/protocol' +import { describe, expect, it, vi } from 'vitest' +import { RemoteTypertGateway } from '../src/remote-typert-gateway.js' + +type Frame = { type: 'baseline'; items: string[] } | { type: 'upsert'; item: string } + +function carrier() { + const events = new Set<(event: EventPayload) => void>() + const closes = new Set<() => void>() + let streamId = '' + const client = { + rpc: vi.fn(async (method: string, params: any) => { + if (method === 'harness.transport.describe') return { capabilities: [] } + if (method === 'harness.remote.stream.open') streamId = params.streamId + return {} + }), + onEvent: (handler: (event: EventPayload) => void) => { events.add(handler); return () => { events.delete(handler) } }, + onClose: (handler: () => void) => { closes.add(handler); return () => { closes.delete(handler) } }, + } + return { + client: client as unknown as RemoteClientCore, + events, closes, + opened: () => streamId !== '', + frame: (value: Frame) => { for (const handler of events) handler({ event: 'harness.remote.frame', data: { streamId, hasValue: true, value } } as EventPayload) }, + drop: () => { for (const handler of [...closes]) handler() }, + fail: () => { for (const handler of events) handler({ event: 'harness.remote.stream.closed', data: { streamId, reason: 'failed', failure: { code: 'permission/denied', message: 'denied', details: {} } } } as EventPayload) }, + } +} + +describe('native metadata subscription recovery', () => { + it('keeps the native snapshot consumer alive until carrier replacement, then accepts new workspaces', async () => { + const first = carrier(), second = carrier() + let gateway = new RemoteTypertGateway(first.client, undefined, undefined, true) + const failed = vi.fn() + let visible: string[] = [] + const stream = new RemoteStream({ generation: { getSnapshot: () => undefined, subscribe: () => () => {} } }, { + name: 'Workspace state stream', + open: async function* (signal) { yield* await gateway.open('workspace/follow', { args: {} }, signal) as AsyncIterable }, + ended: () => new RemoteStreamCarrierError('workspace stream ended'), + }) + const snapshot = new RemoteSnapshotStream, Extract>(stream, { + name: 'Workspace state stream', + isSnapshot: (frame): frame is Extract => frame.type === 'baseline', + replace: frame => { visible = [...frame.items] }, + update: frame => { visible.push(frame.item) }, + failed, + }) + snapshot.start() + try { + await vi.waitFor(() => expect(first.opened()).toBe(true)) + first.frame({ type: 'baseline', items: ['existing'] }) + await vi.waitFor(() => expect(visible).toEqual(['existing'])) + first.drop() + await new Promise(resolve => setTimeout(resolve, 20)) + // A wire error kills RemoteSnapshotStream permanently; restart cannot revive it. + expect(failed).not.toHaveBeenCalled() + expect(visible).toEqual(['existing']) + gateway = new RemoteTypertGateway(second.client, undefined, undefined, true) + snapshot.restart() // Native carrier reset after fresh authentication is ready. + await vi.waitFor(() => expect(second.opened()).toBe(true)) + second.frame({ type: 'baseline', items: ['existing', 'created-offline'] }) + second.frame({ type: 'upsert', item: 'created-after-recovery' }) + await vi.waitFor(() => expect(visible).toEqual(['existing', 'created-offline', 'created-after-recovery'])) + expect(failed).not.toHaveBeenCalled() + } finally { await snapshot.dispose() } + expect(first.events.size + first.closes.size + second.events.size + second.closes.size).toBe(0) + }) + + it('does not defer business refusals or one-shot gateway transport failures', async () => { + const business = carrier(), query = carrier() + const signal = new AbortController().signal + const refused = (await new RemoteTypertGateway(business.client, undefined, undefined, true).open('workspace/follow', { args: {} }, signal))[Symbol.asyncIterator]() + const refusedRead = refused.next() + business.fail() + business.drop() + await expect(refusedRead).rejects.toMatchObject({ code: 'permission/denied' }) + const once = (await new RemoteTypertGateway(query.client).open('workspace/follow', { args: {} }, signal))[Symbol.asyncIterator]() + const read = once.next() + query.drop() + await expect(read).rejects.toBeInstanceOf(RemoteClientError) + expect(query.events.size + query.closes.size + business.events.size + business.closes.size).toBe(0) + }) + + it.each(['describe', 'open'] as const)('releases an interrupted %s on caller cancellation without reopening it', async phase => { + const f = carrier() + const lifetime = new AbortController() + const original = f.client.rpc.bind(f.client) + let rejectPending!: (error: Error) => void + vi.spyOn(f.client, 'rpc').mockImplementation((method, params, signal) => { + if (method === `harness.${phase === 'describe' ? 'transport.describe' : 'remote.stream.open'}`) { + return new Promise((_resolve, reject) => { rejectPending = reject }) + } + return original(method, params, signal) + }) + const settled = vi.fn() + const opening = new RemoteTypertGateway(f.client, undefined, undefined, true) + .open('workspace/follow', { args: {} }, lifetime.signal).catch(error => { settled(); throw error }) + const released = expect(opening).rejects.toMatchObject({ code: 'TRANSPORT_CLOSED' }) + await vi.waitFor(() => expect(rejectPending).toBeTypeOf('function')) + f.drop() + rejectPending(new RemoteClientError('TRANSPORT_CLOSED', 'disconnected')) + await new Promise(resolve => setTimeout(resolve, 20)) + expect(settled).not.toHaveBeenCalled() + lifetime.abort() + await released + expect(f.events.size + f.closes.size).toBe(0) + expect(vi.mocked(f.client.rpc).mock.calls.filter(([method]) => method === 'harness.remote.stream.open')) + .toHaveLength(phase === 'open' ? 1 : 0) + }) + + it('fails a slow consumer while the carrier is still connected', async () => { + const f = carrier() + const stream = await new RemoteTypertGateway(f.client, undefined, undefined, true) + .open('workspace/follow', { args: {} }, new AbortController().signal) + for (let index = 0; index < 257; index++) f.frame({ type: 'upsert', item: String(index) }) + await expect(stream[Symbol.asyncIterator]().next()).rejects.toMatchObject({ + code: 'TRANSPORT_CLOSED', message: expect.stringContaining('too slow'), + }) + expect(f.events.size + f.closes.size).toBe(0) + }) +})