mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 04:11:35 +00:00
Change-detectors, tautologies, source-reading tests, redundant duplicates, mock-echo tests and dead/unrunnable tests. Per-test rationale in the lane ledger (category + reason for every removal).
142 lines
5.2 KiB
TypeScript
142 lines
5.2 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest'
|
|
|
|
import { BackendDialClaims } from './backend-dial-claim'
|
|
import { backendScopeKey, parseBackendScopeKey } from './connection-registry'
|
|
import { resolveDesktopConnectionRequest } from './desktop-profile'
|
|
|
|
describe('BackendDialClaims (#90812)', () => {
|
|
it('coalesces two concurrent dials for the same (connectionId, profile) onto ONE backend spawn', async () => {
|
|
const claims = new BackendDialClaims()
|
|
let spawns = 0
|
|
let resolveSpawn: ((value: { baseUrl: string }) => void) | undefined
|
|
|
|
const dial = vi.fn(() => {
|
|
spawns += 1
|
|
|
|
return new Promise<{ baseUrl: string }>(resolve => {
|
|
resolveSpawn = resolve
|
|
})
|
|
})
|
|
|
|
// Two renderer windows race the same reconnect: reconnectGateway()'s
|
|
// in-flight lock is per-renderer, so BOTH invoke the main-process dial.
|
|
const first = claims.run('conn:office-ssh::default', dial)
|
|
const second = claims.run('conn:office-ssh::default', dial)
|
|
|
|
expect(spawns).toBe(1)
|
|
|
|
resolveSpawn?.({ baseUrl: 'http://127.0.0.1:53150' })
|
|
|
|
const [firstResult, secondResult] = await Promise.all([first, second])
|
|
|
|
// The second caller receives the FIRST dial's result, not its own spawn.
|
|
expect(firstResult).toBe(secondResult)
|
|
expect(firstResult).toEqual({ baseUrl: 'http://127.0.0.1:53150' })
|
|
expect(dial).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('scopes claims by key: different (connectionId, profile) pairs dial independently', async () => {
|
|
const claims = new BackendDialClaims()
|
|
const dialA = vi.fn(async () => 'a')
|
|
const dialB = vi.fn(async () => 'b')
|
|
|
|
const [a, b] = await Promise.all([
|
|
claims.run('conn:office-ssh::default', dialA),
|
|
claims.run('conn:office-ssh::work', dialB)
|
|
])
|
|
|
|
expect(a).toBe('a')
|
|
expect(b).toBe('b')
|
|
expect(dialA).toHaveBeenCalledTimes(1)
|
|
expect(dialB).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('releases the claim once the dial settles so a later reconnect can dial again (bounded, not latched)', async () => {
|
|
const claims = new BackendDialClaims()
|
|
const dial = vi.fn(async () => 'fresh')
|
|
|
|
await claims.run('default', dial)
|
|
expect(claims.inFlight('default')).toBe(false)
|
|
|
|
await claims.run('default', dial)
|
|
expect(dial).toHaveBeenCalledTimes(2)
|
|
})
|
|
|
|
it('propagates a failed dial to every coalesced waiter and never caches the rejection', async () => {
|
|
const claims = new BackendDialClaims()
|
|
let rejectSpawn: ((error: Error) => void) | undefined
|
|
|
|
const failingDial = vi.fn(
|
|
() =>
|
|
new Promise<never>((_resolve, reject) => {
|
|
rejectSpawn = reject
|
|
})
|
|
)
|
|
|
|
const first = claims.run('conn:office-ssh::default', failingDial)
|
|
const second = claims.run('conn:office-ssh::default', failingDial)
|
|
expect(failingDial).toHaveBeenCalledTimes(1)
|
|
|
|
rejectSpawn?.(new Error('ssh dial failed'))
|
|
|
|
await expect(first).rejects.toThrow('ssh dial failed')
|
|
await expect(second).rejects.toThrow('ssh dial failed')
|
|
|
|
// Fail closed but not latched: the NEXT dial attempt runs fresh.
|
|
const recovered = vi.fn(async () => 'recovered')
|
|
await expect(claims.run('conn:office-ssh::default', recovered)).resolves.toBe('recovered')
|
|
expect(recovered).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('a synchronously-throwing dial rejects the claim instead of escaping the coalescing seam', async () => {
|
|
const claims = new BackendDialClaims()
|
|
|
|
await expect(
|
|
claims.run('default', () => {
|
|
throw new Error('spawn refused')
|
|
})
|
|
).rejects.toThrow('spawn refused')
|
|
|
|
expect(claims.inFlight('default')).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('parseBackendScopeKey (#90812/#93910)', () => {
|
|
it('round-trips the composite pool key back to (connectionId, profile)', () => {
|
|
expect(parseBackendScopeKey('conn:office-ssh::default')).toEqual({
|
|
connectionId: 'office-ssh',
|
|
profile: 'default'
|
|
})
|
|
expect(parseBackendScopeKey('conn:office-ssh::work')).toEqual({ connectionId: 'office-ssh', profile: 'work' })
|
|
})
|
|
|
|
it('treats a bare profile key as the local/primary scope', () => {
|
|
expect(parseBackendScopeKey('default')).toEqual({ connectionId: null, profile: 'default' })
|
|
expect(parseBackendScopeKey('work')).toEqual({ connectionId: null, profile: 'work' })
|
|
})
|
|
})
|
|
|
|
describe('resolved window routes share one dial claim (#90812)', () => {
|
|
it.each([null, 'office-ssh'])(
|
|
'coalesces resolved window routes without absorbing a same-named source (%s)',
|
|
async connectionId => {
|
|
const claims = new BackendDialClaims()
|
|
const source = { connectionId, profile: 'work', registryScoped: connectionId !== null }
|
|
const route = resolveDesktopConnectionRequest(undefined, source, 'default')
|
|
const key = backendScopeKey(route.connectionId, route.profile)
|
|
const dial = vi.fn(async () => ({ baseUrl: 'http://localhost:53150' }))
|
|
const other = vi.fn(async () => ({ baseUrl: 'http://localhost:53151' }))
|
|
|
|
const [first, second, separate] = await Promise.all([
|
|
claims.run(key, dial),
|
|
claims.run(key, dial),
|
|
claims.run(backendScopeKey('another-source', route.profile), other)
|
|
])
|
|
|
|
expect(first).toBe(second)
|
|
expect(first).not.toBe(separate)
|
|
expect(dial).toHaveBeenCalledTimes(1)
|
|
expect(other).toHaveBeenCalledTimes(1)
|
|
}
|
|
)
|
|
})
|