Como posso fazer um teste JUnit esperar?

Eu tenho um teste JUnit que quero esperar por um período de tempo, de forma síncrona. Meu teste JUnit se parece com isto:

@Test
public void testExipres(){
    SomeCacheObject sco = new SomeCacheObject();
    sco.putWithExipration("foo", 1000);
    //WAIT FOR 2 SECONDS
    assertNull(sco.getIfNotExipred("foo"));
}

Eu tentei Thread.currentThread (). Wait (), mas ele lança uma IllegalMonitorStateException (conforme o esperado). Existe algum truque para isso ou eu preciso de um monitor diferente?

Que tal Thread.sleep(2000);? :)

Thread.sleep () pode funcionar na maioria dos casos, mas geralmente se você estiver esperando, está na verdade esperando que uma condição ou estado específico ocorra. Thread.sleep () não garante que tudo o que você está esperando realmente aconteceu.

Se você está esperando por uma solicitação de descanso, por exemplo, talvez ele retorne em 5 segundos, mas se você definir seu sono para 5 segundos no dia em que sua solicitação voltar em 10 segundos, seu teste irá falhar.

Para remediar isso, JayWay tem um ótimo utilitário chamado Awatility, que é perfeito para garantir que uma condição específica ocorra antes de você seguir em frente.

Tem uma boa API fluente também

await().until(() -> 
{
    return yourConditionIsMet();
});  

https://github.com/jayway/awaitility

No caso do seu analisador de código estático (como SonarQube) reclamar, mas você não conseguir pensar em outra maneira, ao invés de dormir, você pode tentar um hack como: Awaitility.await().pollDelay(Durations.ONE_SECOND).until(() -> true); É conceitualmente incorreto, mas é o mesmo que Thread.sleep(1000).

A melhor maneira, claro, é passar um Callable, com sua condição apropriada, ao invés do trueque eu tenho.

https://github.com/awaitility/awaitility

Você pode usar a biblioteca java.util.concurrent.TimeUnit que usa Thread.sleep internamente. A sintaxe deve ser semelhante a esta:

@Test
public void testExipres(){
    SomeCacheObject sco = new SomeCacheObject();
    sco.putWithExipration("foo", 1000);

    TimeUnit.MINUTES.sleep(2);

    assertNull(sco.getIfNotExipred("foo"));
}

Esta biblioteca fornece uma interpretação mais clara para a unidade de tempo. Você pode usar 'HOURS' / 'MINUTES' / 'SECONDS'.

Você também pode usar o CountDownLatch objeto conforme explicado aqui .

Há um problema geral: é difícil zombar do tempo. Além disso, é uma prática muito ruim colocar código de longa execução / espera em um teste de unidade.

Portanto, para tornar uma API de agendamento testável, usei uma interface com uma implementação real e uma simulação como esta:

public interface Clock {

    public long getCurrentMillis();

    public void sleep(long millis) throws InterruptedException;

}

public static class SystemClock implements Clock {

    @Override
    public long getCurrentMillis() {
        return System.currentTimeMillis();
    }

    @Override
    public void sleep(long millis) throws InterruptedException {
        Thread.sleep(millis);
    }

}

public static class MockClock implements Clock {

    private final AtomicLong currentTime = new AtomicLong(0);


    public MockClock() {
        this(System.currentTimeMillis());
    }

    public MockClock(long currentTime) {
        this.currentTime.set(currentTime);
    }


    @Override
    public long getCurrentMillis() {
        return currentTime.addAndGet(5);
    }

    @Override
    public void sleep(long millis) {
        currentTime.addAndGet(millis);
    }

}

Com isso, você pode imitar o tempo em seu teste:

@Test
public void testExipres() {
    MockClock clock = new MockClock();
    SomeCacheObject sco = new SomeCacheObject();
    sco.putWithExipration("foo", 1000);
    clock.sleep(2000) // WAIT FOR 2 SECONDS
    assertNull(sco.getIfNotExpired("foo"));
}

Um mock avançado multi-threading para Clocké muito mais complexo, é claro, mas você pode fazer isso com ThreadLocalreferências e uma boa estratégia de sincronização de tempo, por exemplo.