From 8851efddc04ca76e425ddbc3fde30d9bf51fa2d0 Mon Sep 17 00:00:00 2001
From: tligui_y <yasmine.tligui@psi.ch>
Date: Tue, 5 Aug 2025 02:03:50 +0200
Subject: [PATCH] Update tests/test_utils_run_later.py

---
 tests/test_utils_run_later.py | 108 +++++++++++++++++++++++-----------
 1 file changed, 73 insertions(+), 35 deletions(-)

diff --git a/tests/test_utils_run_later.py b/tests/test_utils_run_later.py
index 096f1bd9..27c623cc 100644
--- a/tests/test_utils_run_later.py
+++ b/tests/test_utils_run_later.py
@@ -1,74 +1,112 @@
 import pytest
 from datetime import datetime, timedelta
-from freezegun import freeze_time
-from slic.utils.run_later import run_at, run_in, run_later
+from slic.utils.run_later import run_at, run_in, run_later, today, tomorrow, yesterday
 
-# Dummy for tqdm
+# Dummy progress bar replacement
 class DummyBar:
     def __enter__(self): return self
     def __exit__(self, *a): pass
     def set(self, val): pass
 
-# Monkeypatch tqdm and sleep globally
-@pytest.fixture(autouse=True)
-def patch_sleep_and_tqdm(monkeypatch):
+# Fake datetime module wrapper
+class FakeDateTimeModule:
+    def __init__(self, now):
+        self._now = now
+
+    def now(self):
+        return self._now
+
+    def advance(self, seconds):
+        self._now += timedelta(seconds=seconds)
+
+    def __getattr__(self, attr):
+        from datetime import datetime as real_datetime
+        return getattr(real_datetime, attr)
+
+
+@pytest.fixture
+def clock(monkeypatch):
+    # Initial fake datetime
+    fake_dt = FakeDateTimeModule(datetime(2025, 1, 1, 6, 0, 0))
+
+    # Patch the target module's datetime, sleep, tqdm, today/tomorrow/yesterday
+    monkeypatch.setattr("slic.utils.run_later.datetime", fake_dt)
     monkeypatch.setattr("slic.utils.run_later.sleep", lambda x: None)
     monkeypatch.setattr("slic.utils.run_later.tqdm_mod", lambda *a, **k: DummyBar())
 
-@freeze_time("2025-01-01 06:00:00")
-def test_run_at():
-    triggered = []
+    monkeypatch.setattr("slic.utils.run_later.today", lambda *args, **kwargs:
+        datetime(fake_dt.now().year, fake_dt.now().month, fake_dt.now().day, *args, **kwargs))
+    monkeypatch.setattr("slic.utils.run_later.tomorrow", lambda *args, **kwargs:
+        datetime(fake_dt.now().year, fake_dt.now().month, fake_dt.now().day, *args, **kwargs) + timedelta(days=1))
+    monkeypatch.setattr("slic.utils.run_later.yesterday", lambda *args, **kwargs:
+        datetime(fake_dt.now().year, fake_dt.now().month, fake_dt.now().day, *args, **kwargs) - timedelta(days=1))
 
+    return fake_dt
+
+
+def test_run_at(clock):
+    triggered = []
     def fexample(label): triggered.append(label)
 
-    # Target is 30min later → should NOT run
-    run_at(datetime(2025, 1, 1, 6, 30), fexample, "not yet")
+    # Trop tôt
+    run_at(today(6, 30), fexample, "not yet")
     assert "not yet" not in triggered
 
-    # Target is now → should run
-    run_at(datetime(2025, 1, 1, 6, 0), fexample, "now OK")
+    # Moment déclenché
+    clock.advance(31 * 60)
+    run_at(today(6, 30), fexample, "now OK")
     assert "now OK" in triggered
 
-    # Target is in the past → should NOT run
-    run_at(datetime(2024, 12, 31, 23, 59), fexample, "too late")
+    # Trop tard
+    run_at(yesterday(23, 59), fexample, "too late")
     assert "too late" not in triggered
 
-@freeze_time("2025-01-01 06:00:00")
-def test_run_in():
-    triggered = []
 
+def test_run_in(clock):
+    triggered = []
     def fexample(label): triggered.append(label)
 
-    # Delay is in the future → should NOT run
-    run_in(timedelta(minutes=30), fexample, "not yet")
+    clock._now = datetime(2025, 1, 1, 12, 0, 0)
+
+    # Trop tôt
+    run_in(timedelta(seconds=60), fexample, "not yet")
     assert "not yet" not in triggered
 
-    # Delay is now → should run
-    run_in(timedelta(minutes=0), fexample, "now OK")
+    # Moment déclenché
+    clock.advance(61)
+    run_in(timedelta(seconds=60), fexample, "now OK")
     assert "now OK" in triggered
 
-    # Delay is negative → should NOT run
-    run_in(timedelta(minutes=-1), fexample, "too late")
+    # Trop tard
+    clock.advance(-100)
+    run_in(timedelta(seconds=-1), fexample, "too late")
     assert "too late" not in triggered
 
-@freeze_time("2025-01-01 06:00:00")
-def test_run_later():
-    triggered = []
 
+def test_run_later(clock):
+    triggered = []
     def fexample(label): triggered.append(label)
 
-    # Seconds in the future → should NOT run
-    run_later(30, fexample, "not yet")
+    clock._now = datetime(2025, 1, 1, 14, 0, 0)
+
+    # Trop tôt (float seconds)
+    run_later(45, fexample, "not yet")
     assert "not yet" not in triggered
 
-    # Zero seconds → should run
-    run_later(0, fexample, "now OK")
+    # Moment déclenché
+    clock.advance(60)
+    run_later(45, fexample, "now OK")
     assert "now OK" in triggered
 
-    # timedelta negative → should NOT run
+    # Trop tard
     run_later(timedelta(seconds=-1), fexample, "too late")
     assert "too late" not in triggered
 
-    # Using datetime target → should run
-    run_later(datetime(2025, 1, 1, 6, 0), fexample, "datetime OK")
-    assert "datetime OK" in triggered
+    # Format datetime
+    clock._now = datetime(2025, 1, 1, 15, 0, 0)
+    run_later(today(15, 5), fexample, "not yet dt")
+    assert "not yet dt" not in triggered
+
+    clock.advance(6 * 60)
+    run_later(today(15, 5), fexample, "now OK dt")
+    assert "now OK dt" in triggered