test(phase2): add unit tests for core, persistence, plugin, utils

- Add test_handler_helpers.py for plugin handler helpers (7 tests)
- Add test_mgr_methods.py for persistence manager (5 tests)
- Add test_app_config_validation.py for core app config (12 tests)
- Add test_knowledge_service.py for API knowledge service (22 tests)
- Add test_kbmgr.py for RAG knowledge base manager (39 tests)
- Add test_survey_manager.py for survey manager (22 tests)
- Add test_connector_methods.py for plugin connector (24 tests)
- Add test_funcschema.py for utils function schema (9 tests)
- Add test_platform.py for utils platform detection (7 tests)
- Add test_extract_deps.py for plugin deps extraction (7 tests)
- Add test_database_decorator.py for persistence decorator (7 tests)
- Add test_load_config.py for core config loading (19 tests)
- Add COVERAGE_EXCLUSIONS.md documenting external adapter exclusions
- Fix test_chat_session_limit.py path for portability

Coverage: core 28% → 30%, persistence 24% → 24.4%, plugin 27% → 28%
Total: 1082 tests passed, core module coverage 45.5%

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

tests/unit_tests/persistence/test_database_decorator.py

@@ -0,0 +1,201 @@
+"""Unit tests for persistence database decorators.
+
+Tests cover:
+- manager_class decorator registration
+- Class attribute setting
+- preregistered_managers list population
+
+Note: Uses import isolation to break circular import chains.
+"""
+from __future__ import annotations
+
+import sys
+from unittest.mock import Mock, MagicMock
+from contextlib import contextmanager
+from typing import Generator
+
+
+@contextmanager
+def isolated_database_import() -> Generator[None, None, None]:
+    """Context manager to isolate circular imports for database testing."""
+    # Mock modules that cause circular imports
+    mock_app = MagicMock()
+
+    mock_importutil = MagicMock()
+    mock_importutil.import_modules_in_pkg = lambda pkg: None
+    mock_importutil.import_modules_in_pkgs = lambda pkgs: None
+
+    mock_mgr = MagicMock()
+
+    mocks = {
+        'langbot.pkg.core.app': mock_app,
+        'langbot.pkg.utils.importutil': mock_importutil,
+        'langbot.pkg.persistence.mgr': mock_mgr,
+    }
+
+    # Save original state
+    saved = {}
+    for name in mocks:
+        if name in sys.modules:
+            saved[name] = sys.modules[name]
+
+    # Clear database module to force re-import
+    database_name = 'langbot.pkg.persistence.database'
+    if database_name in sys.modules:
+        saved[database_name] = sys.modules[database_name]
+
+    # Also clear databases submodules
+    for sub in ['sqlite', 'postgresql']:
+        full_name = f'langbot.pkg.persistence.databases.{sub}'
+        if full_name in sys.modules:
+            saved[full_name] = sys.modules[full_name]
+
+    try:
+        # Apply mocks
+        for name, module in mocks.items():
+            sys.modules[name] = module
+
+        # Clear database and submodules
+        sys.modules.pop(database_name, None)
+        for sub in ['sqlite', 'postgresql']:
+            sys.modules.pop(f'langbot.pkg.persistence.databases.{sub}', None)
+
+        yield
+    finally:
+        # Restore
+        for name in mocks:
+            if name in saved:
+                sys.modules[name] = saved[name]
+            else:
+                sys.modules.pop(name, None)
+
+        if database_name in saved:
+            sys.modules[database_name] = saved[database_name]
+        else:
+            sys.modules.pop(database_name, None)
+
+        for sub in ['sqlite', 'postgresql']:
+            full_name = f'langbot.pkg.persistence.databases.{sub}'
+            if full_name in saved:
+                sys.modules[full_name] = saved[full_name]
+            else:
+                sys.modules.pop(full_name, None)
+
+
+def get_database_module():
+    """Get database module with import isolation."""
+    with isolated_database_import():
+        from langbot.pkg.persistence import database
+        return database
+
+
+class TestManagerClassDecorator:
+    """Tests for manager_class decorator."""
+
+    def test_decorator_sets_name_attribute(self):
+        """Test that decorator sets the 'name' attribute on class."""
+        database = get_database_module()
+
+        # Clear preregistered_managers for this test
+        database.preregistered_managers.clear()
+
+        @database.manager_class('test_db')
+        class TestManager(database.BaseDatabaseManager):
+            async def initialize(self):
+                pass
+
+        assert TestManager.name == 'test_db'
+
+    def test_decorator_adds_to_preregistered_list(self):
+        """Test that decorator adds class to preregistered_managers."""
+        database = get_database_module()
+
+        # Clear preregistered_managers for this test
+        database.preregistered_managers.clear()
+
+        @database.manager_class('test_db2')
+        class TestManager2(database.BaseDatabaseManager):
+            async def initialize(self):
+                pass
+
+        assert len(database.preregistered_managers) == 1
+        assert database.preregistered_managers[0] == TestManager2
+
+    def test_decorator_returns_original_class(self):
+        """Test that decorator returns the same class."""
+        database = get_database_module()
+
+        database.preregistered_managers.clear()
+
+        class OriginalClass(database.BaseDatabaseManager):
+            async def initialize(self):
+                pass
+
+        decorated = database.manager_class('test_db3')(OriginalClass)
+
+        assert decorated is OriginalClass
+
+    def test_multiple_decorators_register_separately(self):
+        """Test that multiple decorated classes register separately."""
+        database = get_database_module()
+
+        database.preregistered_managers.clear()
+
+        @database.manager_class('db_a')
+        class ManagerA(database.BaseDatabaseManager):
+            async def initialize(self):
+                pass
+
+        @database.manager_class('db_b')
+        class ManagerB(database.BaseDatabaseManager):
+            async def initialize(self):
+                pass
+
+        assert len(database.preregistered_managers) == 2
+        assert database.preregistered_managers[0].name == 'db_a'
+        assert database.preregistered_managers[1].name == 'db_b'
+
+    def test_base_database_manager_has_name_annotation(self):
+        """Test that BaseDatabaseManager has name as class annotation."""
+        database = get_database_module()
+
+        # BaseDatabaseManager has name annotation (type hint)
+        # Check __annotations__ for the type hint
+        assert 'name' in database.BaseDatabaseManager.__annotations__
+
+    def test_decorated_class_inherits_from_base(self):
+        """Test that decorated class properly inherits BaseDatabaseManager."""
+        database = get_database_module()
+
+        database.preregistered_managers.clear()
+
+        @database.manager_class('test_inherit')
+        class TestChild(database.BaseDatabaseManager):
+            async def initialize(self):
+                pass
+
+        assert issubclass(TestChild, database.BaseDatabaseManager)
+        # Has abstract method requirement satisfied
+        assert hasattr(TestChild, 'initialize')
+
+    def test_decorator_preserves_class_methods(self):
+        """Test that decorator preserves existing class methods."""
+        database = get_database_module()
+
+        database.preregistered_managers.clear()
+
+        @database.manager_class('preserve_test')
+        class ManagerWithMethods(database.BaseDatabaseManager):
+            custom_attr = 'test_value'
+
+            async def initialize(self):
+                pass
+
+            def custom_method(self):
+                return self.custom_attr
+
+        assert ManagerWithMethods.custom_attr == 'test_value'
+        # Create instance to test method (with mock app)
+        mock_app = Mock()
+        instance = ManagerWithMethods(mock_app)
+        assert instance.custom_method() == 'test_value'

