El propósito de una prueba unitaria es identificar los errores en una aplicación tan pronto como sea posible. Aunque varios canales pueden llevarlo al mismo objetivo, debe intentar utilizar la ruta más eficiente.
Un conjunto de pruebas JUnit puede tener varias clases de prueba que necesitan los mismos datos, pero no puede reutilizar los datos de prueba. En versiones anteriores de JUnit, un buen enfoque era crear un método de utilidad y luego llamar a ese método cada vez que una clase de prueba necesitaba sus datos.
JUnit 5 proporciona un enfoque más eficiente para este problema: inyección de dependencia (DI).
¿Qué es la inyección de dependencia?
DI es un patrón de diseño en el que un objeto proporciona las dependencias de otro objeto. Cuando está creando una aplicación Java, es posible que tenga una clase que dependa de un objeto creado por otra clase para realizar su función.
Antes de la inyección de dependencia, para usar un objeto de una clase diferente, tendría que crear una nueva instancia de ese objeto dentro de la clase que depende de él. Entonces, si tuviera varias clases que dependieran del mismo objeto, tendría que crear varias instancias dentro de las clases dependientes.
DI le permite usar un objeto en una clase dependiente, sin crear una nueva instancia del mismo en esa clase.
Inyección de dependencia en JUnit 5
JUnit 5 le permite inyectar dependencias tanto en métodos de prueba como en constructores. Esto es importante ya que las versiones anteriores del marco no permitían que los métodos de prueba o los constructores tuvieran parámetros.
JUnit 5 le permite inyectar tantos parámetros como desee. El único inconveniente es que la API de ParameterResolver debe poder resolver cada parámetro en tiempo de ejecución. JUnit actualmente tiene tres solucionadores de parámetros incorporados que usa automáticamente. Para usar cualquier otro solucionador, deberá registrarlo explícitamente mediante la anotación @ExtendWith.
Inyectando Dependencias en JUnit
Este programa de muestra utiliza uno de los parámetros incorporados de JUnit (el TestInfoParameterResolver) para demostrar cómo puede inyectar una dependencia en un Prueba JUnit 5. TestInfoParameterResolver resuelve objetos que pertenecen a la interfaz TestInfo. Entonces, JUnit 5 proporcionará una instancia de la interfaz TestInfo a cualquier método o constructor que la use.
importarestático org.junit.jupiter.api. Afirmaciones.*;
importar org.junit.jupiter.api. Nombre para mostrar;
importar org.junit.jupiter.api. Prueba;
importar org.junit.jupiter.api. Información de prueba;claseInfoTestInterfaceTest{
// Inyectar un objeto testInfo en el constructor InfoTestInterfaceTest
InfoTestInterfaceTest (TestInfo testInfo) {
afirmarEquals("InfoTestInterfaceTest", testInfo.getDisplayName());
}// Inyectar un objeto testInfo en los métodos
@Prueba
vacíotestMethodName(Información de prueba Información de prueba){
afirmarEquals("testMethodName (TestInfo)", testInfo.getDisplayName());
}
@Prueba
@Nombre para mostrar("método que usa el @Nombre para mostrar anotación")
vacíopruebaMétodoNombreDos(Información de prueba Información de prueba){
afirmarEquals("método que usa el @Nombre para mostrar anotación", testInfo.getDisplayName());
}
}
La prueba JUnit anterior demuestra cómo inyectar un objeto en un constructor y dos métodos. El Información de prueba JUnit La interfaz tiene cuatro métodos que puede usar con su objeto.
El método getDisplayName() es el más útil. Devuelve el nombre para mostrar del método de prueba o constructor actual. De forma predeterminada, este nombre se basa en la clase. pero si usas la anotación @DisplayName, el método getDisplayName() devolverá ese texto en su lugar.
La clase de prueba anterior genera el siguiente informe de prueba:
Use DI en los métodos @Before y @After
Hay otros cuatro tipos de métodos anotados de JUnit que admiten dependencias. Estas son las anotaciones @BeforeAll, @BeforeEach, @AfterAll y @AfterEach. Al igual que el método @Test, todo lo que necesita hacer es pasar un objeto a cualquiera de los métodos anteriores o posteriores como parámetro, y listo.
Las anotaciones @Before y @After son importantes, ya que también lo ayudan a desarrollar un código de prueba más eficiente. Tener la capacidad de inyectar también dependencias en estos métodos mejorará aún más su código de prueba.
