napistu 0.2.5.dev6__py3-none-any.whl → 0.3.1__py3-none-any.whl

tests/test_mcp_config.py

@@ -0,0 +1,193 @@
+"""
+Tests for MCP configuration validation, presets, and Pydantic models.
+"""
+
+import pytest
+from pydantic import ValidationError
+import click
+
+from napistu.mcp.config import (
+    MCPServerConfig,
+    MCPClientConfig,
+    local_server_config,
+    production_server_config,
+    local_client_config,
+    production_client_config,
+    validate_server_config_flags,
+    validate_client_config_flags,
+)
+from napistu.mcp.constants import MCP_DEFAULTS
+
+
+def test_configuration_validation():
+    """Test validation logic for preset conflicts and manual configuration requirements."""
+
+    # Test conflicting presets
+    with pytest.raises(
+        click.BadParameter, match="Cannot use both --local and --production"
+    ):
+        validate_server_config_flags(
+            local=True, production=True, host=None, port=None, server_name=None
+        )
+
+    with pytest.raises(
+        click.BadParameter, match="Cannot use both --local and --production"
+    ):
+        validate_client_config_flags(
+            local=True, production=True, host=None, port=None, use_https=None
+        )
+
+    # Test preset + manual config conflicts
+    with pytest.raises(click.BadParameter, match="Cannot use --local with manual"):
+        validate_server_config_flags(
+            local=True,
+            production=False,
+            host="192.168.1.1",
+            port=None,
+            server_name=None,
+        )
+
+    with pytest.raises(click.BadParameter, match="Cannot use --production with manual"):
+        validate_client_config_flags(
+            local=False, production=True, host="localhost", port=None, use_https=None
+        )
+
+    # Test incomplete manual configuration
+    with pytest.raises(
+        click.BadParameter,
+        match="Manual configuration requires --host, --port, and --server-name",
+    ):
+        validate_server_config_flags(
+            local=False, production=False, host="localhost", port=None, server_name=None
+        )
+
+    with pytest.raises(
+        click.BadParameter,
+        match="Manual configuration requires --host, --port, and --https",
+    ):
+        validate_client_config_flags(
+            local=False, production=False, host="localhost", port=8080, use_https=None
+        )
+
+    # Test valid configurations don't raise errors
+    config = validate_server_config_flags(
+        local=True, production=False, host=None, port=None, server_name=None
+    )
+    assert isinstance(config, MCPServerConfig)
+
+    config = validate_client_config_flags(
+        local=False, production=True, host=None, port=None, use_https=None
+    )
+    assert isinstance(config, MCPClientConfig)
+
+    # Test valid manual configuration
+    config = validate_server_config_flags(
+        local=False,
+        production=False,
+        host="localhost",
+        port=9000,
+        server_name="test-server",
+    )
+    assert config.host == "localhost"
+    assert config.port == 9000
+    assert config.server_name == "test-server"
+
+
+def test_preset_configurations():
+    """Test that preset functions return correct and consistent configurations."""
+
+    # Test local server preset
+    local_server = local_server_config()
+    assert local_server.host == MCP_DEFAULTS.LOCAL_HOST
+    assert local_server.port == MCP_DEFAULTS.LOCAL_PORT
+    assert local_server.server_name == MCP_DEFAULTS.LOCAL_SERVER_NAME
+    assert (
+        local_server.bind_address
+        == f"{MCP_DEFAULTS.LOCAL_HOST}:{MCP_DEFAULTS.LOCAL_PORT}"
+    )
+
+    # Test production server preset
+    production_server = production_server_config()
+    assert production_server.host == MCP_DEFAULTS.PRODUCTION_HOST
+    assert production_server.port == MCP_DEFAULTS.PRODUCTION_PORT
+    assert production_server.server_name == MCP_DEFAULTS.PRODUCTION_SERVER_NAME
+
+    # Test local client preset
+    local_client = local_client_config()
+    assert local_client.host == MCP_DEFAULTS.LOCAL_HOST
+    assert local_client.port == MCP_DEFAULTS.LOCAL_PORT
+    assert not local_client.use_https
+    assert (
+        local_client.base_url
+        == f"http://{MCP_DEFAULTS.LOCAL_HOST}:{MCP_DEFAULTS.LOCAL_PORT}"
+    )
+    assert (
+        local_client.mcp_url
+        == f"http://{MCP_DEFAULTS.LOCAL_HOST}:{MCP_DEFAULTS.LOCAL_PORT}{MCP_DEFAULTS.MCP_PATH}"
+    )
+
+    # Test production client preset
+    production_client = production_client_config()
+    assert production_client.use_https
+    assert production_client.port == MCP_DEFAULTS.HTTPS_PORT
+    assert (
+        "napistu-mcp-server" in production_client.host
+    )  # Extracted from production URL
+    assert production_client.base_url.startswith("https://")
+    assert production_client.mcp_url.endswith(MCP_DEFAULTS.MCP_PATH)
+
+    # Test that presets are deterministic (same result on multiple calls)
+    assert local_server_config().host == local_server_config().host
+    assert production_client_config().port == production_client_config().port
+
+
+def test_pydantic_model_validation():
+    """Test Pydantic model validation for ports, hosts, and computed properties."""
+
+    # Test valid configurations
+    valid_server = MCPServerConfig(host="localhost", port=8080, server_name="test")
+    assert valid_server.host == "localhost"
+    assert valid_server.port == 8080
+    assert valid_server.server_name == "test"
+    assert valid_server.bind_address == "localhost:8080"
+
+    valid_client = MCPClientConfig(host="example.com", port=443, use_https=True)
+    assert valid_client.host == "example.com"
+    assert valid_client.base_url == "https://example.com:443"
+    assert valid_client.mcp_url == f"https://example.com:443{MCP_DEFAULTS.MCP_PATH}"
+
+    # Test invalid port validation
+    with pytest.raises(
+        ValidationError, match="Input should be greater than or equal to 1"
+    ):
+        MCPServerConfig(host="localhost", port=0, server_name="test")
+
+    with pytest.raises(
+        ValidationError, match="Input should be less than or equal to 65535"
+    ):
+        MCPServerConfig(host="localhost", port=70000, server_name="test")
+
+    with pytest.raises(
+        ValidationError, match="Input should be greater than or equal to 1"
+    ):
+        MCPClientConfig(host="localhost", port=-1, use_https=False)
+
+    # Test empty/whitespace host validation
+    with pytest.raises(ValidationError, match="Host cannot be empty"):
+        MCPServerConfig(host="", port=8080, server_name="test")
+
+    with pytest.raises(ValidationError, match="Host cannot be empty"):
+        MCPServerConfig(host="   ", port=8080, server_name="test")
+
+    # Test host whitespace trimming
+    server_with_spaces = MCPServerConfig(
+        host="  localhost  ", port=8080, server_name="test"
+    )
+    assert server_with_spaces.host == "localhost"  # Should be trimmed
+
+    # Test URL generation with different protocols
+    http_client = MCPClientConfig(host="localhost", port=8080, use_https=False)
+    assert http_client.base_url == "http://localhost:8080"
+
+    https_client = MCPClientConfig(host="secure.com", port=443, use_https=True)
+    assert https_client.base_url == "https://secure.com:443"

