Tests

Les routes Lacis sont de simples fonctions async — elles sont faciles à tester. L’approche recommandée est de démarrer un vrai serveur sur un port aléatoire avec vos handlers passés directement, puis de l’interroger avec supertest.

Installation

Installez supertest :

npm install -D supertest @types/supertest

Helper de test

Créez un petit helper qui enveloppe createServer avec un port aléatoire :

// tests/helpers/server.ts
import supertest from 'supertest'
import { createServer } from 'lacis'
import type { ServerlessRoute, ServerConfig } from 'lacis'
import type { Server } from 'http'

export async function createTestApp(options: {
  routes: ServerlessRoute[]
  middleware?: ServerConfig['middleware']
  hooks?: ServerConfig['hooks']
}) {
  const server = await createServer('', {
    platform: 'node',
    port: 0,          // port disponible aléatoire
    cluster: { enabled: false },
    routes: options.routes,
    middleware: options.middleware,
    hooks: options.hooks,
  }) as Server

  const { port } = server.address() as { port: number }

  return {
    request: supertest.agent(`http://localhost:${port}`),
    close: () => new Promise<void>((resolve, reject) =>
      server.close(err => err ? reject(err) : resolve())
    ),
  }
}

Écrire des tests

Importez vos handlers directement et passez-les en routes :

// tests/users.test.ts
import { createTestApp } from './helpers/server'
import { GET, POST } from '../routes/users/index'

describe('GET /users', () => {
  it('retourne une liste d\'utilisateurs', async () => {
    const { request, close } = await createTestApp({
      routes: [{ path: '/users', handlers: { GET, POST } }],
    })

    await request.get('/users')
      .expect(200)
      .expect(res => {
        expect(Array.isArray(res.body.users)).toBe(true)
      })

    await close()
  })
})

Tests avec paramètres

import { GET } from '../routes/users/[id]/index'

it('retourne un utilisateur par id', async () => {
  const { request, close } = await createTestApp({
    routes: [{ path: '/users/:id', handlers: { GET } }],
  })

  await request.get('/users/123').expect(200).expect({ id: '123' })
  await close()
})

Tests avec body

import { POST } from '../routes/users/index'

it('crée un utilisateur', async () => {
  const { request, close } = await createTestApp({
    routes: [{ path: '/users', handlers: { POST } }],
  })

  await request
    .post('/users')
    .send({ name: 'Alice', email: '[email protected]' })
    .expect(201)

  await close()
})

Tests de middleware

Passez le middleware directement — aucun chargement de fichier nécessaire :

import { createUnauthorizedError } from 'lacis'

it('rejette les requêtes sans token', async () => {
  const { request, close } = await createTestApp({
    routes: [{ path: '/protected', handlers: { GET: async (_req, res) => res.json({ ok: true }) } }],
    middleware: {
      beforeRequest: async (req, res) => {
        if (!req.getHeader('authorization')) {
          throw createUnauthorizedError()
        }
      },
    },
  })

  await request.get('/protected').expect(401)
  await request.get('/protected').set('Authorization', 'Bearer token').expect(200)

  await close()
})

Tests de cookies

it('définit un cookie de session à la connexion', async () => {
  const { request, close } = await createTestApp({
    routes: [{
      path: '/login',
      handlers: {
        POST: async (_req, res) => {
          res.cookies.set('session', 'abc123', { httpOnly: true })
          res.json({ ok: true })
        },
      },
    }],
  })

  const res = await request.post('/login').expect(200)
  expect(res.headers['set-cookie'][0]).toContain('session=abc123')
  expect(res.headers['set-cookie'][0]).toContain('HttpOnly')

  await close()
})