Tutorial de JUnit: Configuración, escritura y ejecución de pruebas unitarias de Java

Comprenda los conceptos básicos y amplíe su práctica de pruebas unitarias como un profesional con este tutorial.

¿Quieres saltarte los conceptos básicos y ver cómo automatizar generación de pruebas unitarias mejorada con IA pasar de 0 a 60%+ de cobertura de código en <5 minutos? Echa un vistazo a Jtest >>

Puntos Clave

• JUnit es el estándar de pruebas de facto de Java. JUnit es el marco más utilizado para escribir y ejecutar pruebas unitarias automatizadas, detectando errores en las primeras etapas del desarrollo.
• El marco JUnit es maduro y está en continua evolución. JUnit continúa evolucionando para satisfacer las necesidades de los desarrolladores de Java y contiene muchas características que respaldan todas las facetas de una práctica de pruebas unitarias sólida.
• La instalación es sencilla. JUnit está preconfigurado en IDE populares como Eclipse e IntelliJ, mientras que los sistemas de compilación como Maven y Gradle pueden configurarse para usar JUnit usando unas pocas líneas de configuración, independientemente de la versión utilizada.
• Las pruebas JUnit siguen un patrón estructurado. El marco JUnit proporciona una API simple para la definición de pruebas, mientras que el formato Dado-Cuando-Entonces proporciona una organización útil para el código de prueba.
• Las pruebas JUnit se pueden ejecutar en cualquier lugar. Las pruebas se pueden ejecutar directamente en el IDE para obtener comentarios rápidos durante el desarrollo o mediante comandos Maven o Gradle, canalizaciones CI/CD y la línea de comandos para ejecución automatizada.
• Los marcos de simulación se pueden integrar fácilmente. Cuando el código bajo prueba depende de sistemas externos u objetos complejos, se pueden usar marcos de simulación como Mockito para aislar el código simulando dependencias, lo que permite realizar pruebas unitarias enfocadas y confiables sin efectos secundarios.
• La IA acelera las pruebas JUnit a escala. Parasoft Jtest genera automáticamente casos de prueba, simulacros y afirmaciones directamente en el IDE o en los flujos de trabajo de solicitudes de extracción, lo que ayuda a los equipos a lograr una cobertura de código significativa al tiempo que reduce el esfuerzo de creación y mantenimiento de pruebas en más del 50 %.

¿Qué son las pruebas JUnit?

JUnit es el marco de pruebas unitarias de Java más popular. Un marco de código abierto, se utiliza para escribir y ejecutar pruebas automatizadas repetibles.

JUnit se consolidó como el estándar de facto para las pruebas unitarias de Java gracias a una combinación de funciones potentes y bien diseñadas que funcionan a la perfección. Fue el primer framework de pruebas unitarias desarrollado y se ha mantenido como la opción preferida por los desarrolladores de Java de todo el mundo gracias a sus características distintivas y su continua evolución.

¿Cuáles son las características clave de JUnit y las principales diferencias entre versiones?

Como ocurre con cualquier otra cosa, el marco de pruebas JUnit ha evolucionado con el tiempo.

JUnit 4.0 se lanzó en 2006, 5.0 se lanzó en 2017 y 6.0 se lanzó en septiembre de 2025.

A partir de febrero de 2026, la última versión es 6.0.2.

• JUnit 5.x migró a una arquitectura modular y abordó muchas de las limitaciones anteriores de JUnit.
• JUnit 6.x es una iteración más suave que mantiene el enfoque de JUnit 5, pero ha modernizado y simplificado aún más el marco.
• JUnit 4 y 5 Ambos todavía disfrutan de altas tasas de uso, pero el futuro probablemente pertenece a JUnit 6.

A continuación se muestran algunos de los aspectos y características clave de JUnit junto con las diferencias entre versiones:

Trabajando juntos para realizar pruebas integrales

Estas características se combinan sinérgicamente para crear un marco completo y extensible que respalda las prácticas profesionales de desarrollo de software.

• Pruebe el aislamiento y la consistencia. Los métodos de instalación y desmontaje garantizan que cada prueba comience en un estado predefinido deseado.
• Flexibilidad organizacional. Los conjuntos de pruebas, las pruebas anidadas y el etiquetado permiten organizar y ejecutar las pruebas adecuadas en el momento adecuado.
• Expresión de prueba clara. La API principal proporciona las herramientas necesarias para escribir pruebas comprensibles y fáciles de mantener.
• Escalabilidad Funciona para desarrolladores individuales que escriben unas pocas pruebas y para equipos empresariales que mantienen miles de pruebas en múltiples módulos.

Cómo configurar las pruebas de JUnit

Así que vamos a sumergirnos en el tema. Estos son los pasos para configurar JUnit.

Los IDE más comunes, como Eclipse e IntelliJ, ya tendrán la integración de pruebas JUnit instalada de forma predeterminada.

