Merge pull request #4 from mrexodia/gh-actions

Extensive testing and CI

Author: mrexodia

.github/workflows/ci.yml

@@ -0,0 +1,61 @@
+name: CI
+
+on: [push, pull_request]
+
+# Automatically cancel previous runs of this workflow on the same branch
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  linux:
+    # Skip building pull requests from the same repository
+    if: ${{ github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository) }}
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    env:
+      PYTHONUNBUFFERED: 1
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Update pyproject.toml version
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        shell: bash
+        run: |
+          # Extract version from tag (strip 'v' prefix if present)
+          VERSION=${GITHUB_REF#refs/tags/}
+          VERSION=${VERSION#v}
+          echo "Extracted version: $VERSION"
+          
+          # Update version in pyproject.toml (works on both GNU and BSD sed)
+          sed -i.bak "s/^version = .*/version = \"$VERSION\"/" pyproject.toml
+          rm pyproject.toml.bak
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          version: "0.9.3"
+
+      - name: Create venv
+        run: uv sync
+
+      - name: Type check
+        run: uvx ty check
+
+      - name: Test JSON-RPC
+        run: uv run coverage run --data-file=.coverage.jsonrpc tests/jsonrpc_test.py
+
+      - name: Test MCP
+        run: uv run coverage run --data-file=.coverage.mcp tests/mcp_test.py
+
+      - name: Generate coverage report
+        run: |
+          uv run coverage combine
+          uv run coverage report
+
+      - name: Publish
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        run: uv build && uv publish

.gitignore

@@ -8,3 +8,7 @@ wheels/
 
 # Virtual environments
 .venv
+
+# Coverage
+htmlcov/
+.coverage*

CONTRIBUTING.md

@@ -0,0 +1,22 @@
+# Development notes
+
+Run the tests with coverage:
+
+```sh
+uv run coverage run --data-file=.coverage.mcp tests/mcp_test.py
+uv run coverage run --data-file=.coverage.jsonrpc tests/jsonrpc_test.py
+```
+
+Combine coverage and generate report:
+
+```sh
+uv run coverage combine
+uv run coverage report
+uv run coverage html
+```
+
+Generate report for just `jsonrpc_test.py:
+
+```sh
+uv run coverage html --data-file=.coverage.jsonrpc
+```

examples/mcp_example.py

@@ -1,22 +1,12 @@
 """Example MCP server with test tools"""
 import time
 import argparse
+from urllib.parse import urlparse
 from typing import Annotated, Optional, TypedDict, NotRequired
 from zeromcp import McpToolError, McpServer
 
 mcp = McpServer("example")
 
-class SystemInfo(TypedDict):
-    platform: Annotated[str, "Operating system platform"]
-    python_version: Annotated[str, "Python version"]
-    machine: Annotated[str, "Machine architecture"]
-    timestamp: Annotated[float, "Current timestamp"]
-
-class GreetingResponse(TypedDict):
-    message: Annotated[str, "Greeting message"]
-    name: Annotated[str, "Name that was greeted"]
-    age: Annotated[NotRequired[int], "Age if provided"]
-
 @mcp.tool
 def divide(
     numerator: Annotated[float, "Numerator"],
@@ -25,6 +15,11 @@ def divide(
     """Divide two numbers (no zero check - tests natural exceptions)"""
     return numerator / denominator
 
+class GreetingResponse(TypedDict):
+    message: Annotated[str, "Greeting message"]
+    name: Annotated[str, "Name that was greeted"]
+    age: Annotated[NotRequired[int], "Age if provided"]
+
 @mcp.tool
 def greet(
     name: Annotated[str, "Name to greet"],
@@ -42,6 +37,12 @@ def greet(
         "name": name
     }
 
+class SystemInfo(TypedDict):
+    platform: Annotated[str, "Operating system platform"]
+    python_version: Annotated[str, "Python version"]
+    machine: Annotated[str, "Machine architecture"]
+    timestamp: Annotated[float, "Current timestamp"]
+
 @mcp.tool
 def get_system_info() -> SystemInfo:
     """Get system information"""
@@ -78,6 +79,16 @@ def struct_get(
         for name in (names if isinstance(names, list) else [names])
     ]
 
+@mcp.tool
+def random_dict(param: dict[str, int] | None) -> dict:
+    """Return a random dictionary for testing serialization"""
+    return {
+        **(param or {}),
+        "x": 42,
+        "y": 7,
+        "z": 99,
+    }
+
 @mcp.resource("example://system_info")
 def system_info_resource() -> SystemInfo:
     """Resource providing system information"""
@@ -90,28 +101,32 @@ def greeting_resource(
     """Resource providing greeting message"""
     return greet(name)
 
+@mcp.resource("example://error")
+def error_resource() -> None:
+    """Resource that always fails (for testing error handling)"""
+    raise McpToolError("This is a resource error for testing purposes.")
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="MCP Example Server")
-    parser.add_argument("--stdio", action="store_true", help="Run MCP server over stdio")
+    parser.add_argument("--transport", help="Transport (stdio or http://host:port)", default="http://127.0.0.1:5001")
     args = parser.parse_args()
-    if args.stdio:
+    if args.transport == "stdio":
         mcp.stdio()
     else:
+        url = urlparse(args.transport)
+        if url.hostname is None or url.port is None:
+            raise Exception(f"Invalid transport URL: {args.transport}")
+
         print("Starting MCP Example Server...")
         print("\nAvailable tools:")
         for name in mcp._tools.methods.keys():
             func = mcp._tools.methods[name]
             print(f"  - {name}: {func.__doc__}")
 
-        mcp.serve("127.0.0.1", 5001)
-
-        print("\n" + "="*60)
-        print("Server is running. Press Ctrl+C to stop.")
-        print("="*60)
+        mcp.serve(url.hostname, url.port)
 
         try:
-            while True:
-                time.sleep(1)
-        except KeyboardInterrupt:
+            input("Server is running, press Enter or Ctrl+C to stop.")
+        except (KeyboardInterrupt, EOFError):
             print("\n\nStopping server...")
             mcp.stop()

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "zeromcp"
-version = "1.0.0"
+version = "0.0.0"
 description = "Zero-dependency MCP server implementation"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -15,3 +15,12 @@ Issues = "https://github.com/mrexodia/zeromcp/issues"
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "coverage>=7.11.3",
+    "mcp>=1.21.2",
+]
+
+[tool.coverage.report]
+omit = ["tests/*"]

src/zeromcp/jsonrpc.py

@@ -3,6 +3,7 @@
 import inspect
 import traceback
 from typing import Any, Callable, get_type_hints, get_origin, get_args, Union, TypedDict, TypeAlias, NotRequired, is_typeddict
+from types import UnionType
 
 JsonRpcId: TypeAlias = str | int | float | None
 JsonRpcParams: TypeAlias = dict[str, Any] | list[Any] | None
@@ -113,12 +114,12 @@ def _call(self, method: str, params: Any) -> Any:
                     -32602,
                     f"Invalid params: expected at least {len(required_params)} arguments, got {len(params)}"
                 )
-            if len(params) > len(hints):
+            if len(params) > len(sig.parameters):
                 raise JsonRpcException(
                     -32602,
-                    f"Invalid params: expected at most {len(hints)} arguments, got {len(params)}"
+                    f"Invalid params: expected at most {len(sig.parameters)} arguments, got {len(params)}"
                 )
-            params = dict(zip(hints.keys(), params))
+            params = dict(zip(sig.parameters.keys(), params))
 
         # Validate dict params
         if isinstance(params, dict):
@@ -131,19 +132,22 @@ def _call(self, method: str, params: Any) -> Any:
                 )
 
             # Check no extra params
-            extra = set(params.keys()) - set(hints.keys())
+            extra = set(params.keys()) - set(sig.parameters.keys())
             if extra:
                 raise JsonRpcException(
                     -32602,
                     f"Invalid params: unexpected parameters: {list(extra)}"
                 )
 
             validated_params = {}
-            for param_name, expected_type in hints.items():
-                if param_name not in params:
-                    continue  # Skip optional params not provided
+            for param_name, value in params.items():
+                # If no type hint, pass through without validation
+                if param_name not in hints:
+                    validated_params[param_name] = value
+                    continue
 
-                value = params[param_name]
+                # Has type hint, validate
+                expected_type = hints[param_name]
 
                 # Inline type validation
                 origin = get_origin(expected_type)
@@ -153,13 +157,13 @@ def _call(self, method: str, params: Any) -> Any:
                 if value is None:
                     if expected_type is not type(None):
                         # Check if None is allowed in a Union
-                        if not (origin is Union and type(None) in args):
+                        if not (origin in (Union, UnionType) and type(None) in args):
                             raise JsonRpcException(-32602, f"Invalid params: {param_name} cannot be null")
                     validated_params[param_name] = None
                     continue
 
                 # Handle Union types (int | str, Optional[int], etc.)
-                if origin is Union or (hasattr(types, 'UnionType') and origin is types.UnionType):
+                if origin in (Union, UnionType):
                     type_matched = False
                     for arg_type in args:
                         if arg_type is type(None):
@@ -177,7 +181,7 @@ def _call(self, method: str, params: Any) -> Any:
                             break
 
                     if not type_matched:
-                        raise JsonRpcException(-32602, f"Invalid params: {param_name} has invalid type")
+                        raise JsonRpcException(-32602, f"Invalid params: {param_name} union does not contain {type(value).__name__}")
                     validated_params[param_name] = value
                     continue
 
@@ -201,6 +205,11 @@ def _call(self, method: str, params: Any) -> Any:
                     validated_params[param_name] = value
                     continue
 
+                # Handle Any
+                if expected_type is Any:
+                    validated_params[param_name] = value
+                    continue
+
                 # Handle basic types
                 if isinstance(expected_type, type):
                     # Allow int -> float conversion
@@ -215,9 +224,6 @@ def _call(self, method: str, params: Any) -> Any:
                     validated_params[param_name] = value
                     continue
 
-                # Fallback for Any or unknown
-                validated_params[param_name] = value
-
             return func(**validated_params)
 
         else: