Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
7.5 KB
Raw Blame
import { afterEach, describe, expect, it, vi } from 'vitest'
import * as k8s from '@kubernetes/client-node'
import * as http from 'node:http'
import {
  HOST_K8S_REQUEST_TIMEOUT_CODE,
  HostK8sRequestTimeoutError,
  withHostK8sRequestDeadline,
} from './hostK8sApiClient'

const servers: http.Server[] = []

function deferred<T>(): {
  promise: Promise<T>
  resolve: (value: T | PromiseLike<T>) => void
  reject: (reason?: unknown) => void
} {
  let resolve!: (value: T | PromiseLike<T>) => void
  let reject!: (reason?: unknown) => void
  const promise = new Promise<T>((res, rej) => {
    resolve = res
    reject = rej
  })
  return { promise, resolve, reject }
}

async function startServer(handler: http.RequestListener): Promise<string> {
  const server = http.createServer(handler)
  servers.push(server)
  await new Promise<void>((resolve, reject) => {
    server.once('error', reject)
    server.listen(0, '127.0.0.1', resolve)
  })
  const address = server.address()
  if (!address || typeof address === 'string') {
    throw new Error('local test server did not expose a TCP address')
  }
  return `http://127.0.0.1:${address.port}`
}

function clientFor(baseUrl: string, timeoutMs: number): k8s.CoreV1Api {
  const rawClient = new k8s.CoreV1Api(
    k8s.createConfiguration({ baseServer: new k8s.ServerConfiguration(baseUrl, {}) })
  )
  return withHostK8sRequestDeadline(rawClient, timeoutMs)
}

function respond(res: http.ServerResponse, name: string): void {
  const body = JSON.stringify({ apiVersion: 'v1', kind: 'Namespace', metadata: { name } })
  res.writeHead(200, {
    'content-type': 'application/json',
    'content-length': Buffer.byteLength(body),
  })
  res.end(body)
}

function observable<T>(value: T): k8s.Observable<T> {
  return new k8s.Observable(Promise.resolve(value))
}

afterEach(async () => {
  for (const server of servers.splice(0)) {
    server.closeAllConnections()
    await new Promise<void>(resolve => server.close(() => resolve()))
  }
})

