intervall

tests/sync/test_scheduler.py

@@ -1,8 +1,14 @@
 import asyncio
+from datetime import datetime
 
 import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.pool import StaticPool
 
-from app.sync.scheduler import SyncScheduler
+from app.db.models import Base
+from app.db.repositories import SchedulerSettingsRepository
+from app.db.session import create_session_factory
+from app.sync.scheduler import DayNightIntervalProvider, SyncScheduler, is_daytime
 
 
 class FakeSyncManager:
@@ -40,3 +46,91 @@ async def test_scheduler_stop_cancels_the_loop() -> None:
     calls_after_stop = fake.calls
     await asyncio.sleep(0.05)
     assert fake.calls == calls_after_stop
+
+
+@pytest.mark.parametrize(
+    ("hour", "day_start", "night_start", "expected"),
+    [
+        (6, 6, 22, True),
+        (21, 6, 22, True),
+        (5, 6, 22, False),
+        (22, 6, 22, False),
+        (0, 6, 22, False),
+        # wraps past midnight: day period is [20, 6)
+        (23, 20, 6, True),
+        (2, 20, 6, True),
+        (10, 20, 6, False),
+        (20, 20, 6, True),
+        (6, 20, 6, False),
+        # degenerate: identical start hours means always day
+        (13, 9, 9, True),
+    ],
+)
+def test_is_daytime(hour, day_start, night_start, expected) -> None:
+    assert is_daytime(hour, day_start, night_start) is expected
+
+
+@pytest.fixture
+def db_session_factory():
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+    Base.metadata.create_all(engine)
+    factory = create_session_factory(engine)
+    try:
+        yield factory
+    finally:
+        engine.dispose()
+
+
+@pytest.mark.asyncio
+async def test_interval_provider_uses_day_interval_during_the_day(db_session_factory) -> None:
+    provider = DayNightIntervalProvider(
+        db_session_factory, default_minutes=5, now=lambda: datetime(2026, 1, 1, 12, 0)
+    )
+    assert provider() == 5 * 60
+
+
+@pytest.mark.asyncio
+async def test_interval_provider_uses_night_interval_at_night(db_session_factory) -> None:
+    with db_session_factory() as session:
+        repo = SchedulerSettingsRepository(session)
+        row = repo.get_or_create(default_minutes=5)
+        repo.update(row, night_interval_minutes=30)
+
+    provider = DayNightIntervalProvider(
+        db_session_factory, default_minutes=5, now=lambda: datetime(2026, 1, 1, 23, 0)
+    )
+    assert provider() == 30 * 60
+
+
+@pytest.mark.asyncio
+async def test_scheduler_uses_interval_provider_for_next_tick(db_session_factory) -> None:
+    with db_session_factory() as session:
+        repo = SchedulerSettingsRepository(session)
+        row = repo.get_or_create(default_minutes=5)
+        repo.update(row, day_interval_minutes=1, night_interval_minutes=1)
+
+    provider = DayNightIntervalProvider(
+        db_session_factory, default_minutes=5, now=lambda: datetime(2026, 1, 1, 12, 0)
+    )
+    fake = FakeSyncManager()
+    scheduler = SyncScheduler(fake, interval_seconds=999, interval_provider=provider)
+
+    await scheduler.run_once()
+
+    expected_seconds = 60  # day_interval_minutes=1 -> 60s, not the unrelated interval_seconds=999 fallback
+    delta = (scheduler.next_tick - scheduler.last_tick).total_seconds()
+    assert abs(delta - expected_seconds) < 1
+
+
+@pytest.mark.asyncio
+async def test_scheduler_falls_back_when_interval_provider_raises() -> None:
+    def broken_provider():
+        raise RuntimeError("db unavailable")
+
+    fake = FakeSyncManager()
+    scheduler = SyncScheduler(fake, interval_seconds=42, interval_provider=broken_provider)
+
+    await scheduler.run_once()
+
+    delta = (scheduler.next_tick - scheduler.last_tick).total_seconds()
+    assert abs(delta - 42) < 1