web tests

tests/web/conftest.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 
 import os
 from collections.abc import AsyncIterator
-from collections.abc import Iterator
 
 import pytest
 import pytest_asyncio
-from fastapi.testclient import TestClient
+from httpx import ASGITransport
 from httpx import AsyncClient
 from mcp import ClientSession
 from mcp.client.streamable_http import streamable_http_client
@@ -14,10 +13,15 @@ from mcp.client.streamable_http import streamable_http_client
 from personal_mcp.web.app import create_app
 
 
-@pytest.fixture
-def client() -> Iterator[TestClient]:
-    """Provides a TestClient bound to a fresh application instance."""
-    with TestClient(create_app()) as test_client:
+@pytest_asyncio.fixture
+async def client() -> AsyncIterator[AsyncClient]:
+    """Provides an AsyncClient bound to a fresh application instance."""
+    app = create_app()
+    async with AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://testserver",
+        timeout=10.0,
+    ) as test_client:
         yield test_client
 
 

tests/web/test_endpoint_connections.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import pytest
-from fastapi.testclient import TestClient
+from httpx import AsyncClient
 from mcp import ClientSession
 
 pytestmark = pytest.mark.smoke
@@ -13,9 +13,10 @@ class TestMcpHttpEndpoints:
     class TestHealthz:
         """Covers health endpoint smoke behavior."""
 
-        def test_returns_ok_payload(self, client: TestClient) -> None:
+        @pytest.mark.asyncio
+        async def test_returns_ok_payload(self, client: AsyncClient) -> None:
             """Ensures GET /healthz responds with a healthy status payload."""
-            response = client.get("/healthz")
+            response = await client.get("/healthz")
 
             assert response.status_code == 200
             assert response.json() == {"status": "ok"}
@@ -23,9 +24,10 @@ class TestMcpHttpEndpoints:
     class TestDocsRoute:
         """Covers static docs route smoke behavior."""
 
-        def test_serves_docs_entrypoint(self, client: TestClient) -> None:
+        @pytest.mark.asyncio
+        async def test_serves_docs_entrypoint(self, client: AsyncClient) -> None:
             """Ensures GET /docs returns the docs site entrypoint response."""
-            response = client.get("/docs")
+            response = await client.get("/docs")
 
             assert response.status_code == 200
             assert "text/html" in response.headers["content-type"]
@@ -36,11 +38,11 @@ class TestMcpHttpEndpoints:
         @pytest.mark.asyncio
         async def test_rejects_get_stream_without_support(
             self,
-            client: TestClient,
+            client: AsyncClient,
             mcp_session: ClientSession,
         ) -> None:
             """Ensures GET /mcp returns method not allowed for current transport mode."""
-            response = client.get(
+            response = await client.get(
                 "/mcp",
                 headers={"Accept": "text/event-stream"},
             )

tests/web/test_mcp_skills.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import pytest
+from mcp import ClientSession
+
+pytestmark = pytest.mark.smoke
+
+
+class TestMcpCatalogSurface:
+    """Covers smoke-level MCP catalog discovery and tool execution paths."""
+
+    class TestTools:
+        """Covers MCP tool-list and tool-call smoke behavior."""
+
+        @pytest.mark.asyncio
+        async def test_lists_core_catalog_tools(self, mcp_session: ClientSession) -> None:
+            """Ensures tools/list exposes the core catalog tool names."""
+            result = await mcp_session.list_tools()
+            tool_names = {tool.name for tool in result.tools}
+
+            assert {
+                "search_patterns",
+                "get_pattern_by_id",
+                "get_skill_document_by_id",
+                "search_prompts",
+                "get_prompt_by_id",
+            }.issubset(tool_names)
+
+        @pytest.mark.asyncio
+        async def test_calls_search_patterns_tool(self, mcp_session: ClientSession) -> None:
+            """Ensures tools/call succeeds for search_patterns with basic args."""
+            result = await mcp_session.call_tool(
+                "search_patterns",
+                {
+                    "query": "pytest",
+                    "limit": 5,
+                },
+            )
+
+            assert result.isError is False
+            assert result.content
+
+    class TestResources:
+        """Covers MCP resource and resource-template discovery."""
+
+        @pytest.mark.asyncio
+        async def test_lists_catalog_resources(self, mcp_session: ClientSession) -> None:
+            """Ensures resources/list exposes core catalog resource URIs."""
+            result = await mcp_session.list_resources()
+            resource_uris = {str(resource.uri) for resource in result.resources}
+
+            assert "resource://catalog/skills_index" in resource_uris
+            assert "resource://catalog/prompts_index" in resource_uris
+
+        @pytest.mark.asyncio
+        async def test_lists_resource_templates(self, mcp_session: ClientSession) -> None:
+            """Ensures resources/templates/list includes skills and prompt templates."""
+            result = await mcp_session.list_resource_templates()
+            template_uris = {template.uriTemplate for template in result.resourceTemplates}
+
+            assert "resource://skills/{skill_id}/document" in template_uris
+            assert "resource://prompts/{prompt_id}/document" in template_uris
+
+    class TestPrompts:
+        """Covers MCP prompt discovery surface."""
+
+        @pytest.mark.asyncio
+        async def test_lists_registered_prompts(self, mcp_session: ClientSession) -> None:
+            """Ensures prompts/list returns at least one registered prompt."""
+            result = await mcp_session.list_prompts()
+
+            assert result.prompts