basicmachines-co-basic-memory/tests/cli/test_cli_exit.py

"""Regression tests for CLI command exit behavior.

These tests verify that CLI commands exit cleanly without hanging,
which was a bug fixed in the database initialization refactor.
"""

import subprocess
from pathlib import Path


def test_bm_version_exits_cleanly():
    """Test that 'bm --version' exits cleanly within timeout."""
    # Use uv run to ensure correct environment
    result = subprocess.run(
        ["uv", "run", "bm", "--version"],
        capture_output=True,
        text=True,
        # `uv run` startup under full-suite load (especially on Windows runners)
        # can exceed a tight 10s budget even though --version short-circuits
        # before any heavy work. This test guards against hangs, not a startup
        # performance budget, so match the looser --help timeout below.
        timeout=20,
        cwd=Path(__file__).parent.parent.parent,  # Project root
    )
    assert result.returncode == 0
    assert "Basic Memory version:" in result.stdout


def test_bm_help_exits_cleanly():
    """Test that 'bm --help' exits cleanly within timeout."""
    result = subprocess.run(
        ["uv", "run", "bm", "--help"],
        capture_output=True,
        text=True,
        # Help builds the full command tree, so use a looser timeout than the
        # version fast path. This test is guarding against hangs, not enforcing
        # a tight performance budget under full-suite load.
        timeout=20,
        cwd=Path(__file__).parent.parent.parent,
    )
    assert result.returncode == 0
    assert "Basic Memory" in result.stdout


def test_bm_tool_help_exits_cleanly():
    """Test that 'bm tool --help' exits cleanly within timeout."""
    result = subprocess.run(
        ["uv", "run", "bm", "tool", "--help"],
        capture_output=True,
        text=True,
        timeout=10,
        cwd=Path(__file__).parent.parent.parent,
    )
    assert result.returncode == 0
    assert "tool" in result.stdout.lower()


def test_bm_version_does_not_import_heavy_modules():
    """Regression test: 'bm --version' must not import heavy modules.

    The fast-path guard in cli/main.py skips command registration when
    argv is exactly ['--version']. This test verifies that modules like
    basic_memory.mcp (which pull in FastAPI, SQLAlchemy, etc.) are NOT
    loaded during a version-only invocation.
    """
    # Run a Python snippet that imports main.py the same way the entrypoint does,
    # then checks sys.modules for heavy imports
    check_script = (
        "import sys; "
        "sys.argv = ['bm', '--version']; "
        "import basic_memory.cli.main; "
        "heavy = [m for m in sys.modules if m.startswith('basic_memory.mcp')]; "
        "print(','.join(heavy) if heavy else 'CLEAN')"
    )
    result = subprocess.run(
        ["uv", "run", "python", "-c", check_script],
        capture_output=True,
        text=True,
        timeout=10,
        cwd=Path(__file__).parent.parent.parent,
    )
    assert result.returncode == 0
    # The fast path should NOT have loaded any mcp modules
    assert "CLEAN" in result.stdout, (
        f"Heavy modules loaded during --version: {result.stdout.strip()}"
    )


def test_bm_cli_import_does_not_load_heavy_stack():
    """Regression test (#886): registering all CLI commands must stay lightweight.

    Importing basic_memory.cli.main with a normal argv registers every command
    module. None of them may pull FastAPI, the API app, SQLAlchemy/Alembic, the
    MCP tool stack, or the markdown/services layers in at import time — those
    must load lazily when a command actually runs.
    """
    heavy_modules = (
        "fastapi",
        "sqlalchemy",
        "alembic",
        "fastmcp",
        "mcp",
        "basic_memory.api.app",
        "basic_memory.db",
        "basic_memory.markdown",
        "basic_memory.mcp.tools",
        "basic_memory.services",
    )
    check_script = (
        "import sys; "
        "sys.argv = ['bm', 'tool', 'search-notes', '--help']; "
        "import basic_memory.cli.main; "
        f"heavy = [m for m in {heavy_modules!r} if m in sys.modules]; "
        "print(','.join(heavy) if heavy else 'CLEAN')"
    )
    result = subprocess.run(
        ["uv", "run", "python", "-c", check_script],
        capture_output=True,
        text=True,
        timeout=20,
        cwd=Path(__file__).parent.parent.parent,
    )
    assert result.returncode == 0
    assert "CLEAN" in result.stdout, (
        f"Heavy modules loaded during CLI import: {result.stdout.strip()}"
    )


def test_bm_help_does_not_import_api_app():
    """Regression test: 'bm --help' must not build the FastAPI app graph."""
    check_script = (
        "import sys; "
        "sys.argv = ['bm', '--help']; "
        "import basic_memory.cli.main; "
        "heavy = [m for m in sys.modules "
        "if m == 'basic_memory.api.app' or m.startswith('basic_memory.api.v2.routers')]; "
        "print(','.join(heavy) if heavy else 'CLEAN')"
    )
    result = subprocess.run(
        ["uv", "run", "python", "-c", check_script],
        capture_output=True,
        text=True,
        timeout=10,
        cwd=Path(__file__).parent.parent.parent,
    )
    assert result.returncode == 0
    assert "CLEAN" in result.stdout, (
        f"API app modules loaded during --help: {result.stdout.strip()}"
    )