Configuración de un entorno de prueba en JUnit

3.1 Anotaciones @BeforeEach, @AfterEach

Tenga en cuenta que en el ejemplo anterior, en cada método teníamos que escribir código para crear un objetocalculadora.

Por supuesto, esto es solo una línea, pero si probamos sistemas reales, a menudo tendremos una situación en la que necesitamos crear y configurar varios objetos, lo que puede tomar varias docenas de líneas de código. Ejemplo:

//Crear un objeto HttpClient
   HttpClient client = HttpClient.newBuilder()
    	.version(Version.HTTP_1_1)
    	.followRedirects(Redirect.NORMAL)
        .connectTimeout(Duration.ofSeconds(20))
    	.proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))
        .authenticator(Authenticator.getDefault())
    	.build();

   //Crear un objeto HttpRequest
  HttpRequest request = HttpRequest.newBuilder()
     .uri(new URI("https://codegym.cc"))
     .headers("Content-Type", " application/octet-stream")
     .POST( HttpRequest.BodyPublishers. ofInputStream ( () -> is; ))
     .build();

   //Llamar al método enviar()
   HttpResponse response = client.send(request, BodyHandlers.ofString());
   System.out.println(response.statusCode());
   System.out.println(response.body());

En el ejemplo anterior, hemos creado y configurado un objetoCliente Httpy quiere probar el método send() .

Para que cada vez en el método de prueba no escriba la creación de un objetoCliente Http, se puede mover a un método separado y recibir una anotación @BeforeEach especial . Entonces Junit llamará a este método antes de cada método de prueba. Ejemplo:

class HttpClientTest {
     	public HttpClient client;

   	@BeforeEach
    	public void init(){
   	   client = HttpClient.newBuilder()
   	        .version(Version.HTTP_1_1)
   	        .followRedirects(Redirect.NORMAL)
   	        .connectTimeout(Duration.ofSeconds(20))
   	        .proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))
   	        .authenticator(Authenticator.getDefault())
   	        .build();
    	}

   	@Test
    	public void send200() throws Exception {
     	   //Crear un objeto HttpRequest()
         	HttpRequest request = HttpRequest.newBuilder(new URI("https://codegym.cc")).build();

     	   //Llamar al método enviar()
     	   HttpResponse response = client.send(request, BodyHandlers.ofString());
        	assertEquals(200, response.statusCode());
        }

   	@Test
    	public void send404() throws Exception {
     	   //Crear un objeto HttpRequest()
         	HttpRequest request = HttpRequest.newBuilder(new URI("https://codegym.cc/unknown")).build();

     	   //Llamar al método enviar()
     	   HttpResponse response = client.send(request, BodyHandlers.ofString());
        	assertEquals(404, response.statusCode());
    	}
}

También puede crear un método especial que se llamará cada vez después del siguiente método de prueba y limpiar los recursos usados , escribir algo en el registro, etc. Dicho método debe marcarse con la anotación @AfterEach .

Si tiene 3 métodos de prueba test1() , test2() y test3() , entonces el orden de llamada será:

• antes de cada método
• prueba1()
• Después de cada método
• antes de cada método
• prueba2()
• Después de cada método
• antes de cada método
• prueba3()
• Después de cada método

3.2 Anotaciones @BeforeAll, @AfterAll

JUnit también le permite agregar un método que se llamará una vez antes de todos los métodos de prueba . Dicho método debe anotarse con @BeforeAll . También tiene una anotación @AfterAll emparejada . JUnit llamará al método marcado con él después de todos los métodos de prueba.

Escribamos un ejemplo especial que le permita comprender mejor cómo funciona todo. Tomemos la prueba de nuestra calculadora como base:

class CalculatorTest {
    private Calculator calc = new Calculator();

    @BeforeAll
    public static void init(){
        System.out.println("BeforeAll init() method called");
    }

    @BeforeEach
    public void initEach(){
        System.out.println("BeforeEach initEach() method called");
    }

    @Test
    public void add(){
        System.out.println("Testing Addition");
    }

    @Test
    public void sub() {
        System.out.println("Testing Subtraction");
    }

    @Test
    public void mul(){
        System.out.println("Testing Multiplication");
    }

    @Test
    public void div() {
        System.out.println("Testing Division");
    }
}

Esta prueba imprimirá el siguiente texto en la consola:

BeforeAll init() method called
BeforeEach initEach() method called
Testing Addition
 
BeforeEach initEach() method called
Testing Subtraction
 
BeforeEach initEach() method called
Testing Multiplication
 
BeforeEach initEach() method called
Testing Division