Pruebas

elide test ejecuta archivos node:test de JavaScript y TypeScript y pruebas JUnit.

elide test

Una prueba que falla hace que el código de salida sea distinto de cero.

JavaScript y TypeScript

Las pruebas usan la API node:test y no necesitan manifiesto. Un archivo es una prueba si coincide con *.test.*, *.spec.*, *_test.* o *_spec.*, o si está dentro de test, tests o __tests__. Extensiones: .js, .mjs, .cjs, .ts, .mts, .cts.

El descubrimiento omite los directorios ocultos, los de dependencias y los de salida de compilación. Se detiene en cualquier proyecto anidado (un directorio con elide.pkl, package.json, pom.xml o requirements.txt), así que la raíz de un espacio de trabajo no encuentra las pruebas de sus miembros. Indique una ruta para ejecutarlas.

import test from "node:test";
import assert from "node:assert";

test("adds two values", () => {
  assert.equal(1 + 1, 2);
});

Pruebas JVM

Las pruebas JVM se ejecutan en JUnit Platform y necesitan un elide.pkl. src/test es el conjunto de fuentes de pruebas predeterminado; un conjunto de fuentes declarado de tipo test lo sustituye (Conjuntos de fuentes).

• Los conjuntos de pruebas reciben testPackages más las dependencias del conjunto principal.
• Las bibliotecas JUnit incluidas se añaden por defecto. jvm.features.testing = false elimina tanto las API de compilación de JUnit como el entorno de ejecución incluido; entonces una ejecución de pruebas JVM necesita un lanzador de consola de JUnit (junit-platform-console) en testPackages y, si no lo hay, falla con un error. Las ejecuciones sin pruebas JVM no se ven afectadas.
• Los processors se ejecutan sobre las fuentes de prueba.
• La JVM de pruebas recibe jvm.flags y jvm.defs (como -D).
• Las dependencias modules de los conjuntos de pruebas y principal van en --module-path con --add-modules=ALL-MODULE-PATH.
• La configuración de paralelismo de un junit-platform.properties en el classpath de pruebas tiene prioridad sobre --concurrency.

Seleccionar pruebas

Las rutas, los directorios o los globs acotan las pruebas de JavaScript y TypeScript:

elide test src/api
elide test src/api/client.test.ts

Los argumentos de ruta omiten las pruebas JVM e imprimen Path filtering unsupported for JVM tests: <paths>. -t filtra por nombre de prueba en ambos ejecutores:

elide test -t 'parses .+ headers'

Las pruebas JVM admiten selectores de JUnit y expresiones de etiquetas:

elide test --select=class:com.example.ParserTest
elide test --select=method:com.example.ParserTest#parsesHeaders
elide test --select=package:com.example.parser   # the package and its subpackages
elide test com.example.parser                     # a dotted bare token is a package selector
elide test --include-tag=fast --include-tag=unit  # fast OR unit
elide test --exclude-tag=slow --exclude-tag=flaky # neither slow nor flaky
elide build test --select=class:com.example.ParserTest

--include-tag='slow & !flaky' es una sola expresión. Los filtros de etiquetas se aplican después de los selectores.

Salida e informes

El progreso va a stderr; el recuento final, a stdout:

elide test > summary.txt
elide test 2> progress.txt

Los informes se escriben en .dev/reports/tests/<language>/<source-set>/. testing.reports en elide.pkl los activa sin ninguna opción:

import "elide:Testing.pkl" as Testing

testing {
  reports { Testing.xmlReport() }
}

Salida TAP

--reporter=tap convierte stdout en un flujo TAP 13 puro:

TAP version 13
# start 1: suite A > t1
# out 1: printed from inside a test
ok 1 - suite A > t1
# start 2: broken
not ok 2 - broken
  ---
  message: "expected 1 to equal 2"
  severity: "ERR_ASSERTION"
  ...
1..2

• # start <id> abre una prueba; sus líneas de salida son # out <id>: <text>. # out: <text> no pertenece a ninguna prueba.
• Los puntos de prueba se numeran 1..N en orden de finalización. Asocie los puntos a las pruebas por la línea # start, no por el número.
• Un bloque YAML solo aparece en fallos con detalles; severity es el código de error del ejecutor, si lo hay.
• Stderr no se encapsula: elide test --reporter=tap 2>&1 no es TAP válido.
• JVM: la salida se asocia a su prueba solo mientras se ejecuta exactamente una prueba. Con --concurrency mayor que 1 o un junit-platform.properties en el proyecto, queda sin asociar.
• JavaScript: console.log dentro de una prueba, o en el nivel superior después de importar node:test, se encapsula. La salida anterior a esa importación sale tal cual. La salida de un hook pertenece a la prueba que el hook envuelve; t.diagnostic se encapsula como # out.

Cobertura

elide test --coverage
elide run --coverage

La cobertura JVM va a .dev/reports/coverage/jvm/<task>/ en HTML, XML o CSV; la de JavaScript y TypeScript es LCOV, en .dev/reports/coverage/js/lcov.info para las pruebas y .dev/reports/coverage/js/run/lcov.info para las ejecuciones. La consola imprime un único resumen combinado. El bloque coverage de nivel superior recopila sin la opción:

import "elide:Coverage.pkl" as Coverage

coverage {
  enabled = true
  scope = "tests"
  jvm {
    excludes { "org.example.generated.*" }
    reports {
      Coverage.xmlReport()
      Coverage.htmlReport()
    }
  }
  js {
    paths { "src" }
  }
}

Con cobertura, elide run inicia un proceso JVM aparte.

Opciones

Sintaxis: Depuración. Una opción desconocida o un valor ausente falla antes de que se ejecute nada (Tareas de compilación).

Límites

• No hay descubrimiento de pruebas de Python; ejecute unittest o pytest en su lugar (Pruebas de Python).
• Las pruebas JVM necesitan un manifiesto.
• Sin implementar: instantáneas de node:test, mock.module, modo de observación, run() programático, node:test/reporters.

API compatible: API de pruebas de Node.

Ejemplos

• Pruebas de TypeScript
• Pruebas de Kotlin
• Filtrar pruebas con CEL
• JUnit XML en CI

Empiece con una plantilla:

elide init --template java        # Java app with a JUnit test
elide init --template ktjvm       # Kotlin app with a test