Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

4.6 KB
Raw Blame
"""Background SQLite repositories release connections without waiting for GC."""

from __future__ import annotations

from collections.abc import Iterator
from pathlib import Path
import sqlite3

import pytest

from deeptutor.services.cron.repository import SQLiteCronRepository
from deeptutor.services.web_source.repository import SQLiteWebSourceSyncRepository


@pytest.fixture(params=[SQLiteCronRepository, SQLiteWebSourceSyncRepository])
def repository_type(
    request: pytest.FixtureRequest,
) -> type[SQLiteCronRepository] | type[SQLiteWebSourceSyncRepository]:
    """Exercise both repositories used by periodic background tasks."""
    return request.param


@pytest.fixture
def connections(monkeypatch: pytest.MonkeyPatch) -> Iterator[list[sqlite3.Connection]]:
    """Retain real connections so garbage collection cannot hide a missing close."""
    opened: list[sqlite3.Connection] = []
    connect = sqlite3.connect

    def track_connection(*args, **kwargs) -> sqlite3.Connection:
        connection = connect(*args, **kwargs)
        opened.append(connection)
        return connection

    monkeypatch.setattr(sqlite3, "connect", track_connection)
    try:
        yield opened
    finally:
        # Also clean up when this regression test runs against the unfixed code.
        for connection in opened:
            connection.close()


def assert_closed(connections: list[sqlite3.Connection]) -> None:
    """Every returned connection must already reject database operations."""
    assert connections
    for connection in connections:
        with pytest.raises(sqlite3.ProgrammingError, match="closed"):
            connection.execute("SELECT 1")


def test_polling_closes_every_connection(repository_type, connections, tmp_path: Path) -> None:
    """Initialization and repeated empty polling must not retain DB/WAL handles."""
    repository = repository_type(tmp_path / "jobs.sqlite")
    for _ in range(10):
        if isinstance(repository, SQLiteCronRepository):
            assert repository.revision() == 0
            assert repository.list_payloads() == []
        else:
            repository.reconcile_sources(set(), scanned_owner_ids={"local-admin"})
            assert repository.due_jobs() == []
    assert_closed(connections)


def test_failed_operation_closes_connection(repository_type, connections, tmp_path: Path) -> None:
    """An exception during a repository operation must release its connection."""
    repository = repository_type(tmp_path / "jobs.sqlite")
    with pytest.raises(sqlite3.OperationalError):
        with repository._connect() as connection:
            connection.execute("SELECT * FROM nonexistent_table")
    assert_closed(connections)


@pytest.mark.parametrize("pragma", ["journal_mode", "busy_timeout", "synchronous"])
def test_failed_setup_closes_connection(
    repository_type, connections, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, pragma: str
) -> None:
    """Close even when connection setup fails before the context yields."""
    repository = repository_type(tmp_path / "jobs.sqlite")
    connect = sqlite3.connect

    class SetupFailureConnection(sqlite3.Connection):
        def execute(self, sql, *args, **kwargs):
            if sql.startswith(f"PRAGMA {pragma}"):
                raise sqlite3.OperationalError("injected setup failure")
            return super().execute(sql, *args, **kwargs)

    def fail_setup(*args, **kwargs) -> sqlite3.Connection:
        return connect(*args, **kwargs, factory=SetupFailureConnection)

    monkeypatch.setattr(sqlite3, "connect", fail_setup)
    with pytest.raises(sqlite3.OperationalError, match="injected setup failure"):
        with repository._connect():
            pytest.fail("failed setup must not yield a connection")
    assert_closed(connections)


def test_connection_context_preserves_commit_and_rollback(
    repository_type, connections, tmp_path: Path
) -> None:
    """Closing must preserve the existing SQLite transaction context semantics."""
    repository = repository_type(tmp_path / "jobs.sqlite")
    with repository._connect() as connection:
        connection.execute("CREATE TABLE lifecycle_test (value INTEGER)")
        connection.execute("BEGIN")
        connection.execute("INSERT INTO lifecycle_test VALUES (1)")
    with pytest.raises(RuntimeError, match="abort transaction"):
        with repository._connect() as connection:
            connection.execute("BEGIN")
            connection.execute("INSERT INTO lifecycle_test VALUES (2)")
            raise RuntimeError("abort transaction")
    with repository._connect() as connection:
        rows = connection.execute("SELECT value FROM lifecycle_test").fetchall()
    assert [row[0] for row in rows] == [1]
    assert_closed(connections)