mcp-proxy-adapter 3.0.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

mcp_proxy_adapter/tests/commands/test_help_command.py

@@ -0,0 +1,133 @@
+"""
+Tests for the help command.
+"""
+
+import pytest
+from unittest.mock import patch, MagicMock
+
+from mcp_proxy_adapter.commands.help_command import HelpCommand, HelpResult
+from mcp_proxy_adapter.core.errors import NotFoundError
+
+
+@pytest.fixture
+def mock_registry():
+    """Mock for command registry."""
+    with patch("mcp_proxy_adapter.commands.help_command.registry") as mock_reg:
+        yield mock_reg
+
+
+async def test_help_command_without_params(mock_registry):
+    """Test help command without parameters."""
+    # Setup mocks
+    mock_registry.get_all_metadata.return_value = {
+        "help": {
+            "name": "help",
+            "summary": "Get help information",
+            "description": "Get help information",
+            "params": {},
+            "examples": []
+        },
+        "health": {
+            "name": "health",
+            "summary": "Check server health",
+            "description": "Check server health",
+            "params": {},
+            "examples": []
+        }
+    }
+    
+    # Execute command
+    command = HelpCommand()
+    result = await command.execute()
+    
+    # Check result
+    assert isinstance(result, HelpResult)
+    assert result.commands_info is not None
+    assert result.command_info is None
+    
+    # Check content
+    commands_dict = result.to_dict()
+    assert "commands" in commands_dict
+    assert "help" in commands_dict["commands"]
+    assert "health" in commands_dict["commands"]
+    assert "summary" in commands_dict["commands"]["help"]
+    assert "Get help information" in commands_dict["commands"]["help"]["summary"]
+
+
+async def test_help_command_with_cmdname(mock_registry):
+    """Test help command with cmdname parameter."""
+    # Setup mocks
+    mock_registry.get_command_metadata.return_value = {
+        "name": "health",
+        "description": "Check server health",
+        "summary": "Check server health",
+        "params": {
+            "check_type": {
+                "type": "string",
+                "description": "Type of health check",
+                "required": False,
+                "default": "basic"
+            }
+        },
+        "examples": []
+    }
+    
+    # Execute command
+    command = HelpCommand()
+    result = await command.execute(cmdname="health")
+    
+    # Check result
+    assert isinstance(result, HelpResult)
+    assert result.commands_info is None
+    assert result.command_info is not None
+    
+    # Check content
+    command_dict = result.to_dict()
+    assert "cmdname" in command_dict
+    assert command_dict["cmdname"] == "health"
+    assert "info" in command_dict
+    assert "description" in command_dict["info"]
+    assert "Check server health" in command_dict["info"]["description"]
+    assert "params" in command_dict["info"]
+    assert "check_type" in command_dict["info"]["params"]
+
+
+async def test_help_command_with_invalid_cmdname(mock_registry):
+    """Test help command with invalid cmdname parameter."""
+    # Setup mocks
+    mock_registry.get_command_metadata.side_effect = NotFoundError("Command not found")
+    
+    # Execute command and check exception
+    command = HelpCommand()
+    with pytest.raises(NotFoundError) as excinfo:
+        await command.execute(cmdname="non_existent")
+    
+    assert "not found" in str(excinfo.value)
+
+
+def test_help_result_schema():
+    """Test help command result schema."""
+    schema = HelpResult.get_schema()
+    
+    assert schema["type"] == "object"
+    assert "oneOf" in schema
+    assert len(schema["oneOf"]) == 2
+    
+    commands_schema = schema["oneOf"][0]
+    assert "properties" in commands_schema
+    assert "commands" in commands_schema["properties"]
+    
+    command_schema = schema["oneOf"][1]
+    assert "properties" in command_schema
+    assert "cmdname" in command_schema["properties"]
+    assert "info" in command_schema["properties"]
+
+
+def test_help_command_schema():
+    """Test help command schema."""
+    schema = HelpCommand.get_schema()
+    
+    assert schema["type"] == "object"
+    assert "properties" in schema
+    assert "cmdname" in schema["properties"]
+    assert schema["properties"]["cmdname"]["type"] == "string" 

mcp_proxy_adapter/tests/conftest.py

