Cómo verificar un método vacío en JUnit

22 Jul, 2023 Programación 0

Soy bastante nuevo en las pruebas. Como parece que tengo problemas con el mock, decidí pedir ayuda a ustedes. ¿Podrían decirme cómo deberían ser las pruebas para esos métodos, por favor? Esto es lo que tengo hasta ahora:

Clase para la prueba:

public class EnhancedJwtCache extends TimerTask {
    ConcurrentHashMap<string, ejwt=""> cache = new ConcurrentHashMap<>();

    public void init() {
        new Timer().scheduleAtFixedRate(this, TimeUnit.MINUTES.toMillis(1), TimeUnit.MINUTES.toMillis(1));
    }

    @Override
    public void run() {
        log.debug("Comprobando las entradas expiradas en la caché del token mejorado.");

        // Eliminar cualquier eJWT de la caché que haya expirado.
        Iterator<string> iterator = cache.keySet().iterator();

        while (iterator.hasNext()) {
            String key = iterator.next();
            if (cache.get(key).isExpired()) {
                log.debug("Eliminando token vencido de la caché para el usuario {}", cache.get(key).getUsername());
                iterator.remove();
            }
        }
    }
}

Y mi prueba hasta ahora, que me devuelve un error porque no está mockeada:

class EnhancedJwtCacheTest {

    ConcurrentHashMap<string, ejwtauthenticationtoken.ejwt=""> cache;

    @Mock
    EnhancedJwtCache underTest;

    EJwtAuthenticationToken.EJwt ejwt;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void runTest(){
        List<string> roles = Arrays.asList("Roles1");
        ejwt = new EJwtAuthenticationToken.EJwt(
                "encodedJwt",
                Instant.now().plus(10, ChronoUnit.DAYS),
                "nombre",
                "nombreDeUsuario",
                roles
        );

        cache = new ConcurrentHashMap<>();
        cache.put("caché", ejwt);

        verify(underTest,times(1)).run();
    }
}

(Sin traducir el código y la salida en Markdown)</string,></string,>

davy.ai

July 22, 2023 at 11:13 pm

Para probar correctamente la clase EnhancedJwtCache, debes utilizar el mocking para aislar la clase de sus dependencias y probar su comportamiento de forma aislada. Aquí tienes un ejemplo de cómo escribir pruebas para los métodos init y run utilizando Mockito:

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

import static org.mockito.Mockito.*;

class EnhancedJwtCacheTest {

    ConcurrentHashMap<string, ejwtauthenticationtoken.ejwt=""> cache;

    @Mock
    Timer timer;

    EnhancedJwtCache underTest;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        underTest = new EnhancedJwtCache(cache, timer);
    }

    @Test
    void initTest() {
        underTest.init();
        verify(timer, times(1)).scheduleAtFixedRate(underTest, TimeUnit.MINUTES.toMillis(1), TimeUnit.MINUTES.toMillis(1));
    }

    @Test
    void runTest() {
        List<string> roles = Arrays.asList("Roles1");
        EJwtAuthenticationToken.EJwt ejwt = new EJwtAuthenticationToken.EJwt(
                "encodedJwt",
                Instant.now().plus(10, ChronoUnit.DAYS),
                "name",
                "username",
                roles
        );

        cache = new ConcurrentHashMap<>();
        String cacheKey = "cache";
        cache.put(cacheKey, ejwt);

        Iterator<string> iterator = mock(Iterator.class);
        when(cache.keySet().iterator()).thenReturn(iterator);
        when(iterator.hasNext()).thenReturn(true, false);
        when(iterator.next()).thenReturn(cacheKey);
        when(cache.get(cacheKey)).thenReturn(ejwt);
        when(ejwt.isExpired()).thenReturn(true);

        underTest.run();

        verify(cache, times(1)).remove(cacheKey);
        verify(ejwt, times(1)).getUsername();
    }
}

En este ejemplo, estamos utilizando Mockito para crear un objeto simulado (Mock) de Timer, e inyectarlo como una dependencia de EnhancedJwtCache. Luego, en la prueba init, verificamos que se llame al método scheduleAtFixedRate en el objeto simulado de Timer con los parámetros esperados.

En la prueba run, configuramos un iterador simulado (Iterator) para recorrer las claves del cache, y devolvemos objetos simulados (Mock) de EJwt para cada clave. También configuramos el método isExpired para que devuelva true en el objeto simulado de EJwt. Luego, llamamos al método run en EnhancedJwtCache, y verificamos que el objeto EJwt vencido se elimine del cache, y que se llame al método getUsername en el objeto vencido.</string,>

es.davy.ai

¿Tienes una pregunta?

Cómo verificar un método vacío en JUnit

Answer

davy.ai