Parcourir la source

add tests for tools and resources

Khanh Nguyen il y a 5 mois
Parent
commit
b43143c9c8
3 fichiers modifiés avec 518 ajouts et 0 suppressions
  1. 73 0
      tests/conftest.py
  2. 242 0
      tests/test_resources.py
  3. 203 0
      tests/test_tools.py

+ 73 - 0
tests/conftest.py

@@ -0,0 +1,73 @@
+"""Fixtures partagées pour les tests d'intégration MCP."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+from mcp.client.session import ClientSession
+from mcp.server.fastmcp import FastMCP
+from mcp.shared.memory import create_connected_server_and_client_session
+
+from src.config.initialization import InitializationError, get_settings
+from src.server_mcp.resources import register_resources
+from src.server_mcp.server import build_server
+from src.server_mcp.tools import register_tools
+from src.services.client_rest import ClientRest
+
+
+@pytest.fixture
+def client_rest() -> MagicMock:
+    return MagicMock()
+
+
+@pytest.fixture
+def mcp_server(client_rest: MagicMock) -> FastMCP:
+    server = FastMCP("lw-copilot-mcp-server-test")
+    register_resources(server, client_rest)
+    register_tools(server, client_rest)
+    return server
+
+
+@pytest.fixture
+async def mcp_session(mcp_server: FastMCP) -> ClientSession:
+    async with create_connected_server_and_client_session(mcp_server) as session:
+        yield session
+
+
+async def read_resource_json(session: ClientSession, uri: str) -> Any:
+    """Lit une ressource MCP et parse son contenu JSON."""
+    result = await session.read_resource(uri)
+    return json.loads(result.contents[0].text)
+
+
+async def call_tool(session: ClientSession, tool_name: str, params: dict[str, Any]) -> Any:
+    result = await session.call_tool(tool_name, params)
+    return json.loads(result.content[0].text)
+
+
+@pytest.fixture
+def require_integration_env() -> None:
+    """Ignore le test si l'environnement d'integration live n'est pas active."""
+    if os.getenv("RUN_INTEGRATION_TESTS") != "1":
+        pytest.skip("Definir RUN_INTEGRATION_TESTS=1 pour executer les tests live.")
+
+
+@pytest.fixture
+def live_mcp_server(require_integration_env: None) -> FastMCP:
+    """Serveur MCP connecte au ClientRest reel (API LWE distante)."""
+    get_settings.cache_clear()
+    try:
+        client_rest = ClientRest()
+    except InitializationError as exc:
+        pytest.skip(f"Configuration LWE indisponible: {exc}")
+    return build_server(client_rest)
+
+
+@pytest.fixture
+async def live_mcp_session(live_mcp_server: FastMCP) -> ClientSession:
+    async with create_connected_server_and_client_session(live_mcp_server) as session:
+        yield session

+ 242 - 0
tests/test_resources.py