@@ -0,0 +1,131 @@
+"""
+Module with fixtures and configuration for tests.
+"""
+
+import json
+import os
+import tempfile
+from typing import Any, Dict, Generator
+
+import pytest
+from fastapi.testclient import TestClient
+
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.config import Config
+
+
+@pytest.fixture
+def temp_config_file() -> Generator[str, None, None]:
+    """
+    Creates temporary configuration file for tests.
+
+    Returns:
+        Path to temporary configuration file.
+    """
+    # Create temporary file
+    fd, path = tempfile.mkstemp(suffix=".json")
+    
+    # Write test configuration
+    test_config = {
+        "server": {
+            "host": "127.0.0.1",
+            "port": 8888
+        },
+        "logging": {
+            "level": "DEBUG",
+            "file": None
+        },
+        # Отключаем аутентификацию и ограничение скорости для тестов
+        "auth_enabled": False,
+        "rate_limit_enabled": False
+    }
+    
+    with os.fdopen(fd, "w") as f:
+        json.dump(test_config, f)
+    
+    yield path
+    
+    # Remove temporary file after tests
+    os.unlink(path)
+
+
+@pytest.fixture
+def test_config(temp_config_file: str) -> Config:
+    """
+    Creates test configuration instance.
+
+    Args:
+        temp_config_file: Path to temporary configuration file.
+
+    Returns:
+        Test configuration instance.
+    """
+    return Config(temp_config_file)
+
+
+@pytest.fixture
+def test_client() -> TestClient:
+    """
+    Creates test client for FastAPI application.
+
+    Returns:
+        FastAPI test client.
+    """
+    app = create_app()
+    return TestClient(app)
+
+
+@pytest.fixture
+def clean_registry() -> Generator[None, None, None]:
+    """
+    Cleans command registry before test and restores it after.
+
+    Yields:
+        None
+    """
+    # Save current commands
+    original_commands = dict(registry._commands)
+    
+    # Clear registry
+    registry.clear()
+    
+    yield
+    
+    # Restore registry
+    registry.clear()
+    for name, command in original_commands.items():
+        registry._commands[name] = command
+
+
+@pytest.fixture
+def json_rpc_request() -> Dict[str, Any]:
+    """
+    Creates base JSON-RPC request.
+
+    Returns:
+        Dictionary with JSON-RPC request data.
+    """
+    return {
+        "jsonrpc": "2.0",
+        "method": "test_command",
+        "params": {},
+        "id": "test-id"
+    }
+
+
+@pytest.fixture(autouse=True)
+def register_test_commands():
+    """
+    Регистрирует тестовые команды в registry для всех тестов.
+    """
+    from mcp_proxy_adapter.tests.stubs.echo_command import EchoCommand
+    from mcp_proxy_adapter.commands.command_registry import registry
+    
+    # Регистрируем команды для тестирования
+    registry.register(EchoCommand)
+    
+    yield
+    
+    # Очищаем registry после тестов
+    registry.clear()

mcp_proxy_adapter/tests/functional/__init__.py

@@ -0,0 +1,3 @@
+"""
+Functional tests for the mcp_microservice package.
+""" 

mcp_proxy_adapter/tests/functional/test_api.py

