arckode-framework 1.0.0 → 1.0.1

package/kernel/__tests__/middlewares.test.ts

@@ -1,174 +0,0 @@
-import { describe, it, expect, beforeEach } from 'bun:test'
-import { Router } from '../framework'
-import { cors, rateLimit, requestLogger, bodyLimit, timeout, compression } from '../middlewares'
-
-function makeRouter(): Router {
-  const r = new Router()
-  r.get('/test', () => ({ status: 200, body: { ok: true } }))
-  r.post('/data', (req) => ({ status: 201, body: req.body }))
-  return r
-}
-
-describe('cors middleware', () => {
-  it('agrega headers CORS a OPTIONS', async () => {
-    const r = makeRouter()
-    r.use(cors({ origins: ['http://example.com'] }))
-
-    const res = await r.resolve('OPTIONS', '/test')
-    expect(res.status).toBe(204)
-    expect(res.headers).toBeDefined()
-    expect(res.headers!['Access-Control-Allow-Origin']).toBe('http://example.com')
-    expect(res.headers!['Access-Control-Allow-Methods']).toContain('GET')
-    expect(res.headers!['Access-Control-Max-Age']).toBe('86400')
-  })
-
-  it('agrega CORS a responses normales', async () => {
-    const r = makeRouter()
-    r.use(cors())
-
-    const res = await r.resolve('GET', '/test')
-    expect(res.headers).toBeDefined()
-    expect(res.headers!['Access-Control-Allow-Origin']).toBe('*')
-  })
-
-  it('no rompe si no se pasa configuración', async () => {
-    const r = makeRouter()
-    r.use(cors())
-
-    const res = await r.resolve('GET', '/test')
-    expect(res.status).toBe(200)
-    expect(res.body).toEqual({ ok: true })
-  })
-})
-
-describe('rateLimit middleware', () => {
-  it('deja pasar requests dentro del límite', async () => {
-    const r = makeRouter()
-    const rl = rateLimit({ windowMs: 60000, max: 5 })
-    r.use(rl)
-
-    for (let i = 0; i < 5; i++) {
-      const res = await r.resolve('GET', '/test')
-      expect(res.status).toBe(200)
-    }
-  })
-
-  it('bloquea cuando se excede el límite', async () => {
-    const r = makeRouter()
-    const rl = rateLimit({ windowMs: 60000, max: 2 })
-    r.use(rl)
-
-    await r.resolve('GET', '/test')
-    await r.resolve('GET', '/test')
-    const res = await r.resolve('GET', '/test')
-    expect(res.status).toBe(429)
-  })
-
-  it('reset funciona para una clave específica', async () => {
-    const r = makeRouter()
-    const rl = rateLimit({ windowMs: 60000, max: 1, keyBy: () => 'test-ip' })
-    r.use(rl)
-
-    await r.resolve('GET', '/test')
-    rl.reset('test-ip')
-    const res = await r.resolve('GET', '/test')
-    expect(res.status).toBe(200)
-  })
-})
-
-describe('requestLogger middleware', () => {
-  it('no rompe el request', async () => {
-    const r = makeRouter()
-    const logs: string[] = []
-    const fakeLogger = { info: (msg: string) => logs.push(msg) }
-    r.use(requestLogger(fakeLogger as any))
-
-    const res = await r.resolve('GET', '/test')
-    expect(res.status).toBe(200)
-    expect(logs.length).toBeGreaterThan(0)
-  })
-})
-
-describe('bodyLimit middleware', () => {
-  it('rechaza cuerpos grandes', async () => {
-    const r = makeRouter()
-    r.use(bodyLimit(10))
-
-    const res = await r.resolve('POST', '/data', { body: { data: 'x'.repeat(100) } })
-    expect(res.status).toBe(413)
-  })
-
-  it('acepta cuerpos chicos', async () => {
-    const r = makeRouter()
-    r.use(bodyLimit(1024))
-
-    const res = await r.resolve('POST', '/data', { body: { nombre: 'test' } })
-    expect(res.status).toBe(201)
-  })
-})
-
-describe('timeout middleware', () => {
-  it('timeout si el handler tarda mucho', async () => {
-    const r = new Router()
-    r.get('/slow', async () => {
-      await new Promise(r => setTimeout(r, 500))
-      return { status: 200, body: {} }
-    })
-    r.use(timeout(50))
-
-    const res = await r.resolve('GET', '/slow')
-    expect(res.status).toBe(500)
-  })
-
-  it('no afecta handlers rápidos', async () => {
-    const r = makeRouter()
-    r.use(timeout(5000))
-
-    const res = await r.resolve('GET', '/test')
-    expect(res.status).toBe(200)
-  })
-})
-
-describe('compression middleware', () => {
-  it('comprime respuestas grandes con gzip', async () => {
-    const r = new Router()
-    r.get('/big', () => ({
-      status: 200,
-      body: { data: 'x'.repeat(2000) },
-    }))
-    r.use(compression({ threshold: 100 }))
-
-    const res = await r.resolve('GET', '/big', {
-      headers: { 'accept-encoding': 'gzip' },
-    })
-    expect(res.status).toBe(200)
-    expect(res.headers).toBeDefined()
-    expect(res.headers!['Content-Encoding']).toBe('gzip')
-    expect(Buffer.isBuffer(res.body)).toBe(true)
-  })
-
-  it('no comprime si no se acepta gzip', async () => {
-    const r = new Router()
-    r.get('/big', () => ({
-      status: 200,
-      body: { data: 'x'.repeat(2000) },
-    }))
-    r.use(compression({ threshold: 100 }))
-
-    const res = await r.resolve('GET', '/big')
-    expect(res.status).toBe(200)
-    expect(res.headers?.['Content-Encoding']).toBeUndefined()
-    expect(typeof res.body).toBe('object')
-  })
-
-  it('no comprime respuestas sin body', async () => {
-    const r = new Router()
-    r.get('/empty', () => ({ status: 204, body: null }))
-    r.use(compression())
-
-    const res = await r.resolve('GET', '/empty', {
-      headers: { 'accept-encoding': 'gzip' },
-    })
-    expect(res.status).toBe(204)
-  })
-})