tests/test_mcp_documentation_utils.py

@@ -1,13 +1,22 @@
 import pytest
-from napistu.mcp.documentation_utils import load_readme_content
-from napistu.mcp.constants import READMES
+from napistu.mcp.documentation_utils import load_readme_content, fetch_wiki_page
+from napistu.mcp.constants import READMES, WIKI_PAGES
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("name,url", READMES.items())
+@pytest.mark.parametrize("name,url", list(READMES.items())[:2])
 async def test_load_readme_content(name, url):
     content = await load_readme_content(url)
     assert isinstance(content, str)
     assert len(content) > 0
     # Optionally, check for a keyword in the content
     assert "napistu" in content.lower() or "Napistu" in content
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("page_name", list(WIKI_PAGES)[:2])
+async def test_fetch_wiki_page(page_name):
+    content = await fetch_wiki_page(page_name)
+    assert isinstance(content, str)
+    assert len(content) > 0
+    assert "napistu" in content.lower() or "Napistu" in content

tests/test_mcp_server.py

@@ -0,0 +1,356 @@
+"""
+Tests to validate MCP tool and resource naming conventions.
+"""
+
+import re
+from typing import List, Tuple
+from fastmcp import FastMCP
+
+from napistu.mcp import (
+    documentation,
+    codebase,
+    tutorials,
+    execution,
+    health,
+)
+
+# Regex patterns for validation
+VALID_RESOURCE_PATH = re.compile(
+    r"^napistu://[a-zA-Z][a-zA-Z0-9_]*(?:/[a-zA-Z0-9_{}.-]+)*$"
+)
+VALID_TOOL_NAME = re.compile(r"^[a-zA-Z][a-zA-Z0-9_]*$")
+
+
+def collect_resources_and_tools(mcp: FastMCP) -> Tuple[List[str], List[str]]:
+    """
+    Collect all registered resource paths and tool names from an MCP server instance.
+
+    Args:
+        mcp: FastMCP server instance
+
+    Returns:
+        Tuple of (resource_paths, tool_names)
+    """
+    # Get all registered resources and tools
+    resources = mcp._resource_manager.get_resources()
+    tool_names = mcp._tool_manager.get_tools()
+
+    # Extract resource paths from the resource objects
+    resource_paths = []
+
+    # Add all resources (including parameterized ones)
+    for resource in resources.values():
+        resource_paths.append(str(resource.uri))
+
+    return resource_paths, tool_names
+
+
+def test_documentation_naming():
+    """Test that documentation component uses valid names."""
+    mcp = FastMCP("test")
+    documentation_component = documentation.get_component()
+    documentation_component.register(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check resource paths
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+
+    # Check tool names
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+
+
+def test_codebase_naming():
+    """Test that codebase component uses valid names."""
+    mcp = FastMCP("test")
+    codebase_component = codebase.get_component()
+    codebase_component.register(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check resource paths
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+
+    # Check tool names
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+
+
+def test_tutorials_naming():
+    """Test that tutorials component uses valid names."""
+    mcp = FastMCP("test")
+    tutorials_component = tutorials.get_component()
+    tutorials_component.register(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check resource paths
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+
+    # Check tool names
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+
+
+def test_execution_naming():
+    """Test that execution component uses valid names."""
+    mcp = FastMCP("test")
+
+    # Create execution component with test session context
+    test_session_context = {}
+    test_object_registry = {}
+    execution_component = execution.create_component(
+        session_context=test_session_context, object_registry=test_object_registry
+    )
+    execution_component.register(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check resource paths
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+
+    # Check tool names
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+
+
+def test_health_naming():
+    """Test that health component uses valid names."""
+    mcp = FastMCP("test")
+    health.register_components(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check resource paths
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+
+    # Check tool names
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+
+
+def test_all_components_naming():
+    """Test that all components together use valid names without conflicts."""
+    mcp = FastMCP("test")
+
+    # Register all components using new class-based API
+    documentation_component = documentation.get_component()
+    documentation_component.register(mcp)
+
+    codebase_component = codebase.get_component()
+    codebase_component.register(mcp)
+
+    tutorials_component = tutorials.get_component()
+    tutorials_component.register(mcp)
+
+    # Create execution component with test context
+    test_session_context = {}
+    test_object_registry = {}
+    execution_component = execution.create_component(
+        session_context=test_session_context, object_registry=test_object_registry
+    )
+    execution_component.register(mcp)
+
+    # Health component still uses legacy registration
+    health.register_components(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check for duplicate resource paths
+    path_counts = {}
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+        path_counts[path] = path_counts.get(path, 0) + 1
+        assert path_counts[path] == 1, f"Duplicate resource path: {path}"
+
+    # Check for duplicate tool names
+    name_counts = {}
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+        name_counts[name] = name_counts.get(name, 0) + 1
+        assert name_counts[name] == 1, f"Duplicate tool name: {name}"
+
+
+def test_expected_resources_exist():
+    """Test that all expected resources are registered."""
+    mcp = FastMCP("test")
+
+    # Register all components using new class-based API
+    documentation_component = documentation.get_component()
+    documentation_component.register(mcp)
+
+    codebase_component = codebase.get_component()
+    codebase_component.register(mcp)
+
+    tutorials_component = tutorials.get_component()
+    tutorials_component.register(mcp)
+
+    # Create execution component with test context
+    test_session_context = {}
+    test_object_registry = {}
+    execution_component = execution.create_component(
+        session_context=test_session_context, object_registry=test_object_registry
+    )
+    execution_component.register(mcp)
+
+    # Health component still uses legacy registration
+    health.register_components(mcp)
+
+    resource_paths, _ = collect_resources_and_tools(mcp)
+
+    # Debug: Print all registered resources
+    print("\nRegistered resources:")
+    for path in sorted(resource_paths):
+        print(f"  {path}")
+    print()
+
+    # List of expected base resources (no templates)
+    expected_resources = {
+        "napistu://documentation/summary",
+        "napistu://codebase/summary",
+        "napistu://tutorials/index",
+        "napistu://execution/registry",
+        "napistu://execution/environment",
+        "napistu://health",
+    }
+
+    # Check that each expected resource exists
+    for resource in expected_resources:
+        assert resource in resource_paths, f"Missing expected resource: {resource}"
+
+
+def test_expected_tools_exist():
+    """Test that all expected tools are registered."""
+    mcp = FastMCP("test")
+
+    # Register all components using new class-based API
+    documentation_component = documentation.get_component()
+    documentation_component.register(mcp)
+
+    codebase_component = codebase.get_component()
+    codebase_component.register(mcp)
+
+    tutorials_component = tutorials.get_component()
+    tutorials_component.register(mcp)
+
+    # Create execution component with test context
+    test_session_context = {}
+    test_object_registry = {}
+    execution_component = execution.create_component(
+        session_context=test_session_context, object_registry=test_object_registry
+    )
+    execution_component.register(mcp)
+
+    # Health component still uses legacy registration
+    health.register_components(mcp)
+
+    _, tool_names = collect_resources_and_tools(mcp)
+
+    # Debug: Print all registered tools
+    print("\nRegistered tools:")
+    for name in sorted(tool_names):
+        print(f"  {name}")
+    print()
+
+    # List of expected tools
+    expected_tools = {
+        "search_documentation",
+        "search_codebase",
+        "get_function_documentation",
+        "get_class_documentation",
+        "search_tutorials",
+        "list_registry",
+        "describe_object",
+        "execute_function",
+        "search_paths",
+        "check_health",
+    }
+
+    # Check that all expected tools exist
+    for tool in expected_tools:
+        assert tool in tool_names, f"Missing expected tool: {tool}"
+
+
+def test_component_state_health():
+    """Test that component states can provide health information."""
+    # Test documentation component state
+    doc_component = documentation.get_component()
+    doc_state = doc_component.get_state()
+    health_status = doc_state.get_health_status()
+    assert "status" in health_status
+    assert health_status["status"] in [
+        "initializing",
+        "healthy",
+        "inactive",
+        "unavailable",
+    ]
+
+    # Test codebase component state
+    codebase_component = codebase.get_component()
+    codebase_state = codebase_component.get_state()
+    health_status = codebase_state.get_health_status()
+    assert "status" in health_status
+    assert health_status["status"] in [
+        "initializing",
+        "healthy",
+        "inactive",
+        "unavailable",
+    ]
+
+    # Test tutorials component state
+    tutorials_component = tutorials.get_component()
+    tutorials_state = tutorials_component.get_state()
+    health_status = tutorials_state.get_health_status()
+    assert "status" in health_status
+    assert health_status["status"] in [
+        "initializing",
+        "healthy",
+        "inactive",
+        "unavailable",
+    ]
+
+    # Test execution component state
+    test_session_context = {"test": "value"}
+    test_object_registry = {}
+    execution_component = execution.create_component(
+        session_context=test_session_context, object_registry=test_object_registry
+    )
+    execution_state = execution_component.get_state()
+    health_status = execution_state.get_health_status()
+    assert "status" in health_status
+    assert health_status["status"] in [
+        "initializing",
+        "healthy",
+        "inactive",
+        "unavailable",
+    ]
+
+
+def test_execution_object_registration():
+    """Test that execution component can register and track objects."""
+    test_session_context = {}
+    test_object_registry = {}
+    execution_component = execution.create_component(
+        session_context=test_session_context, object_registry=test_object_registry
+    )
+
+    # Register a test object
+    test_object = {"test": "data"}
+    execution_component.register_object("test_obj", test_object)
+
+    # Check that object was registered
+    state = execution_component.get_state()
+    assert "test_obj" in state.session_objects
+    assert state.session_objects["test_obj"] == test_object
+
+    # Check health details include the object
+    health_details = state.get_health_details()
+    assert "registered_objects" in health_details
+    assert health_details["registered_objects"] == 1
+    assert "test_obj" in health_details["object_names"]