napistu 0.2.5.dev7__py3-none-any.whl → 0.3.1.dev1__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

@@ -48,7 +48,8 @@ def collect_resources_and_tools(mcp: FastMCP) -> Tuple[List[str], List[str]]:
 def test_documentation_naming():
     """Test that documentation component uses valid names."""
     mcp = FastMCP("test")
-    documentation.register_components(mcp)
+    documentation_component = documentation.get_component()
+    documentation_component.register(mcp)
 
     resource_paths, tool_names = collect_resources_and_tools(mcp)
 
@@ -64,7 +65,8 @@ def test_documentation_naming():
 def test_codebase_naming():
     """Test that codebase component uses valid names."""
     mcp = FastMCP("test")
-    codebase.register_components(mcp)
+    codebase_component = codebase.get_component()
+    codebase_component.register(mcp)
 
     resource_paths, tool_names = collect_resources_and_tools(mcp)
 
@@ -80,7 +82,8 @@ def test_codebase_naming():
 def test_tutorials_naming():
     """Test that tutorials component uses valid names."""
     mcp = FastMCP("test")
-    tutorials.register_components(mcp)
+    tutorials_component = tutorials.get_component()
+    tutorials_component.register(mcp)
 
     resource_paths, tool_names = collect_resources_and_tools(mcp)
 
@@ -96,7 +99,14 @@ def test_tutorials_naming():
 def test_execution_naming():
     """Test that execution component uses valid names."""
     mcp = FastMCP("test")
-    execution.register_components(mcp)
+
+    # 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)
 
@@ -129,11 +139,25 @@ def test_all_components_naming():
     """Test that all components together use valid names without conflicts."""
     mcp = FastMCP("test")
 
-    # Register all components
-    documentation.register_components(mcp)
-    codebase.register_components(mcp)
-    tutorials.register_components(mcp)
-    execution.register_components(mcp)
+    # 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)
@@ -157,11 +181,25 @@ def test_expected_resources_exist():
     """Test that all expected resources are registered."""
     mcp = FastMCP("test")
 
-    # Register all components
-    documentation.register_components(mcp)
-    codebase.register_components(mcp)
-    tutorials.register_components(mcp)
-    execution.register_components(mcp)
+    # 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)
@@ -191,15 +229,35 @@ def test_expected_tools_exist():
     """Test that all expected tools are registered."""
     mcp = FastMCP("test")
 
-    # Register all components
-    documentation.register_components(mcp)
-    codebase.register_components(mcp)
-    tutorials.register_components(mcp)
-    execution.register_components(mcp)
+    # 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",
@@ -217,3 +275,82 @@ def test_expected_tools_exist():
     # 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"]