From cf70a4e5e78fd87924332145e66503a559a853bd Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 15:01:05 +0800 Subject: [PATCH] Import packages/plugin/tests/control-stream.test.ts --- packages/plugin/tests/control-stream.test.ts | 412 +++++++++++++++++++ 1 file changed, 412 insertions(+) create mode 100644 packages/plugin/tests/control-stream.test.ts diff --git a/packages/plugin/tests/control-stream.test.ts b/packages/plugin/tests/control-stream.test.ts new file mode 100644 index 0000000..1f53844 --- /dev/null +++ b/packages/plugin/tests/control-stream.test.ts @@ -0,0 +1,412 @@ +import { runScenarios } from '../../../scripts/test-scenarios.mjs' +import { createServer, type Server } from 'node:http' +import type { IncomingMessage, ServerResponse } from 'node:http' +import type { AddressInfo } from 'node:net' +import type { ControlResult } from '../src/control-result.js' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { + CONTROL_RPC_PREFIX, + registerControlRoute, + STATUS_STREAM_PATH, + type ControlRouteHandler, + type HostWebServerLike, +} from '../src/control-route.js' +import { ControlStatusStream } from '../src/control-stream.js' +import type { HostAuthorizationControl, HostConnectionHandle } from '../src/client-runtime.js' +import { resolveConfig } from '../src/config.js' +import { PluginControlRuntime } from '../src/control-runtime.js' + +const servers: Server[] = [] + +const cleanupContract1 = async () => { + vi.useRealTimers() + await Promise.all( + servers.splice(0).map( + (server) => + new Promise((resolve) => { + server.closeAllConnections() + server.close(() => { + resolve() + }) + }), + ), + ) +} +afterEach(cleanupContract1) + +describe('loopback status event stream', () => { + it('sends status baselines and changes to current and late subscribers', async () => { + await runScenarios( + [ + { + name: 'writes the retry hint and the current status as the first frame', + run: async () => { + const stream = new ControlStatusStream(async () => ({ mode: 'remote', connected: true }), { + retryMs: 3_000, + }) + const response = fakeResponse() + + await stream.handle(response.response) + + expect(response.statusCode).toBe(200) + expect(response.headers).toMatchObject({ + 'content-type': 'text/event-stream', + 'cache-control': 'no-store', + }) + expect(response.chunks).toEqual(['retry: 3000\n\n', 'data: {"mode":"remote","connected":true}\n\n']) + stream.close() + }, + }, + { + name: 'pushes a frame only when the sampled status changes', + run: async () => { + vi.useFakeTimers() + let status: Record = { mode: 'local' } + const readStatus = vi.fn(async () => status) + const stream = new ControlStatusStream(readStatus, { sampleIntervalMs: 10 }) + const response = fakeResponse() + await stream.handle(response.response) + + await vi.advanceTimersByTimeAsync(35) + expect(readStatus).toHaveBeenCalledTimes(4) + expect(response.chunks).toHaveLength(2) + + status = { mode: 'remote' } + await vi.advanceTimersByTimeAsync(10) + expect(response.chunks.at(-1)).toBe('data: {"mode":"remote"}\n\n') + stream.close() + }, + }, + { + name: 'serves a late subscriber the current status without waiting for a change', + run: async () => { + const stream = new ControlStatusStream(async () => ({ mode: 'remote' })) + const first = fakeResponse() + await stream.handle(first.response) + const second = fakeResponse() + + await stream.handle(second.response) + + expect(second.chunks.at(-1)).toBe('data: {"mode":"remote"}\n\n') + stream.close() + }, + }, + ], + async () => { + await cleanupContract1() + }, + ) + }, 15000) + + it('keeps an idle connection alive with a comment frame', async () => { + vi.useFakeTimers() + const stream = new ControlStatusStream(async () => ({ mode: 'local' }), { + sampleIntervalMs: 10, + heartbeatIntervalMs: 50, + }) + const response = fakeResponse() + await stream.handle(response.response) + + await vi.advanceTimersByTimeAsync(60) + + expect(response.chunks.filter(chunk => chunk === ': keep-alive\n\n').length).toBeGreaterThan(0) + stream.close() + }) + + it('cleans up disconnected, failed and disposed status streams', async () => { + await runScenarios( + [ + { + name: 'stops sampling when the client disconnects', + run: async () => { + vi.useFakeTimers() + const readStatus = vi.fn(async () => ({ mode: 'local' })) + const stream = new ControlStatusStream(readStatus, { sampleIntervalMs: 10 }) + const response = fakeResponse() + await stream.handle(response.response) + + response.disconnect() + await vi.advanceTimersByTimeAsync(100) + + expect(readStatus).toHaveBeenCalledTimes(1) + stream.close() + }, + }, + { + name: 'drops a subscriber whose response fails and ends every stream on close', + run: async () => { + vi.useFakeTimers() + const broken = fakeResponse({ failWrites: true }) + const healthy = fakeResponse() + const stream = new ControlStatusStream(async () => ({ mode: 'local' }), { sampleIntervalMs: 10 }) + await stream.handle(broken.response) + await stream.handle(healthy.response) + const writesBefore = broken.writes + + await vi.advanceTimersByTimeAsync(30) + + expect(broken.writes).toBe(writesBefore) + expect(healthy.chunks.length).toBeGreaterThanOrEqual(2) + + stream.close() + expect(healthy.ended).toBe(true) + const refused = fakeResponse() + await stream.handle(refused.response) + expect(refused.statusCode).toBe(503) + }, + }, + { + name: 'ends an open stream when the control route is disposed', + run: async () => { + const stream = new ControlStatusStream(async () => ({ mode: 'remote' })) + const route = captureRoute() + const dispose = registerControlRoute( + connectionHandle(), + async () => ({ ok: true, value: {} }), + route.webServer, + stream, + ) + const base = await listen((req, res) => { + route.handle(req, res) + }) + + const response = await fetch(`${base}${STATUS_STREAM_PATH}`) + const reader = response.body!.getReader() + await readText(reader, (text) => text.includes('data: ')) + + await dispose() + + await expect(reader.read()).resolves.toMatchObject({ done: true }) + }, + }, + ], + async () => { + await cleanupContract1() + }, + ) + }, 15000) + + it('keeps the connection open when the status read fails', async () => { + vi.useFakeTimers() + let readable = false + const stream = new ControlStatusStream(async () => { + if (!readable) throw new Error('transport stats unavailable') + return { mode: 'remote' } + }, { sampleIntervalMs: 10 }) + const response = fakeResponse() + await stream.handle(response.response) + + expect(response.chunks).toEqual(['retry: 3000\n\n']) + + readable = true + await vi.advanceTimersByTimeAsync(10) + expect(response.chunks.at(-1)).toBe('data: {"mode":"remote"}\n\n') + stream.close() + }) + + it('serves the stream over the registered loopback route and keeps the RPC path intact', async () => { + const calls: string[] = [] + const handler: ControlRouteHandler = async (endpoint, payload): Promise> => { + calls.push(`${endpoint}:${JSON.stringify(payload)}`) + return { ok: true, value: { mode: 'local' } } + } + const stream = new ControlStatusStream(async () => ({ mode: 'remote', deviceName: 'host-one' })) + const route = captureRoute() + const dispose = registerControlRoute(connectionHandle(), handler, route.webServer, stream) + const base = await listen((req, res) => { route.handle(req, res) }) + + const response = await fetch(`${base}${STATUS_STREAM_PATH}`) + expect(response.status).toBe(200) + expect(response.headers.get('content-type')).toBe('text/event-stream') + const reader = response.body!.getReader() + const head = await readText(reader, text => text.includes('data: ')) + expect(head).toContain('retry: 3000') + expect(head).toContain('data: {"mode":"remote","deviceName":"host-one"}') + + // The RPC path keeps owning POST on the same endpoint name. + await expect(fetch(`${base}${STATUS_STREAM_PATH}`, { + method: 'POST', + headers: { 'content-type': 'application/json' }, + body: JSON.stringify({ type: 'client-request', rpcId: 'rpc-1', method: 'status.events', payload: {} }), + })).resolves.toMatchObject({ status: 200 }) + await expect(fetch(`${base}${CONTROL_RPC_PREFIX}/settings.get`, { method: 'GET' })).resolves.toMatchObject({ status: 404 }) + expect(calls).toEqual(['status.events:{}']) + + await reader.cancel() + await dispose() + + expect(route.registered).toBe(false) + await expect(fetch(`${base}${STATUS_STREAM_PATH}`)).resolves.toMatchObject({ status: 404 }) + }) + + it('streams the control runtime status and ends it with the control route', async () => { + const runtime = new PluginControlRuntime( + resolveConfig(), + '/unused', + undefined, + undefined, + hostControl(), + ) + const route = captureRoute() + const dispose = runtime.register(connectionHandle(), route.webServer) + const response = fakeResponse() + + await route.dispatch({ method: 'GET', url: STATUS_STREAM_PATH, headers: {} }, response.response) + + expect(response.statusCode).toBe(200) + const head = response.chunks.join('') + expect(head).toContain('"mode":"local"') + expect(head).toContain('"online":true') + + await dispose() + + expect(response.ended).toBe(true) + }) + + it('keeps the connection rejection policy in front of the stream', async () => { + const stream = new ControlStatusStream(async () => ({ mode: 'local' })) + const route = captureRoute() + registerControlRoute(connectionHandle(401), async () => ({ ok: true, value: {} }), route.webServer, stream) + const base = await listen((req, res) => { route.handle(req, res) }) + + const response = await fetch(`${base}${STATUS_STREAM_PATH}`) + + expect(response.status).toBe(401) + await expect(response.text()).resolves.toBe('unauthorized') + }) + + it('does not throw when a carrier has no web server or rpc handle', async () => { + const dispose = registerControlRoute( + { rpc: {} } as unknown as HostConnectionHandle, + async () => ({ ok: true, value: {} }), + ) + + await expect(dispose()).resolves.toBeUndefined() + }) + +}) + +interface FakeResponse { + response: ServerResponse + readonly chunks: string[] + readonly writes: number + readonly statusCode: number | undefined + readonly headers: Record | undefined + readonly ended: boolean + disconnect(): void +} + +function fakeResponse(options: { failWrites?: boolean } = {}): FakeResponse { + const chunks: string[] = [] + const listeners = new Map void)[]>() + let statusCode: number | undefined + let headers: Record | undefined + let ended = false + let writes = 0 + const response = { + destroyed: false, + writableEnded: false, + writeHead(status: number, next?: Record) { + statusCode = status + headers = next + }, + write(chunk: string) { + writes += 1 + if (options.failWrites === true) throw new Error('write failed') + chunks.push(chunk) + return true + }, + end() { + ended = true + response.writableEnded = true + }, + on(event: string, listener: () => void) { + listeners.set(event, [...(listeners.get(event) ?? []), listener]) + return response + }, + } + return { + response: response as unknown as ServerResponse, + chunks, + get writes() { return writes }, + get statusCode() { return statusCode }, + get headers() { return headers }, + get ended() { return ended }, + disconnect() { + for (const listener of listeners.get('close') ?? []) listener() + }, + } +} + +function hostControl(): HostAuthorizationControl { + return { + hostStatus: () => ({ + configured: true, + online: true, + reconnecting: false, + authorized: true, + accountRequired: false, + }), + reconnectHost: () => undefined, + clearHostAuthorization: async () => undefined, + authorizeHostAsOwned: async () => undefined, + authorizeHostWithAccount: async () => undefined, + authorizeHostWithCode: async () => undefined, + } +} + +function connectionHandle(rejection?: number): HostConnectionHandle { + return { + requestRejection: () => rejection, + rpc: { handle: () => async () => undefined }, + } as unknown as HostConnectionHandle +} + +/** Stands in for the Host Web server prefix table. */ +function captureRoute() { + let handler: ((req: IncomingMessage, res: ServerResponse) => void | Promise) | undefined + return { + webServer: { + register: (route: { handler: (req: IncomingMessage, res: ServerResponse) => void | Promise }) => { + handler = route.handler + return () => { handler = undefined } + }, + } as unknown as HostWebServerLike, + get registered() { return handler !== undefined }, + /** Drive one request through the registered prefix route. */ + async dispatch(request: { method: string; url: string; headers: Record }, res: ServerResponse): Promise { + if (handler === undefined) throw new Error('the loopback prefix route is not registered') + await handler(request as unknown as IncomingMessage, res) + }, + handle(req: IncomingMessage, res: ServerResponse): void { + if (handler === undefined) { + res.writeHead(404) + res.end() + return + } + void handler(req, res) + }, + } +} + +async function listen(serve: (req: IncomingMessage, res: ServerResponse) => void): Promise { + const server = createServer(serve) + servers.push(server) + await new Promise(resolve => { server.listen(0, '127.0.0.1', resolve) }) + const { port } = server.address() as AddressInfo + return `http://127.0.0.1:${String(port)}` +} + +async function readText( + reader: ReadableStreamDefaultReader, + until: (text: string) => boolean, +): Promise { + const decoder = new TextDecoder() + let text = '' + for (let chunk = 0; chunk < 8 && !until(text); chunk += 1) { + const { value, done } = await reader.read() + if (done) break + text += decoder.decode(value, { stream: true }) + } + return text +}