Si no está utilizando un IDE y quizás confía únicamente en un sistema de compilación como Maven o Gradle, la configuración de JUnit se maneja a través del archivo pom.xml o build.gradle, respectivamente.

Es importante tener en cuenta que Unidad 5 se dividió en tres módulos, uno de los cuales es un módulo vintage que admite la ejecución de Unidad 4 y tres pruebas de Unidad 5.

Unidad 6 Mantiene esta arquitectura.

Unidad 3 El uso es muy bajo en este momento y generalmente solo se ve en proyectos mucho más antiguos.

Cómo configurar JUnit 6

Debido al diseño modular de JUnit 6, se utiliza una Lista de Materiales (POM) para importar todos los módulos y dependencias de JUnit. Si solo se necesitan módulos específicos, se pueden especificar grupos o artefactos individuales.

Para agregar JUnit 6 a Maven, agregue lo siguiente a pom.xml:

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.junit</groupId>
			<artifactId>junit-bom</artifactId>
			<version>6.0.2</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
<dependencies>
	<dependency>
		<groupId>org.junit</groupId>
		<artifactId>junit-bom</artifactId>
		<version>6.0.2</version>
		<scope>test</scope>
	</dependency>
</dependencies>

Para Gradle, agregue lo siguiente al archivo build.gradle:

dependencies {
	testImplementation platform("org.junit:junit-bom:6.0.2")
	testImplementation "org.junit.jupiter:junit-jupiter-api"
	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
	testRuntimeOnly "org.junit.platform:junit-platform-launcher"
}
test {
	useJUnitPlatform()
}

Cómo configurar JUnit 5

Debido al diseño modular de JUnit 5, se utiliza una Lista de Materiales (POM) para importar todos los módulos y dependencias de JUnit. Si solo se necesitan módulos específicos, se pueden especificar grupos o artefactos individuales.

JUnit 5 se configura de la misma manera que JUnit 6:

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.junit</groupId>
			<artifactId>junit-bom</artifactId>
			<version>5.14.2</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
<dependencies>
	<dependency>
		<groupId>org.junit</groupId>
		<artifactId>junit-bom</artifactId>
		<version>5.14.2</version>
		<scope>test</scope>
	</dependency>
</dependencies>

Para Gradle, agregue lo siguiente al archivo build.gradle:

dependencies {
	testImplementation platform("org.junit:junit-bom:5.14.2")
	testImplementation "org.junit.jupiter:junit-jupiter-api"
	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
	testRuntimeOnly "org.junit.platform:junit-platform-launcher"
}
test {
	useJUnitPlatform()
}

Cómo configurar JUnit 4

Para agregar JUnit 4 a Maven, agregue lo siguiente a pom.xml.

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.13.2</version>
	<scope>test</scope>
</dependency>

Para Gradle, agregue lo siguiente a build.gradle:

dependencies {
	testImplementation 'junit:junit:4.13.2'
}
test {
	useJUnit()
}

Si necesita agregar JUnit manualmente a la ruta de clases para realizar pruebas, debe referenciar directamente los archivos jar sin procesar, aunque esto no suele ser necesario. JUnit 4, 5 y 6 tienen el archivo jar disponible para descargar directamente. Para JUnit 5 y 6, deberá descargar un archivo jar completo (también conocido como uberjar) como se describe. aquí.

¿Cuáles son los componentes de una prueba JUnit?

Ahora que hemos hablado un poco sobre la configuración de JUnit, pasemos a la construcción y ejecución de estas pruebas. Para ilustrar mejor la creación de JUnits, comenzaremos con algo básico. En el siguiente ejemplo de prueba JUnit, tenemos un método simple (izquierda) que convierte Fahrenheit a Celsius y una prueba JUnit (derecha) escrito para probar nuestro método. He numerado las partes clave de la prueba JUnit y discutiré cada parte en detalle a continuación.

 

Importaciones y dependencias en JUnit

Las partes 1 y 2 de la captura de pantalla anterior son importaciones para las clases y métodos de JUnit utilizados en la prueba unitaria. Las importaciones pueden especificarse como clases o métodos individuales, pero normalmente se especifican como paquetes completos mediante asteriscos. Cualquiera de las dos opciones funciona; el nivel de granularidad de las importaciones es una cuestión de preferencia.

Cómo definir una clase de prueba JUnit

La parte 3 define el inicio de nuestra clase de prueba. Es importante tener en cuenta la convención de nomenclatura utilizada para la clase, que es Prueba de nombre de clase. Esta convención de nomenclatura no es necesaria, pero es la forma más común de nombrar las clases JUnit porque el nombre describe de manera sucinta el propósito de la clase de prueba unitaria y qué clase está probando.

Anotaciones de JUnit y cómo se utilizan

