feat(tests): implement resource reading and prompt retrieval via middleware

- Added functionality to handle `resources/read` and `prompts/get` requests through middleware, allowing seamless proxying to mounted backend services.
- Introduced new integration tests to validate the correct behavior of the middleware for reading resources and retrieving prompts.
- Updated Gherkin scenarios to cover the new resource reading feature, ensuring comprehensive testing of the passthrough functionality.
- Enhanced existing fixtures to support the new middleware interactions, improving overall test coverage and reliability.

Author: qdrddr

scripts/local/tests/pytest-unit-shard-weights.json

@@ -58,7 +58,7 @@
     "src/tests/unit/test_cyt_mcp_cli.py": 0.37,
     "src/tests/unit/test_cyt_mcp_config.py": 0.72,
     "src/tests/unit/test_cyt_mcp_mcp_entry.py": 0.48,
-    "src/tests/unit/test_cyt_mcp_offerings_cache.py": 0.24,
+    "src/tests/unit/gherkin/test_cyt_mcp_offerings_passthrough_gherkin.py": 0.24,
     "src/tests/unit/test_cyt_mcp_search.py": 0.63,
     "src/tests/unit/test_cyt_mcp_session_log_wire_name.py": 0.02,
     "src/tests/unit/test_cyt_mcp_session_runtime.py": 0.24,

src/tests/fixtures/cyt_mcp_offerings_passthrough/scenarios.json

@@ -20,6 +20,11 @@
       "method": "tools/list",
       "cached_tool_name": "gitnexus_cypher",
       "expects_call_next": false
+    },
+    {
+      "id": "read_resource_passthrough",
+      "method": "resources/read",
+      "expected_resource_body": "demo resource body"
     }
   ]
 }

src/tests/integration/test_cyt_mcp_offerings_passthrough_integration.py

@@ -11,9 +11,12 @@
 from cyt_mcp.search import MCP_WIRE_SEARCH_TOOL_NAME
 from tests.support.cyt_mcp_offerings_passthrough_fixtures import (
     build_aggregator_with_offerings_backend,
+    get_prompt_via_middleware,
     list_offerings_via_middleware,
+    load_backend_offerings,
     load_offerings_passthrough_scenarios,
     make_offerings_list_context,
+    read_resource_via_middleware,
 )
 
 
@@ -106,3 +109,39 @@ async def test_tools_list_still_serves_stubs_while_offerings_passthrough() -> No
     assert scenario.cached_tool_name in names
     assert MCP_WIRE_SEARCH_TOOL_NAME in names
     call_next.assert_not_awaited()
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_middleware_read_resource_proxies_mounted_backend() -> None:
+    server, middleware, _coordinator, spec = build_aggregator_with_offerings_backend()
+    scenario = next(
+        item
+        for item in load_offerings_passthrough_scenarios()
+        if item.id == "read_resource_passthrough"
+    )
+    assert scenario.expected_resource_body is not None
+    resource_uri = spec.resources[0].uri
+    namespaced_uri = f"gitnexus://{spec.server_key}/{resource_uri.split('://', 1)[1]}"
+
+    result = await read_resource_via_middleware(
+        middleware,
+        server,
+        uri=namespaced_uri,
+    )
+
+    contents = getattr(result, "contents", None) or []
+    assert contents
+    assert scenario.expected_resource_body in str(getattr(contents[0], "content", ""))
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_middleware_get_prompt_proxies_mounted_backend() -> None:
+    server, middleware, _coordinator, spec = build_aggregator_with_offerings_backend()
+    offerings = load_backend_offerings()
+    prompt_name = f"{spec.server_key}_{offerings.prompts[0].name}"
+
+    result = await get_prompt_via_middleware(middleware, server, name=prompt_name)
+
+    assert str(getattr(result, "name", "")) == prompt_name

src/tests/support/cyt_mcp_offerings_passthrough_fixtures.py

@@ -12,11 +12,14 @@
 from fastmcp import FastMCP
 from fastmcp.server.middleware import MiddlewareContext
 from mcp.types import (
+    GetPromptRequestParams,
     ListPromptsRequest,
     ListResourcesRequest,
     ListResourceTemplatesRequest,
     ListToolsRequest,
+    ReadResourceRequestParams,
 )
+from pydantic.networks import AnyUrl
 
 from cyt_mcp.aggregator import build_aggregator
 from cyt_mcp.config import AggregatorConfig, sample_aggregator_config
@@ -67,6 +70,8 @@ class OfferingsPassthroughScenario:
     expected_template_names: tuple[str, ...] = ()
     cached_tool_name: str | None = None
     expects_call_next: bool | None = None
+    expected_resource_body: str | None = None
+    read_resource_uri: str | None = None
 
 
 def _load_json(path: Path) -> dict[str, Any]:
@@ -161,6 +166,14 @@ def load_offerings_passthrough_scenarios(
                 expects_call_next=(
                     bool(item["expects_call_next"]) if "expects_call_next" in item else None
                 ),
+                expected_resource_body=(
+                    str(item["expected_resource_body"])
+                    if item.get("expected_resource_body")
+                    else None
+                ),
+                read_resource_uri=(
+                    str(item["read_resource_uri"]) if item.get("read_resource_uri") else None
+                ),
             ),
         )
     return tuple(scenarios)
@@ -295,3 +308,47 @@ async def _call_next(_ctx: MiddlewareContext[Any]) -> Sequence[Any]:
 
     result = await handler(context, _call_next)
     return cast(Sequence[Any], result)
