¿Qué son las pruebas parametrizadas y las pruebas dirigidas por datos?

Question

Accepted Answer

**Pruebas parametrizadas (dirigidas por datos)** ejecutan **la misma lógica de prueba con múltiples conjuntos de entradas y salidas esperadas** — evitando duplicar la prueba para cada caso. Facilitan probar muchos escenarios (incluyendo casos límite) de forma concisa.

## El problema: pruebas duplicadas

```text
Without parameterization, testing many input/output cases means COPYING the test:
  test('add 2+3', () => expect(add(2,3)).toBe(5));
  test('add 0+0', () => expect(add(0,0)).toBe(0));
  test('add -1+1', () => expect(add(-1,1)).toBe(0));
  → lots of near-identical, repetitive tests (tedious, hard to maintain)
```

## Pruebas parametrizadas — una prueba, muchos casos

```js
// run the SAME test logic over a TABLE of cases (Jest's test.each)
test.each([
  [2, 3, 5],
  [0, 0, 0],
  [-1, 1, 0],
  [100, 200, 300],
])('add(%i, %i) === %i', (a, b, expected) => {
  expect(add(a, b)).toBe(expected);     // one logic, run per case
});
// → each row is a separate reported test case; add a case = add a row
```

La mayoría de frameworks lo soportan (Jest `test.each`, pytest `@parametrize`, JUnit `@ParameterizedTest`).

## Beneficios

```text
✓ CONCISE — test many scenarios without duplicating the test body
✓ Easy to ADD CASES — just add a row of data (great for edge cases / many inputs)
✓ Each case reported SEPARATELY — you see exactly which input failed
✓ Clear, maintainable — the data table documents the cases
→ Ideal for functions with many input/output combinations and edge cases.
```

## Por qué es importante

Comprender las pruebas parametrizadas (dirigidas por datos) es valioso porque **facilitan probar muchos escenarios de forma concisa**, lo que respalda pruebas exhaustivas (especialmente casos límite), por lo que es un conocimiento práctico útil.

El problema que resuelven — probar muchas combinaciones de entrada/salida de otro modo requeriría **duplicar la prueba para cada caso** (tedioso, repetitivo, difícil de mantener) — es real, y las pruebas parametrizadas lo abordan ejecutando la **misma lógica de prueba sobre una tabla de casos**.

Esto hace que probar muchos escenarios sea **conciso** (un cuerpo de prueba, muchos casos), **fácil de agregar casos** (solo agrega una fila de datos — lo que fomenta probar más entradas y **casos límite**, respaldando la cobertura exhaustiva de casos límite que detecta errores), reporta **cada caso por separado** (para que veas exactamente qué entrada falló, facilitando la depuración), y mantiene las pruebas mantenibles (la tabla de datos documenta claramente los casos).

Comprender que la mayoría de frameworks lo soportan (el `test.each` de Jest, el `@parametrize` de pytest, el `@ParameterizedTest` de JUnit) lo hace prácticamente aplicable en diferentes stacks.

Las pruebas parametrizadas son ideales para funciones con muchas combinaciones de entrada/salida — común en funciones de utilidad, validadores, analizadores sintácticos y cálculos — donde permiten probar el rango completo de casos (incluyendo límites y casos límite) sin la carga de código de prueba duplicado.

Esta forma concisa y mantenible de lograr cobertura amplia de entradas fomenta pruebas más exhaustivas.

Ya que probar muchos escenarios (especialmente casos límite) es importante para pruebas exhaustivas y las pruebas parametrizadas lo hacen conciso y mantenible (evitando pruebas duplicadas, fomentando cobertura amplia de entradas), y ya que comprenderlas y su soporte en frameworks es útil para pruebas efectivas, comprender las pruebas parametrizadas y dirigidas por datos es un conocimiento valioso y prácticamente relevante — una técnica útil para probar muchos casos de forma concisa, respaldando la cobertura exhaustiva de casos límite que las pruebas efectivas requieren, y una herramienta práctica aplicable dondequiera que las funciones tengan muchas combinaciones de entrada/salida para verificar.