ArctonArcton
Testing

Testing de middleware

Testea un Middleware de forma aislada con un ctx armado a mano y un next falso.

Un Middleware no es más que una función (ctx, next) => .... Eso significa que se puede testear directamente, sin servidor ni ruta: se arma un ctx mínimo a mano, se le pasa un next falso, y se verifica qué hizo el middleware.

Un helper makeCtx

import type { Context } from '@arcton/contracts'

function makeCtx(request: Request): Context {
  return {
    request,
    params: {},
    query: {},
    response: { headers: new Headers() }
  }
}

Esto construye el Context mínimo que necesita un middleware: el request entrante, params/query vacíos, y un response nuevo con Headers vacíos. Se puede reutilizar para cualquier middleware bajo test, no solo uno específico de tu app.

Testeando un middleware que llama a next()

import { expect, test } from 'bun:test'
import type { Context } from '@arcton/contracts'
import { cors } from '@arcton/cors'

function makeCtx(request: Request): Context {
  return {
    request,
    params: {},
    query: {},
    response: { headers: new Headers() }
  }
}

test('cors adds Access-Control-Allow-Origin for an allowed origin', async () => {
  const middleware = cors({ origin: 'https://app.example.com' })
  const ctx = makeCtx(
    new Request('http://localhost/', {
      headers: { origin: 'https://app.example.com' }
    })
  )

  await middleware(ctx, async () => {})

  expect(ctx.response.headers.get('Access-Control-Allow-Origin')).toBe(
    'https://app.example.com'
  )
})

Testeando un middleware que corta la cadena

Un middleware que devuelve un valor sin llamar a next() corta la cadena del pipeline. Hay que verificar que next nunca se llamó e inspeccionar el valor devuelto directamente:

import { expect, test } from 'bun:test'
import type { Context } from '@arcton/contracts'
import { cors } from '@arcton/cors'

function makeCtx(request: Request): Context {
  return {
    request,
    params: {},
    query: {},
    response: { headers: new Headers() }
  }
}

test('a real preflight short-circuits with a 204 Response', async () => {
  const middleware = cors({ origin: 'https://app.example.com' })
  const ctx = makeCtx(
    new Request('http://localhost/users', {
      method: 'OPTIONS',
      headers: {
        origin: 'https://app.example.com',
        'access-control-request-method': 'POST'
      }
    })
  )
  let nextCalled = false

  const result = await middleware(ctx, async () => {
    nextCalled = true
  })

  expect(nextCalled).toBe(false)
  expect(result).toBeInstanceOf(Response)
  expect((result as Response).status).toBe(204)
})

Testeando tu propio middleware

La misma técnica aplica a cualquier middleware que escribas, no solo a uno incluido en el framework:

import { expect, test } from 'bun:test'
import type { Context, Middleware } from '@arcton/contracts'

function makeCtx(request: Request): Context {
  return {
    request,
    params: {},
    query: {},
    response: { headers: new Headers() }
  }
}

const withRequestId: Middleware = async (ctx, next) => {
  ctx.response.headers.set('X-Request-Id', 'test-id')
  await next()
}

test('withRequestId sets a header before calling next', async () => {
  const ctx = makeCtx(new Request('http://localhost/'))
  let nextCalled = false

  await withRequestId(ctx, async () => {
    nextCalled = true
  })

  expect(nextCalled).toBe(true)
  expect(ctx.response.headers.get('X-Request-Id')).toBe('test-id')
})

Context se importa como tipo desde @arcton/contracts. Esto testea la función de middleware de forma aislada, desacoplada del routing y del resto del pipeline — para un test de punta a punta que corre un middleware como parte de un request real, ver Testing routes.

En esta página