Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

6.3 KB
Raw Blame
"""A schema-neutral exemption must reject real DDL changes and failed proof."""

# allow: no-sut-import - guardian tests exercise the migration gate against committed fixture repositories; model imports run in isolated snapshot processes.

import subprocess
from pathlib import Path

import pytest

from tests.database.schema_change_rule import (
    MIN_METADATA_TABLES,
    classify,
    violations,
)
from tests.database.schema_snapshot import model_edits_preserve_schema


_MODEL_PATH = "src/local_deep_research/database/models/__init__.py"
_MODELS = f"""
from sqlalchemy import (
    CheckConstraint, Column, DDL, Enum, ForeignKey, Index, Integer,
    String, Table, UniqueConstraint, event,
)
from sqlalchemy.orm import Mapped, declarative_base, mapped_column

Base = declarative_base()
# Meet the production discovery floor so an empty snapshot cannot pass.
for i in range({MIN_METADATA_TABLES}):
    Table(f"baseline_{{i}}", Base.metadata, Column("id", Integer, primary_key=True))

class Parent(Base):
    __tablename__ = "parents"
    id = Column(Integer, primary_key=True)

class Record(Base):
    __tablename__ = "records"
    id = Column(Integer, primary_key=True)
    value = Column(String(20), nullable=False, server_default="old")
    parent_id = Column(Integer, ForeignKey("parents.id", ondelete="CASCADE"), nullable=True)
    state = Column(Enum("one", "two", name="record_state", create_constraint=True))
    __table_args__ = (
        Index("ix_record_value", "value"),
        UniqueConstraint("value", name="uq_record_value"),
        CheckConstraint("length(value) > 0", name="ck_record_value"),
    )

event.listen(Record.__table__, "after_create", DDL(
    "CREATE TRIGGER record_trigger AFTER DELETE ON records BEGIN SELECT 1; END"
))
"""


def _git(repo: Path, *args: str) -> str:
    return subprocess.run(
        ["git", *args],
        cwd=repo,
        capture_output=True,
        text=True,
        check=True,
    ).stdout.strip()


@pytest.fixture
def model_repo(tmp_path):
    _git(tmp_path, "init", "-q")
    _git(tmp_path, "config", "user.name", "Schema test")
    _git(tmp_path, "config", "user.email", "[email protected]")
    model_file = tmp_path / _MODEL_PATH
    model_file.parent.mkdir(parents=True)
    package = tmp_path / "src/local_deep_research"
    for directory in (package, package / "database"):
        (directory / "__init__.py").write_text("")

    def commit(source):
        model_file.write_text(source)
        _git(tmp_path, "add", "src")
        _git(tmp_path, "commit", "-qm", "Update test schema")
        return _git(tmp_path, "rev-parse", "HEAD")

    base = commit(_MODELS)
    return tmp_path, base, commit


def _proof(repo, base, after="HEAD"):
    changes = classify({_MODEL_PATH: "before"}, {_MODEL_PATH: "after"})
    revisions = classify({}, {})
    preserved = model_edits_preserve_schema(
        repo, base, after, changes, revisions
    )
    return preserved, violations(changes, revisions, schema_unchanged=preserved)


def test_typed_mapping_refactor_is_verified_from_isolated_sources(
    model_repo, tmp_path, monkeypatch
):
    repo, base, commit = model_repo
    commit(
        _MODELS.replace(
            "id = Column(Integer, primary_key=True)",
            "id: Mapped[int] = mapped_column(Integer, primary_key=True)",
        )
    )
    # An inherited import path must not replace either committed package.
    shadow = tmp_path / "shadow/local_deep_research/database/models"
    shadow.mkdir(parents=True)
    (shadow / "__init__.py").write_text("raise RuntimeError('wrong models')")
    monkeypatch.setenv("PYTHONPATH", str(tmp_path / "shadow"))
    assert _proof(repo, base) == (True, [])


@pytest.mark.parametrize(
    ("old", "new"),
    [
        ('__tablename__ = "records"', '__tablename__ = "renamed_records"'),
        ("String(20)", "String(21)"),
        ("nullable=False", "nullable=True"),
        ('server_default="old"', 'server_default="new"'),
        ('ondelete="CASCADE"', 'ondelete="SET NULL"'),
        ('Index("ix_record_value"', 'Index("ix_record_value_new"'),
        ('UniqueConstraint("value"', 'UniqueConstraint("parent_id"'),
        ('"length(value) > 0"', '"length(value) > 1"'),
        ('Enum("one", "two"', 'Enum("one", "two", "three"'),
        ("CREATE TRIGGER record_trigger", "CREATE TRIGGER renamed_trigger"),
        (
            '    value = Column(String(20), nullable=False, server_default="old")',
            '    value: Mapped[str | None] = mapped_column(String(20), server_default="old")',
        ),
        (
            '    value = Column(String(20), nullable=False, server_default="old")',
            '    value = Column(String(20), nullable=False, server_default="old")\n'
            "    extra = Column(Integer)",
        ),
    ],
    ids=[
        "table",
        "type",
        "nullable",
        "default",
        "foreign-key",
        "index",
        "unique",
        "check",
        "enum",
        "ddl-event",
        "inferred-nullability",
        "added-column",
    ],
)
def test_actual_schema_change_still_requires_a_revision(model_repo, old, new):
    repo, base, commit = model_repo
    assert old in _MODELS
    commit(_MODELS.replace(old, new))
    preserved, problems = _proof(repo, base)
    assert preserved is False
    assert len(problems) == 1 and _MODEL_PATH in problems[0]


def test_snapshot_cache_follows_head_when_a_second_commit_changes_schema(
    model_repo,
):
    repo, base, commit = model_repo
    typed = _MODELS.replace(
        "id = Column(Integer, primary_key=True)",
        "id: Mapped[int] = mapped_column(Integer, primary_key=True)",
    )
    commit(typed)
    assert _proof(repo, base) == (True, [])
    commit(typed.replace("String(20)", "String(21)"))
    assert _proof(repo, base)[0] is False


@pytest.mark.parametrize(
    "source",
    [
        "Base = None",
        _MODELS.replace(f"range({MIN_METADATA_TABLES})", "range(0)"),
        _MODELS + '\nRecord.__module__ = "sqlalchemy"\n',
    ],
)
def test_failed_or_collapsed_snapshot_cannot_grant_an_exemption(
    model_repo, source
):
    repo, base, commit = model_repo
    commit(source)
    preserved, problems = _proof(repo, base)
    assert preserved is False and len(problems) == 1


def test_unreadable_ref_cannot_grant_an_exemption(model_repo):
    repo, base, _ = model_repo
    preserved, problems = _proof(repo, base, "missing-schema-ref")
    assert preserved is False and len(problems) == 1