Updated test suite

tests/test_db.py

@@ -1,97 +1,67 @@
-"""Tests for transcription.db — schema bootstrap and session factory."""
+"""Tests for transcription.db runtime and schema bootstrap behavior."""
 
-from sqlalchemy import inspect, text
-from sqlmodel import Session, SQLModel, create_engine
-from sqlmodel.pool import StaticPool
+import pytest
+from sqlalchemy import inspect
+
+from transcription.config import Settings
+from transcription.db import create_all
+from transcription.db import dispose_database_runtime
+from transcription.db import get_session
+from transcription.db import initialize_database_runtime
 
 
-def _in_memory_engine():
-    """Create a fresh in-memory SQLite engine for isolated db tests."""
-    return create_engine(
-        "sqlite://",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
+@pytest.mark.asyncio
+async def test_create_all_creates_expected_tables(tmp_path):
+    settings = Settings(
+        openrouter_api_key="test-key",
+        database_url=f"sqlite:///{tmp_path / 'schema.db'}",
+        environment="test",
     )
+    runtime = initialize_database_runtime(settings=settings)
 
+    try:
+        await create_all(engine=runtime.engine)
+        async with runtime.engine.connect() as conn:
+            table_names = set(await conn.run_sync(lambda c: inspect(c).get_table_names()))
 
-class TestSchemaBootstrap:
-    """Verify create_all produces the expected table set."""
-
-    def test_create_all_creates_expected_tables(self):
-        """After create_all(), document, source, job, and revision tables exist."""
-        engine = _in_memory_engine()
-        # Ensure models are imported so metadata is populated
-        from transcription.models import Document, Job, Revision, Source  # noqa: F401
-
-        import transcription.db as db_module
-
-        db_module.create_all(engine=engine)
-
-        inspector = inspect(engine)
-        table_names = set(inspector.get_table_names())
         assert "document" in table_names
         assert "job" in table_names
         assert "source" in table_names
         assert "revision" in table_names
+    finally:
+        await dispose_database_runtime()
 
 
-class TestSessionFactory:
-    """Verify get_session yields and cleans up sessions."""
+@pytest.mark.asyncio
+async def test_get_session_yields_async_session(tmp_path):
+    settings = Settings(
+        openrouter_api_key="test-key",
+        database_url=f"sqlite:///{tmp_path / 'session.db'}",
+        environment="test",
+    )
+    initialize_database_runtime(settings=settings)
 
-    def test_get_session_yields_session(self):
-        """get_session() yields a usable Session object."""
-        engine = _in_memory_engine()
-        SQLModel.metadata.create_all(engine)
-
-        import transcription.db as db_module
-
-        with db_module.get_session(engine=engine) as session:
-            assert isinstance(session, Session)
-
-    def test_session_is_closed_after_generator_exit(self):
-        """After the context manager exits, the session is closed."""
-        engine = _in_memory_engine()
-        SQLModel.metadata.create_all(engine)
-
-        import transcription.db as db_module
-
-        with db_module.get_session(engine=engine) as session:
-            # Session is usable inside the context
-            session.execute(text("SELECT 1"))
-            captured = session
-
-        # After exiting, the session's internal connection is released
-        # (no active transaction bound to the session)
-        assert captured._transaction is None
+    try:
+        async with get_session(settings=settings) as session:
+            assert session is not None
+    finally:
+        await dispose_database_runtime()
 
 
-class TestBootstrapPolicy:
-    """Verify schema bootstrap policy defaults and overrides."""
+def test_bootstrap_policy_production_defaults_false():
+    settings = Settings(openrouter_api_key="test-key", environment="production")
+    assert settings.should_bootstrap_schema is False
 
-    def test_production_defaults_to_no_bootstrap(self):
-        """Production defaults to explicit non-bootstrap startup behavior."""
-        from transcription.config import Settings
-        from transcription.db import should_bootstrap_schema
 
-        settings = Settings(openrouter_api_key="test-key", environment="production")
-        assert should_bootstrap_schema(settings) is False
+def test_bootstrap_policy_development_defaults_true():
+    settings = Settings(openrouter_api_key="test-key", environment="development")
+    assert settings.should_bootstrap_schema is True
 
-    def test_development_defaults_to_bootstrap(self):
-        """Development defaults to schema bootstrap for local workflows."""
-        from transcription.config import Settings
-        from transcription.db import should_bootstrap_schema
 
-        settings = Settings(openrouter_api_key="test-key", environment="development")
-        assert should_bootstrap_schema(settings) is True
-
-    def test_explicit_override_wins(self):
-        """Explicit bootstrap_schema_on_startup overrides environment default."""
-        from transcription.config import Settings
-        from transcription.db import should_bootstrap_schema
-
-        settings = Settings(
-            openrouter_api_key="test-key",
-            environment="production",
-            bootstrap_schema_on_startup=True,
-        )
-        assert should_bootstrap_schema(settings) is True
+def test_bootstrap_policy_explicit_override_true():
+    settings = Settings(
+        openrouter_api_key="test-key",
+        environment="production",
+        bootstrap_schema_on_startup=True,
+    )
+    assert settings.should_bootstrap_schema is True