Simulando "tiempo más rápido" en Linux

Question

Tengo una aplicación Java que se ejecuta en Linux que tiene muchos eventos y lógica de negocios que giran en torno a horas y fechas.

Para las pruebas, es posible modificar algo en el tiempo y hacerlo más rápido. Digamos, ¿hacer un fin de año completo en una hora de pared?

Answer 1

Puede escribir una interfaz de contenedor para sus llamadas de fecha/hora. Tenga una implementación real que haga llamadas reales al sistema, y ​​una implementación de prueba que pueda hacer lo que quiera (ejecutar más rápido, más lento, fechas falsas, etc.).

Answer 2

Si se trata de llamadas al sistema para obtener la hora del sistema (es decir, System.currentTimeMillis()), es de suponer que puede acelerar el tiempo cambiando la hora del sistema. Esto debería reflejar el tiempo que ve en su aplicación.

Si está utilizando otras formas de calcular el tiempo (tiempo transcurrido desde el inicio de JVM (es decir, System.nanoTime()), servidores de hora netos, etc.), entonces la respuesta es que no es posible.

---

No puedo expresar con palabras lo que estoy explicando cómo hacer lo que se le pide, y esto es bueno sólo para las pruebas de integración, si se toma en consideraciones de cualquier otra cosa que está afectando en dicha máquina.

Esto no debe reemplazar a las pruebas unitarias adecuadas y exhaustivas.

Answer 3

Tiene que diseñar su sistema para que pueda "reprogramar" el reloj durante la prueba. Para algunas clases de sistema, hay una cola de eventos, que almacena eventos programados en orden de tiempo. En cualquier punto de la simulación, el próximo evento es el primer elemento en la cola; puede sacarlo de la cola y ajustar el tiempo efectivo para que coincida con la hora en que ocurre ese evento. A medida que se programan nuevos eventos, se agregan a la cola. Por lo tanto, puede procesar los eventos tan rápido como lo permita el sistema, en lugar de tener que esperar a que transcurra el tiempo real. Pero tienes que diseñar tu sistema para permitir que ese mecanismo funcione.

Answer 4

Un enfoque que funciona mejor para las pruebas unitarias es abstraer la forma en que se accede a la hora actual en su código.

En lugar de llamar a System.currentTimeMillis() directamente, puede proporcionar su propia implementación.

Algo como esto (pseudo-código):

class MyTime { 
    private static TimeInterface CurrentTimeInterface = new DefaultTimeImpl(); 

    public setTimeInterface(TimeInterface timeInterface) { 
     CurrentTimeInterface = timeInterface; 
    } 

    public int getTime() { CurrentTimeInterface.getTime(); } 

} 

class DefaultTimeImpl implements TimeInterface { 
    public int getTime() { return System.currentTimeMillis(); } 
} 

class TestTimeImpl implements TimeInterface { 
    private int CurrentTimeMillis = 0; 
    public int getTime() { return CurrentTimeMillis; } 
    public void setTime(int timeMillis) { CurrentTimeMillis = timeMillis} 
    public void sleep(int millis) { CurrentTimeMillis += millis; } 
} 

Entonces, en todas partes se habría llamado System.getTimeMillis() en lugar llamar MyTime.getTime(). Cuando estás probando tu código, simplemente crea TestTimeImpl y llama a MyTime.setTimeInterface (testTimeImpl). Luego, cuando desee tiempo para avanzar, llame a testTimeImpl.sleep() o testTimeImpl.setTime().

Esto le permite simular cualquier momento hasta el milisegundo.