Import packages/plugin/tests/connection-controller.test.ts
This commit is contained in:
parent
cd72e4284b
commit
f6e659436f
|
|
@ -0,0 +1,253 @@
|
|||
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
|
||||
import { MAX_SECURE_MESSAGE_BYTES, createRpcRequest, createRpcResponse, type RemoteMessage } from '@dsh-remote/protocol'
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import { ConnectionController, ConnectionRejectedError } from '../src/connection-controller.js'
|
||||
import { SafeLogger } from '../src/logging.js'
|
||||
import type { IdentityStore } from '../src/identity-store.js'
|
||||
import type { RpcRouter } from '../src/rpc-router.js'
|
||||
import type { AuthenticatedPeerChannel } from '../src/types.js'
|
||||
|
||||
describe('ConnectionController', () => {
|
||||
it('rejects an identity that is absent from local trust', async () => {
|
||||
const channel = fakeChannel()
|
||||
const controller = new ConnectionController(
|
||||
{ isTrusted: () => false } as unknown as IdentityStore,
|
||||
() => ({ handle: vi.fn(), closePeerStreams: vi.fn() } as unknown as RpcRouter),
|
||||
)
|
||||
await expect(controller.accept(channel)).rejects.toBeInstanceOf(ConnectionRejectedError)
|
||||
expect(channel.close).toHaveBeenCalledWith('PEER_IDENTITY_MISMATCH')
|
||||
})
|
||||
|
||||
it('isolates Client device channels and connection replacement', async () => {
|
||||
await runScenarios([
|
||||
{
|
||||
name: 'keeps different Client devices connected and routes responses to their own channel',
|
||||
run: async () => {
|
||||
const routers = new Map<string, RpcRouter>()
|
||||
const controller = new ConnectionController(
|
||||
{ isTrusted: () => true } as unknown as IdentityStore,
|
||||
(context) => {
|
||||
const response = createRpcRequest('harness.api.call', {
|
||||
connectionId: context.connectionId,
|
||||
}) as RemoteMessage
|
||||
const router = {
|
||||
handle: vi.fn(async () => response),
|
||||
closePeerStreams: vi.fn(async () => undefined),
|
||||
} as unknown as RpcRouter
|
||||
routers.set(context.connectionId, router)
|
||||
return router
|
||||
},
|
||||
)
|
||||
const phone = fakeChannel('connection-phone', 'client-phone')
|
||||
const desktop = fakeChannel('connection-desktop', 'client-desktop')
|
||||
await controller.accept(phone)
|
||||
await controller.accept(desktop)
|
||||
|
||||
expect(controller.connectionCount()).toBe(2)
|
||||
expect(controller.peerDeviceIds()).toEqual(['client-phone', 'client-desktop'])
|
||||
expect(controller.connectedPeers()).toEqual([
|
||||
{ deviceId: 'client-phone' },
|
||||
{ deviceId: 'client-desktop' },
|
||||
])
|
||||
expect(controller.peerDeviceId()).toBeUndefined()
|
||||
expect(phone.close).not.toHaveBeenCalled()
|
||||
expect(desktop.close).not.toHaveBeenCalled()
|
||||
|
||||
phone.push(createRpcRequest('harness.api.call', { method: 'session.list' }))
|
||||
desktop.push(createRpcRequest('harness.api.call', { method: 'host.describe' }))
|
||||
await vi.waitFor(() => {
|
||||
expect(phone.send).toHaveBeenCalledOnce()
|
||||
expect(desktop.send).toHaveBeenCalledOnce()
|
||||
})
|
||||
expect(routers.get('connection-phone')!.handle).toHaveBeenCalledOnce()
|
||||
expect(routers.get('connection-desktop')!.handle).toHaveBeenCalledOnce()
|
||||
expect(phone.send).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
payload: expect.objectContaining({ params: { connectionId: 'connection-phone' } }),
|
||||
}),
|
||||
)
|
||||
expect(desktop.send).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
payload: expect.objectContaining({ params: { connectionId: 'connection-desktop' } }),
|
||||
}),
|
||||
)
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'replaces only the previous connection from the same Client device',
|
||||
run: async () => {
|
||||
const routers = new Map<
|
||||
string,
|
||||
{ handle: ReturnType<typeof vi.fn>; closePeerStreams: ReturnType<typeof vi.fn> }
|
||||
>()
|
||||
const controller = new ConnectionController(
|
||||
{ isTrusted: () => true } as unknown as IdentityStore,
|
||||
(context) => {
|
||||
const router = {
|
||||
handle: vi.fn(async () => createRpcRequest('harness.api.call', {}) as RemoteMessage),
|
||||
closePeerStreams: vi.fn(async () => undefined),
|
||||
}
|
||||
routers.set(context.connectionId, router)
|
||||
return router as unknown as RpcRouter
|
||||
},
|
||||
)
|
||||
const firstPhone = fakeChannel('connection-phone-1', 'client-phone')
|
||||
const desktop = fakeChannel('connection-desktop', 'client-desktop')
|
||||
const nextPhone = fakeChannel('connection-phone-2', 'client-phone')
|
||||
await controller.accept(firstPhone)
|
||||
await controller.accept(desktop)
|
||||
await controller.accept(nextPhone)
|
||||
|
||||
expect(firstPhone.close).toHaveBeenCalledWith('CONNECTION_REPLACED')
|
||||
expect(routers.get('connection-phone-1')!.closePeerStreams).toHaveBeenCalledOnce()
|
||||
expect(desktop.close).not.toHaveBeenCalled()
|
||||
expect(routers.get('connection-desktop')!.closePeerStreams).not.toHaveBeenCalled()
|
||||
expect(nextPhone.close).not.toHaveBeenCalled()
|
||||
expect(controller.connectionCount()).toBe(2)
|
||||
expect(controller.peerDeviceIds()).toEqual(['client-desktop', 'client-phone'])
|
||||
|
||||
desktop.push(createRpcRequest('harness.api.call', { method: 'session.list' }))
|
||||
nextPhone.push(createRpcRequest('harness.api.call', { method: 'session.list' }))
|
||||
await vi.waitFor(() => {
|
||||
expect(desktop.send).toHaveBeenCalledOnce()
|
||||
expect(nextPhone.send).toHaveBeenCalledOnce()
|
||||
})
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'delivers stream events only through the connection that opened the stream',
|
||||
run: async () => {
|
||||
const publishers = new Map<string, (message: RemoteMessage) => Promise<void>>()
|
||||
const controller = new ConnectionController(
|
||||
{ isTrusted: () => true } as unknown as IdentityStore,
|
||||
(context, send) => {
|
||||
publishers.set(context.connectionId, send)
|
||||
return {
|
||||
handle: vi.fn(),
|
||||
closePeerStreams: vi.fn(async () => undefined),
|
||||
} as unknown as RpcRouter
|
||||
},
|
||||
)
|
||||
const phone = fakeChannel('connection-phone', 'client-phone')
|
||||
const desktop = fakeChannel('connection-desktop', 'client-desktop')
|
||||
await controller.accept(phone)
|
||||
await controller.accept(desktop)
|
||||
|
||||
const phoneFrame = createRpcRequest('harness.api.call', { streamId: 'phone-stream' }) as RemoteMessage
|
||||
await publishers.get('connection-phone')!(phoneFrame)
|
||||
|
||||
expect(phone.send).toHaveBeenCalledWith(phoneFrame)
|
||||
expect(desktop.send).not.toHaveBeenCalled()
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'closes only the connection named by a Server connection error',
|
||||
run: async () => {
|
||||
const routers = new Map<string, { closePeerStreams: ReturnType<typeof vi.fn> }>()
|
||||
const controller = new ConnectionController(
|
||||
{ isTrusted: () => true } as unknown as IdentityStore,
|
||||
(context) => {
|
||||
const router = {
|
||||
handle: vi.fn(),
|
||||
closePeerStreams: vi.fn(async () => undefined),
|
||||
}
|
||||
routers.set(context.connectionId, router)
|
||||
return router as unknown as RpcRouter
|
||||
},
|
||||
)
|
||||
const phone = fakeChannel('connection-phone', 'client-phone')
|
||||
const desktop = fakeChannel('connection-desktop', 'client-desktop')
|
||||
await controller.accept(phone)
|
||||
await controller.accept(desktop)
|
||||
|
||||
await expect(controller.closeConnection('connection-phone', 'CONNECTION_FAILED')).resolves.toBe(true)
|
||||
|
||||
expect(phone.close).toHaveBeenCalledWith('CONNECTION_FAILED')
|
||||
expect(routers.get('connection-phone')!.closePeerStreams).toHaveBeenCalledOnce()
|
||||
expect(desktop.close).not.toHaveBeenCalled()
|
||||
expect(routers.get('connection-desktop')!.closePeerStreams).not.toHaveBeenCalled()
|
||||
expect(controller.connectionCount()).toBe(1)
|
||||
await expect(controller.closeConnection('missing')).resolves.toBe(false)
|
||||
},
|
||||
},
|
||||
])
|
||||
}, 20000)
|
||||
|
||||
it('returns a small RPC error instead of silently dropping an oversized response', async () => {
|
||||
const oversized = createRpcResponse('request-1', { value: 'x'.repeat(MAX_SECURE_MESSAGE_BYTES) })
|
||||
const logger = new SafeLogger({ warn: vi.fn(), info: vi.fn(), debug: vi.fn(), error: vi.fn() })
|
||||
vi.spyOn(logger, 'warn')
|
||||
const controller = new ConnectionController(
|
||||
{ isTrusted: () => true } as unknown as IdentityStore,
|
||||
() => ({
|
||||
handle: vi.fn(async () => oversized),
|
||||
closePeerStreams: vi.fn(async () => undefined),
|
||||
} as unknown as RpcRouter),
|
||||
logger,
|
||||
)
|
||||
const channel = fakeChannel()
|
||||
await controller.accept(channel)
|
||||
|
||||
channel.push(createRpcRequest('harness.api.call', { method: 'session.history' }))
|
||||
|
||||
await vi.waitFor(() => expect(channel.send).toHaveBeenCalledOnce())
|
||||
expect(channel.send).toHaveBeenCalledWith(expect.objectContaining({
|
||||
type: 'rpc.error',
|
||||
payload: expect.objectContaining({
|
||||
code: 'RESPONSE_TOO_LARGE',
|
||||
retryable: true,
|
||||
}),
|
||||
}))
|
||||
expect(logger.warn).toHaveBeenCalledWith('host response exceeds secure channel', expect.objectContaining({
|
||||
endpoint: 'session.history',
|
||||
bytes: expect.any(Number),
|
||||
limit: MAX_SECURE_MESSAGE_BYTES,
|
||||
}))
|
||||
expect(channel.close).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('logs a warning with the requested endpoint when a response exceeds the secure message limit', async () => {
|
||||
const oversized = createRpcResponse('req-oversized', { value: 'x'.repeat(MAX_SECURE_MESSAGE_BYTES) })
|
||||
const logger = new SafeLogger({ warn: vi.fn(), info: vi.fn(), debug: vi.fn(), error: vi.fn() })
|
||||
vi.spyOn(logger, 'warn')
|
||||
const controller = new ConnectionController(
|
||||
{ isTrusted: () => true } as unknown as IdentityStore,
|
||||
() => ({
|
||||
handle: vi.fn(async () => oversized),
|
||||
closePeerStreams: vi.fn(async () => undefined),
|
||||
} as unknown as RpcRouter),
|
||||
logger,
|
||||
)
|
||||
const channel = fakeChannel()
|
||||
await controller.accept(channel)
|
||||
|
||||
channel.push(createRpcRequest('harness.remote.call', { endpoint: 'session/list', payload: { args: {} } }))
|
||||
|
||||
await vi.waitFor(() => expect(channel.send).toHaveBeenCalledOnce())
|
||||
expect(logger.warn).toHaveBeenCalledWith('host response exceeds secure channel', {
|
||||
endpoint: 'session/list',
|
||||
bytes: expect.any(Number),
|
||||
limit: MAX_SECURE_MESSAGE_BYTES,
|
||||
})
|
||||
expect(channel.send).toHaveBeenCalledWith(expect.objectContaining({
|
||||
type: 'rpc.error',
|
||||
payload: expect.objectContaining({
|
||||
code: 'RESPONSE_TOO_LARGE',
|
||||
}),
|
||||
}))
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
function fakeChannel(connectionId = 'connection-1', peerDeviceId = 'client-1'): AuthenticatedPeerChannel & { push(message: RemoteMessage): void } {
|
||||
let handler: (message: RemoteMessage) => void = () => undefined
|
||||
return {
|
||||
security: { protocol: 'Noise_IK_25519_ChaChaPoly_SHA256', connectionId, membershipId: 'membership-1' },
|
||||
peerDeviceId,
|
||||
peerIdentityKey: `key-${peerDeviceId}`,
|
||||
send: vi.fn(async () => undefined),
|
||||
close: vi.fn(async () => undefined),
|
||||
onMessage: vi.fn(next => { handler = next; return () => { handler = () => undefined } }),
|
||||
push: message => handler(message),
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue