diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b152778..6dae58f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -38,5 +38,7 @@ jobs: - name: Entrypoint smoke test run: | - out=$(uv run merlin-hpc-mcp 2>&1 || true) - echo "$out" | grep -q "not wired" + # Test that the entrypoint can start and display help + uv run merlin-hpc-mcp --help > /dev/null 2>&1 + # Test that local mode can be invoked (will timeout but should not crash immediately) + timeout 2 uv run merlin-hpc-mcp --mode local --transport stdio 2>&1 || true diff --git a/packages/merlin-hpc-mcp/tests/test_entrypoint.py b/packages/merlin-hpc-mcp/tests/test_entrypoint.py index 0d94553..948ec7a 100644 --- a/packages/merlin-hpc-mcp/tests/test_entrypoint.py +++ b/packages/merlin-hpc-mcp/tests/test_entrypoint.py @@ -1,5 +1,10 @@ -"""Entrypoint tests for the gateway server.""" +"""Entrypoint tests for the gateway server. +These tests verify that the merlin-hpc-mcp entrypoint works correctly +with various command-line options and environment variable configurations. +""" + +import os import threading import time @@ -7,35 +12,202 @@ import merlin_hpc_mcp from merlin_hpc_mcp.server import main -def test_version_exported(): - """Test that the version is exported.""" - assert merlin_hpc_mcp.__version__ +class TestEntrypointBasics: + """Basic entrypoint tests.""" + def test_version_exported(self): + """Test that the version is exported.""" + assert merlin_hpc_mcp.__version__ == "0.1.0" -def test_ssh_mode_requires_host(capsys): - """Test that SSH mode requires a host to be specified.""" - result = main(["--mode", "ssh"]) - assert result == 1 - err = capsys.readouterr().err - assert "SSH host required" in err - - -def test_local_mode_works(): - """Test that local mode can be invoked.""" - - # This will fail because it tries to start a server, but we can at least - # verify it gets past the argument parsing - def run_server(): + def test_help_option(self, capsys): + """Test that --help displays usage information.""" try: - main(["--mode", "local", "--transport", "stdio"]) - except SystemExit: - pass + result = main(["--help"]) + assert result == 0 + except SystemExit as e: + # --help causes SystemExit(0) + assert e.code == 0 + out = capsys.readouterr().out + assert "Merlin HPC MCP Gateway" in out + assert "--mode" in out + assert "--ssh-host" in out + assert "--transport" in out - # Run in a thread and kill it quickly - t = threading.Thread(target=run_server) - t.daemon = True - t.start() - time.sleep(0.5) - # The test passes if we got this far without crashing - assert True +class TestEntrypointModes: + """Test different execution modes.""" + + def test_ssh_mode_requires_host(self, capsys): + """Test that SSH mode requires a host to be specified.""" + result = main(["--mode", "ssh"]) + assert result == 1 + err = capsys.readouterr().err + assert "SSH host required" in err + + def test_ssh_mode_with_host_fails_without_server(self, capsys): + """Test that SSH mode with host fails if SSH connection cannot be established.""" + # This will fail because we don't have an actual SSH server + # but it should get past argument parsing + result = main(["--mode", "ssh", "--ssh-host", "nonexistent.example.com"]) + assert result == 1 + err = capsys.readouterr().err + # Should fail with connection error, not argument error + assert "SSH host required" not in err + + def test_local_mode_starts_successfully(self): + """Test that local mode can be started.""" + + def run_server(): + try: + main(["--mode", "local", "--transport", "stdio"]) + except SystemExit: + pass + + # Run in a thread and let it start + t = threading.Thread(target=run_server, daemon=True) + t.start() + time.sleep(0.5) + + # If we got here without crashing, the server started successfully + assert True + + def test_delegate_mode_starts_successfully(self): + """Test that delegate mode can be started.""" + + def run_server(): + try: + main(["--mode", "delegate", "--transport", "stdio"]) + except SystemExit: + pass + + # Run in a thread and let it start + t = threading.Thread(target=run_server, daemon=True) + t.start() + time.sleep(0.5) + + # If we got here without crashing, the server started successfully + assert True + + +class TestEntrypointTransport: + """Test different transport options.""" + + def test_stdio_transport(self): + """Test that stdio transport works.""" + + def run_server(): + try: + main(["--mode", "local", "--transport", "stdio"]) + except SystemExit: + pass + + t = threading.Thread(target=run_server, daemon=True) + t.start() + time.sleep(0.3) + assert True + + def test_http_transport(self): + """Test that HTTP transport can be configured.""" + + def run_server(): + try: + main(["--mode", "local", "--transport", "http", "--port", "9999"]) + except SystemExit: + pass + + t = threading.Thread(target=run_server, daemon=True) + t.start() + time.sleep(0.3) + assert True + + def test_sse_transport(self): + """Test that SSE transport can be configured.""" + + def run_server(): + try: + main(["--mode", "local", "--transport", "sse", "--port", "9998"]) + except SystemExit: + pass + + t = threading.Thread(target=run_server, daemon=True) + t.start() + time.sleep(0.3) + assert True + + +class TestEntrypointEnvironment: + """Test environment variable configuration.""" + + def test_mode_from_env_variable(self, capsys): + """Test that mode can be set via environment variable.""" + os.environ["MERLIN_HPC_MCP_MODE"] = "local" + try: + # This should work without specifying --mode + def run_server(): + try: + main(["--transport", "stdio"]) + except SystemExit: + pass + + t = threading.Thread(target=run_server, daemon=True) + t.start() + time.sleep(0.3) + assert True + finally: + del os.environ["MERLIN_HPC_MCP_MODE"] + + def test_ssh_host_from_env_variable(self, capsys): + """Test that SSH host can be set via environment variable.""" + os.environ["MERLIN_HPC_MCP_MODE"] = "ssh" + os.environ["MERLIN_HPC_MCP_SSH_HOST"] = "test.example.com" + try: + # This should get past the SSH host check + # but will fail at connection + result = main([]) + assert result == 1 # Will fail at connection, not at argument parsing + err = capsys.readouterr().err + # Should NOT have "SSH host required" error + assert "SSH host required" not in err + finally: + del os.environ["MERLIN_HPC_MCP_MODE"] + del os.environ["MERLIN_HPC_MCP_SSH_HOST"] + + def test_context_dir_from_env_variable(self): + """Test that context directory can be set via environment variable.""" + os.environ["MERLIN_HPC_MCP_MODE"] = "delegate" + os.environ["MERLIN_HPC_MCP_CONTEXT_DIR"] = "/custom/agents.d" + try: + + def run_server(): + try: + main(["--transport", "stdio"]) + except SystemExit: + pass + + t = threading.Thread(target=run_server, daemon=True) + t.start() + time.sleep(0.3) + assert True + finally: + del os.environ["MERLIN_HPC_MCP_MODE"] + del os.environ["MERLIN_HPC_MCP_CONTEXT_DIR"] + + +class TestEntrypointVerbose: + """Test verbose logging option.""" + + def test_verbose_flag(self, capsys): + """Test that --verbose enables debug logging.""" + + def run_server(): + try: + main(["--mode", "local", "--transport", "stdio", "--verbose"]) + except SystemExit: + pass + + t = threading.Thread(target=run_server, daemon=True) + t.start() + time.sleep(0.3) + + # Check that the server started (we can't easily check log level here) + assert True diff --git a/packages/merlin-hpc-mcp/tests/test_policy_middleware.py b/packages/merlin-hpc-mcp/tests/test_policy_middleware.py new file mode 100644 index 0000000..6304f05 --- /dev/null +++ b/packages/merlin-hpc-mcp/tests/test_policy_middleware.py @@ -0,0 +1,129 @@ +"""Tests for the policy middleware.""" + +import pytest +from merlin_hpc_mcp.config import Settings +from merlin_hpc_mcp.server import PolicyMiddleware, assemble_server + + +class TestPolicyMiddleware: + """Test the policy middleware functionality.""" + + def test_denies_unvetted_command(self): + """Test that the middleware denies commands not in the allowlist.""" + import asyncio + + async def run_test(): + middleware = PolicyMiddleware() + + # Create a mock call_next + async def mock_call_next(context): + return None # Should not be reached + + # Create a request with a non-vetted command (rm) + from fastmcp.server.middleware import MiddlewareContext + from mcp.types import CallToolRequestParams + + params = CallToolRequestParams( + name="run_command", + arguments={"command": ["rm", "-rf", "/"]}, + ) + + context = MiddlewareContext( + message=params, + fastmcp_context=None, + source="client", + type="request", + method="tools/call", + ) + + # Should raise ValueError + with pytest.raises(ValueError, match="Command denied by policy"): + await middleware.on_call_tool(context, mock_call_next) + + asyncio.run(run_test()) + + def test_allows_vetted_command(self): + """Test that the middleware allows commands in the allowlist.""" + import asyncio + + async def run_test(): + middleware = PolicyMiddleware() + + called = False + + # Create a mock call_next that marks it was called + async def mock_call_next(context): + nonlocal called + called = True + return None + + # Create a request with a vetted command (squeue) + from fastmcp.server.middleware import MiddlewareContext + from mcp.types import CallToolRequestParams + + params = CallToolRequestParams( + name="run_command", + arguments={"command": ["squeue"]}, + ) + + context = MiddlewareContext( + message=params, + fastmcp_context=None, + source="client", + type="request", + method="tools/call", + ) + + # Should not raise, and should call the next middleware + await middleware.on_call_tool(context, mock_call_next) + assert called + + asyncio.run(run_test()) + + def test_adds_provenance_to_sbatch(self): + """Test that the middleware adds provenance tags to sbatch commands.""" + import asyncio + + async def run_test(): + middleware = PolicyMiddleware() + + # Create a mock call_next that returns the context + async def mock_call_next(context): + return context + + # Create a request with sbatch command + from fastmcp.server.middleware import MiddlewareContext + from mcp.types import CallToolRequestParams + + params = CallToolRequestParams( + name="run_command", + arguments={"command": ["sbatch", "script.sh"]}, + ) + + context = MiddlewareContext( + message=params, + fastmcp_context=None, + source="client", + type="request", + method="tools/call", + ) + + # Call the middleware + result = await middleware.on_call_tool(context, mock_call_next) + + # Check that the command was tagged + tagged_command = result.message.arguments.get("command") + assert tagged_command is not None + assert "--comment=ai-mcp" in tagged_command or any( + "ai-mcp" in str(c) for c in tagged_command + ) + + asyncio.run(run_test()) + + def test_middleware_is_added_to_server(self): + """Test that the policy middleware is added to the server.""" + settings = Settings(mode="local", ssh_host=None, context_dir="/etc/agents.d") + server = assemble_server(settings) + + # Check that the server was created successfully + assert server is not None