Skip to content

"Vibe-Trading: Your Personal Trading Agent"

8.7 KB
Raw Blame
"""Allowlist registry security + resolution contract (scheduler unification T5).

The registry is the ONLY name→callable surface for ``executor_kind ==
"internal"`` jobs. These tests pin: exact-key resolution, the malformed-name
rejection table (separators, ``..``, whitespace, shell metacharacters), the
name-space/import-space isolation (a real import path resolves to nothing
unless literally registered), and the mechanical no-dynamic-resolution guard
mirroring the CI grep gates.
"""

from __future__ import annotations

from pathlib import Path

import pytest

import src.scheduling.registry as registry
from src.scheduling.registry import (
    InternalCallableError,
    _INTERNAL_CALLABLES,
    is_registered,
    list_internal,
    register_internal,
    resolve_internal,
)


def _fake_sync() -> None:
    pass


async def _fake_async() -> None:
    pass


# ---------------------------------------------------------------------------
# Happy path
# ---------------------------------------------------------------------------


def test_registered_name_resolves_to_the_same_object(clean_registry) -> None:
    register_internal("test.fake", _fake_sync)
    assert resolve_internal("test.fake") is _fake_sync
    assert is_registered("test.fake")
    assert "test.fake" in list_internal()


def test_sync_and_async_callables_are_both_accepted(clean_registry) -> None:
    register_internal("test.sync", _fake_sync)
    register_internal("test.async", _fake_async)
    assert resolve_internal("test.sync") is _fake_sync
    assert resolve_internal("test.async") is _fake_async


def test_list_internal_is_a_sorted_tuple(clean_registry) -> None:
    register_internal("test.b", _fake_sync)
    register_internal("test.a", _fake_async)
    listed = list_internal()
    assert isinstance(listed, tuple)
    assert listed == tuple(sorted(listed))
    assert {"test.a", "test.b"} <= set(listed)


def test_resolve_is_exact_key_only_no_prefix_or_suffix_match(clean_registry) -> None:
    register_internal("a.b", _fake_sync)
    with pytest.raises(InternalCallableError):
        resolve_internal("a")
    with pytest.raises(InternalCallableError):
        resolve_internal("a.b.c")
    assert not is_registered("a")
    assert not is_registered("a.b.c")


# ---------------------------------------------------------------------------
# Unregistered names
# ---------------------------------------------------------------------------


def test_unregistered_name_error_lists_registered_names(clean_registry) -> None:
    register_internal("test.known", _fake_sync)
    with pytest.raises(InternalCallableError) as excinfo:
        resolve_internal("test.unknown")
    message = str(excinfo.value)
    assert "test.unknown" in message
    assert "not registered" in message
    assert "test.known" in message


def test_error_is_a_key_error_with_readable_str(clean_registry) -> None:
    with pytest.raises(KeyError):
        resolve_internal("test.absent")
    try:
        resolve_internal("test.absent")
    except InternalCallableError as exc:
        # KeyError.__str__ would repr() the message; ours must not be quoted.
        assert str(exc) == exc.args[0]
        assert not str(exc).startswith("'")


@pytest.mark.parametrize(
    "name",
    [
        # Real, dangerous import paths — well-formed dotted identifiers, but
        # NOT registered: the name space is isolated from the import space.
        "os.system",
        "src.br_data.sync.run_sync",
        "shutil.rmtree",
    ],
)
def test_real_import_paths_are_rejected_when_not_registered(clean_registry, name: str) -> None:
    with pytest.raises(InternalCallableError) as excinfo:
        resolve_internal(name)
    assert "not registered" in str(excinfo.value)
    assert not is_registered(name)
    # Isolation proof: rejecting the name never touched the import machinery,
    # so nothing new appeared in the registry either.
    assert name not in _INTERNAL_CALLABLES


# ---------------------------------------------------------------------------
# Malformed-name rejection table
# ---------------------------------------------------------------------------