En la Parte 4, vemos nuestra primera sintaxis específica de JUnit: la anotación @Test. Las anotaciones son fundamentales al crear JUnits. Así es como el framework JUnit identifica las partes importantes de la prueba unitaria. En nuestro ejemplo, la anotación @Test indica a JUnit que el método público void al que está asociada puede ejecutarse como caso de prueba.

Hay muchas otras anotaciones, pero algunas de las más comunes para JUnit 5 y 6 son las siguientes.

• @BeforeEach identifica un método que debe ejecutarse antes de cada método de prueba de la clase. Se suele usar para actualizar o restablecer el estado necesario para que los métodos de prueba se ejecuten correctamente.
• @AfterEach identifica un método que debe ejecutarse después de cada método de prueba en la clase. Puede usarse para restablecer variables, eliminar archivos temporales, etc.
• @Disabled especifica que no se debe ejecutar un método de prueba.
• @BeforeAll identifica un método que debe ejecutarse una vez antes de ejecutar cualquier método de prueba.
• @AfterAll identifica un método que debe ejecutarse una vez que se hayan ejecutado todos los métodos de prueba.

Nomenclatura de métodos de prueba en JUnit

Para la Parte 5, nuevamente, tenga en cuenta la convención de nomenclatura. nombre del método de prueba, donde nombreMétodo Es el nombre del método que se está probando en la clase bajo prueba. Esta convención de nomenclatura es común, pero no obligatoria. A veces se añade una descripción adicional al nombre para describir el comportamiento específico que verifica la prueba.

La sección "Dado" y cómo configurar una prueba

En la Parte 6, el Dado que los sección de la prueba, construimos una nueva instancia de la clase bajo prueba y la inicializamos según corresponda. Esto es necesario ya que el método de prueba necesita llamar al método bajo prueba para probarlo. En nuestro ejemplo, no se necesita ninguna otra inicialización más allá de instanciar la clase, pero en muchos casos, es posible que se deba realizar una configuración adicional, como inicializar objetos para pasar al constructor o llamar a métodos que configuran el estado de la clase bajo prueba.

La sección "Cuándo" y cómo invocar el método bajo prueba

En la Parte 7, el Al La sección de la prueba incluye la inicialización de variables que deben pasarse al llamar al método que se está probando y luego llamar al método de prueba (parte 8). Las variables deben recibir valores significativos que hagan que la prueba ejerza las partes del método de prueba que nos interesan. Tenga en cuenta que si una variable es un objeto, se puede crear una instancia o burlarse de ella.

Capturar la salida del método bajo prueba

En la Parte 8, si el método bajo prueba devuelve un valor, éste debe capturarse en una variable para que se pueda afirmar su valor.

La sección "Entonces" y el uso de afirmaciones para verificar los resultados de las pruebas

Las pruebas unitarias solo son valiosas si incluyen aserciones que validen que el método probado devuelve el valor correcto o ajusta el estado de otros objetos según lo esperado. Sin aserciones, como se muestra en la Parte 9, no hay verificación. La prueba es, en el mejor de los casos, una prueba de humo que solo proporciona retroalimentación cuando se lanza una excepción.

Los métodos de aserción de JUnit, incluidos en la clase org.junit.jupiter.api.Assertions en JUnit 5 y 6, y en la clase org.junit.Assert en JUnit 4, se utilizan habitualmente para determinar el estado de aprobación o rechazo de los casos de prueba. El framework JUnit solo informa de las aserciones fallidas. Al igual que con las anotaciones, existen numerosas opciones de aserción.

En nuestro ejemplo JUnit anterior, usamos el método assertEquals (esperado, real, delta). El primer argumento es:

• El gastos esperados, que define el autor de la prueba.
• El salida real, que es el valor de retorno del método que se llama
• El delta, que permite una desviación aceptable entre los valores esperados y reales. Este delta es específico del hecho de que estamos validando el valor de un tipo doble.

Cómo ejecutar un JUnit

¡Elige tu propia aventura! Aquí veremos tres maneras de ejecutar JUnits:

• Directamente desde la línea de comandos
• Desde el IDE (Eclipse e IntelliJ)
• Uso de sistemas de compilación (Maven y Gradle)

Cómo ejecutar un JUnit desde el IDE

eclipsar

Dentro del Explorador de paquetes, busque su prueba JUnit. Haga clic con el botón derecho y seleccione Ejecutar como > Prueba JUnit. Esto ejecutará su prueba e informará los resultados dentro de la vista JUnit Eclipse.

IntelliJ

Ejecutar una prueba en IntelliJ es similar a Eclipse. En la ventana Proyecto, localice su prueba, haga clic con el botón derecho y seleccione Ejecutar 'testName'. Al igual que Eclipse, se abrirá una ventana JUnit con los resultados de la prueba.

Cómo ejecutar una prueba JUnit desde los sistemas de compilación Maven