@@ -0,0 +1,235 @@
+"""
+Functional tests for the API.
+"""
+
+import pytest
+from typing import Dict, Any
+
+from fastapi.testclient import TestClient
+
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.tests.stubs.echo_command import EchoCommand
+
+
+@pytest.fixture
+def register_echo_command(clean_registry):
+    """
+    Fixture to register the Echo command for testing.
+    
+    Args:
+        clean_registry: Fixture to clean registry before and after test.
+    """
+    registry.register(EchoCommand)
+    yield
+    registry.clear()
+
+
+@pytest.mark.functional
+def test_execute_command(test_client: TestClient, json_rpc_request: Dict[str, Any], register_echo_command):
+    """
+    Test execution of command via API.
+    
+    Args:
+        test_client: FastAPI test client.
+        json_rpc_request: Base JSON-RPC request.
+        register_echo_command: Fixture to register test command.
+    """
+    # Create JSON-RPC request
+    request_data = json_rpc_request.copy()
+    request_data["method"] = "echo"
+    request_data["params"] = {"test_key": "test_value"}
+    
+    # Send request
+    response = test_client.post("/api/jsonrpc", json=request_data)
+    
+    # Check response
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    
+    # Check response structure
+    data = response.json()
+    assert "jsonrpc" in data and data["jsonrpc"] == "2.0"
+    assert "result" in data
+    assert "id" in data and data["id"] == request_data["id"]
+    
+    # Check result content
+    assert "params" in data["result"]
+    assert data["result"]["params"] == {"test_key": "test_value"}
+
+
+@pytest.mark.functional
+def test_execute_nonexistent_command(test_client: TestClient, json_rpc_request: Dict[str, Any]):
+    """
+    Test execution of nonexistent command.
+    
+    Args:
+        test_client: FastAPI test client.
+        json_rpc_request: Base JSON-RPC request.
+    """
+    # Create JSON-RPC request with nonexistent command
+    request_data = json_rpc_request.copy()
+    request_data["method"] = "nonexistent_command"
+    
+    # Send request
+    response = test_client.post("/api/jsonrpc", json=request_data)
+    
+    # Check response
+    assert response.status_code == 400 or response.status_code == 200
+    
+    # Check response structure
+    data = response.json()
+    assert "jsonrpc" in data and data["jsonrpc"] == "2.0"
+    assert "error" in data
+    assert "id" in data and data["id"] == request_data["id"]
+    
+    # Check error content
+    assert "code" in data["error"]
+    assert "message" in data["error"]
+    assert data["error"]["code"] == -32601  # Method not found
+    assert "not found" in data["error"]["message"].lower()
+
+
+@pytest.mark.functional
+def test_invalid_json_rpc_request(test_client: TestClient):
+    """
+    Test invalid JSON-RPC request.
+    
+    Args:
+        test_client: FastAPI test client.
+    """
+    # Create invalid JSON-RPC request
+    request_data = {
+        "method": "echo",
+        "params": {}
+        # Missing jsonrpc and id fields
+    }
+    
+    # Send request
+    response = test_client.post("/api/jsonrpc", json=request_data)
+    
+    # Check response
+    assert response.status_code == 400 or response.status_code == 200
+    
+    # Check response structure
+    data = response.json()
+    assert "jsonrpc" in data and data["jsonrpc"] == "2.0"
+    assert "error" in data
+    
+    # Check error content
+    assert "code" in data["error"]
+    assert "message" in data["error"]
+    assert data["error"]["code"] == -32600  # Invalid Request
+
+
+@pytest.mark.functional
+def test_get_commands(test_client: TestClient, register_echo_command):
+    """
+    Test getting list of commands.
+    
+    Args:
+        test_client: FastAPI test client.
+        register_echo_command: Fixture to register test command.
+    """
+    # Send request
+    response = test_client.get("/api/commands")
+    
+    # Check response
+    assert response.status_code == 200
+    
+    # Check response structure
+    data = response.json()
+    assert "commands" in data
+    assert isinstance(data["commands"], dict)
+    
+    # Check that echo command is in the list
+    assert "echo" in data["commands"]
+    assert "description" in data["commands"]["echo"]
+    assert "schema" in data["commands"]["echo"]
+
+
+@pytest.mark.functional
+def test_health_check(test_client: TestClient):
+    """
+    Test health check endpoint.
+    
+    Args:
+        test_client: FastAPI test client.
+    """
+    # Send request
+    response = test_client.get("/health")
+    
+    # Check response
+    assert response.status_code == 200
+    
+    # Check response structure
+    data = response.json()
+    assert "status" in data
+    assert data["status"] == "ok"
+
+
+@pytest.mark.functional
+def test_openapi_schema(test_client: TestClient):
+    """
+    Test OpenAPI schema endpoint.
+    
+    Args:
+        test_client: FastAPI test client.
+    """
+    # Send request
+    response = test_client.get("/openapi.json")
+    
+    # Check response
+    assert response.status_code == 200
+    
+    # Check response content
+    data = response.json()
+    assert "openapi" in data
+    assert "info" in data
+    assert "paths" in data
+    
+    # Check that API endpoints are in schema
+    assert "/cmd" in data["paths"]
+    assert "/api/commands" in data["paths"]
+    assert "/health" in data["paths"]
+
+
+@pytest.mark.functional
+def test_batch_requests(test_client: TestClient, json_rpc_request: Dict[str, Any], register_echo_command):
+    """
+    Test batch requests processing.
+    
+    Args:
+        test_client: FastAPI test client.
+        json_rpc_request: Base JSON-RPC request.
+        register_echo_command: Fixture to register test command.
+    """
+    # Create batch request
+    request1 = json_rpc_request.copy()
+    request1["method"] = "echo"
+    request1["params"] = {"request_id": "1"}
+    request1["id"] = "1"
+    
+    request2 = json_rpc_request.copy()
+    request2["method"] = "echo"
+    request2["params"] = {"request_id": "2"}
+    request2["id"] = "2"
+    
+    batch_request = [request1, request2]
+    
+    # Send request
+    response = test_client.post("/api/jsonrpc", json=batch_request)
+    
+    # Check response
+    assert response.status_code == 200
+    
+    # Check response structure
+    data = response.json()
+    assert isinstance(data, list)
+    assert len(data) == 2
+    
+    # Check individual responses
+    assert data[0]["result"]["params"] == {"request_id": "1"}
+    assert data[0]["id"] == "1"
+    
+    assert data[1]["result"]["params"] == {"request_id": "2"}
+    assert data[1]["id"] == "2" 

