π The fast, Pythonic way to build MCP servers and clients.
Ensure objects are copied properly and test mounting fastapi
Jeremiah Lowin0269905263b5
diff --git a/src/fastmcp/prompts/prompt.py b/src/fastmcp/prompts/prompt.pyindex 20ed5cb06..06cc23301 100644--- a/src/fastmcp/prompts/prompt.py+++ b/src/fastmcp/prompts/prompt.py@@ -8,7 +8,6 @@ from typing import Annotated, Any, Literalimport pydantic_corefrom mcp.types import EmbeddedResource, ImageContent, TextContentfrom pydantic import BaseModel, BeforeValidator, Field, TypeAdapter, validate_call-from typing_extensions import Selffrom fastmcp.utilities.types import _convert_set_defaults@@ -163,13 +162,6 @@ class Prompt(BaseModel):except Exception as e:raise ValueError(f"Error rendering prompt {self.name}: {e}")- def copy(self, updates: dict[str, Any] | None = None) -> Self:- """Copy the prompt with optional updates."""- data = self.model_dump()- if updates:- data.update(updates)- return type(self)(**data)-def __eq__(self, other: object) -> bool:if not isinstance(other, Prompt):return Falsediff --git a/src/fastmcp/prompts/prompt_manager.py b/src/fastmcp/prompts/prompt_manager.pyindex 9b76a44e9..40251e1ca 100644--- a/src/fastmcp/prompts/prompt_manager.py+++ b/src/fastmcp/prompts/prompt_manager.py@@ -1,5 +1,6 @@"""Prompt management functionality."""+import copyfrom collections.abc import Awaitable, Callablefrom typing import Any@@ -84,7 +85,8 @@ class PromptManager:# Create prefixed nameprefixed_name = f"{prefix}{name}" if prefix else name- new_prompt = prompt.copy(updates=dict(name=prefixed_name))+ new_prompt = copy.copy(prompt)+ new_prompt.name = prefixed_name# Store the prompt with the prefixed nameself.add_prompt(new_prompt)diff --git a/src/fastmcp/resources/resource.py b/src/fastmcp/resources/resource.pyindex 01e0995ac..a583d6357 100644--- a/src/fastmcp/resources/resource.py+++ b/src/fastmcp/resources/resource.py@@ -1,7 +1,7 @@"""Base classes and interfaces for FastMCP resources."""import abc-from typing import Annotated, Any+from typing import Annotatedfrom pydantic import (AnyUrl,@@ -13,7 +13,6 @@ from pydantic import (ValidationInfo,field_validator,)-from typing_extensions import Selffrom fastmcp.utilities.types import _convert_set_defaults@@ -54,13 +53,6 @@ class Resource(BaseModel, abc.ABC):"""Read the resource content."""pass- def copy(self, updates: dict[str, Any] | None = None) -> Self:- """Copy the resource with optional updates."""- data = self.model_dump()- if updates:- data.update(updates)- return type(self)(**data)-def __eq__(self, other: object) -> bool:if not isinstance(other, Resource):return Falsediff --git a/src/fastmcp/resources/resource_manager.py b/src/fastmcp/resources/resource_manager.pyindex 647299448..2cfe2d6cd 100644--- a/src/fastmcp/resources/resource_manager.py+++ b/src/fastmcp/resources/resource_manager.py@@ -1,5 +1,6 @@"""Resource manager functionality."""+import copyimport inspectimport refrom collections.abc import Callable@@ -238,7 +239,8 @@ class ResourceManager:# Create prefixed URI and copy the resource with the new URIprefixed_uri = f"{prefix}{uri}" if prefix else uri- new_resource = resource.copy(updates=dict(uri=prefixed_uri))+ new_resource = copy.copy(resource)+ new_resource.uri = AnyUrl(prefixed_uri)# Store directly in resources dictionaryself.add_resource(new_resource)@@ -266,9 +268,8 @@ class ResourceManager:f"{prefix}{uri_template}" if prefix else uri_template)- new_template = template.copy(- updates=dict(uri_template=prefixed_uri_template)- )+ new_template = copy.copy(template)+ new_template.uri_template = prefixed_uri_template# Store directly in templates dictionaryself.add_template(new_template)diff --git a/src/fastmcp/resources/template.py b/src/fastmcp/resources/template.pyindex 289b23050..022312bc3 100644--- a/src/fastmcp/resources/template.py+++ b/src/fastmcp/resources/template.py@@ -8,7 +8,6 @@ from collections.abc import Callablefrom typing import Annotated, Anyfrom pydantic import BaseModel, BeforeValidator, Field, TypeAdapter, validate_call-from typing_extensions import Selffrom fastmcp.resources.types import FunctionResource, Resourcefrom fastmcp.utilities.types import _convert_set_defaults@@ -92,13 +91,6 @@ class ResourceTemplate(BaseModel):except Exception as e:raise ValueError(f"Error creating resource from template: {e}")- def copy(self, updates: dict[str, Any] | None = None) -> Self:- """Copy the resource template with optional updates."""- data = self.model_dump()- if updates:- data.update(updates)- return type(self)(**data)-def __eq__(self, other: object) -> bool:if not isinstance(other, ResourceTemplate):return Falsediff --git a/src/fastmcp/tools/tool.py b/src/fastmcp/tools/tool.pyindex 537bde396..e8e56ecc6 100644--- a/src/fastmcp/tools/tool.py+++ b/src/fastmcp/tools/tool.py@@ -5,7 +5,6 @@ from collections.abc import Callablefrom typing import TYPE_CHECKING, Annotated, Anyfrom pydantic import BaseModel, BeforeValidator, Field-from typing_extensions import Selffrom fastmcp.exceptions import ToolErrorfrom fastmcp.utilities.func_metadata import FuncMetadata, func_metadata@@ -102,13 +101,6 @@ class Tool(BaseModel):except Exception as e:raise ToolError(f"Error executing tool {self.name}: {e}") from e- def copy(self, updates: dict[str, Any] | None = None) -> Self:- """Copy the tool with optional updates."""- data = self.model_dump()- if updates:- data.update(updates)- return type(self)(**data)-def __eq__(self, other: object) -> bool:if not isinstance(other, Tool):return Falsediff --git a/src/fastmcp/tools/tool_manager.py b/src/fastmcp/tools/tool_manager.pyindex 9bfb95ad0..b8ec2460f 100644--- a/src/fastmcp/tools/tool_manager.py+++ b/src/fastmcp/tools/tool_manager.py@@ -1,5 +1,6 @@from __future__ import annotations as _annotations+import copyfrom collections.abc import Callablefrom typing import TYPE_CHECKING, Any@@ -90,7 +91,9 @@ class ToolManager:for name, tool in tool_manager._tools.items():prefixed_name = f"{prefix}{name}" if prefix else name- new_tool = tool.copy(updates=dict(name=prefixed_name))+ new_tool = copy.copy(tool)+ new_tool.name = prefixed_name+# Store the copied toolself.add_tool(new_tool)logger.debug(f'Imported tool "{name}" as "{prefixed_name}"')diff --git a/src/fastmcp/utilities/openapi.py b/src/fastmcp/utilities/openapi.pyindex fcda41160..5cf50cf06 100644--- a/src/fastmcp/utilities/openapi.py+++ b/src/fastmcp/utilities/openapi.py@@ -150,93 +150,6 @@ def _resolve_ref(return item-def _extract_schema_as_dict(- schema_obj: Schema | Reference, openapi: OpenAPI-) -> JsonSchema:- """Resolves a schema/reference and returns it as a dictionary."""- resolved_schema = _resolve_ref(schema_obj, openapi)- if isinstance(resolved_schema, Schema):- # Using exclude_none=True might be better than exclude_unset sometimes- return resolved_schema.model_dump(mode="json", by_alias=True, exclude_none=True)- elif isinstance(resolved_schema, dict):- logger.warning(- "Resolved schema reference resulted in a dict, not a Schema model."- )- return resolved_schema- else:- ref_str = getattr(schema_obj, "ref", "unknown")- logger.warning(- f"Expected Schema after resolving ref '{ref_str}', got {type(resolved_schema)}. Returning empty dict."- )- return {}---def _convert_to_parameter_location(param_in: str) -> ParameterLocation:- """Convert string parameter location to our ParameterLocation type."""- if param_in == "path":- return "path"- elif param_in == "query":- return "query"- elif param_in == "header":- return "header"- elif param_in == "cookie":- return "cookie"- else:- logger.warning(f"Unknown parameter location: {param_in}, defaulting to 'query'")- return "query"---def _extract_responses(- operation_responses: dict[str, Response | Reference] | None,- openapi: OpenAPI,-) -> dict[str, ResponseInfo]:- """Extracts and resolves response information for an operation."""- extracted_responses: dict[str, ResponseInfo] = {}- if not operation_responses:- return extracted_responses-- for status_code, resp_or_ref in operation_responses.items():- try:- response = cast(Response, _resolve_ref(resp_or_ref, openapi))- if not isinstance(response, Response):- ref_str = getattr(resp_or_ref, "ref", "unknown")- logger.warning(- f"Expected Response after resolving ref '{ref_str}' for status code {status_code}, got {type(response)}. Skipping."- )- continue-- content_schemas: dict[str, JsonSchema] = {}- if response.content:- for media_type_str, media_type_obj in response.content.items():- if (- isinstance(media_type_obj, MediaType)- and media_type_obj.media_type_schema- ):- try:- schema_dict = _extract_schema_as_dict(- media_type_obj.media_type_schema, openapi- )- content_schemas[media_type_str] = schema_dict- except ValueError as schema_err:- logger.error(- f"Failed to extract schema for media type '{media_type_str}' in response {status_code}: {schema_err}"- )-- resp_info = ResponseInfo(- description=response.description, content_schema=content_schemas- )- extracted_responses[str(status_code)] = resp_info-- except (ValidationError, ValueError, AttributeError) as e:- ref_name = getattr(resp_or_ref, "ref", "unknown")- logger.error(- f"Failed to extract response for status code {status_code} (ref: '{ref_name}'): {e}",- exc_info=False,- )-- return extracted_responses--# --- Main Parsing Function ---# (No changes needed in the main loop logic, only in the helpers it calls)def parse_openapi_to_http_routes(openapi_dict: dict[str, Any]) -> list[HTTPRoute]:diff --git a/tests/server/test_openapi.py b/tests/server/test_openapi.pyindex ece9c1168..b06a40ee1 100644--- a/tests/server/test_openapi.py+++ b/tests/server/test_openapi.py@@ -73,7 +73,7 @@ def api_client(fastapi_app: FastAPI) -> AsyncClient:@pytest.fixture-async def fastmcp_server(+async def fastmcp_openapi_server(fastapi_app: FastAPI, api_client: httpx.AsyncClient) -> FastMCPOpenAPI:openapi_spec = fastapi_app.openapi()@@ -113,11 +113,11 @@ async def test_create_fastapi_server_classmethod(fastapi_app: FastAPI):class TestTools:- async def test_list_tools(self, fastmcp_server: FastMCPOpenAPI):+ async def test_list_tools(self, fastmcp_openapi_server: FastMCPOpenAPI):"""By default, tools exclude GET methods"""- tools = await fastmcp_server._mcp_list_tools()+ tools = await fastmcp_openapi_server._mcp_list_tools()assert len(tools) == 2assert tools[0].model_dump() == dict(@@ -148,12 +148,12 @@ class TestTools:)async def test_call_create_user_tool(- self, fastmcp_server: FastMCPOpenAPI, api_client+ self, fastmcp_openapi_server: FastMCPOpenAPI, api_client):"""The tool created by the OpenAPI server should be the same as the original"""- tool_response = await fastmcp_server.call_tool(+ tool_response = await fastmcp_openapi_server.call_tool("create_user_users_post", {"name": "David", "active": False})assert tool_response == User(id=4, name="David", active=False)@@ -164,19 +164,19 @@ class TestTools:assert len(response.json()) == 4# Check that the user was created via MCP- user_response = await fastmcp_server._mcp_read_resource(+ user_response = await fastmcp_openapi_server._mcp_read_resource("resource://openapi/get_user_users__user_id__get/4")user = user_response[0].contentassert user == tool_response.model_dump()async def test_call_update_user_name_tool(- self, fastmcp_server: FastMCPOpenAPI, api_client+ self, fastmcp_openapi_server: FastMCPOpenAPI, api_client):"""The tool created by the OpenAPI server should be the same as the original"""- tool_response = await fastmcp_server.call_tool(+ tool_response = await fastmcp_openapi_server.call_tool("update_user_name_users__user_id__name_patch", {"user_id": 1, "name": "XYZ"})assert tool_response == dict(id=1, name="XYZ", active=True)@@ -186,7 +186,7 @@ class TestTools:assert dict(id=1, name="XYZ", active=True) in response.json()# Check that the user was updated via MCP- user_response = await fastmcp_server._mcp_read_resource(+ user_response = await fastmcp_openapi_server._mcp_read_resource("resource://openapi/get_user_users__user_id__get/1")user = user_response[0].content@@ -194,17 +194,20 @@ class TestTools:class TestResources:- async def test_list_resources(self, fastmcp_server: FastMCPOpenAPI):+ async def test_list_resources(self, fastmcp_openapi_server: FastMCPOpenAPI):"""By default, resources exclude GET methods without parameters"""- resources = await fastmcp_server._mcp_list_resources()+ resources = await fastmcp_openapi_server._mcp_list_resources()assert len(resources) == 1assert resources[0].uri == AnyUrl("resource://openapi/get_users_users_get")assert resources[0].name == "get_users_users_get"async def test_get_resource(- self, fastmcp_server: FastMCPOpenAPI, api_client, users_db: dict[int, User]+ self,+ fastmcp_openapi_server: FastMCPOpenAPI,+ api_client,+ users_db: dict[int, User],):"""The resource created by the OpenAPI server should be the same as the original@@ -212,7 +215,7 @@ class TestResources:json_users = TypeAdapter(list[User]).dump_python(sorted(users_db.values(), key=lambda x: x.id))- resource_response = await fastmcp_server._mcp_read_resource(+ resource_response = await fastmcp_openapi_server._mcp_read_resource("resource://openapi/get_users_users_get")resource = resource_response[0].content@@ -222,11 +225,13 @@ class TestResources:class TestResourceTemplates:- async def test_list_resource_templates(self, fastmcp_server: FastMCPOpenAPI):+ async def test_list_resource_templates(+ self, fastmcp_openapi_server: FastMCPOpenAPI+ ):"""By default, resource templates exclude GET methods without parameters"""- resource_templates = await fastmcp_server._mcp_list_resource_templates()+ resource_templates = await fastmcp_openapi_server._mcp_list_resource_templates()assert len(resource_templates) == 1assert resource_templates[0].name == "get_user_users__user_id__get"assert (@@ -235,13 +240,16 @@ class TestResourceTemplates:)async def test_get_resource_template(- self, fastmcp_server: FastMCPOpenAPI, api_client, users_db: dict[int, User]+ self,+ fastmcp_openapi_server: FastMCPOpenAPI,+ api_client,+ users_db: dict[int, User],):"""The resource template created by the OpenAPI server should be the same as the original"""user_id = 2- resource_response = await fastmcp_server._mcp_read_resource(+ resource_response = await fastmcp_openapi_server._mcp_read_resource(f"resource://openapi/get_user_users__user_id__get/{user_id}")@@ -252,21 +260,23 @@ class TestResourceTemplates:class TestPrompts:- async def test_list_prompts(self, fastmcp_server: FastMCPOpenAPI):+ async def test_list_prompts(self, fastmcp_openapi_server: FastMCPOpenAPI):"""By default, there are no prompts."""- prompts = await fastmcp_server._mcp_list_prompts()+ prompts = await fastmcp_openapi_server._mcp_list_prompts()assert len(prompts) == 0class TestTagTransfer:- """Tests for transferring tags from OpenAPI to MCP objects."""+ """Tests for transferring tags from OpenAPI routes to MCP objects."""- async def test_tags_transferred_to_tools(self, fastmcp_server: FastMCPOpenAPI):+ async def test_tags_transferred_to_tools(+ self, fastmcp_openapi_server: FastMCPOpenAPI+ ):"""Test that tags from OpenAPI routes are correctly transferred to Tools."""# Get internal tools directly (not the public API which returns MCP.Content)- tools = fastmcp_server._tool_manager.list_tools()+ tools = fastmcp_openapi_server._tool_manager.list_tools()# Find the create_user and update_user_name toolscreate_user_tool = next(@@ -293,10 +303,12 @@ class TestTagTransfer:assert "update" in update_user_tool.tagsassert len(update_user_tool.tags) == 2- async def test_tags_transferred_to_resources(self, fastmcp_server: FastMCPOpenAPI):+ async def test_tags_transferred_to_resources(+ self, fastmcp_openapi_server: FastMCPOpenAPI+ ):"""Test that tags from OpenAPI routes are correctly transferred to Resources."""# Get internal resources directly- resources = fastmcp_server._resource_manager.list_resources()+ resources = fastmcp_openapi_server._resource_manager.list_resources()# Find the get_users resourceget_users_resource = next(@@ -311,11 +323,11 @@ class TestTagTransfer:assert len(get_users_resource.tags) == 2async def test_tags_transferred_to_resource_templates(- self, fastmcp_server: FastMCPOpenAPI+ self, fastmcp_openapi_server: FastMCPOpenAPI):"""Test that tags from OpenAPI routes are correctly transferred to ResourceTemplates."""# Get internal resource templates directly- templates = fastmcp_server._resource_manager.list_templates()+ templates = fastmcp_openapi_server._resource_manager.list_templates()# Find the get_user templateget_user_template = next(@@ -330,11 +342,11 @@ class TestTagTransfer:assert len(get_user_template.tags) == 2async def test_tags_preserved_in_resources_created_from_templates(- self, fastmcp_server: FastMCPOpenAPI+ self, fastmcp_openapi_server: FastMCPOpenAPI):"""Test that tags are preserved when creating resources from templates."""# Get internal resource templates directly- templates = fastmcp_server._resource_manager.list_templates()+ templates = fastmcp_openapi_server._resource_manager.list_templates()# Find the get_user templateget_user_template = next(@@ -353,3 +365,355 @@ class TestTagTransfer:assert "users" in resource.tagsassert "detail" in resource.tagsassert len(resource.tags) == 2+++class TestOpenAPI30Compatibility:+ """Tests for compatibility with OpenAPI 3.0 specifications."""++ @pytest.fixture+ def openapi_30_spec(self) -> dict:+ """Fixture that returns a simple OpenAPI 3.0 specification."""+ return {+ "openapi": "3.0.0",+ "info": {"title": "Product API (3.0)", "version": "1.0.0"},+ "paths": {+ "/products": {+ "get": {+ "operationId": "listProducts",+ "summary": "List all products",+ "responses": {"200": {"description": "A list of products"}},+ },+ "post": {+ "operationId": "createProduct",+ "summary": "Create a new product",+ "requestBody": {+ "required": True,+ "content": {+ "application/json": {+ "schema": {+ "type": "object",+ "properties": {+ "name": {"type": "string"},+ "price": {"type": "number"},+ },+ "required": ["name", "price"],+ }+ }+ },+ },+ "responses": {"201": {"description": "Product created"}},+ },+ },+ "/products/{product_id}": {+ "get": {+ "operationId": "getProduct",+ "summary": "Get product by ID",+ "parameters": [+ {+ "name": "product_id",+ "in": "path",+ "required": True,+ "schema": {"type": "string"},+ }+ ],+ "responses": {"200": {"description": "A product"}},+ }+ },+ },+ }++ @pytest.fixture+ async def mock_30_client(self) -> httpx.AsyncClient:+ """Mock client that returns predefined responses for the 3.0 API."""++ async def _responder(request):+ if request.url.path == "/products" and request.method == "GET":+ return httpx.Response(+ 200,+ json=[+ {"id": "p1", "name": "Product 1", "price": 19.99},+ {"id": "p2", "name": "Product 2", "price": 29.99},+ ],+ )+ elif request.url.path == "/products" and request.method == "POST":+ import json++ data = json.loads(request.content)+ return httpx.Response(+ 201, json={"id": "p3", "name": data["name"], "price": data["price"]}+ )+ elif request.url.path.startswith("/products/") and request.method == "GET":+ product_id = request.url.path.split("/")[-1]+ products = {+ "p1": {"id": "p1", "name": "Product 1", "price": 19.99},+ "p2": {"id": "p2", "name": "Product 2", "price": 29.99},+ }+ if product_id in products:+ return httpx.Response(200, json=products[product_id])+ return httpx.Response(404, json={"error": "Product not found"})+ return httpx.Response(404)++ transport = httpx.MockTransport(_responder)+ return httpx.AsyncClient(transport=transport, base_url="http://test")++ @pytest.fixture+ async def openapi_30_server(+ self, openapi_30_spec, mock_30_client+ ) -> FastMCPOpenAPI:+ """Create a FastMCPOpenAPI server from the OpenAPI 3.0 spec."""+ return FastMCPOpenAPI(+ openapi_spec=openapi_30_spec, client=mock_30_client, name="Product API 3.0"+ )++ async def test_server_creation(self, openapi_30_server):+ """Test that a server can be created from an OpenAPI 3.0 spec."""+ assert isinstance(openapi_30_server, FastMCP)+ assert openapi_30_server.name == "Product API 3.0"++ async def test_resource_discovery(self, openapi_30_server):+ """Test that resources are correctly discovered from an OpenAPI 3.0 spec."""+ resources = await openapi_30_server._mcp_list_resources()+ assert len(resources) == 1+ assert resources[0].uri == AnyUrl("resource://openapi/listProducts")++ async def test_resource_template_discovery(self, openapi_30_server):+ """Test that resource templates are correctly discovered from an OpenAPI 3.0 spec."""+ templates = await openapi_30_server._mcp_list_resource_templates()+ assert len(templates) == 1+ assert templates[0].name == "getProduct"+ assert templates[0].uriTemplate == r"resource://openapi/getProduct/{product_id}"++ async def test_tool_discovery(self, openapi_30_server):+ """Test that tools are correctly discovered from an OpenAPI 3.0 spec."""+ tools = await openapi_30_server._mcp_list_tools()+ assert len(tools) == 1+ assert tools[0].name == "createProduct"+ assert "name" in tools[0].inputSchema["properties"]+ assert "price" in tools[0].inputSchema["properties"]++ async def test_resource_access(self, openapi_30_server):+ """Test reading a resource from an OpenAPI 3.0 server."""+ resource_response = await openapi_30_server._mcp_read_resource(+ "resource://openapi/listProducts"+ )+ content = resource_response[0].content+ assert len(content) == 2+ assert content[0]["name"] == "Product 1"+ assert content[1]["name"] == "Product 2"++ async def test_resource_template_access(self, openapi_30_server):+ """Test reading a resource from template from an OpenAPI 3.0 server."""+ resource_response = await openapi_30_server._mcp_read_resource(+ "resource://openapi/getProduct/p1"+ )+ content = resource_response[0].content+ assert content["id"] == "p1"+ assert content["name"] == "Product 1"+ assert content["price"] == 19.99++ async def test_tool_execution(self, openapi_30_server):+ """Test executing a tool from an OpenAPI 3.0 server."""+ tool_response = await openapi_30_server.call_tool(+ "createProduct", {"name": "New Product", "price": 39.99}+ )+ assert tool_response["id"] == "p3"+ assert tool_response["name"] == "New Product"+ assert tool_response["price"] == 39.99+++class TestOpenAPI31Compatibility:+ """Tests for compatibility with OpenAPI 3.1 specifications."""++ @pytest.fixture+ def openapi_31_spec(self) -> dict:+ """Fixture that returns a simple OpenAPI 3.1 specification."""+ return {+ "openapi": "3.1.0",+ "info": {"title": "Order API (3.1)", "version": "1.0.0"},+ "paths": {+ "/orders": {+ "get": {+ "operationId": "listOrders",+ "summary": "List all orders",+ "responses": {"200": {"description": "A list of orders"}},+ },+ "post": {+ "operationId": "createOrder",+ "summary": "Place a new order",+ "requestBody": {+ "required": True,+ "content": {+ "application/json": {+ "schema": {+ "type": "object",+ "properties": {+ "customer": {"type": "string"},+ "items": {+ "type": "array",+ "items": {"type": "string"},+ },+ },+ "required": ["customer", "items"],+ }+ }+ },+ },+ "responses": {"201": {"description": "Order created"}},+ },+ },+ "/orders/{order_id}": {+ "get": {+ "operationId": "getOrder",+ "summary": "Get order by ID",+ "parameters": [+ {+ "name": "order_id",+ "in": "path",+ "required": True,+ "schema": {"type": "string"},+ }+ ],+ "responses": {"200": {"description": "An order"}},+ }+ },+ },+ }++ @pytest.fixture+ async def mock_31_client(self) -> httpx.AsyncClient:+ """Mock client that returns predefined responses for the 3.1 API."""++ async def _responder(request):+ if request.url.path == "/orders" and request.method == "GET":+ return httpx.Response(+ 200,+ json=[+ {"id": "o1", "customer": "Alice", "items": ["item1", "item2"]},+ {"id": "o2", "customer": "Bob", "items": ["item3"]},+ ],+ )+ elif request.url.path == "/orders" and request.method == "POST":+ import json++ data = json.loads(request.content)+ return httpx.Response(+ 201,+ json={+ "id": "o3",+ "customer": data["customer"],+ "items": data["items"],+ },+ )+ elif request.url.path.startswith("/orders/") and request.method == "GET":+ order_id = request.url.path.split("/")[-1]+ orders = {+ "o1": {+ "id": "o1",+ "customer": "Alice",+ "items": ["item1", "item2"],+ },+ "o2": {"id": "o2", "customer": "Bob", "items": ["item3"]},+ }+ if order_id in orders:+ return httpx.Response(200, json=orders[order_id])+ return httpx.Response(404, json={"error": "Order not found"})+ return httpx.Response(404)++ transport = httpx.MockTransport(_responder)+ return httpx.AsyncClient(transport=transport, base_url="http://test")++ @pytest.fixture+ async def openapi_31_server(+ self, openapi_31_spec, mock_31_client+ ) -> FastMCPOpenAPI:+ """Create a FastMCPOpenAPI server from the OpenAPI 3.1 spec."""+ return FastMCPOpenAPI(+ openapi_spec=openapi_31_spec, client=mock_31_client, name="Order API 3.1"+ )++ async def test_server_creation(self, openapi_31_server):+ """Test that a server can be created from an OpenAPI 3.1 spec."""+ assert isinstance(openapi_31_server, FastMCP)+ assert openapi_31_server.name == "Order API 3.1"++ async def test_resource_discovery(self, openapi_31_server):+ """Test that resources are correctly discovered from an OpenAPI 3.1 spec."""+ resources = await openapi_31_server._mcp_list_resources()+ assert len(resources) == 1+ assert resources[0].uri == AnyUrl("resource://openapi/listOrders")++ async def test_resource_template_discovery(self, openapi_31_server):+ """Test that resource templates are correctly discovered from an OpenAPI 3.1 spec."""+ templates = await openapi_31_server._mcp_list_resource_templates()+ assert len(templates) == 1+ assert templates[0].name == "getOrder"+ assert templates[0].uriTemplate == r"resource://openapi/getOrder/{order_id}"++ async def test_tool_discovery(self, openapi_31_server):+ """Test that tools are correctly discovered from an OpenAPI 3.1 spec."""+ tools = await openapi_31_server._mcp_list_tools()+ assert len(tools) == 1+ assert tools[0].name == "createOrder"+ assert "customer" in tools[0].inputSchema["properties"]+ assert "items" in tools[0].inputSchema["properties"]++ async def test_resource_access(self, openapi_31_server):+ """Test reading a resource from an OpenAPI 3.1 server."""+ resource_response = await openapi_31_server._mcp_read_resource(+ "resource://openapi/listOrders"+ )+ content = resource_response[0].content+ assert len(content) == 2+ assert content[0]["customer"] == "Alice"+ assert content[1]["customer"] == "Bob"++ async def test_resource_template_access(self, openapi_31_server):+ """Test reading a resource from template from an OpenAPI 3.1 server."""+ resource_response = await openapi_31_server._mcp_read_resource(+ "resource://openapi/getOrder/o1"+ )+ content = resource_response[0].content+ assert content["id"] == "o1"+ assert content["customer"] == "Alice"+ assert content["items"] == ["item1", "item2"]++ async def test_tool_execution(self, openapi_31_server):+ """Test executing a tool from an OpenAPI 3.1 server."""+ tool_response = await openapi_31_server.call_tool(+ "createOrder", {"customer": "Charlie", "items": ["item4", "item5"]}+ )+ assert tool_response["id"] == "o3"+ assert tool_response["customer"] == "Charlie"+ assert tool_response["items"] == ["item4", "item5"]+++class TestMountFastMCP:+ """Tests for mounting FastMCP servers."""++ async def test_mount_fastmcp(self, fastmcp_openapi_server: FastMCPOpenAPI):+ """Test mounting an OpenAPI server."""+ mcp = FastMCP("MainApp")++ mcp.mount("fastapi", fastmcp_openapi_server)++ resources = await mcp._mcp_list_resources()+ assert len(resources) == 1+ assert resources[0].uri == AnyUrl(+ "fastapi+resource://openapi/get_users_users_get"+ )++ templates = await mcp._mcp_list_resource_templates()+ assert len(templates) == 1+ assert templates[0].name == "get_user_users__user_id__get"+ assert (+ templates[0].uriTemplate+ == r"fastapi+resource://openapi/get_user_users__user_id__get/{user_id}"+ )++ tools = await mcp._mcp_list_tools()+ assert len(tools) == 2+ assert tools[0].name == "fastapi_create_user_users_post"+ assert tools[1].name == "fastapi_update_user_name_users__user_id__name_patch"++ prompts = await mcp._mcp_list_prompts()+ assert len(prompts) == 0diff --git a/uv.lock b/uv.lockindex 166e9b8b0..d95c7312d 100644--- a/uv.lock+++ b/uv.lock@@ -254,7 +254,7 @@ wheels = [[[package]]name = "fastmcp"-version = "2.1.1.dev3+4f58d82"+version = "2.1.2.dev2+c0de75e"source = { editable = "." }dependencies = [{ name = "dotenv" },@@ -1323,4 +1323,4 @@ dependencies = [sdist = { url = "https://files.pythonhosted.org/packages/60/d9/6625ead93412c5ce86db1f8b4f2a70b8043e0a7c1d30099ba3c6a81641ff/wmctrl-0.5.tar.gz", hash = "sha256:7839a36b6fe9e2d6fd22304e5dc372dbced2116ba41283ea938b2da57f53e962", size = 5202 }wheels = [{ url = "https://files.pythonhosted.org/packages/13/ca/723e3f8185738d7947f14ee7dc663b59415c6dee43bd71575f8c7f5cd6be/wmctrl-0.5-py2.py3-none-any.whl", hash = "sha256:ae695c1863a314c899e7cf113f07c0da02a394b968c4772e1936219d9234ddd7", size = 4268 },-]\ No newline at end of file+]