Come posso far aspettare un test JUnit?

Ho un test JUnit che voglio aspettare per un periodo di tempo, in modo sincrono. Il mio test JUnit ha questo aspetto:

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

Ho provato Thread.currentThread (). Wait (), ma genera un'eccezione IllegalMonitorStateException (come previsto). C'è qualche trucco o ho bisogno di un monitor diverso?

Che ne dici Thread.sleep(2000);? :)

Thread.sleep () potrebbe funzionare nella maggior parte dei casi, ma di solito se stai aspettando, in realtà stai aspettando che si verifichi una particolare condizione o stato. Thread.sleep () non garantisce che tutto ciò che stai aspettando sia effettivamente accaduto.

Ad esempio, se stai aspettando una richiesta di riposo, di solito questa ritorna in 5 secondi, ma se imposti il ​​sonno per 5 secondi il giorno in cui la tua richiesta torna tra 10 secondi, il test fallirà.

Per rimediare a questo JayWay ha una grande utilità chiamata Awatility, perfetta per garantire che si verifichi una condizione specifica prima di andare avanti.

Ha anche una bella api fluente

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

https://github.com/jayway/awaitility

Nel caso in cui il tuo analizzatore di codice statico (come SonarQube) si lamenta, ma non riesci a pensare a un altro modo, piuttosto che dormire, puoi provare con un hack come: Awaitility.await().pollDelay(Durations.ONE_SECOND).until(() -> true); è concettualmente errato, ma è lo stesso di Thread.sleep(1000).

Il modo migliore, ovviamente, è passare un Callable, con la tua condizione appropriata, piuttosto che quello trueche ho.

https://github.com/awaitility/awaitility

È possibile utilizzare la libreria java.util.concurrent.TimeUnit che utilizza internamente Thread.sleep. La sintassi dovrebbe essere simile a questa:

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

    TimeUnit.MINUTES.sleep(2);

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

Questa libreria fornisce un'interpretazione più chiara per l'unità di tempo. Puoi utilizzare "HOURS" / "MINUTES" / "SECONDS".

Puoi anche usare l' CountDownLatchoggetto come spiegato qui .

C'è un problema generale: è difficile prendere in giro il tempo. Inoltre, è davvero una cattiva pratica inserire codice a lunga esecuzione / attesa in uno unit test.

Quindi, per rendere testabile un'API di pianificazione, ho utilizzato un'interfaccia con un'implementazione reale e simulata come questa:

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);
    }

}

Con questo, potresti imitare il tempo nel tuo test:

@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"));
}

Un mocking multi-threading avanzato per Clockè molto più complesso, ovviamente, ma puoi farlo con ThreadLocalriferimenti e una buona strategia di sincronizzazione temporale, ad esempio.