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.

4.2 KB
Raw Blame
# allow: no-sut-import — policy guardian over OSV configuration and dependency floors.
"""Keep release-gate OSV exceptions narrow and tied to reachable sinks."""

from __future__ import annotations

import datetime as dt
import tomllib
from pathlib import Path

from packaging.requirements import Requirement
from packaging.specifiers import SpecifierSet
from packaging.utils import canonicalize_name
from packaging.version import Version


ROOT = Path(__file__).resolve().parents[2]


def test_osv_exceptions_are_exact_and_expiring() -> None:
    config = tomllib.loads(
        (ROOT / "osv-scanner.toml").read_text(encoding="utf-8")
    )
    assert set(config) == {"IgnoredVulns"}
    exceptions = config["IgnoredVulns"]
    assert {entry["id"] for entry in exceptions} == {
        "GHSA-4mvj-m6j5-pmf7",
        "GHSA-v5mq-3xhg-98m9",
    }
    assert len(exceptions) == 2
    for entry in exceptions:
        assert set(entry) == {"id", "ignoreUntil", "reason"}
        assert isinstance(entry["ignoreUntil"], dt.date)
        assert dt.date.today() < entry["ignoreUntil"]
        assert len(entry["reason"]) > 80


# First version with all security fixes required by the release. A floor
# below this lets a fresh pip install (which does not read pdm.lock) resolve
# a still-vulnerable release.
FIRST_FIXED = {
    "certifi": "2026.10.19",  # PYSEC-2026-4320 / GHSA-6q48-6c7w-9gw2
    "filelock": "4.2.1",
    "nltk": "3.10.4",  # GHSA-8mgp-746c-j5xp
    "oauthlib": "4.0.0",  # GHSA-hj66-6f7g-4r5v, GHSA-xpv3-w29h-x7cv
    "pillow": "13.0.0",  # CVE-2026-112390 … CVE-2026-112406, CVE-2026-112891 … CVE-2026-112902
    "pyjwt": "2.15.0",  # GHSA-42vr-xj54-vc7v (the 2.14.0 set is older)
    "pypdf": "6.21.4",
    "setuptools": "84.1.0",
    "urllib3": "2.8.0",  # GHSA-8988-9cw3-xx77, GHSA-gh4c-6fx4-qh6g, ...
    "virtualenv": "21.14.13",
}


def _declared_requirements() -> dict[str, list[SpecifierSet]]:
    project = tomllib.loads(
        (ROOT / "pyproject.toml").read_text(encoding="utf-8")
    )
    raw = list(project["project"]["dependencies"])
    for extra in project["project"].get("optional-dependencies", {}).values():
        raw.extend(extra)
    for group in project.get("dependency-groups", {}).values():
        raw.extend(item for item in group if isinstance(item, str))
    declared: dict[str, list[SpecifierSet]] = {}
    for line in raw:
        req = Requirement(line)
        declared.setdefault(canonicalize_name(req.name), []).append(
            req.specifier
        )
    return declared


def _locked_versions() -> dict[str, set[Version]]:
    lock = tomllib.loads((ROOT / "pdm.lock").read_text(encoding="utf-8"))
    locked: dict[str, set[Version]] = {}
    for package in lock["package"]:
        locked.setdefault(canonicalize_name(package["name"]), set()).add(
            Version(package["version"])
        )
    return locked


def _floor(spec: SpecifierSet) -> Version | None:
    floors = [
        Version(item.version)
        for item in spec
        if item.operator in {">=", ">", "~=", "=="}
    ]
    return max(floors) if floors else None


def test_security_floors_reach_first_fixed_version() -> None:
    declared = _declared_requirements()
    locked = _locked_versions()
    for name, fixed in FIRST_FIXED.items():
        fixed_version = Version(fixed)
        assert name in declared, f"{name} lost its security floor"
        for spec in declared[name]:
            floor = _floor(spec)
            assert floor is not None and floor >= fixed_version, (
                f"{name}{spec} still admits releases below {fixed}"
            )
        assert locked.get(name), f"{name} missing from pdm.lock"
        assert min(locked[name]) >= fixed_version, (
            f"pdm.lock pins {name} below {fixed}"
        )


def test_sqlalchemy_stays_on_tested_2_0_series() -> None:
    """#6876: 2.1.1 was reported to segfault; 2.1 also URL-decodes paths."""
    declared = _declared_requirements()["sqlalchemy"]
    for spec in declared:
        assert spec.contains("2.0.52")
        assert not spec.contains("2.1.0")
        assert not spec.contains("2.1.1")
    locked = _locked_versions()["sqlalchemy"]
    assert locked and all(
        Version("2.0") <= version < Version("2.1") for version in locked
    )