test: cover multi-db schema registration

Author: Sakeeb91

tests/unit/test_registry.py

@@ -20,6 +20,7 @@
     get_database_registry,
     reset_database_registry,
 )
+from db.schema import SchemaInfo
 
 
 class TestDatabaseConfig:
@@ -280,6 +281,29 @@ async def test_get_adapter(self, registry: DatabaseRegistry) -> None:
 
         await registry.close_all()
 
+    @pytest.mark.asyncio
+    async def test_update_schema_stores_metadata(
+        self, registry: DatabaseRegistry
+    ) -> None:
+        """Test storing schema metadata for a registered database."""
+        config = DatabaseConfig(
+            database_id="schema_test",
+            connection_string="sqlite+aiosqlite:///:memory:",
+        )
+        registered = await registry.register_database(config, test_connection=False)
+
+        schema = SchemaInfo(
+            database_id="schema_test",
+            dialect="sqlite",
+            tables=[],
+        )
+        registry.update_schema("schema_test", schema)
+
+        assert registered.schema is schema
+        assert registered.schema_updated_at == schema.last_updated
+
+        await registry.close_all()
+
     @pytest.mark.asyncio
     async def test_health_check(self, registry: DatabaseRegistry) -> None:
         """Test health check on database."""

tests/unit/test_routes_schema.py

@@ -0,0 +1,102 @@
+"""
+Unit tests for schema routes (Issue #31: Multi-DB registry wiring).
+"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from app.routes import router
+from db.schema import SchemaInfo
+
+
+@pytest.fixture
+def app() -> FastAPI:
+    """Create test FastAPI app."""
+    from app.error_handlers import setup_exception_handlers
+    from app.security import limiter
+
+    test_app = FastAPI()
+    test_app.state.limiter = limiter
+    setup_exception_handlers(test_app)
+    test_app.include_router(router)
+
+    return test_app
+
+
+@pytest.fixture
+def client(app: FastAPI, auth_headers: dict[str, str]) -> TestClient:
+    """Create test client."""
+    client = TestClient(app)
+    client.headers.update(auth_headers)
+    return client
+
+
+class TestSchemaRoutes:
+    """Tests for schema registration endpoints."""
+
+    def test_register_schema_registers_and_caches(
+        self,
+        client: TestClient,
+    ) -> None:
+        """Ensure schema registration wires registry and cache."""
+        schema_info = SchemaInfo(
+            database_id="analytics",
+            dialect="postgresql",
+            tables=[],
+        )
+
+        mock_introspector = MagicMock()
+        mock_introspector.get_schema = AsyncMock(return_value=schema_info)
+        mock_introspector.serialize_for_prompt.return_value = "schema"
+
+        registry = MagicMock()
+        registry.database_count = 0
+        registry.register_database = AsyncMock()
+        registered = MagicMock()
+        registered.engine = MagicMock()
+        registry.register_database.return_value = registered
+
+        settings = MagicMock()
+        settings.multi_database.enabled = True
+        settings.multi_database.max_databases = 50
+        settings.multi_database.default_pool_size = 5
+        settings.multi_database.default_max_overflow = 10
+        settings.multi_database.default_pool_timeout = 30
+        settings.multi_database.allow_mutations = False
+        settings.multi_database.require_connection_test = True
+        settings.cache.enabled = True
+
+        with (
+            patch("app.routes.get_settings", return_value=settings),
+            patch("db.registry.get_database_registry", return_value=registry),
+            patch("db.schema.SchemaIntrospector", return_value=mock_introspector),
+            patch("app.cache.cache_schema", new_callable=AsyncMock) as cache_schema,
+        ):
+            response = client.post(
+                "/api/v1/schema/register",
+                json={
+                    "database_id": "analytics",
+                    "connection_string": "sqlite:///test.db",
+                    "dialect": "postgresql",
+                },
+            )
+
+        assert response.status_code == 200
+        payload = response.json()
+        assert payload["status"] == "registered"
+        assert payload["database_id"] == "analytics"
+        assert payload["dialect"] == "postgresql"
+
+        registry.register_database.assert_awaited_once()
+        args, kwargs = registry.register_database.call_args
+        config = args[0]
+        assert config.database_id == "analytics"
+        assert config.connection_string == "sqlite:///test.db"
+        assert config.pool_size == 5
+        assert kwargs["test_connection"] is True
+
+        mock_introspector.get_schema.assert_awaited_once_with("analytics")
+        cache_schema.assert_awaited_once()

tests/unit/test_text2sql_engine.py

@@ -433,6 +433,7 @@ def mock_settings(self) -> MagicMock:
         )
         settings.cache = MagicMock(enabled=False)
         settings.huggingface = MagicMock(model_name="test-model")
+        settings.multi_database = MagicMock(enabled=False)
         return settings
 
     def test_initialization(
@@ -633,6 +634,35 @@ async def test_generate_with_retry_uses_fallback_when_circuit_open(
             assert result.metadata.get("fallback") is True
             assert any("circuit" in w for w in warnings)
 
+    @pytest.mark.asyncio
+    async def test_resolve_database_context_uses_registry(
+        self,
+        mock_db_manager: MagicMock,
+        mock_settings: MagicMock,
+    ) -> None:
+        """Test registry-based context resolution when enabled."""
+        mock_settings.multi_database.enabled = True
+
+        registered = MagicMock()
+        registered.engine = MagicMock()
+        registered.config.dialect = MagicMock()
+        registered.config.dialect.value = "postgresql"
+
+        registry = MagicMock()
+        registry.get_database.return_value = registered
+        registry.session.return_value = "session_ctx"
+
+        with (
+            patch("app.text2sql_engine.get_settings", return_value=mock_settings),
+            patch("app.text2sql_engine.get_database_registry", return_value=registry),
+        ):
+            engine = Text2SQLEngine(mock_db_manager)
+            context = await engine._resolve_database_context("analytics")
+
+        assert context.database_id == "analytics"
+        assert context.dialect == "postgresql"
+        assert context.session_provider() == "session_ctx"
+
 
 # =============================================================================
 # Test Global Engine Management
@@ -681,6 +711,7 @@ async def test_get_text2sql_engine(self) -> None:
                     ),
                     cache=MagicMock(enabled=False),
                     huggingface=MagicMock(model_name="test-model"),
+                    multi_database=MagicMock(enabled=False),
                 )
 
                 engine = await get_text2sql_engine()