Skip to content

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

TypeScript
5.7 KB
Raw Blame
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
import express from 'express'
import { createPublicKey, randomBytes } from 'node:crypto'
import type { Server } from 'node:http'
import { Pool } from 'pg'
import request from 'supertest'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'

const quotaHeaders = [
  'x-ratelimit-limit',
  'x-ratelimit-remaining',
  'x-ratelimit-reset',
  'ratelimit',
  'ratelimit-policy',
  'ratelimit-limit',
  'ratelimit-remaining',
  'ratelimit-reset',
]
const adminUrl = process.env.CONTROL_API_REAL_PG_ADMIN_URL
const realPg = adminUrl ? describe : describe.skip
realPg('RP-003 complete password admission response metadata', () => {
  const database = `rp003_${randomBytes(6).toString('hex')}`
  const email = '[email protected]'
  const serviceToken = `synthetic-${randomBytes(16).toString('hex')}`
  let admin: Pool
  let db: typeof import('../src/db.js')
  let engine: typeof import('../src/services/auth/passwordCredentialVerification.js')
  let app: express.Express, edge: express.Express, server: Server
  let externalConfig: (typeof import('../../external-rest-api/src/config.js'))['config']
  let previousUrl: string, previousToken: string
  beforeAll(async () => {
    admin = new Pool({ connectionString: adminUrl })
    await admin.query(`CREATE DATABASE "${database}"`)
    const url = new URL(adminUrl!)
    url.pathname = `/${database}`
    vi.stubEnv('CONTROL_API_PG_CONNECTION_STRING', url.toString())
    vi.stubEnv('CONTROL_API_INTERNAL_SERVICE_TOKENS', `external-rest-api=${serviceToken}`)
    vi.stubEnv(
      'EXTERNAL_REST_API_JWT_PUBLIC_KEY',
      createPublicKey(process.env.CONTROL_API_SESSION_JWT_PRIVATE_KEY!)
        .export({ type: 'spki', format: 'pem' })
        .toString()
    )
    vi.resetModules()
    db = await import('../src/db.js')
    await db.initDb()
    engine = await import('../src/services/auth/passwordCredentialVerification.js')
    const { requireInternalToken } = await import('../src/middleware/internalServiceAuth.js')
    const { createExternalAuthRouter } = await import('../src/routes/external/auth.js')
    app = express()
    app.use(express.json())
    app.use(requireInternalToken)
    app.use(createExternalAuthRouter({} as Parameters<typeof createExternalAuthRouter>[0]))
    server = app.listen(0, '127.0.0.1')
    await new Promise<void>(resolve => server.once('listening', resolve))
    externalConfig = (await import('../../external-rest-api/src/config.js')).config
    previousUrl = externalConfig.controlApiBaseUrl
    previousToken = externalConfig.controlApiServiceToken
    externalConfig.controlApiBaseUrl = `http://127.0.0.1:${(server.address() as { port: number }).port}`
    externalConfig.controlApiServiceToken = serviceToken
    const { withExternalRequestContext } =
      await import('../../external-rest-api/src/requestContext.js')
    const { createAuthRouter } = await import('../../external-rest-api/src/routes/auth.js')
    edge = express()
    edge.set('trust proxy', 1)
    edge.use(express.json())
    edge.use(withExternalRequestContext)
    edge.use('/api/v1', createAuthRouter())
  }, 60_000)
  beforeEach(async () => {
    vi.restoreAllMocks()
    await db.pool.query(
      'TRUNCATE password_identifier_state, password_verification_pace, rate_limit_buckets'
    )
  })
  afterAll(async () => {
    try {
      vi.restoreAllMocks()
      if (externalConfig) {
        externalConfig.controlApiBaseUrl = previousUrl
        externalConfig.controlApiServiceToken = previousToken
      }
      if (server)
        await new Promise<void>((resolve, reject) =>
          server.close(error => (error ? reject(error) : resolve()))
        )
      if (db) {
        await endPoolAndWaitForClients(db.pool)
        await endPoolAndWaitForClients(db.rateLimitPool)
      }
      if (admin) await admin.query(`DROP DATABASE "${database}"`)
    } finally {
      await admin?.end()
      vi.unstubAllEnvs()
    }
  })
  async function cooldown() {
    for (let i = 0; i < 5; i++)
      await engine.completePasswordEvaluation(
        await engine.capturePasswordEvaluation(email, false),
        false
      )
  }
  function assertDenial(response: request.Response, status: number) {
    expect(response.status).toBe(status)
    for (const header of quotaHeaders) expect(response.headers[header], header).toBeUndefined()
    expect(response.body.retryAfterSeconds).toBe(Number(response.headers['retry-after']))
    expect(response.headers['cache-control']).toBe('no-store')
  }
  function internalLogin() {
    return request(app)
      .post('/external/auth/password-login')
      .set('Authorization', `Bearer ${serviceToken}`)
      .set('x-service-token', 'external-rest-api')
      .set('x-external-client-ip', '192.0.2.18')
      .send({ email, password: 'synthetic-wrong' })
  }
  it('removes every source quota family when identifier cooldown denies internally', async () => {
    await cooldown()
    assertDenial(await internalLogin(), 429)
  })
  it('preserves sanitized retry metadata through the authenticated two-service seam', async () => {
    await cooldown()
    assertDenial(
      await request(edge)
        .post('/api/v1/auth/password-login')
        .set('X-Forwarded-For', '192.0.2.19')
        .send({ email, password: 'synthetic-wrong' }),
      429
    )
  })
  it('removes every source quota family on credential authority unavailability', async () => {
    const query = db.pool.query.bind(db.pool)
    vi.spyOn(db.pool, 'query').mockImplementation((...args: unknown[]) => {
      if (String(args[0]).includes('FROM users WHERE email'))
        return Promise.reject(new Error('synthetic backend failure'))
      return (query as Function)(...args)
    })
    assertDenial(await internalLogin(), 503)
  })
})