Yury Pukhov, YuSMP Group
Yury Pukhov CEO & Mobile Engineering Lead, YuSMP Group
Añada YuSMP como fuente preferida en Google
TL;DR: Las pruebas unitarias en el desarrollo de software son la práctica de comprobar las piezas de código más pequeñas que se pueden probar, normalmente una sola función, método o clase, de forma aislada de bases de datos, redes y otros módulos. Los tests unitarios son automatizados, se ejecutan en milisegundos y los escriben los desarrolladores para detectar defectos en el mismo momento en que se introducen.

¿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érminoSignificadoEjemplo
Unidad bajo pruebaLa función, el método o la clase que se compruebaapply_discount()
Caso de pruebaUn escenario con una entrada concreta y un resultado esperado«25% de descuento sobre $200 devuelve $150»
AserciónLa instrucción que compara los valores real y esperadoassert total == 150
FixtureDatos u objetos de preparación reutilizables que comparten varios testsUn registro de cliente de ejemplo
Suite de testsUn grupo de casos de prueba relacionados que se ejecutan juntosTodos los tests del módulo de precios
Test runnerLa herramienta que descubre, ejecuta e informa de los testspytest, Jest, JUnit Platform
Doble de pruebaUn sustituto de una dependencia real durante el testUna 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:

  1. Elija la unidad. Identifique la función o la clase que va a añadir o modificar.
  2. Defina el comportamiento esperado. Enumere el caso normal, los casos límite (vacío, cero, máximo) y los casos de error.
  3. 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.
  4. Escriba las pruebas con el patrón AAA. Un comportamiento por prueba, con un nombre que se lea como un requisito.
  5. 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.
  6. 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.
  7. 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.

TipoQué compruebaAlcanceVelocidadQuién las escribeHerramientas habitualesDetecta
UnitariasUna función, un método o una claseMínimoMilisegundosDesarrolladorespytest, JUnit, JestErrores de lógica y de casos límite
IntegraciónVarias unidades o una unidad con una dependencia realDe pequeño a medioSegundosDesarrolladores, QATestcontainers, Spring Test, SupertestConexiones, consultas, configuración
Funcionales / APIUna funcionalidad a través de su interfaz públicaMediumSegundosQA, desarrolladoresPostman, REST Assured, PactErrores de contrato y de reglas de negocio
De extremo a extremo / UIUn recorrido completo del usuario en una app desplegadaTodo el sistemaMinutosAutomatización de QAPlaywright, Cypress, AppiumFlujos rotos entre servicios
RegresiónQue las funciones antiguas siguen funcionando tras un cambioCualquier nivelVariableTodo el equipoLas baterías existentes, ejecutadas de nuevoEfectos secundarios del código nuevo
UATQue el producto cumple las necesidades del negocioTodo el sistemaDíasUsuarios de negocioGuiones de prueba, stagingRequisitos 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.

Pirámide de piedras: muchas pruebas unitarias rápidas en la base y pocas pruebas de extremo a extremo en la cima

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.

Un único componente aislado en un banco de pruebas, como una unidad bajo prueba con sus dependencias sustituidas
DobleQué haceCuándo usarloEjemplo
DummyRellena un parámetro pero nunca se usaUna firma necesita un argumento que a la prueba no le importaUn objeto logger vacío
StubDevuelve respuestas fijas y predefinidasNecesita que la dependencia devuelva un valor concretoUn cliente de tipos de cambio que siempre devuelve 1.10
FakeUna implementación funcional pero simplificadaNecesita un comportamiento realista sin el sistema realUn repositorio en memoria en lugar de PostgreSQL
SpyRegistra cómo se le ha llamadoNecesita comprobar a posteriori que se produjo una llamadaUn remitente de correo que guarda los mensajes enviados
MockProgramado de antemano con expectativas que después verificaLa propia interacción es el comportamiento que se pruebaUna 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.

PrincipioSignificadoSíntoma cuando se incumple
Fast (rápida)Se ejecuta en milisegundos, de modo que toda la batería corre con cada cambioLos desarrolladores se saltan las pruebas en local porque «tardan demasiado»
Independent (independiente)No depende de otras pruebas ni de su ordenLas pruebas pasan por separado, pero fallan al ejecutarse juntas
Repeatable (repetible)Da el mismo resultado en cualquier máquina y en cualquier momentoFallos los lunes, a medianoche o solo en la CI
Self-validating (autovalidable)Indica si pasa o falla sin interpretación humanaAlguien tiene que leer la salida del log para decidir
Timely (oportuna)Se escribe junto con el código, no meses despuésGrandes 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 coberturaQué mideNotas
Línea / sentenciaProporción de líneas o sentencias ejecutadasLa más fácil de obtener; puede parecer alta aunque falten ramas enteras
RamaProporción de resultados de if/else y switch recorridosMejor indicador para el código con mucha lógica
CondiciónSi cada subcondición booleana ha sido verdadera y falsaDetecta condiciones complejas que la cobertura de ramas pasa por alto
MC/DCQue cada condición afecta de forma independiente a la decisiónObligatoria para el software de aviónica más crítico
Puntuación de mutaciónProporción de bugs inyectados que detectan las pruebasMuestra 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.

IdiomaFrameworkBiblioteca de mocksNotas
Java / KotlinJUnit 5Mockito, MockK (Kotlin)Estándar de facto en la JVM; AssertJ para aserciones legibles
Pythonpytest, unittestunittest.mock y pytest-mockpytest domina en los proyectos nuevos; unittest viene incluido con Python
JavaScript / TypeScriptJest, VitestMocks integradosVitest es popular en los frontends basados en Vite; mismo estilo de API que Jest
C# / .NETxUnit.net, NUnit, MSTestMoq, NSubstitutexUnit.net es la opción habitual para el código .NET nuevo
Gotesting integradotestify, gomockLas pruebas basadas en tablas son la forma idiomática en Go
SwiftXCTest, Swift TestingFakes basados en protocolosSwift Testing es el framework más reciente de Apple, basado en macros
C / C++GoogleTest, Catch2GoogleMockHabitual en código embebido y en código crítico para el rendimiento
PHPPHPUnit, PestMockery, mocks integradosPest añade una sintaxis más ligera sobre PHPUnit
RubyRSpec, Minitestrspec-mocksMinitest 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.

VentajasLimitaciones
Detectan los defectos en el momento en que se introducenNo detectan problemas de integración, de configuración ni de interfaz de usuario
Hacen que la refactorización y las actualizaciones sean segurasRequieren un mantenimiento continuo a medida que cambia el código
Documentan el comportamiento en forma ejecutableLas aserciones superficiales dan una falsa sensación de seguridad
Aceleran la depuración al señalar la unidad que fallaLas pruebas con exceso de mocks se rompen con refactorizaciones inofensivas
Empujan el código hacia un diseño modular y poco acopladoEl 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 CINo 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.

  1. ¿Se ejecutan las pruebas unitarias automáticamente en cada pull request y un fallo bloquea el merge?
  2. ¿Cuál es la cobertura del código modificado en los pull requests recientes, y no solo la cifra global del proyecto?
  3. ¿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?
  4. ¿Miden una puntuación de mutación en los módulos críticos y cuál es?
  5. ¿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?
  6. ¿Cuánto tarda en ejecutarse la suite unitaria? El objetivo son minutos, no horas.
  7. ¿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