package/kernel/__tests__/static.test.ts

@@ -1,94 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'bun:test'
-import { mkdir, writeFile, rm } from 'node:fs/promises'
-import { join } from 'node:path'
-import { Router } from '../framework'
-import { serveStatic } from '../static'
-
-const TMP_DIR = join(import.meta.dirname, '..', '__test_fixtures__')
-
-beforeAll(async () => {
-  await mkdir(TMP_DIR, { recursive: true })
-  await writeFile(join(TMP_DIR, 'index.html'), '<h1>Hello</h1>')
-  await writeFile(join(TMP_DIR, 'styles.css'), 'body { color: red; }')
-  await writeFile(join(TMP_DIR, 'app.js'), 'console.log("hi")')
-})
-
-afterAll(async () => {
-  await rm(TMP_DIR, { recursive: true, force: true })
-})
-
-describe('serveStatic', () => {
-  it('sirve un archivo existente', async () => {
-    const router = new Router()
-    serveStatic(router, TMP_DIR)
-
-    const res = await router.resolve('GET', '/index.html')
-    expect(res.status).toBe(200)
-    expect(res.headers).toBeDefined()
-    expect(res.headers!['Content-Type']).toBe('text/html')
-    expect(Buffer.isBuffer(res.body)).toBe(true)
-  })
-
-  it('sirve CSS con Content-Type correcto', async () => {
-    const router = new Router()
-    serveStatic(router, TMP_DIR)
-
-    const res = await router.resolve('GET', '/styles.css')
-    expect(res.status).toBe(200)
-    expect(res.headers!['Content-Type']).toBe('text/css')
-  })
-
-  it('sirve JS con Content-Type correcto', async () => {
-    const router = new Router()
-    serveStatic(router, TMP_DIR)
-
-    const res = await router.resolve('GET', '/app.js')
-    expect(res.status).toBe(200)
-    expect(res.headers!['Content-Type']).toBe('application/javascript')
-  })
-
-  it('devuelve 404 si el archivo no existe', async () => {
-    const router = new Router()
-    serveStatic(router, TMP_DIR)
-
-    const res = await router.resolve('GET', '/no-existe.txt')
-    expect(res.status).toBe(404)
-  })
-
-  it('sirve index.html por defecto en la raíz', async () => {
-    const router = new Router()
-    serveStatic(router, TMP_DIR)
-
-    const res = await router.resolve('GET', '/')
-    expect(res.status).toBe(200)
-    expect(res.headers!['Content-Type']).toBe('text/html')
-  })
-
-  it('sirve fallback (SPA) si el archivo no existe', async () => {
-    const router = new Router()
-    serveStatic(router, TMP_DIR, { fallback: 'index.html' })
-
-    const res = await router.resolve('GET', '/alguna/ruta/spa')
-    expect(res.status).toBe(200)
-    expect(res.headers!['Content-Type']).toBe('text/html')
-  })
-
-  it('usa prefijo para rutas', async () => {
-    const router = new Router()
-    serveStatic(router, TMP_DIR, { prefix: '/static' })
-
-    const res1 = await router.resolve('GET', '/static/index.html')
-    expect(res1.status).toBe(200)
-
-    const res2 = await router.resolve('GET', '/index.html')
-    expect(res2.status).toBe(404)
-  })
-
-  it('agrega Cache-Control header', async () => {
-    const router = new Router()
-    serveStatic(router, TMP_DIR, { cacheControl: 'public, max-age=3600' })
-
-    const res = await router.resolve('GET', '/index.html')
-    expect(res.headers!['Cache-Control']).toBe('public, max-age=3600')
-  })
-})

