@gemus/mcp-proxy 0.1.9 → 0.1.10

package/src/__tests__/upstreamHttp.real.test.ts

@@ -1,37 +0,0 @@
-import { createServer, type Server } from 'node:http'
-import type { Socket } from 'node:net'
-import { afterEach, describe, expect, it } from 'vitest'
-import { createUpstreamHttp } from '../upstreamHttp.mjs'
-
-let server: Server | undefined
-
-afterEach(async () => {
-  server?.closeAllConnections()
-  if (server?.listening) {
-    await new Promise<void>((resolve) => server?.close(() => resolve()))
-  }
-  server = undefined
-})
-
-describe('createUpstreamHttp with real Undici dispatchers', () => {
-  it('force-closes an established hanging response after the graceful budget expires', async () => {
-    let activeSocket!: Socket
-    server = createServer((request, response) => {
-      activeSocket = request.socket
-      response.writeHead(200, { 'content-type': 'text/event-stream' })
-      response.write(': heartbeat\n\n')
-    })
-    await new Promise<void>((resolve) => server?.listen(0, '127.0.0.1', resolve))
-    const address = server.address()
-    if (!address || typeof address === 'string') throw new Error('expected a TCP listener')
-
-    const upstream = createUpstreamHttp()
-    const response = await upstream.fetch(`http://127.0.0.1:${address.port}/api/mcp`)
-    expect(response.ok).toBe(true)
-    expect(activeSocket.destroyed).toBe(false)
-
-    await upstream.shutdown()
-
-    await expect.poll(() => activeSocket.destroyed, { timeout: 500 }).toBe(true)
-  }, 5000)
-})

package/src/__tests__/upstreamHttp.test.ts

@@ -1,151 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-const undiciFetch = vi.fn()
-const agents: Array<{ options: unknown; close: ReturnType<typeof vi.fn>; destroy: ReturnType<typeof vi.fn> }> = []
-const pools: Array<{ origin: unknown; options: unknown; destroy: ReturnType<typeof vi.fn> }> = []
-
-const Agent = vi.fn(function Agent(options) {
-  const agent = {
-    options,
-    close: vi.fn(() => Promise.resolve()),
-    destroy: vi.fn(),
-  }
-  agents.push(agent)
-  return agent
-})
-
-const Pool = vi.fn(function Pool(origin, options) {
-  const pool = {
-    origin,
-    options,
-    destroy: vi.fn(() => Promise.resolve()),
-  }
-  pools.push(pool)
-  return pool
-})
-
-vi.mock('undici', () => ({ Agent, Pool, fetch: undiciFetch }))
-
-async function createAdapter() {
-  return (await import('../upstreamHttp.mjs')).createUpstreamHttp()
-}
-
-beforeEach(() => {
-  agents.length = 0
-  pools.length = 0
-  Agent.mockClear()
-  Pool.mockClear()
-  undiciFetch.mockReset()
-  delete process.env.PROXY_CONNECT_ATTEMPT_TIMEOUT_MS
-})
-
-afterEach(() => {
-  vi.useRealTimers()
-  delete process.env.PROXY_CONNECT_ATTEMPT_TIMEOUT_MS
-})
-
-describe('createUpstreamHttp', () => {
-  it('creates one Agent with the 1000ms address-family attempt window by default', async () => {
-    const upstream = await createAdapter()
-
-    expect(upstream.attemptTimeoutMs).toBe(1000)
-    expect(Agent).toHaveBeenCalledTimes(1)
-    expect(agents[0].options).toEqual({
-      factory: expect.any(Function),
-      connect: {
-        autoSelectFamily: true,
-        autoSelectFamilyAttemptTimeout: 1000,
-      },
-    })
-  })
-
-  it.each([
-    ['', 1000],
-    ['not-a-number', 1000],
-    ['Infinity', 1000],
-    ['0', 1000],
-    ['-1', 1000],
-    ['9.9', 10],
-    ['10.9', 10],
-    ['251.9', 251],
-  ])('normalizes PROXY_CONNECT_ATTEMPT_TIMEOUT_MS=%j to %i milliseconds', async (value, expected) => {
-    process.env.PROXY_CONNECT_ATTEMPT_TIMEOUT_MS = value
-
-    const upstream = await createAdapter()
-
-    expect(upstream.attemptTimeoutMs).toBe(expected)
-    expect(agents[0].options).toEqual({
-      factory: expect.any(Function),
-      connect: {
-        autoSelectFamily: true,
-        autoSelectFamilyAttemptTimeout: expected,
-      },
-    })
-  })
-
-  it('preserves transport request init while injecting its dispatcher', async () => {
-    const upstream = await createAdapter()
-    const signal = new AbortController().signal
-    const init = {
-      method: 'POST',
-      headers: { authorization: 'Bearer example', accept: 'text/event-stream' },
-      body: '{"jsonrpc":"2.0","id":7}',
-      signal,
-      cache: 'no-store' as RequestCache,
-      redirect: 'manual' as RequestRedirect,
-    }
-    undiciFetch.mockResolvedValue(new Response('ok'))
-
-    await upstream.fetch('https://example.test/api/mcp', init)
-
-    expect(undiciFetch).toHaveBeenCalledTimes(1)
-    expect(undiciFetch).toHaveBeenCalledWith('https://example.test/api/mcp', {
-      ...init,
-      dispatcher: agents[0],
-    })
-    expect(init).not.toHaveProperty('dispatcher')
-  })
-
-  it('propagates a failed request after one fetch attempt', async () => {
-    const upstream = await createAdapter()
-    undiciFetch.mockRejectedValue(new Error('connect failed'))
-
-    await expect(upstream.fetch('https://example.test/api/mcp', { method: 'POST', body: 'side-effecting' })).rejects.toThrow('connect failed')
-
-    expect(undiciFetch).toHaveBeenCalledTimes(1)
-  })
-
-  it('shares one graceful shutdown across repeated calls', async () => {
-    const upstream = await createAdapter()
-    let finishClose!: () => void
-    agents[0].close.mockImplementation(() => new Promise<void>((resolve) => { finishClose = resolve }))
-
-    const first = upstream.shutdown()
-    const second = upstream.shutdown()
-    expect(second).toBe(first)
-    expect(agents[0].close).toHaveBeenCalledTimes(1)
-
-    finishClose()
-    await first
-    await upstream.shutdown()
-    expect(agents[0].close).toHaveBeenCalledTimes(1)
-    expect(agents[0].destroy).not.toHaveBeenCalled()
-  })
-
-  it('destroys retained origin dispatchers and the Agent when graceful close exceeds 2000ms', async () => {
-    vi.useFakeTimers()
-    const upstream = await createAdapter()
-    agents[0].close.mockImplementation(() => new Promise<void>(() => {}))
-    const factory = (agents[0].options as { factory: (origin: string, options: object) => unknown }).factory
-    factory('https://example.test', { connections: 2 })
-
-    const shutdown = upstream.shutdown()
-    await vi.advanceTimersByTimeAsync(2000)
-    await shutdown
-
-    expect(agents[0].close).toHaveBeenCalledTimes(1)
-    expect(agents[0].destroy).toHaveBeenCalledTimes(1)
-    expect(pools[0].destroy).toHaveBeenCalledTimes(1)
-    expect(upstream.shutdown()).toBe(shutdown)
-  })
-})