tests/unit_tests/persistence/test_mgr_methods.py

@@ -0,0 +1,142 @@
+"""Unit tests for persistence manager methods.
+
+Tests cover:
+- execute_async() with mock database
+- get_db_engine() with mock database manager
+"""
+from __future__ import annotations
+
+import pytest
+from unittest.mock import Mock, AsyncMock, MagicMock
+from importlib import import_module
+import sqlalchemy
+
+
+def get_persistence_module():
+    """Lazy import to avoid circular import issues."""
+    return import_module('langbot.pkg.persistence.mgr')
+
+
+class TestExecuteAsync:
+    """Tests for execute_async method."""
+
+    @pytest.mark.asyncio
+    async def test_execute_async_calls_engine_execute(self):
+        """Test that execute_async calls engine execute."""
+        persistence = get_persistence_module()
+
+        mock_app = Mock()
+        mock_app.persistence_mgr = None
+
+        mgr = persistence.PersistenceManager(mock_app)
+
+        # Mock database manager with async engine
+        mock_engine = MagicMock()
+        mock_conn = AsyncMock()
+        mock_conn.execute = AsyncMock(return_value=Mock())
+        mock_conn.commit = AsyncMock()
+
+        # Setup the async context manager
+        async_cm = AsyncMock()
+        async_cm.__aenter__ = AsyncMock(return_value=mock_conn)
+        async_cm.__aexit__ = AsyncMock(return_value=None)
+        mock_engine.connect = Mock(return_value=async_cm)
+
+        mock_db = Mock()
+        mock_db.get_engine = Mock(return_value=mock_engine)
+        mgr.db = mock_db
+
+        # Execute a simple select
+        result = await mgr.execute_async(sqlalchemy.select(1))
+
+        mock_conn.execute.assert_called_once()
+        mock_conn.commit.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_execute_async_returns_result(self):
+        """Test that execute_async returns the result."""
+        persistence = get_persistence_module()
+
+        mock_app = Mock()
+        mgr = persistence.PersistenceManager(mock_app)
+
+        mock_result = Mock(name='query_result')
+
+        mock_engine = MagicMock()
+        mock_conn = AsyncMock()
+        mock_conn.execute = AsyncMock(return_value=mock_result)
+        mock_conn.commit = AsyncMock()
+
+        async_cm = AsyncMock()
+        async_cm.__aenter__ = AsyncMock(return_value=mock_conn)
+        async_cm.__aexit__ = AsyncMock(return_value=None)
+        mock_engine.connect = Mock(return_value=async_cm)
+
+        mock_db = Mock()
+        mock_db.get_engine = Mock(return_value=mock_engine)
+        mgr.db = mock_db
+
+        result = await mgr.execute_async(sqlalchemy.text("SELECT 1"))
+
+        assert result == mock_result
+
+
+class TestGetDbEngine:
+    """Tests for get_db_engine method."""
+
+    def test_get_db_engine_returns_engine_from_db_manager(self):
+        """Test that get_db_engine returns engine from db manager."""
+        persistence = get_persistence_module()
+
+        mock_app = Mock()
+        mgr = persistence.PersistenceManager(mock_app)
+
+        mock_engine = Mock(name='engine')
+        mock_db = Mock()
+        mock_db.get_engine = Mock(return_value=mock_engine)
+        mgr.db = mock_db
+
+        engine = mgr.get_db_engine()
+
+        assert engine == mock_engine
+        mock_db.get_engine.assert_called_once()
+
+    def test_get_db_engine_without_db_set_raises(self):
+        """Test that get_db_engine raises when db is not set."""
+        persistence = get_persistence_module()
+
+        mock_app = Mock()
+        mgr = persistence.PersistenceManager(mock_app)
+
+        # db is not initialized
+        mgr.db = None
+
+        with pytest.raises(AttributeError):
+            mgr.get_db_engine()
+
+
+class TestSerializeModelEdgeCases:
+    """Tests for serialize_model edge cases."""
+
+    def test_serialize_model_with_all_columns_masked(self):
+        """Test serialize_model when all columns are masked."""
+        persistence = get_persistence_module()
+
+        from sqlalchemy import Column, Integer, String
+        from sqlalchemy.orm import declarative_base
+
+        Base = declarative_base()
+
+        class SimpleModel(Base):
+            __tablename__ = 'simple'
+            id = Column(Integer, primary_key=True)
+            name = Column(String(50))
+
+        mock_app = Mock()
+        mgr = persistence.PersistenceManager(mock_app)
+
+        instance = SimpleModel(id=1, name='test')
+        result = mgr.serialize_model(SimpleModel, instance, masked_columns=['id', 'name'])
+
+        # Result should be empty dict when all columns masked
+        assert result == {}

tests/unit_tests/persistence/test_serialize_model.py

@@ -7,9 +7,7 @@ Tests cover:
 """
 from __future__ import annotations
 
-import pytest
 import datetime
-import sqlalchemy
 from sqlalchemy import Column, Integer, String, DateTime
 from sqlalchemy.orm import declarative_base
 from importlib import import_module