theus-cli-linux-arm64 1.2.0 → 1.2.2

package/vendor/chrome-extension/cdp-core.test.ts

@@ -0,0 +1,321 @@
+import { describe, expect, test } from 'bun:test'
+// Efecto lateral: cdp-core.js cuelga TheusCdpCore de globalThis (mismo
+// mecanismo que usa el service worker vía importScripts).
+import './cdp-core.js'
+
+type EntradaConsola = { ts: number; nivel: string; texto: string; url?: string }
+type EntradaRed = {
+  id: string
+  metodo: string
+  url: string
+  tipo: string
+  estado: number | null
+  mime: string | null
+  tam: number | null
+  inicioMs: number
+  duracionMs: number | null
+  error: string | null
+}
+type EstadoRed = { entradas: EntradaRed[]; porId: Map<string, EntradaRed> }
+type DefTecla = {
+  modifiers: number
+  key: string
+  code: string
+  keyCode: number
+  text?: string
+}
+type ResumenAX = {
+  elementos: Array<{
+    ref: string
+    backendDOMNodeId: number
+    rol: string
+    nombre: string
+    valor?: string
+  }>
+  truncado: boolean
+  totalCandidatos: number
+}
+
+type TheusCdpCore = {
+  pushCircular<T>(buffer: T[], item: T, max: number): T | null
+  formatearEventoConsola(
+    method: string,
+    params: Record<string, unknown>,
+    ahoraMs?: number,
+  ): EntradaConsola | null
+  crearEstadoRed(): EstadoRed
+  plegarEventoRed(
+    estado: EstadoRed,
+    method: string,
+    params: Record<string, unknown>,
+    max: number,
+    ahoraMs?: number,
+  ): boolean
+  filtrarEntradas<T>(
+    entradas: T[],
+    opciones: {
+      pattern?: string
+      limit?: number
+      onlyErrors?: boolean
+      campoTexto: string
+    },
+  ): T[]
+  parsearCombinacionTeclas(combo: string): DefTecla | null
+  resumirArbolAX(
+    nodos: unknown[],
+    filtro: string | undefined,
+    maxElementos: number,
+  ): ResumenAX
+  planRecompresionCaptura(
+    base64Length: number,
+    anchoPx: number,
+    opciones?: { maxAncho?: number; maxBase64?: number },
+  ): { reprocesar: boolean; escala?: number; calidad?: number }
+  horaLocal(ms: number): string
+}
+
+const Core = (globalThis as unknown as { TheusCdpCore: TheusCdpCore }).TheusCdpCore
+
+describe('buffers circulares', () => {
+  test('expulsa el más antiguo al desbordar y lo devuelve', () => {
+    const buffer: number[] = []
+    expect(Core.pushCircular(buffer, 1, 2)).toBeNull()
+    expect(Core.pushCircular(buffer, 2, 2)).toBeNull()
+    expect(Core.pushCircular(buffer, 3, 2)).toBe(1)
+    expect(buffer).toEqual([2, 3])
+  })
+})
+
+describe('formatearEventoConsola', () => {
+  test('consoleAPICalled une los argumentos', () => {
+    const entrada = Core.formatearEventoConsola(
+      'Runtime.consoleAPICalled',
+      {
+        type: 'warning',
+        args: [
+          { type: 'string', value: 'hola' },
+          { type: 'number', value: 42 },
+          { type: 'object', description: 'Object' },
+        ],
+      },
+      1000,
+    )!
+    expect(entrada.nivel).toBe('warning')
+    expect(entrada.texto).toBe('hola 42 Object')
+    expect(entrada.ts).toBe(1000)
+  })
+
+  test('exceptionThrown es nivel error con detalle y url', () => {
+    const entrada = Core.formatearEventoConsola('Runtime.exceptionThrown', {
+      exceptionDetails: {
+        text: 'Uncaught',
+        url: 'https://ejemplo.pe/app.js',
+        exception: { description: 'TypeError: x is not a function' },
+      },
+    })!
+    expect(entrada.nivel).toBe('error')
+    expect(entrada.texto).toBe('Uncaught TypeError: x is not a function')
+    expect(entrada.url).toBe('https://ejemplo.pe/app.js')
+  })
+
+  test('Log.entryAdded conserva nivel y texto; otros eventos devuelven null', () => {
+    const entrada = Core.formatearEventoConsola('Log.entryAdded', {
+      entry: { level: 'error', text: 'Mixed Content', url: 'https://x.pe' },
+    })!
+    expect(entrada.nivel).toBe('error')
+    expect(entrada.texto).toBe('Mixed Content')
+    expect(Core.formatearEventoConsola('Network.responseReceived', {})).toBeNull()
+  })
+})
+
+describe('plegarEventoRed', () => {
+  test('pliega el ciclo completo de una petición', () => {
+    const estado = Core.crearEstadoRed()
+    Core.plegarEventoRed(
+      estado,
+      'Network.requestWillBeSent',
+      {
+        requestId: 'r1',
+        type: 'XHR',
+        request: { method: 'POST', url: 'https://api.pe/v1' },
+      },
+      10,
+      1000,
+    )
+    Core.plegarEventoRed(
+      estado,
+      'Network.responseReceived',
+      { requestId: 'r1', response: { status: 201, mimeType: 'application/json' } },
+      10,
+    )
+    Core.plegarEventoRed(
+      estado,
+      'Network.loadingFinished',
+      { requestId: 'r1', encodedDataLength: 512 },
+      10,
+      1350,
+    )
+    expect(estado.entradas).toHaveLength(1)
+    const e = estado.entradas[0]!
+    expect(e.metodo).toBe('POST')
+    expect(e.estado).toBe(201)
+    expect(e.mime).toBe('application/json')
+    expect(e.tam).toBe(512)
+    expect(e.duracionMs).toBe(350)
+    expect(e.error).toBeNull()
+  })
+
+  test('loadingFailed registra el error', () => {
+    const estado = Core.crearEstadoRed()
+    Core.plegarEventoRed(
+      estado,
+      'Network.requestWillBeSent',
+      { requestId: 'r2', request: { method: 'GET', url: 'https://caida.pe' } },
+      10,
+    )
+    Core.plegarEventoRed(
+      estado,
+      'Network.loadingFailed',
+      { requestId: 'r2', errorText: 'net::ERR_CONNECTION_REFUSED' },
+      10,
+    )
+    expect(estado.entradas[0]!.error).toBe('net::ERR_CONNECTION_REFUSED')
+  })
+
+  test('al expulsar una entrada del buffer circular limpia su índice', () => {
+    const estado = Core.crearEstadoRed()
+    for (let i = 0; i < 3; i++) {
+      Core.plegarEventoRed(
+        estado,
+        'Network.requestWillBeSent',
+        { requestId: `r${i}`, request: { method: 'GET', url: `https://p.pe/${i}` } },
+        2,
+      )
+    }
+    expect(estado.entradas).toHaveLength(2)
+    expect(estado.porId.has('r0')).toBe(false)
+    expect(estado.porId.has('r2')).toBe(true)
+  })
+})
+
+describe('filtrarEntradas', () => {
+  const consola: EntradaConsola[] = [
+    { ts: 1, nivel: 'log', texto: '[MiApp] arranque' },
+    { ts: 2, nivel: 'error', texto: '[MiApp] fallo de red' },
+    { ts: 3, nivel: 'log', texto: 'ruido de terceros' },
+    { ts: 4, nivel: 'error', texto: 'otro fallo' },
+  ]
+
+  test('filtra por regex y corta a las más recientes', () => {
+    const r = Core.filtrarEntradas(consola, {
+      pattern: 'MiApp',
+      limit: 1,
+      campoTexto: 'texto',
+    })
+    expect(r).toHaveLength(1)
+    expect(r[0]!.texto).toBe('[MiApp] fallo de red')
+  })
+
+  test('onlyErrors deja solo errores; sin limit usa 100 por defecto', () => {
+    const r = Core.filtrarEntradas(consola, { onlyErrors: true, campoTexto: 'texto' })
+    expect(r.map(e => e.ts)).toEqual([2, 4])
+  })
+
+  test('un pattern inválido lanza error honesto', () => {
+    let caught: unknown
+    try {
+      Core.filtrarEntradas(consola, { pattern: '(', campoTexto: 'texto' })
+    } catch (e) {
+      caught = e
+    }
+    expect(caught instanceof Error).toBe(true)
+    expect((caught as Error).message).toContain('regex')
+  })
+})
+
+describe('parsearCombinacionTeclas', () => {
+  test('tecla simple imprime texto', () => {
+    const def = Core.parsearCombinacionTeclas('a')!
+    expect(def).toMatchObject({ modifiers: 0, key: 'a', code: 'KeyA', keyCode: 65 })
+    expect(def.text).toBe('a')
+  })
+
+  test('ctrl+a no imprime texto y lleva el modificador Ctrl', () => {
+    const def = Core.parsearCombinacionTeclas('ctrl+a')!
+    expect(def.modifiers).toBe(2)
+    expect(def.keyCode).toBe(65)
+    expect(def.text).toBeUndefined()
+  })
+
+  test('ctrl+shift+t combina modificadores y sube a mayúscula', () => {
+    const def = Core.parsearCombinacionTeclas('ctrl+shift+t')!
+    expect(def.modifiers).toBe(10)
+    expect(def.key).toBe('T')
+  })
+
+  test('Enter y F5 se reconocen; lo desconocido devuelve null', () => {
+    expect(Core.parsearCombinacionTeclas('Enter')!.keyCode).toBe(13)
+    expect(Core.parsearCombinacionTeclas('F5')!.keyCode).toBe(116)
+    expect(Core.parsearCombinacionTeclas('teclarara')).toBeNull()
+    expect(Core.parsearCombinacionTeclas('')).toBeNull()
+  })
+})
+
+describe('resumirArbolAX', () => {
+  const nodos = [
+    {
+      backendDOMNodeId: 11,
+      role: { value: 'button' },
+      name: { value: 'Enviar' },
+    },
+    {
+      backendDOMNodeId: 12,
+      role: { value: 'textbox' },
+      name: { value: 'Correo' },
+      value: { value: 'a@b.pe' },
+    },
+    { backendDOMNodeId: 13, role: { value: 'heading' }, name: { value: 'Título' } },
+    { backendDOMNodeId: 14, role: { value: 'GenericContainer' }, name: { value: '' } },
+    { backendDOMNodeId: 15, role: { value: 'link' }, name: { value: 'Inicio' }, ignored: true },
+  ]
+
+  test('interactive (por defecto) solo devuelve interactivos con refs 1..n', () => {
+    const r = Core.resumirArbolAX(nodos, undefined, 150)
+    expect(r.elementos.map(e => e.rol)).toEqual(['button', 'textbox'])
+    expect(r.elementos.map(e => e.ref)).toEqual(['1', '2'])
+    expect(r.elementos[1]!.valor).toBe('a@b.pe')
+    expect(r.truncado).toBe(false)
+  })
+
+  test('all añade estructura pero sigue ignorando nodos ignored y genéricos', () => {
+    const r = Core.resumirArbolAX(nodos, 'all', 150)
+    expect(r.elementos.map(e => e.rol)).toEqual(['button', 'textbox', 'heading'])
+  })
+
+  test('trunca honestamente y lo declara', () => {
+    const r = Core.resumirArbolAX(nodos, undefined, 1)
+    expect(r.elementos).toHaveLength(1)
+    expect(r.truncado).toBe(true)
+    expect(r.totalCandidatos).toBe(2)
+  })
+})
+
+describe('planRecompresionCaptura', () => {
+  test('no reprocesa capturas pequeñas y estrechas', () => {
+    expect(Core.planRecompresionCaptura(1000, 800)).toEqual({ reprocesar: false })
+  })
+
+  test('escala cuando excede el ancho máximo', () => {
+    const plan = Core.planRecompresionCaptura(1000, 3200, { maxAncho: 1600 })
+    expect(plan.reprocesar).toBe(true)
+    expect(plan.escala).toBe(0.5)
+    expect(plan.calidad).toBe(0.8)
+  })
+
+  test('baja la calidad cuando excede el tamaño del canal', () => {
+    const plan = Core.planRecompresionCaptura(13 * 1024 * 1024, 1200)
+    expect(plan.reprocesar).toBe(true)
+    expect(plan.escala).toBe(1)
+    expect(plan.calidad).toBe(0.6)
+  })
+})