@@ -0,0 +1,242 @@
+"""Tests pour src.server_mcp.resources."""
+
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import MagicMock
+
+import httpx
+import pytest
+from mcp.client.session import ClientSession
+
+
+from src.server_mcp.resources import (
+    _GET_RESOURCES_WHITELIST,
+    _filter_list,
+    _unwrap_data,
+)
+from src.services.client_rest import HTTPMethod
+from tests.conftest import read_resource_json
+
+
+def _http_error() -> httpx.HTTPStatusError:
+    request = httpx.Request("GET", "https://api.example.com/rest/tools/resource/1")
+    response = httpx.Response(500, request=request)
+    return httpx.HTTPStatusError("Server Error", request=request, response=response)
+
+
+class TestHelpers:
+    def test_filter_list_filters_dict_items(self) -> None:
+        items = [
+            {"id": 1, "alias": "a", "extra": "x"},
+            "raw-item",
+        ]
+
+        result = _filter_list(items, _GET_RESOURCES_WHITELIST)
+
+        assert result[0] == {"id": 1, "alias": "a"}
+        assert result[1] == "raw-item"
+
+    def test_unwrap_data_returns_response_when_not_wrapped(self) -> None:
+        raw = {"id": 1, "alias": "home"}
+
+        assert _unwrap_data(raw) is raw
+
+
+@pytest.mark.anyio
+class TestResourcesMcpIntegration:
+    async def test_list_resources_exposes_static_endpoints(
+        self,
+        mcp_session: ClientSession,
+    ) -> None:
+        result = await mcp_session.list_resources()
+
+        uris = {str(resource.uri) for resource in result.resources}
+        assert uris == {"modx://templates", "modx://categories"}
+
+    async def test_get_resource_via_client_session(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {
+                "id": 10000,
+                "alias": "accueil",
+                "pagetitle": "Accueil",
+                "internalKey": "ignored",
+            },
+        }
+
+        result = await read_resource_json(mcp_session, "modx://resource/10000")
+
+        assert result == {"id": 10000, "alias": "accueil", "pagetitle": "Accueil"}
+        client_rest.execute.assert_called_once_with(
+            method=HTTPMethod.GET,
+            endpoint="/rest/tools/resource/10000",
+            params={"showUnpublished": 1},
+        )
+
+    async def test_get_resource_falls_back_without_query_params_on_http_error(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.side_effect = [
+            _http_error(),
+            {"code": "200", "data": {"id": 10000, "alias": "accueil"}},
+        ]
+
+        result = await read_resource_json(mcp_session, "modx://resource/10000")
+
+        assert result == {"id": 10000, "alias": "accueil"}
+        assert client_rest.execute.call_count == 2
+
+    async def test_get_resource_returns_raw_wrapper_when_data_is_not_dict(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.return_value = {"code": "200", "data": "unexpected"}
+
+        result = await read_resource_json(mcp_session, "modx://resource/10000")
+
+        assert result == {"data": {"code": "200", "data": "unexpected"}}
+
+    async def test_get_resources_filters_list_items(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": [
+                {"id": 1, "alias": "child", "pagetitle": "Child", "extra": "x"},
+            ],
+        }
+
+        result = await read_resource_json(mcp_session, "modx://resources/10000")
+
+        assert result == {"items": [{"id": 1, "alias": "child", "pagetitle": "Child"}]}
+        client_rest.execute.assert_called_once_with(
+            method=HTTPMethod.GET,
+            endpoint="/rest/tools/getresources/10000",
+            params={"depth": -1, "includedTv": 0, "showUnpublished": 1},
+        )
+
+    async def test_get_resources_filters_items_inside_dict(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {
+                "items": [{"id": 2, "alias": "x", "noise": "y"}],
+                "meta": "kept",
+            },
+        }
+
+        result = await read_resource_json(mcp_session, "modx://resources/10000")
+
+        assert result["items"] == [{"id": 2, "alias": "x"}]
+        assert result["meta"] == "kept"
+
+    async def test_get_resources_filters_flat_dict_when_no_items_key(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {"id": 3, "alias": "solo", "noise": "y"},
+        }
+
+        result = await read_resource_json(mcp_session, "modx://resources/10000")
+
+        assert result == {"id": 3, "alias": "solo"}
+
+    async def test_get_resources_falls_back_without_query_params_on_http_error(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.side_effect = [
+            _http_error(),
+            {"code": "200", "data": [{"id": 1, "alias": "child"}]},
+        ]
+
+        result = await read_resource_json(mcp_session, "modx://resources/10000")
+
+        assert result == {"items": [{"id": 1, "alias": "child"}]}
+        assert client_rest.execute.call_count == 2
+
+    async def test_get_template_via_client_session(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.return_value = {"code": "200", "data": {"id": 12, "name": "Page"}}
+
+        result = await read_resource_json(mcp_session, "modx://template/12")
+
+        assert result == {"id": 12, "name": "Page"}
+
+    async def test_get_templates_via_client_session(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.return_value = {"code": "200", "data": [{"id": 12}]}
+
+        result = await read_resource_json(mcp_session, "modx://templates")
+
+        assert result == {"items": [{"id": 12}]}
+
+    async def test_get_tv_via_client_session(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.return_value = {"code": "200", "data": {"id": 5, "name": "tv"}}
+
+        result = await read_resource_json(mcp_session, "modx://tv/5")
+
+        assert result == {"id": 5, "name": "tv"}
+
+    async def test_get_category_via_client_session(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.return_value = {"code": "200", "data": {"id": 7, "category": "UI"}}
+
+        result = await read_resource_json(mcp_session, "modx://category/7")
+
+        assert result == {"id": 7, "category": "UI"}
+
+    async def test_get_categories_via_client_session(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.return_value = {"code": "200", "data": [{"id": 1}]}
+
+        result = await read_resource_json(mcp_session, "modx://categories")
+
+        assert result == {"items": [{"id": 1}]}
+
+    async def test_get_categories_returns_warning_when_endpoint_unavailable(
+        self,
+        mcp_session: ClientSession,
+        client_rest: MagicMock,
+    ) -> None:
+        client_rest.execute.side_effect = _http_error()
+
+        result = await read_resource_json(mcp_session, "modx://categories")
+
+        assert result == {
+            "items": [],
+            "warning": "Endpoint /rest/tools/categories indisponible sur ce serveur.",
+        }

+ 203 - 0
tests/test_tools.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import pytest
+
+from unittest.mock import MagicMock
+
+from mcp.client.session import ClientSession
+from conftest import call_tool
+from src.services.client_rest import HTTPMethod
+
+@pytest.mark.anyio
+class TestToolsMcpIntegration:
+    async def test_list_tools_exposes_static_endpoints(self, mcp_session: ClientSession) -> None:
+        result = await mcp_session.list_tools()
+        tools_name = {tool.name for tool in result.tools}
+        assert tools_name == {"createResource", "updateResource", "deleteResource",
+                              "createTemplate", "updateTemplate", "createTv", 
+                              "updateTv", "createCategory", "updateCategory"}
+    
+    async def test_create_resource(self, mcp_session: ClientSession, client_rest: MagicMock) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {
+                "id": 1,
+                "alias": "test-resource",
+            },
+        }   
+        result = await call_tool(mcp_session, "createResource", {"pagetitle": "Test Resource"})
+        assert result == {
+            "code": "200",
+            "data": {
+                "id": 1,
+                "alias": "test-resource",
+            },
+        }
+        client_rest.execute.assert_called_once_with(
+            method=HTTPMethod.POST,
+            endpoint="/rest/tools/resource",
+            params={"pagetitle": "Test Resource"},
+        )
+
+    async def test_update_resource(self, mcp_session: ClientSession, client_rest: MagicMock) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": { 
+                "id": 1
+            },
+        }
+        result = await call_tool(mcp_session, "updateResource", {"id": 1, "pagetitle": "Updated Resource"})
+        assert result == {
+            "code": "200",
+            "data": {
+                "id": 1,
+            },
+        }
+        client_rest.execute.assert_called_once_with(
+            method=HTTPMethod.PUT,
+            endpoint="/rest/tools/resource",
+            params={"id": 1, "pagetitle": "Updated Resource"},
+        )
+
+    async def test_delete_resource(self, mcp_session: ClientSession, client_rest: MagicMock) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {
+                "id": 1,
+            },
+        }
+        result = await call_tool(mcp_session, "deleteResource", {"id": 1})
+        assert result == {
+            "code": "200",
+            "data": {
+                "id": 1,
+            },
+        }
+        client_rest.execute.assert_called_once_with(
+            method=HTTPMethod.DELETE,
+            endpoint="/rest/tools/resource",
+            params={"id": 1},
+        )
+    
+    async def test_create_template(self, mcp_session: ClientSession, client_rest: MagicMock) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {
+                "id": 1,
+                "name": "test-template",
+            },
+        }
+        result = await call_tool(mcp_session, "createTemplate", {"name": "Test Template"})
+        assert result == {
+            "code": "200",
+            "data": {
+                "id": 1,
+                "name": "test-template",
+            },
+        }
+        client_rest.execute.assert_called_once_with(
+            method=HTTPMethod.POST,
+            endpoint="/rest/tools/template",
+            params={"name": "Test Template"},
+        )
+    
+    async def test_update_template(self, mcp_session: ClientSession, client_rest: MagicMock) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {
+                "id": 1,
+            },
+        }
+        result = await call_tool(mcp_session, "updateTemplate", {"id": 1, "name": "Updated Template"})
+        assert result == {
+            "code": "200",
+            "data": {
+                "id": 1,
+            },
+        }
+        client_rest.execute.assert_called_once_with(
+            method=HTTPMethod.PUT,
+            endpoint="/rest/tools/template",
+            params={"id": 1, "name": "Updated Template"},
+        )
+    
+    async def test_create_tv(self, mcp_session: ClientSession, client_rest: MagicMock) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {
+                "id": 1,
+                "name": "test-tv",
+            },
+        }
+        result = await call_tool(mcp_session, "createTv", {"name": "Test TV"})
+        assert result == {
+            "code": "200",
+            "data": {
+                "id": 1,
+                "name": "test-tv",
+            },
+        }
+        client_rest.execute.assert_called_once_with(
+            method=HTTPMethod.POST,
+            endpoint="/rest/tools/tv",
+            params={"name": "Test TV"},
+        )
+    
+    async def test_update_tv(self, mcp_session: ClientSession, client_rest: MagicMock) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {
+                "id": 1,
+            },
+        }
+        result = await call_tool(mcp_session, "updateTv", {"id": 1, "name": "Updated TV"})
+        assert result == {
+            "code": "200",
+            "data": {
+                "id": 1,
+            },
+        }
+        client_rest.execute.assert_called_once_with(
+            method=HTTPMethod.PUT,
+            endpoint="/rest/tools/tv",
+            params={"id": 1, "name": "Updated TV"},
+        )
+    
+    async def test_create_category(self, mcp_session: ClientSession, client_rest: MagicMock) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {
+                "id": 1,
+                "name": "test-category",
+            },
+        }
+        result = await call_tool(mcp_session, "createCategory", {"category": "Test Category"})
+        assert result == {
+            "code": "200",
+            "data": {
+                "id": 1,
+                "name": "test-category",
+            },
+        }
+        client_rest.execute.assert_called_once_with(
+            method=HTTPMethod.POST,
+            endpoint="/rest/tools/category",
+            params={"category": "Test Category"},
+        )
+    
+    async def test_update_category(self, mcp_session: ClientSession, client_rest: MagicMock) -> None:
+        client_rest.execute.return_value = {
+            "code": "200",
+            "data": {
+                "id": 1,
+            },
+        }
+        result = await call_tool(mcp_session, "updateCategory", {"id": 1, "name": "Updated Category"})
+        assert result == {
+            "code": "200",
+            "data": {
+                "id": 1,
+            },
+        }
+
+