basic tests and fixes

Author: shahar4499

fastapi_mcp/server.py

@@ -31,8 +31,8 @@ def __init__(
         self.tools: List[types.Tool]
 
         self.fastapi = fastapi
-        self.name = name
-        self.description = description
+        self.name = name or self.fastapi.title or "FastAPI MCP"
+        self.description = description or self.fastapi.description
 
         self._base_url = base_url
         self._describe_all_responses = describe_all_responses
@@ -68,10 +68,6 @@ def create_server(self) -> Server:
             routes=self.fastapi.routes,
         )
 
-        # Get server name and description from app if not provided
-        server_name = self.name or self.fastapi.title or "FastAPI MCP"
-        server_description = self.description or self.fastapi.description
-
         # Convert OpenAPI schema to MCP tools
         self.tools, self.operation_map = convert_openapi_to_mcp_tools(
             openapi_schema,
@@ -98,7 +94,7 @@ def create_server(self) -> Server:
             self._base_url = self._base_url[:-1]
 
         # Create the MCP server
-        mcp_server: Server = Server(server_name, server_description)
+        mcp_server: Server = Server(self.name, self.description)
 
         # Create a lifespan context manager to store the base_url and operation_map
         @asynccontextmanager

tests/conftest.py

@@ -4,7 +4,59 @@
 # Add the parent directory to the path
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 
-from .fixtures import types  # noqa: F401
-from .fixtures import example_data  # noqa: F401
-from .fixtures import simple_app  # noqa: F401
-from .fixtures import complex_app  # noqa: F401
+from .fixtures.types import *  # noqa: F403
+from .fixtures.example_data import *  # noqa: F403
+from .fixtures.simple_app import *  # noqa: F403
+from .fixtures.complex_app import *  # noqa: F403
+
+# Add specific fixtures for MCP testing
+import pytest
+from fastapi.testclient import TestClient
+
+from fastapi_mcp import FastApiMCP
+
+
+@pytest.fixture
+def mcp_server(simple_fastapi_app):
+    """
+    Create a basic MCP server instance for the simple_fastapi_app.
+    This is a utility fixture to be used by multiple tests.
+    """
+    return FastApiMCP(
+        simple_fastapi_app,
+        name="Test MCP Server",
+        description="Test MCP server for unit testing",
+        base_url="http://testserver",
+    )
+
+
+@pytest.fixture
+def complex_mcp_server(complex_fastapi_app):
+    """
+    Create a MCP server instance for the complex_fastapi_app.
+    This is a utility fixture to be used by multiple tests.
+    """
+    return FastApiMCP(
+        complex_fastapi_app,
+        name="Complex Test MCP Server",
+        description="Complex test MCP server for unit testing",
+        base_url="http://testserver",
+        describe_all_responses=True,
+        describe_full_response_schema=True,
+    )
+
+
+@pytest.fixture
+def client(simple_fastapi_app):
+    """
+    Create a test client for the simple_fastapi_app.
+    """
+    return TestClient(simple_fastapi_app)
+
+
+@pytest.fixture
+def complex_client(complex_fastapi_app):
+    """
+    Create a test client for the complex_fastapi_app.
+    """
+    return TestClient(complex_fastapi_app)

tests/fixtures/simple_app.py

@@ -21,15 +21,19 @@ async def list_items(
         sort_by: Optional[str] = Query(None, description="Field to sort by"),
     ):
         """List all items with pagination and sorting options."""
-        return []
+        return [
+            Item(id=1, name="Item 1", price=10.0, tags=["tag1", "tag2"], description="Item 1 description"),
+            Item(id=2, name="Item 2", price=20.0, tags=["tag2", "tag3"]),
+            Item(id=3, name="Item 3", price=30.0, tags=["tag3", "tag4"], description="Item 3 description"),
+        ]
 
     @app.get("/items/{item_id}", response_model=Item, tags=["items"], operation_id="get_item")
     async def read_item(
         item_id: int = Path(..., description="The ID of the item to retrieve"),
         include_details: bool = Query(False, description="Include additional details"),
     ):
         """Get a specific item by its ID with optional details."""
-        return {"id": item_id, "name": "Test Item", "price": 10.0}
+        return Item(id=item_id, name="Test Item", price=10.0, tags=["tag1", "tag2"])
 
     @app.post("/items/", response_model=Item, tags=["items"], operation_id="create_item")
     async def create_item(item: Item = Body(..., description="The item to create")):
@@ -45,9 +49,9 @@ async def update_item(
         item.id = item_id
         return item
 
-    @app.delete("/items/{item_id}", tags=["items"], operation_id="delete_item")
+    @app.delete("/items/{item_id}", status_code=204, tags=["items"], operation_id="delete_item")
     async def delete_item(item_id: int = Path(..., description="The ID of the item to delete")):
         """Delete an item from the database."""
-        return {"message": "Item deleted successfully"}
+        return None
 
     return app

tests/test_basic_functionality.py

@@ -0,0 +1,71 @@
+from fastapi import FastAPI
+from mcp.server.lowlevel.server import Server
+
+from fastapi_mcp import FastApiMCP
+
+
+def test_create_mcp_server(simple_fastapi_app: FastAPI):
+    """Test creating an MCP server without mounting it."""
+    mcp = FastApiMCP(
+        simple_fastapi_app,
+        name="Test MCP Server",
+        description="Test description",
+        base_url="http://localhost:8000",
+    )
+
+    # Verify the MCP server was created correctly
+    assert mcp.name == "Test MCP Server"
+    assert mcp.description == "Test description"
+    assert mcp._base_url == "http://localhost:8000"
+    assert isinstance(mcp.server, Server)
+    assert len(mcp.tools) > 0, "Should have extracted tools from the app"
+    assert len(mcp.operation_map) > 0, "Should have operation mapping"
+
+    # Check that the operation map contains all expected operations from simple_app
+    expected_operations = ["list_items", "get_item", "create_item", "update_item", "delete_item"]
+    for op in expected_operations:
+        assert op in mcp.operation_map, f"Operation {op} not found in operation map"
+
+
+def test_default_values(simple_fastapi_app: FastAPI):
+    """Test that default values are used when not explicitly provided."""
+    mcp = FastApiMCP(simple_fastapi_app)
+
+    # Verify default values
+    assert mcp.name == simple_fastapi_app.title
+    assert mcp.description == simple_fastapi_app.description
+
+    # Default base URL should be derived or defaulted
+    assert mcp._base_url is not None
+
+    # Mount with default path
+    mcp.mount()
+
+    # Check that the MCP server was properly mounted
+    # Look for a route that includes our mount path in its pattern
+    route_found = any("/mcp" in str(route) for route in simple_fastapi_app.routes)
+    assert route_found, "MCP server mount point not found in app routes"
+
+
+def test_normalize_paths(simple_fastapi_app: FastAPI):
+    """Test that mount paths are normalized correctly."""
+    mcp = FastApiMCP(simple_fastapi_app)
+
+    # Test with path without leading slash
+    mount_path = "test-mcp"
+    mcp.mount(mount_path=mount_path)
+
+    # Check that the route was added with a normalized path
+    route_found = any("/test-mcp" in str(route) for route in simple_fastapi_app.routes)
+    assert route_found, "Normalized mount path not found in app routes"
+
+    # Create a new MCP server
+    mcp2 = FastApiMCP(simple_fastapi_app)
+
+    # Test with path with trailing slash
+    mount_path = "/test-mcp2/"
+    mcp2.mount(mount_path=mount_path)
+
+    # Check that the route was added with a normalized path
+    route_found = any("/test-mcp2" in str(route) for route in simple_fastapi_app.routes)
+    assert route_found, "Normalized mount path not found in app routes"

tests/test_configuration.py

@@ -0,0 +1,195 @@
+from fastapi import FastAPI
+
+from fastapi_mcp import FastApiMCP
+
+
+def test_default_configuration(simple_fastapi_app: FastAPI):
+    """Test the default configuration of FastApiMCP."""
+    # Create MCP server with defaults
+    mcp_server = FastApiMCP(simple_fastapi_app)
+
+    # Check default name and description
+    assert mcp_server.name == simple_fastapi_app.title
+    assert mcp_server.description == simple_fastapi_app.description
+
+    # Check default base URL
+    assert mcp_server._base_url is not None
+    assert mcp_server._base_url.startswith("http://")
+
+    # Check default options
+    assert mcp_server._describe_all_responses is False
+    assert mcp_server._describe_full_response_schema is False
+
+
+def test_custom_configuration(simple_fastapi_app: FastAPI):
+    """Test a custom configuration of FastApiMCP."""
+    # Create MCP server with custom options
+    custom_name = "Custom MCP Server"
+    custom_description = "A custom MCP server for testing"
+    custom_base_url = "https://custom-api.example.com"
+
+    mcp_server = FastApiMCP(
+        simple_fastapi_app,
+        name=custom_name,
+        description=custom_description,
+        base_url=custom_base_url,
+        describe_all_responses=True,
+        describe_full_response_schema=True,
+    )
+
+    # Check custom name and description
+    assert mcp_server.name == custom_name
+    assert mcp_server.description == custom_description
+
+    # Check custom base URL
+    assert mcp_server._base_url == custom_base_url
+
+    # Check custom options
+    assert mcp_server._describe_all_responses is True
+    assert mcp_server._describe_full_response_schema is True
+
+
+def test_base_url_normalization(simple_fastapi_app: FastAPI):
+    """Test that base URLs are normalized correctly."""
+    # Test with trailing slash
+    mcp_server1 = FastApiMCP(
+        simple_fastapi_app,
+        base_url="http://example.com/api/",
+    )
+    assert mcp_server1._base_url == "http://example.com/api"
+
+    # Test without trailing slash
+    mcp_server2 = FastApiMCP(
+        simple_fastapi_app,
+        base_url="http://example.com/api",
+    )
+    assert mcp_server2._base_url == "http://example.com/api"
+
+
+def test_describe_all_responses_config_simple_app(simple_fastapi_app: FastAPI):
+    """Test the describe_all_responses behavior with the simple app."""
+    mcp_default = FastApiMCP(
+        simple_fastapi_app,
+        base_url="http://example.com",
+    )
+
+    mcp_all_responses = FastApiMCP(
+        simple_fastapi_app,
+        base_url="http://example.com",
+        describe_all_responses=True,
+    )
+
+    for tool in mcp_default.tools:
+        assert tool.description is not None
+        if tool.name != "delete_item":
+            assert tool.description.count("**200**") == 1, "The description should contain a 200 status code"
+            assert tool.description.count("**Example Response:**") == 1, (
+                "The description should only contain one example response"
+            )
+            assert tool.description.count("**Output Schema:**") == 0, (
+                "The description should not contain a full output schema"
+            )
+        else:
+            # The delete endpoint in the Items API returns a 204 status code
+            assert tool.description.count("**200**") == 0, "The description should not contain a 200 status code"
+            assert tool.description.count("**204**") == 1, "The description should contain a 204 status code"
+            # The delete endpoint in the Items API returns a 204 status code and has no response body
+            assert tool.description.count("**Example Response:**") == 0, (
+                "The description should not contain any example responses"
+            )
+            assert tool.description.count("**Output Schema:**") == 0, (
+                "The description should not contain a full output schema"
+            )
+
+    for tool in mcp_all_responses.tools:
+        assert tool.description is not None
+        if tool.name != "delete_item":
+            assert tool.description.count("**200**") == 1, "The description should contain a 200 status code"
+            assert tool.description.count("**422**") == 1, "The description should contain a 422 status code"
+            assert tool.description.count("**Example Response:**") == 2, (
+                "The description should contain two example responses"
+            )
+            assert tool.description.count("**Output Schema:**") == 0, (
+                "The description should not contain a full output schema"
+            )
+        else:
+            assert tool.description.count("**204**") == 1, "The description should contain a 204 status code"
+            assert tool.description.count("**422**") == 1, "The description should contain a 422 status code"
+            # The delete endpoint in the Items API returns a 204 status code and has no response body
+            # But FastAPI's default 422 response should be present
+            # So just 1 instance of Example Response should be present
+            assert tool.description.count("**Example Response:**") == 1, (
+                "The description should contain one example response"
+            )
+            assert tool.description.count("**Output Schema:**") == 0, (
+                "The description should not contain any output schema"
+            )
+
+
+def test_describe_full_response_schema_config_simple_app(simple_fastapi_app: FastAPI):
+    """Test the describe_full_response_schema behavior with the simple app."""
+
+    mcp_full_response_schema = FastApiMCP(
+        simple_fastapi_app,
+        base_url="http://example.com",
+        describe_full_response_schema=True,
+    )
+
+    for tool in mcp_full_response_schema.tools:
+        assert tool.description is not None
+        if tool.name != "delete_item":
+            assert tool.description.count("**200**") == 1, "The description should contain a 200 status code"
+            assert tool.description.count("**Example Response:**") == 1, (
+                "The description should only contain one example response"
+            )
+            assert tool.description.count("**Output Schema:**") == 1, (
+                "The description should contain one full output schema"
+            )
+        else:
+            # The delete endpoint in the Items API returns a 204 status code
+            assert tool.description.count("**200**") == 0, "The description should not contain a 200 status code"
+            assert tool.description.count("**204**") == 1, "The description should contain a 204 status code"
+            # The delete endpoint in the Items API returns a 204 status code and has no response body
+            assert tool.description.count("**Example Response:**") == 0, (
+                "The description should not contain any example responses"
+            )
+            assert tool.description.count("**Output Schema:**") == 0, (
+                "The description should not contain a full output schema"
+            )
+
+
+def test_describe_all_responses_and_full_response_schema_config_simple_app(simple_fastapi_app: FastAPI):
+    """Test the describe_all_responses and describe_full_response_schema params together with the simple app."""
+
+    mcp_all_responses_and_full_response_schema = FastApiMCP(
+        simple_fastapi_app,
+        base_url="http://example.com",
+        describe_all_responses=True,
+        describe_full_response_schema=True,
+    )
+
+    for tool in mcp_all_responses_and_full_response_schema.tools:
+        assert tool.description is not None
+        if tool.name != "delete_item":
+            assert tool.description.count("**200**") == 1, "The description should contain a 200 status code"
+            assert tool.description.count("**422**") == 1, "The description should contain a 422 status code"
+            assert tool.description.count("**Example Response:**") == 2, (
+                "The description should contain two example responses"
+            )
+            assert tool.description.count("**Output Schema:**") == 2, (
+                "The description should contain two full output schemas"
+            )
+        else:
+            # The delete endpoint in the Items API returns a 204 status code
+            assert tool.description.count("**200**") == 0, "The description should not contain a 200 status code"
+            assert tool.description.count("**204**") == 1, "The description should contain a 204 status code"
+            assert tool.description.count("**422**") == 1, "The description should contain a 422 status code"
+            # The delete endpoint in the Items API returns a 204 status code and has no response body
+            # But FastAPI's default 422 response should be present
+            # So just 1 instance of Example Response and Output Schema should be present
+            assert tool.description.count("**Example Response:**") == 1, (
+                "The description should contain one example response"
+            )
+            assert tool.description.count("**Output Schema:**") == 1, (
+                "The description should contain one full output schema"
+            )