refactor: update tests to use async mocks and improve readability

tests/unit/test_config_service.py

@@ -1,6 +1,6 @@
 """Unit tests for configuration management system."""
 
-from unittest.mock import MagicMock, Mock, patch
+from unittest.mock import AsyncMock, MagicMock, Mock, patch
 
 import pytest
 
@@ -19,15 +19,9 @@ def mock_settings():
 
 @pytest.fixture
 def mock_store():
-    """Create a mock database store with context manager."""
-    store = Mock()
-    cursor = Mock()
-    cursor.fetchone.return_value = None
-    cursor.fetchall.return_value = []
-    cursor.execute.return_value = cursor
-    cntx = MagicMock()
-    cntx.__enter__.return_value = cursor
-    store.connect.return_value = cntx
+    """Create a mock database store (sync — repos are patched)."""
+    store = MagicMock()
+    store.pool = MagicMock()
     return store
 
 
@@ -40,10 +34,8 @@ def mock_audit_repo():
 
 def test_configuration_service_initialization(mock_settings, mock_store, mock_audit_repo):
     """Test that ConfigurationService initializes correctly."""
-    # Create service instance
     service = ConfigurationService(mock_settings, mock_store, mock_audit_repo)
 
-    # Verify attributes are set
     assert service._settings == mock_settings
     assert service._store == mock_store
     assert service._audit_repo == mock_audit_repo
