test: add comprehensive tests for context injection in resources and prompts

Add test cases to verify that:
- Resources can receive Context parameters with automatic injection
- Resources work normally without context parameters
- Custom context parameter names are detected correctly
- Prompts can receive Context parameters (currently not implemented)
- Prompts work normally without context parameters

These tests establish the expected behavior for context injection
across both resources and prompts in the FastMCP framework.

Author: dsp-ant

tests/server/fastmcp/test_server.py

@@ -744,7 +744,7 @@ def get_data(name: str) -> str:
 
 
 class TestContextInjection:
-    """Test context injection in tools."""
+    """Test context injection in tools, resources, and prompts."""
 
     @pytest.mark.anyio
     async def test_context_detection(self):
@@ -881,6 +881,154 @@ async def tool_with_resource(ctx: Context[ServerSession, None]) -> str:
             assert isinstance(content, TextContent)
             assert "Read resource: resource data" in content.text
 
+    @pytest.mark.anyio
+    async def test_resource_with_context(self):
+        """Test that resources can receive context parameter."""
+        mcp = FastMCP()
+
+        @mcp.resource("resource://context/{name}")
+        def resource_with_context(name: str, ctx: Context[ServerSession, None]) -> str:
+            """Resource that receives context."""
+            assert ctx is not None
+            # Context should be provided even if request_id might not be accessible
+            # in all contexts
+            try:
+                request_id = ctx.request_id
+                return f"Resource {name} - request_id: {request_id}"
+            except:
+                # Context was injected but request context not available
+                return f"Resource {name} - context injected"
+
+        # Verify template has context_kwarg set
+        templates = mcp._resource_manager.list_templates()
+        assert len(templates) == 1
+        template = templates[0]
+        assert hasattr(template, "context_kwarg")
+        assert template.context_kwarg == "ctx"
+
+        # Test via client
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.read_resource("resource://context/test")
+            assert len(result.contents) == 1
+            content = result.contents[0]
+            assert isinstance(content, TextResourceContents)
+            # Should have either request_id or indication that context was injected
+            assert "Resource test" in content.text
+            assert "request_id:" in content.text or "context injected" in content.text
+
+    @pytest.mark.anyio
+    async def test_resource_without_context(self):
+        """Test that resources without context work normally."""
+        mcp = FastMCP()
+
+        @mcp.resource("resource://nocontext/{name}")
+        def resource_no_context(name: str) -> str:
+            """Resource without context."""
+            return f"Resource {name} works"
+
+        # Verify template has no context_kwarg
+        templates = mcp._resource_manager.list_templates()
+        assert len(templates) == 1
+        template = templates[0]
+        if hasattr(template, "context_kwarg"):
+            assert template.context_kwarg is None
+
+        # Test via client
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.read_resource("resource://nocontext/test")
+            assert len(result.contents) == 1
+            content = result.contents[0]
+            assert isinstance(content, TextResourceContents)
+            assert content.text == "Resource test works"
+
+    @pytest.mark.anyio
+    async def test_resource_context_custom_name(self):
+        """Test resource context with custom parameter name."""
+        mcp = FastMCP()
+
+        @mcp.resource("resource://custom/{id}")
+        def resource_custom_ctx(id: str, my_ctx: Context[ServerSession, None]) -> str:
+            """Resource with custom context parameter name."""
+            assert my_ctx is not None
+            return f"Resource {id} with context"
+
+        # Verify template detects custom context parameter
+        templates = mcp._resource_manager.list_templates()
+        assert len(templates) == 1
+        template = templates[0]
+        if hasattr(template, "context_kwarg"):
+            assert template.context_kwarg == "my_ctx"
+
+        # Test via client
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.read_resource("resource://custom/123")
+            assert len(result.contents) == 1
+            content = result.contents[0]
+            assert isinstance(content, TextResourceContents)
+            assert "Resource 123 with context" in content.text
+
+    @pytest.mark.anyio
+    async def test_prompt_with_context(self):
+        """Test that prompts can receive context parameter."""
+        mcp = FastMCP()
+
+        @mcp.prompt("prompt_with_ctx")
+        def prompt_with_context(text: str, ctx: Context[ServerSession, None]) -> str:
+            """Prompt that expects context."""
+            if ctx and hasattr(ctx, "request_id"):
+                return f"Prompt '{text}' with context: {ctx.request_id}"
+            return f"Prompt '{text}' - no context"
+
+        # Check if prompt has context parameter detection
+        prompts = mcp._prompt_manager.list_prompts()
+        assert len(prompts) == 1
+        prompt = prompts[0]
+
+        # Check if context_kwarg attribute exists (for future implementation)
+        has_context_kwarg = hasattr(prompt, "context_kwarg")
+
+        # Test via client
+        async with client_session(mcp._mcp_server) as client:
+            try:
+                # Try calling without passing ctx explicitly
+                result = await client.get_prompt("prompt_with_ctx", {"text": "test"})
+                # If this succeeds, check if context was injected
+                assert len(result.messages) == 1
+                message = result.messages[0]
+                content = message.content
+                assert isinstance(content, TextContent)
+                if "with context:" in content.text:
+                    # Context injection is working for prompts
+                    assert has_context_kwarg, "Prompt should have context_kwarg attribute"
+                else:
+                    # Context was not injected
+                    pytest.skip("Prompt context injection not yet implemented")
+            except Exception as e:
+                if "Missing required arguments" in str(e) and "ctx" in str(e):
+                    # Context injection not working - expected for now
+                    pytest.skip("Prompt context injection not yet implemented")
+                else:
+                    raise
+
+    @pytest.mark.anyio
+    async def test_prompt_without_context(self):
+        """Test that prompts without context work normally."""
+        mcp = FastMCP()
+
+        @mcp.prompt("prompt_no_ctx")
+        def prompt_no_context(text: str) -> str:
+            """Prompt without context."""
+            return f"Prompt '{text}' works"
+
+        # Test via client
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.get_prompt("prompt_no_ctx", {"text": "test"})
+            assert len(result.messages) == 1
+            message = result.messages[0]
+            content = message.content
+            assert isinstance(content, TextContent)
+            assert content.text == "Prompt 'test' works"
+
 
 class TestServerPrompts:
     """Test prompt functionality in FastMCP server."""