@pytest.mark.parametrize(
    "name",
    [
        "../../etc/passwd",
        "a:b",
        "a/b",
        "a\\b",
        "a; rm -rf /",
        "a|b",
        "a$(x)",
        "a`x`",
        " a ",
        "",
        "a b",
        "a&&b",
        "a>b",
        "a<b",
        "a(b)",
        "..",
        ".",
        "a..b",
        ".a",
        "a.",
        "a\nb",
        "a\tb",
        "os.system; ls",
        "memory.consolidate --force",
    ],
)
def test_malformed_names_are_rejected_before_any_lookup(clean_registry, name: str) -> None:
    register_internal("test.known", _fake_sync)
    with pytest.raises(InternalCallableError) as excinfo:
        resolve_internal(name)
    assert "rejected" in str(excinfo.value)
    assert not is_registered(name)


@pytest.mark.parametrize("name", [None, 123, b"os.system", ("os", "system")])
def test_non_string_names_are_rejected(clean_registry, name: object) -> None:
    with pytest.raises(InternalCallableError):
        resolve_internal(name)  # type: ignore[arg-type]
    assert not is_registered(name)


def test_is_registered_never_raises(clean_registry) -> None:
    for name in ("", " a ", "a/b", None, 123, "os.system", "test.known"):
        assert isinstance(is_registered(name), bool)


# ---------------------------------------------------------------------------
# register_internal validation (module/test-only surface)
# ---------------------------------------------------------------------------


def test_register_rejects_malformed_names_and_non_callables(clean_registry) -> None:
    with pytest.raises(InternalCallableError):
        register_internal("a/b", _fake_sync)
    with pytest.raises(InternalCallableError):
        register_internal("", _fake_sync)
    with pytest.raises(TypeError):
        register_internal("test.not_callable", "src.memory.consolidate")  # type: ignore[arg-type]
    assert list_internal() == () or "test.not_callable" not in list_internal()


def test_register_rejects_silent_overwrite_without_replace(clean_registry) -> None:
    register_internal("test.dup", _fake_sync)
    with pytest.raises(InternalCallableError):
        register_internal("test.dup", _fake_async)
    assert resolve_internal("test.dup") is _fake_sync
    register_internal("test.dup", _fake_async, replace=True)
    assert resolve_internal("test.dup") is _fake_async


def test_test_registrations_do_not_leak_between_tests() -> None:
    # No clean_registry fixture here: whatever previous tests registered must
    # already be gone (the fixture restores the snapshot on teardown).
    assert not is_registered("test.fake")
    assert not is_registered("test.dup")


# ---------------------------------------------------------------------------
# Mechanical guards (mirror the CI grep gates inside the test suite)
# ---------------------------------------------------------------------------


def test_registry_source_has_no_dynamic_resolution_tokens() -> None:
    source = Path(registry.__file__).read_text(encoding="utf-8")
    for token in ("import_module", "__import__", "eval(", "getattr("):
        assert token not in source, f"registry.py must never contain {token!r}"


def test_registry_has_no_top_level_domain_imports() -> None:
    """The generic scheduling package must not eagerly pull in domain stacks.

    Mechanical pin of the deferred-import contract: every top-level import in
    registry.py is stdlib/typing — the ``src.br_data`` / ``src.memory``
    imports live INSIDE the literal wrapper bodies and run at first firing,
    not at kernel-package import.
    """
    import ast

    tree = ast.parse(Path(registry.__file__).read_text(encoding="utf-8"))
    for node in tree.body:
        if isinstance(node, ast.Import):
            for alias in node.names:
                assert not alias.name.startswith("src."), f"top-level import {alias.name!r}"
        elif isinstance(node, ast.ImportFrom):
            module = node.module or ""
            assert module.startswith("src.scheduling") or not module.startswith("src."), (
                f"top-level domain import {module!r}"
            )


def test_registry_source_has_no_shell_tokens() -> None:
    source = Path(registry.__file__).read_text(encoding="utf-8")
    for token in ("subprocess", "os.system", "shell=True"):
        assert token not in source, f"registry.py must never contain {token!r}"


def test_register_internal_is_documented_module_and_test_only() -> None:
    # Invariant guard: runtime string registration is not a production
    # surface — production entries are explicit dict edits at module bottom.
    assert register_internal.__doc__ is not None
    assert "MODULE/TEST-ONLY" in register_internal.__doc__
    assert "module edit" in register_internal.__doc__