fix: update scheduler tests for v2 ConfigManager, fix SQLite tz comparisons

Scheduler tests: replace set_api_server_url/load_cli_config with
monkeypatch.setenv + cm.reload() (v2 env-var-driven config)

Scheduling tests: fix timezone-aware vs naive datetime comparisons
(SQLite strips tzinfo, DuckDB preserved it)

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: tercel

tests/core/storage/sqlalchemy/test_scheduling.py

@@ -590,9 +590,9 @@ async def test_task_model_with_scheduling(self, sync_db_session):
         assert task.schedule_type == ScheduleType.daily.value
         assert task.schedule_expression == "09:00"
         assert task.schedule_enabled is True
-        assert task.schedule_start_at == schedule_start
-        assert task.schedule_end_at == schedule_end
-        assert task.next_run_at == next_run
+        assert task.schedule_start_at.replace(tzinfo=None) == schedule_start.replace(tzinfo=None)
+        assert task.schedule_end_at.replace(tzinfo=None) == schedule_end.replace(tzinfo=None)
+        assert task.next_run_at.replace(tzinfo=None) == next_run.replace(tzinfo=None)
         assert task.max_runs == 100
         assert task.run_count == 0
 
@@ -621,8 +621,8 @@ async def test_task_model_update_scheduling(self, sync_db_session):
         assert updated_task.schedule_type == ScheduleType.daily.value
         assert updated_task.schedule_expression == "09:00"
         assert updated_task.schedule_enabled is True
-        assert updated_task.last_run_at == last_run
-        assert updated_task.next_run_at == next_run
+        assert updated_task.last_run_at.replace(tzinfo=None) == last_run.replace(tzinfo=None)
+        assert updated_task.next_run_at.replace(tzinfo=None) == next_run.replace(tzinfo=None)
         assert updated_task.run_count == 1
 
     def test_task_model_to_dict_scheduling(self):
@@ -732,7 +732,7 @@ async def test_update_task_scheduling_via_repository(self, sync_db_session):
         assert updated.schedule_type == "cron"
         assert updated.schedule_expression == "0 9 * * 1-5"
         assert updated.schedule_enabled is True
-        assert updated.next_run_at == next_run
+        assert updated.next_run_at.replace(tzinfo=None) == next_run.replace(tzinfo=None)
         assert updated.max_runs == 100
 
     @pytest.mark.asyncio
@@ -1148,7 +1148,7 @@ async def test_complete_scheduled_run(self, sync_db_session):
         assert updated.run_count == 1
         assert updated.last_run_at is not None
         assert updated.next_run_at is not None
-        assert updated.next_run_at > now  # Next run should be in the future
+        assert updated.next_run_at.replace(tzinfo=None) > now.replace(tzinfo=None)  # Next run should be in the future
         assert updated.status == "completed"  # Preserved from executor
         assert updated.result == {"processed": 100}  # Preserved from executor
 

tests/scheduler/test_scheduler.py

@@ -12,7 +12,7 @@
 
 import pytest
 from datetime import datetime, timezone, timedelta
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock
 
 from apflow.scheduler.base import (
     SchedulerConfig,
@@ -983,34 +983,31 @@ class TestSchedulerAPIDetection:
     def _reset_config(self):
         """Reset ConfigManager between tests.
 
-        Patches load_cli_config to prevent re-loading from the developer's
-        local config file (.data/config.cli.yaml), which would re-establish
-        a real api_server_url and defeat the purpose of cm.clear().
+        Clears config and env to ensure clean state.
         """
         from apflow.core.config_manager import get_config_manager
 
         cm = get_config_manager()
         cm.clear()
-        with patch.object(cm, "load_cli_config"):
-            yield
+        yield
         cm.clear()
 
-    def test_detect_api_mode_true_when_url_configured(self):
-        """Detection returns True when api_server_url is configured."""
+    def test_detect_api_mode_true_when_url_configured(self, monkeypatch):
+        """Detection returns True when APFLOW_API_SERVER_URL is set."""
+        monkeypatch.setenv("APFLOW_API_SERVER_URL", "http://localhost:8000")
         from apflow.core.config_manager import get_config_manager
 
-        cm = get_config_manager()
-        cm.set_api_server_url("http://localhost:8000")
+        get_config_manager().reload()
 
         scheduler = InternalScheduler()
         assert scheduler._detect_api_mode() is True
 
     def test_detect_api_mode_false_when_no_url_configured(self):
-        """Detection returns False when no api_server_url is configured."""
+        """Detection returns False when no APFLOW_API_SERVER_URL is set."""
         scheduler = InternalScheduler()
         assert scheduler._detect_api_mode() is False
 
-    def test_detect_api_mode_reflects_config_changes(self):
+    def test_detect_api_mode_reflects_config_changes(self, monkeypatch):
         """Detection re-reads ConfigManager on every call (no stale cache)."""
         from apflow.core.config_manager import get_config_manager
 
@@ -1019,19 +1016,21 @@ def test_detect_api_mode_reflects_config_changes(self):
 
         assert scheduler._detect_api_mode() is False
 
-        cm.set_api_server_url("http://localhost:8000")
+        monkeypatch.setenv("APFLOW_API_SERVER_URL", "http://localhost:8000")
+        cm.reload()
         assert scheduler._detect_api_mode() is True
 
-        cm.set_api_server_url(None)
+        monkeypatch.delenv("APFLOW_API_SERVER_URL")
+        cm.reload()
         assert scheduler._detect_api_mode() is False
 
     @pytest.mark.asyncio
-    async def test_start_enables_api_mode_when_url_configured(self):
+    async def test_start_enables_api_mode_when_url_configured(self, monkeypatch):
         """start() detects API and sets _use_api=True when URL configured."""
         from apflow.core.config_manager import get_config_manager
 
-        cm = get_config_manager()
-        cm.set_api_server_url("http://localhost:8000")
+        monkeypatch.setenv("APFLOW_API_SERVER_URL", "http://localhost:8000")
+        get_config_manager().reload()
 
         scheduler = InternalScheduler()
         scheduler._get_due_tasks = AsyncMock(return_value=[])