package/modules/ws/__tests__/ws.test.ts

@@ -1,114 +0,0 @@
-// modules/ws/__tests__/ws.test.ts — Tests del WebSocket server
-// Prueba: handshake, parseFrame, sendFrame, broadcast, sendTo
-
-import { describe, it, expect } from 'bun:test'
-import { WSServer } from '../index'
-import { createHash } from 'node:crypto'
-
-// ─── Test de generateAccept ────────────────────────────
-describe('WSServer - handshake', () => {
-  it('generateAccept produce output correcto', () => {
-    // El WebSocket server tiene método generateAccept
-    // Probamos que devuelve un string base64 válido
-    const ws = new WSServer() as any
-    const key = 'dGhlIHNhbXBsZSBub25jZQ=='
-    const accept = ws.generateAccept(key)
-    expect(accept).toBeTruthy()
-    expect(typeof accept).toBe('string')
-    expect(accept.length).toBeGreaterThan(0)
-
-    // Verificar que el hash es correcto según RFC 6455
-    const expected = createHash('sha1').update(key + '258EAFA5-E914-47DA-95CA-5AB5DC11B725').digest('base64')
-    expect(accept).toBe(expected)
-  })
-})
-
-// ─── Test de parseFrame ────────────────────────────────
-describe('WSServer - parseFrame', () => {
-  it('parsea un frame de texto sin mask', () => {
-    const ws = new WSServer() as any
-    // Frame: FIN=1, opcode=1 (text), payload=Hola
-    const frame = Buffer.alloc(6)
-    frame[0] = 0x81       // FIN + texto
-    frame[1] = 4           // payload length
-    frame.write('Hola', 2) // payload
-    const result = ws.parseFrame(frame)
-    expect(result).toBe('Hola')
-  })
-
-  it('parsea un frame con mask', () => {
-    const ws = new WSServer() as any
-    const payload = Buffer.from('Hello')
-    const mask = Buffer.from([0x01, 0x02, 0x03, 0x04])
-    const masked = Buffer.alloc(payload.length)
-    for (let i = 0; i < payload.length; i++) {
-      masked[i] = (payload[i] ?? 0) ^ (mask[i % 4] ?? 0)
-    }
-
-    const frame = Buffer.alloc(2 + 4 + payload.length)
-    frame[0] = 0x81
-    frame[1] = 0x80 | payload.length  // MASK bit + length
-    mask.copy(frame, 2)
-    masked.copy(frame, 6)
-
-    const result = ws.parseFrame(frame)
-    expect(result).toBe('Hello')
-  })
-
-  it('devuelve null para frames no-texto', () => {
-    const ws = new WSServer() as any
-    // Frame: ping (opcode 0x09)
-    const frame = Buffer.alloc(2)
-    frame[0] = 0x89
-    frame[1] = 0
-    const result = ws.parseFrame(frame)
-    expect(result).toBeNull()
-  })
-})
-
-// ─── Test de sendFrame ────────────────────────────────
-describe('WSServer - sendFrame', () => {
-  it('construye frame correctamente', () => {
-    const ws = new WSServer() as any
-    const chunks: Buffer[] = []
-    const mockSocket = { write: (b: Buffer) => chunks.push(b) }
-
-    ws.sendFrame(mockSocket, 'Hola')
-    expect(chunks).toHaveLength(1)
-    const frame = chunks[0]!
-    expect(frame[0]).toBe(0x81)  // FIN + texto
-    expect(frame[1]).toBe(4)      // longitud
-    expect(frame.slice(2).toString()).toBe('Hola')
-  })
-})
-
-// ─── Test de broadcast ────────────────────────────────
-describe('WSServer - broadcast', () => {
-  it('envía a todos los clientes conectados', () => {
-    const ws = new WSServer() as any
-    const received: string[] = []
-
-    // Simular clientes conectados
-    ws.clients.set('c1', { id: 'c1', send: (d: string) => received.push(d), close: () => {} })
-    ws.clients.set('c2', { id: 'c2', send: (d: string) => received.push(d), close: () => {} })
-
-    ws.broadcast('test.event', { msg: 'hello' })
-    expect(received).toHaveLength(2)
-    expect(received[0]).toContain('test.event')
-    expect(received[1]).toContain('hello')
-  })
-})
-
-// ─── Test de sendTo ────────────────────────────────────
-describe('WSServer - sendTo', () => {
-  it('envía a un cliente específico', () => {
-    const ws = new WSServer() as any
-    const received: string[] = []
-
-    ws.clients.set('target', { id: 'target', send: (d: string) => received.push(d), close: () => {} })
-    ws.clients.set('other', { id: 'other', send: (d: string) => received.push(d), close: () => {} })
-
-    ws.sendTo('target', 'private.event', { secret: true })
-    expect(received).toHaveLength(1)
-  })
-})