@@ -53,132 +45,109 @@ def test_configuration_service_initialization(mock_settings, mock_store, mock_au
 
 def test_configuration_service_get_setting(mock_settings, mock_store, mock_audit_repo):
     """Test getting configuration settings."""
-    # Create service instance
     service = ConfigurationService(mock_settings, mock_store, mock_audit_repo)
-
-    # Set up mock loaded settings
     service._loaded_settings = {"test_key": "test_value"}
 
-    # Test getting existing setting
-    result = service.get_setting("test_key", "default")
-    assert result == "test_value"
-
-    # Test getting non-existing setting with default
-    result = service.get_setting("non_existing", "default")
-    assert result == "default"
+    assert service.get_setting("test_key", "default") == "test_value"
+    assert service.get_setting("non_existing", "default") == "default"
 
 
-def test_configuration_service_set_setting(mock_settings, mock_store, mock_audit_repo):
+@pytest.mark.asyncio
+async def test_configuration_service_set_setting(mock_settings, mock_store, mock_audit_repo):
     """Test setting configuration settings."""
-    # Create service instance
     service = ConfigurationService(mock_settings, mock_store, mock_audit_repo)
 
-    # Mock the repository
     with patch("arbitrade.storage.repositories.ConfigSettingRepository") as mock_repo_class:
         mock_repo_instance = Mock()
         mock_repo_class.return_value = mock_repo_instance
 
-        # Mock the setting creation
         mock_created_setting = Mock()
         mock_created_setting.updated_at = "2023-01-01T00:00:00"
-        mock_repo_instance.create_setting.return_value = mock_created_setting
-        mock_repo_instance.get_setting.return_value = None  # force create path
+        mock_repo_instance.create_setting = AsyncMock(
+            return_value=mock_created_setting)
+        mock_repo_instance.get_setting = AsyncMock(return_value=None)
 
-        # Set a setting
-        service.set_setting("test_key", "test_value", "test_user")
+        await service.set_setting("test_key", "test_value", "test_user")
 
-        # Verify repository was called
-        mock_repo_instance.create_setting.assert_called_once()
+        mock_repo_instance.create_setting.assert_awaited_once()
 
 
-def test_configuration_service_hot_reload_detection(mock_settings, mock_store, mock_audit_repo):
+@pytest.mark.asyncio
+async def test_configuration_service_hot_reload_detection(mock_settings, mock_store, mock_audit_repo):
     """Test hot-reload detection functionality."""
-    # Create service instance
     service = ConfigurationService(mock_settings, mock_store, mock_audit_repo)
 
-    # Initially should not be outdated
-    assert service.is_config_outdated() is False
-
-    # Test with mock repository that returns a timestamp
     with patch("arbitrade.storage.repositories.ConfigSettingRepository") as mock_repo_class:
         mock_repo_instance = Mock()
         mock_repo_class.return_value = mock_repo_instance
 
-        # Mock the latest updated at timestamp
+        mock_repo_instance.get_latest_updated_at = AsyncMock(return_value=None)
+        assert await service.is_config_outdated() is False
+
         from datetime import datetime
 
-        mock_repo_instance.get_latest_updated_at.return_value = datetime.now()
-
-        # Should detect as outdated when timestamp exists
-        assert service.is_config_outdated() is True
+        mock_repo_instance.get_latest_updated_at = AsyncMock(
+            return_value=datetime.now())
+        assert await service.is_config_outdated() is True
 
 
-def test_configuration_service_reload_if_changed(mock_settings, mock_store, mock_audit_repo):
+@pytest.mark.asyncio
+async def test_configuration_service_reload_if_changed(mock_settings, mock_store, mock_audit_repo):
     """Test hot-reload functionality."""
-    # Create service instance
     service = ConfigurationService(mock_settings, mock_store, mock_audit_repo)
 
-    # Mock the repository
     with patch("arbitrade.storage.repositories.ConfigSettingRepository") as mock_repo_class:
         mock_repo_instance = Mock()
         mock_repo_class.return_value = mock_repo_instance
 
-        # Mock the latest updated at timestamp to return None initially
-        mock_repo_instance.get_latest_updated_at.return_value = None
-        mock_repo_instance.list_settings.return_value = []
+        mock_repo_instance.get_latest_updated_at = AsyncMock(return_value=None)
+        mock_repo_instance.list_settings = AsyncMock(return_value=[])
 
-        # Mock the latest updated at timestamp to return a value
         from datetime import datetime
 
-        mock_repo_instance.get_latest_updated_at.return_value = datetime.now()
+        mock_repo_instance.get_latest_updated_at = AsyncMock(
+            return_value=datetime.now())
 
-        # Should reload when outdated
-        result = service.reload_if_changed()
+        result = await service.reload_if_changed()
         assert result is True
         assert service.get_config_version() == 1
 
 
-def test_configuration_service_get_config_version(mock_settings, mock_store, mock_audit_repo):
+@pytest.mark.asyncio
+async def test_configuration_service_get_config_version(mock_settings, mock_store, mock_audit_repo):
     """Test getting configuration version."""
-    # Create service instance
     service = ConfigurationService(mock_settings, mock_store, mock_audit_repo)
-
-    # Should start at version 0
     assert service.get_config_version() == 0
 
-    # After setting a value, version should increment
     with patch("arbitrade.storage.repositories.ConfigSettingRepository") as mock_repo_class:
         mock_repo_instance = Mock()
         mock_repo_class.return_value = mock_repo_instance
 
         mock_created_setting = Mock()
         mock_created_setting.updated_at = "2023-01-01T00:00:00"
-        mock_repo_instance.create_setting.return_value = mock_created_setting
-        mock_repo_instance.get_setting.return_value = None
+        mock_repo_instance.create_setting = AsyncMock(
+            return_value=mock_created_setting)
+        mock_repo_instance.get_setting = AsyncMock(return_value=None)
 
-        service.set_setting("test_key", "test_value", "test_user")
-        # set_setting bumps version
+        await service.set_setting("test_key", "test_value", "test_user")
         assert service.get_config_version() == 1
 
 
-def test_configuration_service_get_last_updated_at(mock_settings, mock_store, mock_audit_repo):
+@pytest.mark.asyncio
+async def test_configuration_service_get_last_updated_at(mock_settings, mock_store, mock_audit_repo):
     """Test getting last updated timestamp."""
-    # Create service instance
     service = ConfigurationService(mock_settings, mock_store, mock_audit_repo)
-
-    # Should start with None
     assert service.get_last_updated_at() is None
 
-    # After setting a value, should have timestamp
     with patch("arbitrade.storage.repositories.ConfigSettingRepository") as mock_repo_class:
         mock_repo_instance = Mock()
         mock_repo_class.return_value = mock_repo_instance
 
         mock_created_setting = Mock()
         mock_created_setting.updated_at = "2023-01-01T00:00:00"
-        mock_repo_instance.create_setting.return_value = mock_created_setting
-        mock_repo_instance.get_setting.return_value = None
+        mock_repo_instance.create_setting = AsyncMock(
+            return_value=mock_created_setting)
+        mock_repo_instance.get_setting = AsyncMock(return_value=None)
 
-        service.set_setting("test_key", "test_value", "test_user")
-        # set_setting updates _last_updated_at from mock
+        await service.set_setting("test_key", "test_value", "test_user")
         assert service.get_last_updated_at() is not None