+
+
+def make_read_resource_context(uri: str) -> MiddlewareContext[Any]:
+    context = MagicMock()
+    context.method = "resources/read"
+    context.message = ReadResourceRequestParams(uri=AnyUrl(uri))
+    context.fastmcp_context = None
+    return context
+
+
+def make_get_prompt_context(name: str) -> MiddlewareContext[Any]:
+    context = MagicMock()
+    context.method = "prompts/get"
+    context.message = GetPromptRequestParams(name=name)
+    context.fastmcp_context = None
+    return context
+
+
+async def read_resource_via_middleware(
+    middleware: SessionWorkspaceMiddleware,
+    server: FastMCP,
+    *,
+    uri: str,
+) -> Any:
+    context = make_read_resource_context(uri)
+
+    async def _call_next(_ctx: MiddlewareContext[Any]) -> Any:
+        return await server.read_resource(uri)
+
+    return await middleware.on_read_resource(context, _call_next)
+
+
+async def get_prompt_via_middleware(
+    middleware: SessionWorkspaceMiddleware,
+    server: FastMCP,
+    *,
+    name: str,
+) -> Any:
+    context = make_get_prompt_context(name)
+
+    async def _call_next(_ctx: MiddlewareContext[Any]) -> Any:
+        return await server._get_prompt(name)
+
+    return await middleware.on_get_prompt(context, _call_next)

src/tests/unit/gherkin/features/cyt_mcp_offerings_passthrough.feature

@@ -22,3 +22,8 @@ Feature: cyt-mcp offerings passthrough
     When middleware handles tools/list
     Then tools/list should serve stub projections including gitnexus_cypher
     And tools/list should not proxy to backend tools/list
+
+  Scenario: Read resource proxies to mounted backend content
+    Given a cyt-mcp aggregator with mounted backend offerings
+    When middleware handles resources/read for gitnexus://gitnexus/repo/demo
+    Then resources/read should return backend body demo resource body

src/tests/unit/gherkin/test_cyt_mcp_offerings_passthrough_gherkin.py

@@ -14,6 +14,7 @@
     build_aggregator_with_offerings_backend,
     list_offerings_via_middleware,
     make_offerings_list_context,
+    read_resource_via_middleware,
 )
 from tests.unit.gherkin.conftest import GherkinContext
 
@@ -140,3 +141,23 @@ def then_tools_include_stub(tool_name: str, gherkin_context: GherkinContext) ->
 def then_tools_do_not_proxy(gherkin_context: GherkinContext) -> None:
     call_next = gherkin_context.payload["call_next"]
     call_next.assert_not_awaited()
+
+
+@when(parsers.parse("middleware handles resources/read for {uri}"))
+def when_read_resource(uri: str, gherkin_context: GherkinContext) -> None:
+    payload = gherkin_context.payload
+    gherkin_context.payload["result"] = asyncio.run(
+        read_resource_via_middleware(
+            payload["middleware"],
+            payload["server"],
+            uri=uri,
+        ),
+    )
+
+
+@then(parsers.parse("resources/read should return backend body {body}"))
+def then_read_resource_body(body: str, gherkin_context: GherkinContext) -> None:
+    result = gherkin_context.payload["result"]
+    contents = getattr(result, "contents", None) or []
+    assert contents
+    assert body in str(getattr(contents[0], "content", ""))

src/tests/unit/test_session_workspace_middleware.py

@@ -6,13 +6,17 @@
 from pathlib import Path
 from unittest.mock import AsyncMock, MagicMock, patch
 
+from fastmcp.prompts.base import PromptResult
+from fastmcp.resources.base import ResourceResult
 from fastmcp.tools.base import Tool
 from mcp.types import (
+    GetPromptRequestParams,
     ListPromptsRequest,
     ListResourcesRequest,
     ListResourceTemplatesRequest,
     ListToolsRequest,
     Prompt,
+    ReadResourceRequestParams,
     Resource,
     ResourceTemplate,
 )
@@ -285,3 +289,35 @@ def test_list_offering_handlers_never_ignore_call_next(tmp_path: Path) -> None:
         assert result == [sentinel], f"{method} must proxy via call_next"
         call_next.assert_awaited_once_with(context)
         call_next.reset_mock()
+
+
+def test_on_get_prompt_proxies_to_backends(tmp_path: Path) -> None:
+    middleware, coordinator = _middleware_for_scope(tmp_path, catalog_scope="user")
+    backend_result = PromptResult(messages=[])
+    call_next = AsyncMock(return_value=backend_result)
+    context = MagicMock()
+    context.method = "prompts/get"
+    context.message = GetPromptRequestParams(name="gitnexus_review")
+    context.fastmcp_context = None
+
+    with patch.object(coordinator, "ensure_backends_mounted"):
+        result = asyncio.run(middleware.on_get_prompt(context, call_next))
+
+    assert result is backend_result
+    call_next.assert_awaited_once_with(context)
+
+
+def test_on_read_resource_proxies_to_backends(tmp_path: Path) -> None:
+    middleware, coordinator = _middleware_for_scope(tmp_path, catalog_scope="user")
+    backend_result = ResourceResult(contents=[])
+    call_next = AsyncMock(return_value=backend_result)
+    context = MagicMock()
+    context.method = "resources/read"
+    context.message = ReadResourceRequestParams(uri=AnyUrl("gitnexus://gitnexus/repo/demo"))
+    context.fastmcp_context = None
+
+    with patch.object(coordinator, "ensure_backends_mounted"):
+        result = asyncio.run(middleware.on_read_resource(context, call_next))
+
+    assert result is backend_result
+    call_next.assert_awaited_once_with(context)