Maven

Maven ha simplificado la ejecución de pruebas unitarias. Asegúrate de estar en la ubicación correcta en tu consola y de que el archivo pom.xml del proyecto esté configurado correctamente. A continuación, puedes ejecutar lo siguiente para ejecutar tus JUnits.

Para ejecutar todo el conjunto de pruebas:

mvn test

Para ejecutar una(s) prueba(s) única(s)/específica(s):

mvn -D test=TestName test

Cómo ejecutar una prueba JUnit desde el sistema de compilación Gradle

Gradle, al igual que Maven, ha simplificado la ejecución de pruebas.

Para ejecutar todo el conjunto de pruebas:

gradlew test

Para ejecutar una(s) prueba(s) única(s)/específica(s):

gradlew -D test.single=testName test

Nota: Maven y Gradle son sus propias bestias. Lo que se muestra aquí es mínimo para cubrir los conceptos básicos. Consulte su documentación si desea obtener más información.

Cómo ejecutar una prueba JUnit desde la línea de comandos

Para ejecutar un JUnit directamente desde la línea de comandos, necesita algunas cosas:

• JDK en tu camino
• Los archivos jar de JUnit apropiados
• Las clases fuente y de prueba

La forma más sencilla de hacer esto en JUnit 5 y 6 es utilizar el iniciador de consola JUnit de la siguiente manera.

java -jar /path/to/junit-platform-console-standalone-<version>.jar execute -cp /path/to/source/classes -cp /path/to/test/classes <test class name>

Nota: La ejecución de una prueba desde la línea de comandos suele realizarse desde un proceso de CI/CD que se ejecuta en un sistema de compilación como Jenkins o Azure DevOps.

Continuando con las pruebas unitarias

Nuestro ejemplo se ejecutó mediante una prueba unitaria simple, y por supuesto, esto es solo el comienzo de las pruebas unitarias. Los métodos más complejos que requieren prueba pueden llamar a métodos de clases dependientes o conectarse a sistemas externos como una base de datos. En estos casos, puede ser conveniente aislar el código mediante simulaciones.

La simulación ayuda a aislar unidades de código para que nuestras pruebas unitarias puedan centrarse solo en la clase/método específico que se está probando. El marco más común utilizado para burlarse en las pruebas JUnit es Mockito.

Para obtener más información sobre la burla, lea la publicación de mi colega: Cómo automatizar una prueba unitaria de Java, incluidas las burlas y las afirmaciones.

Si las pruebas unitarias son tan importantes, ¿por qué no se realizan de forma sistemática? A pesar de su importancia, no siempre son fáciles de implementar ni de mantener. Requieren un profundo conocimiento de desarrollo y un esfuerzo constante para mantener las suites de pruebas actualizadas. Como resultado, las pruebas unitarias suelen quedar relegadas a un segundo plano, hasta que se producen regresiones.

Pero no tiene por qué ser así.

Acelere las pruebas JUnit con IA

Aquí es donde Parasoft jprueba Su Asistente de Pruebas Unitarias, impulsado por IA, fue diseñado para eliminar la fricción al escribir y mantener pruebas unitarias. Con solo unos clics, los equipos que comienzan con 0% cobertura de código Puede generar automáticamente conjuntos de pruebas robustos que cubran el 60 % o más de su código Java. Como uno empresa de servicios financieros señaló: "Desde que implementamos Parasoft Jtest, hemos reducido con éxito la cantidad de tiempo que lleva crear y mantener pruebas unitarias en más del 50%".

A continuación le mostramos cómo su equipo puede escalar su práctica de pruebas.

• Generar automáticamente casos de prueba JUnit para código previamente descubierto mediante la creación inteligente de pruebas masivas.
• Creación de pruebas de destino para código modificado directamente en el IDE o dentro de los flujos de trabajo de solicitud de extracción.
• Mantenga sus datos seguros con la IA patentada de Parasoft, que puede ejecutarse localmente, ningún código ni dato abandona su entorno.
• Generar simulacros y stubs para aislar dependencias y enfocar sus pruebas, ahorrando tiempo y eliminando la necesidad de escribir lógica de simulación manualmente.
• Personalizar y ampliar pruebas con acciones de un solo clic para agregar afirmaciones, parametrizar casos de prueba y mejorar la capacidad de mantenimiento.
• Acelerar la ejecución de pruebas usando incorporado análisis de impacto de prueba y Pruebas unitarias en vivo, que identifica y ejecuta solo las pruebas necesarias para validar los cambios recientes en el código.

Si escribir y mantener pruebas JUnit le ha parecido una tarea ardua, es hora de modernizar su enfoque. Soluciones de pruebas optimizadas con IA como esta pueden convertir la creación de pruebas en una ventaja estratégica, permitiéndole dedicar más tiempo a desarrollar software de calidad.