mcp_proxy_adapter/tests/integration/__init__.py

@@ -0,0 +1,3 @@
+"""
+Integration tests for the mcp_microservice package.
+""" 

mcp_proxy_adapter/tests/integration/test_cmd_integration.py

@@ -0,0 +1,130 @@
+"""
+Integration tests for /cmd endpoint and help command.
+"""
+
+import pytest
+from fastapi.testclient import TestClient
+
+from mcp_proxy_adapter.api.app import app
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.commands.help_command import HelpCommand
+
+
+@pytest.fixture(autouse=True)
+def setup_registry():
+    """Setup command registry for tests."""
+    # Store original commands
+    original_commands = dict(registry._commands)
+    
+    # Clear registry
+    registry._commands.clear()
+    
+    # Register help command
+    registry.register(HelpCommand)
+    
+    yield
+    
+    # Restore original commands
+    registry._commands.clear()
+    for name, command in original_commands.items():
+        registry._commands[name] = command
+
+
+@pytest.fixture
+def client():
+    """Test client for FastAPI app."""
+    return TestClient(app)
+
+
+def test_cmd_help_without_params(client):
+    """Test /cmd endpoint with help command without parameters."""
+    response = client.post(
+        "/cmd",
+        json={"command": "help"}
+    )
+    
+    assert response.status_code == 200
+    assert "result" in response.json()
+    result = response.json()["result"]
+    
+    assert "commands" in result
+    assert "help" in result["commands"]
+    assert "summary" in result["commands"]["help"]
+
+
+def test_cmd_help_with_cmdname(client):
+    """Test /cmd endpoint with help command with cmdname parameter."""
+    response = client.post(
+        "/cmd",
+        json={
+            "command": "help",
+            "params": {
+                "cmdname": "help"
+            }
+        }
+    )
+    
+    assert response.status_code == 200
+    assert "result" in response.json()
+    result = response.json()["result"]
+    
+    assert "cmdname" in result
+    assert result["cmdname"] == "help"
+    assert "info" in result
+    assert "description" in result["info"]
+    assert "params" in result["info"]
+    assert "cmdname" in result["info"]["params"]
+
+
+def test_cmd_help_unknown_command(client):
+    """Test /cmd endpoint with help command for unknown command."""
+    response = client.post(
+        "/cmd",
+        json={
+            "command": "help",
+            "params": {
+                "cmdname": "unknown_command"
+            }
+        }
+    )
+    
+    assert response.status_code == 200
+    assert "result" in response.json()
+    result = response.json()["result"]
+    
+    assert "success" in result and result["success"] is False
+    assert "error" in result
+    error = result["error"]
+    
+    assert error["code"] == -32601
+    assert "not found" in error["message"]
+
+
+def test_cmd_unknown_command(client):
+    """Test /cmd endpoint with unknown command."""
+    response = client.post(
+        "/cmd",
+        json={"command": "unknown_command"}
+    )
+    
+    assert response.status_code == 200
+    assert "error" in response.json()
+    error = response.json()["error"]
+    
+    assert error["code"] == -32601
+    assert "не найдена" in error["message"]
+
+
+def test_cmd_invalid_request(client):
+    """Test /cmd endpoint with invalid request format."""
+    response = client.post(
+        "/cmd",
+        json={"invalid": "request"}
+    )
+    
+    assert response.status_code == 200
+    assert "error" in response.json()
+    error = response.json()["error"]
+    
+    assert error["code"] == -32600
+    assert "Отсутствует обязательное поле 'command'" in error["message"]