describe('withHostK8sRequestDeadline', () => {
  it('allows a normal request to complete before its deadline', async () => {
    const baseUrl = await startServer((_req, res) => respond(res, 'normal'))
    const namespace = await clientFor(baseUrl, 1_000).readNamespace({ name: 'normal' })
    expect(namespace.metadata?.name).toBe('normal')
  })

  it('aborts a hung transport request and rejects with an identifiable timeout', async () => {
    let requestContext: k8s.RequestContext | undefined
    let socketClosed = false
    let markRequestSeen!: () => void
    const requestSeen = new Promise<void>(resolve => {
      markRequestSeen = resolve
    })
    const baseUrl = await startServer((_req, res) => {
      res.once('close', () => {
        socketClosed = true
      })
      markRequestSeen()
    })
    const captureMiddleware: k8s.ObservableMiddleware = {
      pre: context => {
        requestContext = context
        return observable(context)
      },
      post: context => observable(context),
    }
    const startedAt = Date.now()
    const request = clientFor(baseUrl, 80).readNamespace(
      { name: 'hung' },
      { middleware: [captureMiddleware] }
    )

    await requestSeen
    await expect(request).rejects.toMatchObject({
      name: 'HostK8sRequestTimeoutError',
      code: HOST_K8S_REQUEST_TIMEOUT_CODE,
      timeoutMs: 80,
    })
    expect(Date.now() - startedAt).toBeGreaterThanOrEqual(50)
    expect(Date.now() - startedAt).toBeLessThan(2_000)
    expect(requestContext?.getSignal()?.aborted).toBe(true)
    await vi.waitFor(() => expect(socketClosed).toBe(true))
  })

  it('starts a fresh deadline for every request rather than timing the whole sequence', async () => {
    const baseUrl = await startServer((req, res) =>
      respond(res, req.url?.split('/').pop() || 'unknown')
    )
    const client = clientFor(baseUrl, 80)
    const startedAt = Date.now()

    const first = await client.readNamespace({ name: 'first' })
    await new Promise(resolve => setTimeout(resolve, 120))
    const second = await client.readNamespace({ name: 'second' })

    expect(first.metadata?.name).toBe('first')
    expect(second.metadata?.name).toBe('second')
    expect(Date.now() - startedAt).toBeGreaterThanOrEqual(100)
  })

  it('combines caller cancellation with the deadline without misclassifying it', async () => {
    let markRequestSeen!: () => void
    const requestSeen = new Promise<void>(resolve => {
      markRequestSeen = resolve
    })
    const baseUrl = await startServer((_req, _res) => markRequestSeen())
    const caller = new AbortController()
    const callerSignalMiddleware: k8s.ObservableMiddleware = {
      pre: context => {
        context.setSignal(caller.signal)
        return observable(context)
      },
      post: context => observable(context),
    }
    const request = clientFor(baseUrl, 1_000).readNamespace(
      { name: 'cancelled' },
      { middleware: [callerSignalMiddleware] }
    )

    await requestSeen
    caller.abort(new Error('caller cancelled'))

    let thrown: unknown
    try {
      await request
    } catch (error) {
      thrown = error
    }
    expect(thrown).toBeInstanceOf(Error)
    expect(thrown).not.toBeInstanceOf(HostK8sRequestTimeoutError)
  })

  it('keeps timeout classification when caller cancellation follows the deadline', async () => {
    let markRequestSeen!: () => void
    const requestSeen = new Promise<void>(resolve => {
      markRequestSeen = resolve
    })
    const baseUrl = await startServer((_req, _res) => markRequestSeen())
    const caller = new AbortController()
    const callerSignalMiddleware: k8s.ObservableMiddleware = {
      pre: context => {
        context.setSignal(caller.signal)
        return observable(context)
      },
      post: context => observable(context),
    }
    const request = clientFor(baseUrl, 60).readNamespace(
      { name: 'race' },
      { middleware: [callerSignalMiddleware] }
    )

    await requestSeen
    await expect(request).rejects.toBeInstanceOf(HostK8sRequestTimeoutError)
    caller.abort(new Error('shutdown'))
    await new Promise(resolve => setTimeout(resolve, 20))
  })

  it('does not release the caller until the aborted transport actually rejects', async () => {
    const transport = deferred<{ ok: true }>()
    let requestSignal: AbortSignal | undefined
    let markMiddlewareInstalled!: () => void
    const middlewareInstalled = new Promise<void>(resolve => {
      markMiddlewareInstalled = resolve
    })
    const rawClient = {
      probe: async (
        _request: Record<string, never>,
        options?: k8s.ConfigurationOptions<k8s.ObservableMiddleware>
      ): Promise<{ ok: true }> => {
        let context = new k8s.RequestContext('http://127.0.0.1/probe', k8s.HttpMethod.GET)
        for (const middleware of options?.middleware ?? []) {
          context = await middleware.pre(context).toPromise()
        }
        requestSignal = context.getSignal()
        markMiddlewareInstalled()
        return transport.promise
      },
    }
    const request = withHostK8sRequestDeadline(rawClient, 40).probe({})
    let settled = false
    void request.then(
      () => {
        settled = true
      },
      () => {
        settled = true
      }
    )

    await middlewareInstalled
    await new Promise(resolve => setTimeout(resolve, 70))
    expect(requestSignal?.aborted).toBe(true)
    expect(settled).toBe(false)

    const transportError = new Error('transport acknowledged abort')
    transport.reject(transportError)
    await expect(request).rejects.toMatchObject({
      name: 'HostK8sRequestTimeoutError',
      cause: transportError,
    })
  })
})