¿Qué son las pruebas unitarias en el desarrollo de software? Son la costumbre de demostrar, con pequeñas comprobaciones automatizadas, que cada pieza de un programa hace exactamente lo que debe antes de que nadie combine las piezas en un producto. Todo código serio depende de ellas, desde las plataformas de pago hasta las apps móviles, porque un test unitario que falla señala la línea rota en segundos, mucho antes de que un cliente encuentre el error.
Los tests unitarios no son toda la historia de la calidad. Son la capa base, en manos de los desarrolladores, de una estrategia más amplia de servicios de QA y pruebas de software que también abarca comprobaciones de integración, de regresión y de extremo a extremo. Cuando la capa base es débil, todas las demás capas se vuelven más lentas y caras, y las fechas de lanzamiento empiezan a depender de la suerte.
Esta guía le ofrece una definición sencilla, la anatomía de un test unitario, un ejemplo práctico en Python y JavaScript, cómo se comparan los tests unitarios con otros tipos de pruebas, cuánta cobertura de código cabe esperar, qué frameworks usan los equipos en 2026, qué cambian los asistentes de programación con IA y una lista de verificación para valorar los tests unitarios de cualquier equipo de desarrollo.
¿Qué son las pruebas unitarias en el desarrollo de software?
Las pruebas unitarias en el desarrollo de software son un nivel de pruebas en el que la parte más pequeña que se puede probar de una aplicación, llamada unidad bajo prueba, se comprueba de forma aislada mediante tests automatizados que escriben los desarrolladores. Es el primer nivel de pruebas, antes de las pruebas de integración, de sistema y de aceptación, y se ejecuta con cada cambio de código.
Una «unidad» suele ser una función, un método o una clase. En algunos lenguajes y equipos es un módulo pequeño con una interfaz pública. Lo importante es que la unidad tenga una entrada clara y una salida esperada clara, y que se pueda ejercitar sin arrancar toda la aplicación. Un test unitario nunca necesita una base de datos real, un servidor web en marcha ni una llamada de red para pasar.
Hay dos escuelas de pensamiento sobre el tamaño de una unidad. La escuela clásica, a veces llamada escuela de Detroit o de Chicago, entiende la unidad como una unidad de comportamiento: un pequeño grupo de objetos reales probados juntos, con dobles de prueba solo en los límites lentos o externos. La escuela mockista, a menudo llamada escuela de Londres, trata cada clase como la unidad y sustituye cada colaborador por un mock. Ambas funcionan; muchos equipos se inclinan por la clásica y usan mocks solo en los límites, porque los tests con muchos mocks se rompen cada vez que cambia el diseño interno.
Las pruebas unitarias son una práctica de caja blanca. Quien escribe el test sabe cómo está construido el código y usa ese conocimiento para elegir entradas que lleguen a cada rama. Por eso casi todos los tests unitarios los escriben los desarrolladores y no testers independientes.
Definición de pruebas unitarias: ¿qué son los tests unitarios en el desarrollo de software?
Un test unitario es un pequeño programa que llama a una unidad de código con una entrada conocida y comprueba que la salida, el valor devuelto o el efecto secundario coincide con lo esperado. Si la aserción se cumple, el test pasa; si no, falla e indica qué expectativa no se ha cumplido. Un conjunto de estos tests, ejecutado de forma automática, es la suite de tests unitarios.
Una buena definición práctica de las pruebas unitarias en el desarrollo de software tiene cuatro partes: el objetivo es la unidad más pequeña que se puede probar, la unidad está aislada de sus dependencias, la comprobación es automatizada y repetible, y el resultado es un binario de pasa o falla que no requiere interpretación humana.
Anatomía de un test unitario: Arrange, Act, Assert
La mayoría de los tests unitarios siguen el patrón Arrange, Act, Assert, normalmente abreviado como AAA. Arrange prepara los datos de entrada y los dobles de prueba necesarios. Act llama a la unidad una vez. Assert compara el resultado con el valor esperado. Mantener visibles estos tres pasos hace que un test sea fácil de leer y de depurar cuando falla.
Los equipos que trabajan con desarrollo guiado por comportamiento describen la misma estructura como Given, When, Then: dado un carrito de $200, cuando se aplica un descuento del 25%, entonces el total es de $150. La redacción cambia, pero la forma del test es idéntica. Un test debe tener un solo paso Act y verificar un solo comportamiento, aunque ese comportamiento necesite dos o tres aserciones relacionadas.
Caso de prueba, suite de tests, test runner: el vocabulario
Las pruebas unitarias tienen un vocabulario reducido que aparece en todos los frameworks, en todas las revisiones de pull requests y en todos los informes de proveedores. La tabla siguiente define los términos que oirá con más frecuencia.
| Término | Significado | Ejemplo |
|---|---|---|
| Unidad bajo prueba | La función, el método o la clase que se comprueba | apply_discount() |
| Caso de prueba | Un escenario con una entrada concreta y un resultado esperado | «25% de descuento sobre $200 devuelve $150» |
| Aserción | La instrucción que compara los valores real y esperado | assert total == 150 |
| Fixture | Datos u objetos de preparación reutilizables que comparten varios tests | Un registro de cliente de ejemplo |
| Suite de tests | Un grupo de casos de prueba relacionados que se ejecutan juntos | Todos los tests del módulo de precios |
| Test runner | La herramienta que descubre, ejecuta e informa de los tests | pytest, Jest, JUnit Platform |
| Doble de prueba | Un sustituto de una dependencia real durante el test | Una pasarela de pago simulada |
Un ejemplo sencillo de pruebas unitarias, paso a paso
La forma más clara de entender las pruebas unitarias es leer un test real. El ejemplo siguiente comprueba una pequeña función de precios en Python con pytest y después muestra la misma idea en JavaScript con Jest (Vitest usa la misma sintaxis). Ambas versiones siguen el patrón Arrange, Act, Assert.
La función bajo prueba, apply_discount(price, percent), aplica un descuento porcentual y rechaza los porcentajes no válidos. Sus tres tests tienen este aspecto:
import pytest
from pricing import apply_discount
def test_applies_percentage_discount():
assert apply_discount(200.0, 25) == 150.0
def test_zero_percent_returns_original_price():
assert apply_discount(99.99, 0) == 99.99
def test_rejects_percent_above_100():
with pytest.raises(ValueError):
apply_discount(50.0, 120)
Cada test comprueba un comportamiento: un descuento normal, el caso límite del cero y una entrada no válida que debe lanzar un error. pytest encuentra todas las funciones cuyo nombre empieza por test_, las ejecuta e informa de qué aserciones han fallado. El archivo completo se ejecuta en unos pocos milisegundos porque nada toca el disco, una base de datos ni la red.
// discount.test.js
const { applyDiscount } = require('./discount');
test('applies a percentage discount', () => {
const price = 200; // Arrange
const result = applyDiscount(price, 25); // Act
expect(result).toBe(150); // Assert
});
test('rejects a negative percent', () => {
expect(() => applyDiscount(50, -5)).toThrow(RangeError);
});
La versión en JavaScript etiqueta de forma explícita los tres pasos AAA. En los proyectos reales estos comentarios suelen omitirse cuando el equipo ya está acostumbrado al patrón, pero el orden se mantiene. Fíjese en que los nombres de los tests se leen como requisitos. Cuando rejects a negative percent falla en una pull request, el revisor sabe qué se ha roto sin abrir el código.
¿Por qué son importantes las pruebas unitarias?
Las pruebas unitarias son importantes porque detectan los defectos en el momento y el lugar en que es más barato corregirlos, dan a los desarrolladores una red de seguridad para refactorizar y documentan cómo debe comportarse cada pieza de código. Sin ellas, los errores avanzan más por el pipeline y cuestan más en cada etapa.
El argumento económico está bien documentado. El Planning Report 02-3 del NIST, publicado en 2002, estimó que una infraestructura de pruebas de software inadecuada costaba a la economía de EE. UU. unos $59.5 mil millones al año, y que unos $22.2 mil millones de esa cifra podían evitarse de forma realista con mejores pruebas. Más recientemente, el Consortium for Information & Software Quality (CISQ) estimó en su informe de 2022 que el coste de la mala calidad del software en EE. UU. había alcanzado al menos $2.41 billones. Las cifras difieren en alcance y método, pero ambas apuntan a la misma conclusión: los defectos que escapan a las comprobaciones tempranas salen caros.
Las pruebas unitarias también cambian el trabajo diario de los equipos:
- Feedback rápido. El desarrollador sabe en cuestión de segundos que un cambio ha roto algo, mientras aún tiene el código fresco en la memoria.
- Refactorización segura. Los ingenieros pueden reestructurar o actualizar el código porque la batería de pruebas demuestra que el comportamiento no ha cambiado.
- Documentación viva. Los nombres de las pruebas y sus aserciones describen las reglas de negocio con más fiabilidad que una página de la wiki.
- Mejor diseño. El código fácil de probar suele tener funciones pequeñas y dependencias explícitas.
- Depuración más barata. Una prueba unitaria fallida señala una sola función, no todo un recorrido del usuario.
Esta es la esencia del enfoque shift-left: adelantar las comprobaciones al momento más temprano posible, y la prueba unitaria es la comprobación automatizada más temprana que existe.
¿Cómo funcionan las pruebas unitarias en el flujo de desarrollo?
En un flujo de trabajo moderno, las pruebas unitarias se escriben a la vez que el código, se ejecutan en la máquina del desarrollador y vuelven a ejecutarse automáticamente en la integración continua con cada pull request. Un cambio solo se fusiona cuando toda la batería está en verde. La secuencia típica es la siguiente:
- Elija la unidad. Identifique la función o la clase que va a añadir o modificar.
- Defina el comportamiento esperado. Enumere el caso normal, los casos límite (vacío, cero, máximo) y los casos de error.
- Aísle las dependencias. Sustituya las bases de datos, los relojes, los clientes de red y los generadores aleatorios por dobles de prueba o valores inyectados.
- Escriba las pruebas con el patrón AAA. Un comportamiento por prueba, con un nombre que se lea como un requisito.
- Ejecútelas en local. Use el modo watch o un hook de pre-commit para que las pruebas se ejecuten antes de que el código salga del portátil.
- Ejecútelas en la CI con cada pull request. El pipeline bloquea la fusión si falla cualquier prueba unitaria o si baja la cobertura de las líneas modificadas.
- Mantenga las pruebas sincronizadas. Cuando el comportamiento cambie a propósito, actualice la prueba en el mismo commit; cuando encuentre un bug, añada primero una prueba que lo reproduzca.
Los pasos 6 y 7 son donde muchos equipos fallan. Una batería que solo se ejecuta en las máquinas de los desarrolladores se degrada rápidamente. Nuestra guía sobre CI/CD en el desarrollo de software muestra cómo encaja la etapa unitaria en el pipeline, y el artículo sobre pull requests explica cómo los revisores usan los resultados de las pruebas como filtro para la fusión.
Pruebas unitarias frente a pruebas de integración y pruebas de extremo a extremo
Las pruebas unitarias comprueban una pieza de código de forma aislada, las pruebas de integración comprueban que las piezas funcionan juntas y las pruebas de extremo a extremo comprueban recorridos completos del usuario a través del sistema real. Cada nivel detecta un tipo distinto de defecto, por lo que un proyecto sano los utiliza todos en proporciones diferentes.
| Tipo | Qué comprueba | Alcance | Velocidad | Quién las escribe | Herramientas habituales | Detecta |
|---|---|---|---|---|---|---|
| Unitarias | Una función, un método o una clase | Mínimo | Milisegundos | Desarrolladores | pytest, JUnit, Jest | Errores de lógica y de casos límite |
| Integración | Varias unidades o una unidad con una dependencia real | De pequeño a medio | Segundos | Desarrolladores, QA | Testcontainers, Spring Test, Supertest | Conexiones, consultas, configuración |
| Funcionales / API | Una funcionalidad a través de su interfaz pública | Medium | Segundos | QA, desarrolladores | Postman, REST Assured, Pact | Errores de contrato y de reglas de negocio |
| De extremo a extremo / UI | Un recorrido completo del usuario en una app desplegada | Todo el sistema | Minutos | Automatización de QA | Playwright, Cypress, Appium | Flujos rotos entre servicios |
| Regresión | Que las funciones antiguas siguen funcionando tras un cambio | Cualquier nivel | Variable | Todo el equipo | Las baterías existentes, ejecutadas de nuevo | Efectos secundarios del código nuevo |
| UAT | Que el producto cumple las necesidades del negocio | Todo el sistema | Días | Usuarios de negocio | Guiones de prueba, staging | Requisitos erróneos |
La regresión no es tanto un nivel aparte como un propósito: volver a ejecutar las pruebas existentes después de cada cambio. Las pruebas de aceptación de usuario se sitúan en el extremo opuesto a las pruebas unitarias: son los usuarios de negocio quienes comprueban el producto frente a las necesidades reales. Para ver el panorama completo de tipos de prueba, consulte nuestra guía sobre aseguramiento de la calidad en el desarrollo de software.
Dónde se sitúan las pruebas unitarias en la pirámide de pruebas
Las pruebas unitarias forman la amplia base de la pirámide de pruebas: muchas pruebas rápidas y baratas abajo, menos pruebas de integración en el medio y un número reducido de pruebas lentas de extremo a extremo en la cima. Esta forma mantiene el feedback rápido y la batería estable.
Una entrada de 2015 del Google Testing Blog firmada por Mike Wacker, «Just Say No to More End-to-End Tests», popularizó una regla práctica de aproximadamente un 70% de pruebas unitarias, un 20% de integración y un 10% de extremo a extremo. La propia entrada indica que la combinación exacta será distinta para cada equipo, pero que la batería debe mantener su forma de pirámide. Tome esta proporción como punto de partida, no como una obligación.
Los equipos de frontend a veces prefieren el «testing trophy» descrito por Kent C. Dodds, que da más peso a las pruebas de integración de componentes y menos a las pruebas unitarias aisladas. El trofeo y la pirámide coinciden en lo principal: las pruebas de extremo a extremo, lentas y frágiles, deben ser el grupo más pequeño.
Las pruebas unitarias en el modelo en V
En el modelo en V, las pruebas unitarias son el paso de verificación emparejado con el diseño detallado o de módulos. El lado izquierdo de la V desciende desde los requisitos hasta el diseño de módulos y la codificación; el lado derecho vuelve a subir desde las pruebas unitarias pasando por las de integración, de sistema y de aceptación, y cada nivel de prueba comprueba el nivel de diseño situado enfrente. Los sectores regulados siguen utilizando este modelo, y nuestro artículo sobre el modelo en V en el desarrollo de software explica cómo se corresponden sus niveles de prueba con la documentación.
Mocks, stubs y fakes: cómo aislar la unidad
Los dobles de prueba son sustitutos que reemplazan dependencias lentas, impredecibles o externas, como bases de datos, pasarelas de pago, relojes y clientes HTTP, para que una unidad pueda probarse por sí sola. Mantienen las pruebas unitarias rápidas y deterministas, y permiten simular errores que son difíciles de provocar con la dependencia real.
| Doble | Qué hace | Cuándo usarlo | Ejemplo |
|---|---|---|---|
| Dummy | Rellena un parámetro pero nunca se usa | Una firma necesita un argumento que a la prueba no le importa | Un objeto logger vacío |
| Stub | Devuelve respuestas fijas y predefinidas | Necesita que la dependencia devuelva un valor concreto | Un cliente de tipos de cambio que siempre devuelve 1.10 |
| Fake | Una implementación funcional pero simplificada | Necesita un comportamiento realista sin el sistema real | Un repositorio en memoria en lugar de PostgreSQL |
| Spy | Registra cómo se le ha llamado | Necesita comprobar a posteriori que se produjo una llamada | Un remitente de correo que guarda los mensajes enviados |
| Mock | Programado de antemano con expectativas que después verifica | La propia interacción es el comportamiento que se prueba | Una pasarela de pago a la que se debe cobrar exactamente una vez |
Los dobles de prueba funcionan mejor con la inyección de dependencias: en lugar de crear un cliente de base de datos dentro de una función, el código lo recibe como parámetro o como argumento del constructor. El código de producción pasa el cliente real y la prueba pasa un fake. El código que crea sus propias dependencias, lee directamente el reloj del sistema o llama a servicios globales estáticos es difícil de probar y suele ser lo primero que un equipo refactoriza cuando empieza a tomarse en serio las pruebas unitarias.
El exceso de mocks es el problema contrario. Cuando se simulan todos los colaboradores y cada prueba verifica secuencias exactas de llamadas, las pruebas reflejan la implementación en lugar del comportamiento. Cualquier refactorización rompe entonces decenas de pruebas aunque el producto siga funcionando. Una regla práctica: simule lo que no es suyo o no puede controlar (redes, API de terceros, tiempo) y use objetos reales o fakes para sus propias clases sencillas.
Técnicas de pruebas unitarias: caja blanca, caja negra y caja gris
Las pruebas unitarias se diseñan sobre todo con técnicas de caja blanca, porque el desarrollador puede ver el código, pero el enfoque de caja negra y de caja gris ayuda a elegir mejores entradas. Al combinarlos se obtienen pruebas que cubren tanto las ramas internas como el contrato externo de una unidad.
- Pruebas de caja blanca. Las entradas se eligen para recorrer cada rama, bucle y condición del código, guiándose por los informes de cobertura.
- Pruebas de caja negra. La unidad se prueba solo a través de su interfaz pública frente a su especificación, sin depender de los detalles internos.
- Pruebas de caja gris. Quien prueba conoce parte del funcionamiento interno, como el modelo de datos, y usa ese conocimiento para diseñar pruebas a nivel de interfaz.
- Partición de equivalencia. Las entradas se agrupan en clases que deberían comportarse igual, y se prueba un valor de cada clase.
- Análisis de valores límite. Las pruebas se centran en los bordes de cada rango, como 0, 100 y 101 para un porcentaje, que es donde se esconden los errores por uno.
- Pruebas parametrizadas. Un mismo cuerpo de prueba se ejecuta contra una tabla de entradas y salidas esperadas, lo que mantiene compactos los casos límite.
- Pruebas basadas en propiedades. Herramientas como Hypothesis para Python y fast-check para JavaScript generan cientos de entradas aleatorias y comprueban que una propiedad, como «un descuento nunca aumenta el precio», se cumple siempre.
Pruebas unitarias manuales frente a automatizadas
En 2026, las pruebas unitarias están casi totalmente automatizadas. Recorrer paso a paso una función en un depurador o imprimir valores en la consola puede confirmar un caso concreto, pero no deja ninguna comprobación reutilizable y no escala más allá de unas pocas funciones.
- Repetibilidad. Una prueba automatizada se ejecuta de forma idéntica miles de veces; una comprobación manual depende de quién la realice y con qué cuidado.
- Velocidad. Una batería de varios miles de pruebas unitarias suele terminar en la CI en un tiempo de entre unos segundos y unos pocos minutos.
- Protección frente a regresiones. Las pruebas automatizadas siguen protegiendo el comportamiento antiguo mucho después de que el desarrollador original se haya marchado.
- Evidencia. Los logs de la CI y los informes de cobertura dan a responsables y auditores la prueba de que las comprobaciones se han ejecutado realmente.
- Dónde sigue ayudando lo manual. La depuración exploratoria es útil para entender un fallo, pero el hallazgo debe terminar convertido en una nueva prueba automatizada.
¿Qué hace que una prueba unitaria sea buena? Los principios FIRST
Una buena prueba unitaria es rápida, independiente, repetible, autovalidable y oportuna: las cinco cualidades que recoge el acrónimo FIRST, popularizado por Tim Ottinger y Jeff Langr. Las pruebas que incumplen estos principios se vuelven lentas, inestables o acaban ignoradas.
| Principio | Significado | Síntoma cuando se incumple |
|---|---|---|
| Fast (rápida) | Se ejecuta en milisegundos, de modo que toda la batería corre con cada cambio | Los desarrolladores se saltan las pruebas en local porque «tardan demasiado» |
| Independent (independiente) | No depende de otras pruebas ni de su orden | Las pruebas pasan por separado, pero fallan al ejecutarse juntas |
| Repeatable (repetible) | Da el mismo resultado en cualquier máquina y en cualquier momento | Fallos los lunes, a medianoche o solo en la CI |
| Self-validating (autovalidable) | Indica si pasa o falla sin interpretación humana | Alguien tiene que leer la salida del log para decidir |
| Timely (oportuna) | Se escribe junto con el código, no meses después | Grandes módulos sin pruebas que nadie se atreve a tocar |
Algunos hábitos más separan las pruebas útiles del ruido. Pruebe un solo comportamiento por prueba y dele un nombre descriptivo, como should_reject_negative_percent, para que un fallo se explique por sí mismo. Mantenga la lógica fuera de las pruebas: los bucles y condicionales dentro de una prueba pueden ocultar sus propios bugs. Controle toda fuente de no determinismo, incluidos el reloj, los números aleatorios, las zonas horarias y las llamadas de red. Por último, trate las pruebas inestables (flaky), las que pasan y fallan sin cambios en el código, como defectos: póngalas en cuarentena, corrija la causa y haga seguimiento de la tasa de inestabilidad, porque una batería en la que nadie confía deja de ejecutarse.
Estos hábitos coinciden en parte con las buenas prácticas de desarrollo de software más generales, como los commits pequeños, la revisión de código y una nomenclatura clara.
¿Cuánta cobertura de código necesita?
La cobertura de código mide qué líneas o ramas se ejecutaron durante las pruebas, no si se comprobaron sus resultados, así que no existe un objetivo universal que garantice la calidad. Una referencia útil procede de la guía del blog de pruebas de Google («Code Coverage Best Practices», 2020), que califica un 60% de aceptable, un 75% de encomiable y un 90% de ejemplar.
La misma guía subraya que la cobertura del código modificado en cada commit importa más que un porcentaje global del proyecto. Un sistema heredado con un 45% global puede estar mejorando si cada nueva pull request llega con un 85% de cobertura en sus líneas modificadas. La lógica crítica para el negocio, como precios, facturación, permisos y cálculos, merece una cobertura de ramas casi total, mientras que el código de unión sencillo necesita mucha menos.
| Tipo de cobertura | Qué mide | Notas |
|---|---|---|
| Línea / sentencia | Proporción de líneas o sentencias ejecutadas | La más fácil de obtener; puede parecer alta aunque falten ramas enteras |
| Rama | Proporción de resultados de if/else y switch recorridos | Mejor indicador para el código con mucha lógica |
| Condición | Si cada subcondición booleana ha sido verdadera y falsa | Detecta condiciones complejas que la cobertura de ramas pasa por alto |
| MC/DC | Que cada condición afecta de forma independiente a la decisión | Obligatoria para el software de aviónica más crítico |
| Puntuación de mutación | Proporción de bugs inyectados que detectan las pruebas | Muestra si las aserciones son reales, no solo si el código se ha ejecutado |
Las pruebas de mutación son la comprobación honesta de la cobertura. Herramientas como PIT para Java, Stryker para JavaScript, TypeScript y C#, y mutmut para Python introducen pequeños cambios en el código, como cambiar > por >=, y vuelven a ejecutar las pruebas. Si las pruebas siguen pasando, el «mutante» ha sobrevivido y las aserciones son demasiado débiles. Una batería con un 90% de cobertura de líneas y una puntuación de mutación baja se limita sobre todo a ejecutar código, no a probarlo.
Frameworks de pruebas unitarias más populares por lenguaje (2026)
Todos los lenguajes de uso generalizado cuentan con un framework de pruebas unitarias maduro, normalmente acompañado de una biblioteca de mocks, y la elección depende sobre todo del lenguaje y del stack que ya utiliza el equipo. La tabla recoge las opciones habituales en 2026.
| Idioma | Framework | Biblioteca de mocks | Notas |
|---|---|---|---|
| Java / Kotlin | JUnit 5 | Mockito, MockK (Kotlin) | Estándar de facto en la JVM; AssertJ para aserciones legibles |
| Python | pytest, unittest | unittest.mock y pytest-mock | pytest domina en los proyectos nuevos; unittest viene incluido con Python |
| JavaScript / TypeScript | Jest, Vitest | Mocks integrados | Vitest es popular en los frontends basados en Vite; mismo estilo de API que Jest |
| C# / .NET | xUnit.net, NUnit, MSTest | Moq, NSubstitute | xUnit.net es la opción habitual para el código .NET nuevo |
| Go | testing integrado | testify, gomock | Las pruebas basadas en tablas son la forma idiomática en Go |
| Swift | XCTest, Swift Testing | Fakes basados en protocolos | Swift Testing es el framework más reciente de Apple, basado en macros |
| C / C++ | GoogleTest, Catch2 | GoogleMock | Habitual en código embebido y en código crítico para el rendimiento |
| PHP | PHPUnit, Pest | Mockery, mocks integrados | Pest añade una sintaxis más ligera sobre PHPUnit |
| Ruby | RSpec, Minitest | rspec-mocks | Minitest viene incluido con Ruby y Rails |
El framework rara vez decide si las pruebas unitarias funcionan. Lo deciden los hábitos del equipo: si las pruebas se ejecutan en cada pull request, si los fallos bloquean los merges y si la gente confía en los resultados.
Ventajas y limitaciones de las pruebas unitarias
Las pruebas unitarias ofrecen una retroalimentación rápida y barata y cambios más seguros, pero no pueden demostrar que un sistema completo funcione, y una suite mal diseñada puede generar una falsa sensación de seguridad. Conocer ambas caras ayuda a los equipos a invertir la cantidad adecuada en pruebas unitarias.
| Ventajas | Limitaciones |
|---|---|
| Detectan los defectos en el momento en que se introducen | No detectan problemas de integración, de configuración ni de interfaz de usuario |
| Hacen que la refactorización y las actualizaciones sean seguras | Requieren un mantenimiento continuo a medida que cambia el código |
| Documentan el comportamiento en forma ejecutable | Las aserciones superficiales dan una falsa sensación de seguridad |
| Aceleran la depuración al señalar la unidad que falla | Las pruebas con exceso de mocks se rompen con refactorizaciones inofensivas |
| Empujan el código hacia un diseño modular y poco acoplado | El código heredado sin puntos de separación es difícil de probar al principio |
| Proporcionan la retroalimentación más barata del pipeline de CI | No pueden verificar que los propios requisitos sean correctos |
¿Qué no debería cubrir con pruebas unitarias?
No debería dedicar pruebas unitarias a código que no tiene lógica propia o que se verifica mejor en otro nivel. Probar todo por igual con pruebas unitarias hace perder tiempo y produce pruebas frágiles que ralentizan al equipo.
- Getters y setters triviales que solo almacenan y devuelven un valor.
- Código de frameworks y bibliotecas que usted no ha escrito; sus autores ya lo prueban.
- Código generado, como los modelos ORM o los clientes de API producidos por un generador.
- Archivos de configuración pura y constantes, que se comprueban mejor mediante validación de esquemas.
- Consultas a la base de datos y contratos HTTP, que necesitan una base de datos real o pruebas de contrato en el nivel de integración para tener sentido.
- Detalles superficiales de maquetación de la interfaz que cambian a menudo y que se cubren mejor con comprobaciones visuales o de extremo a extremo.
El código heredado es un caso especial. Antes de modificar código antiguo sin pruebas, escriba pruebas de caracterización: pruebas que registran lo que el código hace actualmente, esté bien o mal. Crean una red de seguridad, tras la cual puede refactorizar hacia unidades comprobables y sustituir las pruebas de caracterización por pruebas de comportamiento propiamente dichas.
Pruebas unitarias frente a TDD: ¿son las pruebas unitarias lo mismo que el desarrollo guiado por pruebas?
No. Las pruebas unitarias son un tipo de prueba, mientras que el desarrollo guiado por pruebas es un flujo de trabajo en el que la prueba unitaria se escribe antes que el código de producción y la prueba guía el diseño. La mayoría de los equipos escriben pruebas unitarias después del código o a la vez que él, sin practicar un TDD estricto, y aun así obtienen una suite fiable. El TDD es una forma disciplinada de garantizar que las pruebas llegan a tiempo y que se ha visto fallar cada una de ellas. Nuestra guía sobre TDD en el desarrollo de software explica ese flujo de trabajo, sus costes y cuándo compensa.
¿Cómo están cambiando los asistentes de programación con IA las pruebas unitarias en 2026?
Los asistentes de programación con IA pueden generar pruebas unitarias en segundos, lo que abarata aumentar la cobertura, pero las pruebas generadas a menudo verifican lo que el código hace actualmente en lugar de lo que debería hacer. En 2026, el trabajo pasa de escribir pruebas a revisarlas, con las pruebas de mutación como comprobación objetiva.
La adopción ya es amplia. En la Stack Overflow Developer Survey 2025, el 84% de los encuestados afirmó que utiliza o tiene previsto utilizar herramientas de IA en su proceso de desarrollo, frente al 76% en 2024. Al mismo tiempo, la confianza cae: el 46% dijo que no confía en la precisión de los resultados de la IA, frente al 31% un año antes, y el 66% señaló como su mayor frustración las «soluciones de IA que casi aciertan, pero no del todo». Los encuestados también incluyeron las pruebas entre las áreas en las que más prevén usar la IA.
«Casi acertar» es exactamente el riesgo de las pruebas generadas. Si el código tiene un error, una prueba generada a partir de ese código lo consolidará sin problema. Los equipos que usan la IA de forma productiva para las pruebas unitarias siguen unas cuantas reglas:
- Revise cada aserción generada frente al requisito, no frente a la salida actual.
- Priorice el comportamiento sobre la implementación. Rechace las pruebas que verifican secuencias de llamadas internas sin una razón de negocio.
- Ejecute pruebas de mutación sobre las suites escritas por IA para demostrar que las pruebas fallan cuando el código está roto.
- No permita nunca que un agente arregle una prueba en rojo modificando la aserción. Una prueba que falla significa que el código o el requisito necesitan una decisión humana.
- Mantenga las pruebas generadas en el diff del pull request, para que los revisores las vean y las aprueben como cualquier otro código.
Los productos que incluyen funciones de IA necesitan una capa de comprobaciones distinta además de las pruebas unitarias, porque la salida del modelo no es determinista. Ese es el ámbito de las pruebas de productos de IA, que evalúan las respuestas, la seguridad y las regresiones en el comportamiento de la IA.
Pruebas unitarias en software regulado
En los sectores regulados, las pruebas unitarias no son solo una buena práctica, sino una evidencia documentada que los auditores y los organismos de certificación esperan ver. Las normas varían según el ámbito, pero todas exigen pruebas de que las unidades se verificaron y de que la verificación se planificó.
- Dispositivos médicos. La IEC 62304 exige la verificación de las unidades de software para el software de las clases de seguridad B y C, con criterios de aceptación definidos de antemano.
- Aviónica. La DO-178C exige la cobertura de condición/decisión modificada (MC/DC) para el software más crítico de Nivel A, además de la cobertura de sentencias y de decisiones.
- Pagos y SaaS. Los auditores de PCI DSS y SOC 2 buscan evidencias de pruebas automatizadas y de una gestión controlada de los cambios en el pipeline de entrega.
En estos entornos, los resultados de las pruebas, los informes de cobertura y la trazabilidad de los requisitos a las pruebas pasan a formar parte del registro de la versión. Nuestro artículo sobre el desarrollo de software para dispositivos médicos explica cómo encaja esta documentación en un proceso de lanzamiento regulado.
Cómo revisar las pruebas unitarias de un equipo de desarrollo: lista de comprobación para el comprador
Puede evaluar las pruebas unitarias de un equipo de desarrollo sin leer el código haciendo unas cuantas preguntas directas. Las respuestas claras y concretas son buena señal; las respuestas vagas sobre una «cobertura alta», no.
- ¿Se ejecutan las pruebas unitarias automáticamente en cada pull request y un fallo bloquea el merge?
- ¿Cuál es la cobertura del código modificado en los pull requests recientes, y no solo la cifra global del proyecto?
- ¿Existe una política para las pruebas inestables, con un seguimiento de la tasa de inestabilidad y un plazo para corregir las pruebas en cuarentena?
- ¿Miden una puntuación de mutación en los módulos críticos y cuál es?
- ¿Cuál es su política sobre los dobles de prueba y qué simulan con mocks frente a lo que prueban con objetos reales o fakes?
- ¿Cuánto tarda en ejecutarse la suite unitaria? El objetivo son minutos, no horas.
- ¿Quién revisa las pruebas generadas por IA y cómo comprueban que verifican el comportamiento correcto?
Si las respuestas son flojas, o ha heredado una base de código de la que nadie puede responder, una auditoría de QA independiente puede medir la cobertura, la puntuación de mutación y la tasa de pruebas inestables, y convertir los hallazgos en un plan concreto para la pirámide de pruebas.
Preguntas frecuentes
¿Qué son las pruebas unitarias en el desarrollo de software?
Las pruebas unitarias en el desarrollo de software son la práctica de comprobar las piezas de código comprobables más pequeñas, como una función, un método o una clase, de forma aislada de las bases de datos, las redes y otros módulos. Los desarrolladores escriben pruebas unitarias automatizadas que llaman a la unidad con una entrada conocida y verifican el resultado esperado. Las pruebas se ejecutan en milisegundos con cada cambio y constituyen el primer nivel, y el más rápido, de las pruebas de software.
¿Qué son las pruebas unitarias en el desarrollo de software? Un ejemplo
Las pruebas unitarias son pequeños programas automatizados que verifican un comportamiento de una unidad de código. Por ejemplo, una prueba para la función apply_discount(price, percent) puede llamar a apply_discount(200, 25) y verificar que el resultado es 150, y una segunda prueba puede verificar que un porcentaje de 120 provoca un error. Cada prueba sigue el patrón Arrange, Act, Assert y se ejecuta sin base de datos ni red.
¿Quién escribe las pruebas unitarias: los desarrolladores o los ingenieros de QA?
Las pruebas unitarias las escriben los desarrolladores, normalmente en el mismo pull request que el código que prueban, porque requieren conocer la estructura interna del código. Los ingenieros de QA rara vez las escriben, pero definen la estrategia global de pruebas, revisan la cobertura en las áreas de riesgo, construyen las suites de integración y de extremo a extremo y orientan a los desarrolladores sobre el diseño de pruebas y los casos límite.
¿Cuál es la diferencia entre las pruebas unitarias y las pruebas de integración?
Las pruebas unitarias comprueban una unidad de código de forma aislada, con las dependencias sustituidas por dobles de prueba, de modo que son rápidas y señalan la línea exacta que falla. Las pruebas de integración comprueban que varias unidades o componentes reales, como un servicio y su base de datos o una API externa, funcionan juntos correctamente. Las pruebas unitarias detectan errores de lógica, mientras que las de integración detectan errores de conexión, de configuración y de contrato.
¿Cuánta cobertura de pruebas unitarias es suficiente?
No hay una cifra universal, porque la cobertura muestra qué código se ejecutó, no si se verificó. La pauta del blog de pruebas de Google considera aceptable el 60 por ciento, encomiable el 75 por ciento y ejemplar el 90 por ciento, e insiste en la cobertura del código modificado en cada commit por encima de una cifra global del proyecto. La lógica de negocio crítica merece una cobertura de ramas casi completa, mientras que el código trivial necesita poca.
¿Son las pruebas unitarias lo mismo que el TDD?
No. Las pruebas unitarias son un tipo de prueba, mientras que el desarrollo guiado por pruebas (TDD) es un flujo de trabajo que decide cuándo se escribe la prueba. En el TDD, el desarrollador escribe primero una prueba unitaria que falla y después el código que la hace pasar. La mayoría de los equipos escriben pruebas unitarias sin practicar un TDD estricto, y ambos enfoques pueden dar lugar a una suite de pruebas unitarias fiable.
¿Puede la IA escribir pruebas unitarias para mi base de código?
Sí, los asistentes de programación con IA pueden generar pruebas unitarias con rapidez, y las pruebas son una de las áreas en las que los desarrolladores más prevén usar la IA. El riesgo es que las pruebas generadas a menudo verifican lo que el código hace actualmente en lugar de lo que debería hacer. Un desarrollador debe revisar cada aserción, y las pruebas de mutación deben confirmar que las pruebas fallan realmente cuando el código está roto.
Fuentes
- NIST, Planning Report 02-3: The Economic Impacts of Inadequate Infrastructure for Software Testing (en inglés) (2002)
- CISQ, Cost of Poor Software Quality in the US: A 2022 Report (en inglés)
- Google Testing Blog, Just Say No to More End-to-End Tests (en inglés) (Mike Wacker, 22 de abril de 2015)
- Google Testing Blog, Code Coverage Best Practices (en inglés) (7 de agosto de 2020)
- Stack Overflow, 2025 Developer Survey: AI (en inglés); nota de prensa (en inglés)