Merge pull request #9 from openapi/dev

Refactor environment setup and improve pytest coverage

Author: francescobianco

docs/env/README.md

@@ -26,15 +26,6 @@ cache backend, and any platform-specific notes.
 | `MCP_CACHE_PORT` | `11211` | Memcached port                                                                           |
 | `MCP_CACHE_URL` | _(none)_ | Redis connection URL (used when `MCP_CACHE_BACKEND=redis`)                               |
 
-### Legacy variables (GCP Cloud Run — deprecated)
-
-These are still read by the current codebase for backward compatibility with the
-existing GCP deployment. Prefer the explicit variables above for new deployments.
-
-| Variable | Description |
-|---|---|
-| `K_SERVICE` | Cloud Run service name — auto-injects `MCP_BASE_URL`, `MCP_OPENAPI_ENV`, Memcached IPs |
-
 ---
 
 ## Why storage matters

docs/env/gcp.md

@@ -43,20 +43,6 @@ MCP_CACHE_PORT=11211
 
 ---
 
-## Legacy variables (backward compatibility)
-
-If you are using a Cloud Run deployment without migrating to the
-explicit variables above, the following variables are still read:
-
-| Variable | Effect |
-|---|---|
-| `K_SERVICE` | Auto-set by Cloud Run. Derives `MCP_BASE_URL` (`K_SERVICE.replace("-",".")`) and `MCP_OPENAPI_ENV` (from service name prefix), and selects the Memcached VPC IP. |
-
-> **Migration path:** set `MCP_BASE_URL`, `MCP_OPENAPI_ENV`, `MCP_CACHE_HOST` explicitly
-> and stop relying on `K_SERVICE`. This makes the server portable to any platform.
-
----
-
 ## Cloud Run deployment
 
 ### Cloud Run service YAML

docs/testing.md

@@ -126,8 +126,8 @@ MCP_URL=https://abcd1234.ngrok-free.app SANDBOX=1 make test-openai-sandbox
 | Data | real | simulated |
 | Token variable | `OPENAPI_TOKEN` | `OPENAPI_SANDBOX_TOKEN` |
 
-The MCP server switches between production and sandbox based on the `K_SERVICE` environment
-variable (handled automatically by the test runners).
+The MCP server switches between production and sandbox based on the `MCP_OPENAPI_ENV`
+environment variable (handled automatically by the test runners).
 
 ---
 

pyproject.toml

@@ -24,5 +24,8 @@ dependencies = [
 [tool.setuptools]
 license-files = ["LICENSE"]
 
+[tool.pytest.ini_options]
+testpaths = ["tests/pytest"]
+
 [project.scripts]
 openapi-mcp-sdk = "openapi_mcp_sdk.cli:main"

requirements.txt

@@ -18,3 +18,4 @@ fastmcp
 requests
 pydantic
 uvicorn
+pytest

src/openapi_mcp_sdk/main.py

@@ -1,3 +1,5 @@
+"""ASGI entrypoint for the OpenAPI MCP server."""
+
 import os
 import re
 import sys
@@ -10,6 +12,23 @@
 from starlette.types import ASGIApp, Scope, Receive, Send, Message
 from .mcp_audit import McpAuditMiddleware
 from .storage_backend import read_file
+from .memory_store import get_callback_result, set_callback_result
+from .mcp_core import mcp
+from .apis import (
+    async_tool,
+    automotive,
+    cap,
+    company,
+    docuengine,
+    exchange,
+    geocoding,
+    info,
+    pec,
+    risk,
+    sms,
+    trust,
+    visurecamerali,
+)
 
 # ---------------------------------------------------------------------------
 # Bootstrap package logger early — before uvicorn configures its own logging.
@@ -59,12 +78,8 @@ def format(self, record: logging.LogRecord) -> str:
         # Fallback: at least mask tokens
         return self._TOKEN_RE.sub(r'\1token=***', result)
 
-    # Delegate everything else to the inner formatter
     def __getattr__(self, name):
         return getattr(self._inner, name)
-from .memory_store import get_callback_result, set_callback_result
-from .mcp_core import mcp # Import MCP instance with tools already registered in mcp_core.py
-from .apis import async_tool, company, cap, trust, visurecamerali, sms, risk, geocoding,automotive,exchange, pec, docuengine, info # Import tool modules (side-effect: triggers @mcp.tool registration)
 
 # Create the MCP ASGI app mounted at root
 mcp_app = mcp.http_app(path='/')
@@ -168,19 +183,31 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
             client_ip = (scope.get("client") or ("?", 0))[0]
             async with registration_lock:
                 if not getattr(app.state, "dynamic_tools_registered", False):
-                    _logger.info('%s %s "Initializing dynamic tools (token: %s...)"', "[JIT]", client_ip, token[:8])
+                    _logger.info(
+                        '%s %s "Initializing dynamic tools (token: %s...)"',
+                        "[JIT]",
+                        client_ip,
+                        token[:8],
+                    )
                     success = await asyncio.to_thread(docuengine.init_dynamic_tools, token)
                     if success:
                         app.state.dynamic_tools_registered = True
                     else:
-                        _logger.warning('%s %s "Registration failed — will retry on next request"', "[JIT]", client_ip)
+                        _logger.warning(
+                            '%s %s "Registration failed — will retry on next request"',
+                            "[JIT]",
+                            client_ip,
+                        )
 
         await self.app(scope, receive, send)
 
 
 _OAUTH_NOT_SUPPORTED_BODY = json.dumps({
     "error": "oauth_not_supported",
-    "message": "This server does not support OAuth. Use a pre-configured Bearer token in the Authorization header."
+    "message": (
+        "This server does not support OAuth. Use a pre-configured Bearer "
+        "token in the Authorization header."
+    ),
 }).encode()
 
 _OAUTH_DISCOVERY_PATHS = {
@@ -190,18 +217,25 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
 }
 
 class RejectOAuthDiscoveryMiddleware:
-    """Return a JSON 404 for OAuth discovery endpoints so MCP clients fall back to Bearer auth."""
+    """Return a JSON 404 for OAuth discovery endpoints."""
     def __init__(self, app: ASGIApp) -> None:
         self.app = app
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] == "http" and scope["path"].rstrip("/") in {p.rstrip("/") for p in _OAUTH_DISCOVERY_PATHS}:
+        if (
+            scope["type"] == "http"
+            and scope["path"].rstrip("/") in {p.rstrip("/") for p in _OAUTH_DISCOVERY_PATHS}
+        ):
             await send({
                 "type": "http.response.start",
                 "status": 404,
                 "headers": [(b"content-type", b"application/json")],
             })
-            await send({"type": "http.response.body", "body": _OAUTH_NOT_SUPPORTED_BODY, "more_body": False})
+            await send({
+                "type": "http.response.body",
+                "body": _OAUTH_NOT_SUPPORTED_BODY,
+                "more_body": False,
+            })
             return
         await self.app(scope, receive, send)
 
@@ -214,7 +248,7 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
 app.add_middleware(McpAuditMiddleware)            # innermost — logs MCP JSON-RPC actions
 app.add_middleware(Enrich404Middleware)           # wraps 404s in JSON
 app.add_middleware(TokenQuerystringMiddleware)    # injects auth header + JIT registration
-app.add_middleware(RejectOAuthDiscoveryMiddleware) # short-circuits OAuth discovery paths
+app.add_middleware(RejectOAuthDiscoveryMiddleware)  # short-circuits OAuth discovery paths
 # CORS must be outermost so it runs before anything else on every request,
 # including pre-flight OPTIONS. expose_headers exposes Mcp-Session-Id to browsers.
 # allow_credentials must NOT be True when allow_origins=["*"].
@@ -243,7 +277,9 @@ async def callbacks_endpoint(request: Request):
         return {"status": "error", "message": "Body not a valid JSON"}
 
     cb_obj = callback.get("callback")
-    custom = callback.get("custom") or (cb_obj.get("data") if isinstance(cb_obj, dict) else None)
+    custom = callback.get("custom") or (
+        cb_obj.get("data") if isinstance(cb_obj, dict) else None
+    )
     if not custom:
         _logger.warning('%s %s "Missing callback.custom field"', "[CB]", client_ip)
         return {"status": "error", "message": "'callback.custom' missing from received data"}

src/openapi_mcp_sdk/mcp_audit.py

@@ -13,7 +13,7 @@
 
 import json
 import logging
-from starlette.types import ASGIApp, Scope, Receive, Send
+from starlette.types import ASGIApp, Scope, Receive, Send  # pylint: disable=import-error
 
 _log = logging.getLogger("openapi_mcp_sdk.audit")
 
@@ -42,7 +42,7 @@ def _emit(body: bytes, client_ip: str) -> None:
     """Parse a JSON-RPC body and emit a structured audit log line."""
     try:
         data = json.loads(body)
-    except Exception:
+    except json.JSONDecodeError:
         return
 
     if not isinstance(data, dict) or "method" not in data:
@@ -79,7 +79,7 @@ def _emit(body: bytes, client_ip: str) -> None:
         _log.info('%s %s "%s"', _TAG, client_ip, label)
 
 
-class McpAuditMiddleware:
+class McpAuditMiddleware:  # pylint: disable=too-few-public-methods
     """Non-destructive ASGI middleware that logs MCP JSON-RPC calls.
 
     Wraps the ``receive`` callable to buffer POST body chunks, emits the audit

src/openapi_mcp_sdk/memory_store.py

@@ -1,22 +1,22 @@
-# memory_store.py
-# Singleton in-memory store for callback results
+"""Shared storage for async callback results."""
+
+from __future__ import annotations
+
+import json
 import os
 import logging
 from typing import Dict
 
 logger = logging.getLogger(__name__)
 try:
     from pymemcache.client import base
-    _pymemcache_available = True
+    _PYMEMCACHE_AVAILABLE = True
 except ImportError:
     base = None  # type: ignore[assignment]
-    _pymemcache_available = False
-import json
+    _PYMEMCACHE_AVAILABLE = False
 
 callback_results = {}
 
-MCP_STORAGE_BUCKET = os.getenv("MCP_STORAGE_BUCKET", "mcp-openapi-storage")
-
 MCP_ENV = os.getenv("MCP_ENV", "production").strip().lower()
 if MCP_ENV not in {"dev", "staging", "production"}:
     logger.warning("Invalid MCP_ENV=%r, defaulting to 'production'", MCP_ENV)
@@ -25,14 +25,6 @@
 MCP_OPENAPI_ENV = os.getenv("MCP_OPENAPI_ENV", "").strip().lower()
 if MCP_OPENAPI_ENV == "sandbox":
     MCP_OPENAPI_ENV = "test"
-if not MCP_OPENAPI_ENV and K_SERVICE and K_SERVICE != "mcp-openapi-com":
-    candidate = K_SERVICE.split("-")[0].strip().lower()
-    if candidate == "alpha":
-        candidate = "dev"
-    if candidate == "sandbox":
-        candidate = "test"
-    if candidate in {"dev", "test"}:
-        MCP_OPENAPI_ENV = candidate
 if MCP_OPENAPI_ENV not in {"", "dev", "test"}:
     logger.warning("Invalid MCP_OPENAPI_ENV=%r, defaulting to production", MCP_OPENAPI_ENV)
     MCP_OPENAPI_ENV = ""
@@ -47,11 +39,14 @@
         callbackUrl = callbackUrl.replace("alpha", "dev")
 
 MEMCACHED_HOST = os.getenv("MCP_CACHE_HOST", '0.0.0.0')
-MEMCACHED_PORT = int(os.getenv("MCP_CACHE_PORT", 11211))
+MEMCACHED_PORT = int(os.getenv("MCP_CACHE_PORT", "11211"))
 # connect_timeout / timeout = 1 s: when Memcached is unreachable (e.g. local dev,
 # Docker without the VPC network) the client fails fast and the except block
 # falls back to the in-process dict, keeping every endpoint responsive.
-memcached_client = base.Client((MEMCACHED_HOST, MEMCACHED_PORT), connect_timeout=1, timeout=1) if _pymemcache_available else None
+memcached_client = (
+    base.Client((MEMCACHED_HOST, MEMCACHED_PORT), connect_timeout=1, timeout=1)
+    if _PYMEMCACHE_AVAILABLE else None
+)
 
 # Funzioni aggiornate per supportare Memcached
 def get_callback_result(request_id: str):
@@ -62,11 +57,13 @@ def get_callback_result(request_id: str):
         if memcached_client is None:
             raise RuntimeError("pymemcache not available")
         return get_from_memcached(memcached_client, request_id)
-    except Exception as e:
+    except (RuntimeError, OSError, ValueError, TypeError) as e:
         # Fallback al dizionario in memoria
         logger.debug("memcached get failed, falling back to in-memory store: %s", e)
         if request_id not in callback_results:
-            raise KeyError(f"Result not found for request_id: {request_id}")
+            raise KeyError(
+                f"Result not found for request_id: {request_id}"
+            ) from e
         return callback_results[request_id]
 
 
@@ -82,20 +79,20 @@ def set_callback_result(request_id: str, data: Dict, custom: Dict):
         if memcached_client is None:
             raise RuntimeError("pymemcache not available")
         save_to_memcached(memcached_client, request_id, result)
-    except Exception as e:
+    except (RuntimeError, OSError, ValueError, TypeError) as e:
         # Fallback al dizionario in memoria
         logger.debug("memcached set failed, falling back to in-memory store: %s", e)
         callback_results[request_id] = result
 
 def save_to_memcached(client, key, value):
-    # Serialize to JSON and encode as UTF-8
+    """Serialize a callback payload and store it in Memcached."""
     binary_value = json.dumps(value).encode('utf-8')
     client.set(key, binary_value)
 
-# Retrieve data from Memcached
+
 def get_from_memcached(client, key):
+    """Read a callback payload from Memcached and decode it from JSON."""
     binary_value = client.get(key)
     if binary_value is not None:
-        # Decode from UTF-8 and deserialize from JSON
         return json.loads(binary_value.decode('utf-8'))
     return None

tests/integration/run-vs-claude.sh

@@ -14,10 +14,10 @@ SERVER_PID=""
 SANDBOX="${SANDBOX:-0}"
 if [ "$SANDBOX" = "1" ]; then
     TOKEN="${OPENAPI_SANDBOX_TOKEN:-}"
-    K_SERVICE_VALUE="test-openapi-mcp-server"
+    MCP_OPENAPI_ENV_VALUE="test"
 else
     TOKEN="${OPENAPI_TOKEN:-}"
-    K_SERVICE_VALUE=""
+    MCP_OPENAPI_ENV_VALUE=""
 fi
 
 cleanup() {
@@ -68,7 +68,7 @@ EOF
 
 echo "Starting MCP server..."
 cd "$ROOT_DIR"
-K_SERVICE="$K_SERVICE_VALUE" PYTHONPATH=src uv run uvicorn openapi_mcp_sdk.main:app \
+MCP_OPENAPI_ENV="$MCP_OPENAPI_ENV_VALUE" PYTHONPATH=src uv run uvicorn openapi_mcp_sdk.main:app \
     --host 0.0.0.0 --port 8080 --log-level warning &
 SERVER_PID=$!
 

tests/integration/run-vs-codex.sh

@@ -15,10 +15,10 @@ SERVER_PID=""
 SANDBOX="${SANDBOX:-0}"
 if [ "$SANDBOX" = "1" ]; then
     TOKEN="${OPENAPI_SANDBOX_TOKEN:-}"
-    K_SERVICE_VALUE="test-openapi-mcp-server"
+    MCP_OPENAPI_ENV_VALUE="test"
 else
     TOKEN="${OPENAPI_TOKEN:-}"
-    K_SERVICE_VALUE=""
+    MCP_OPENAPI_ENV_VALUE=""
 fi
 
 cleanup() {
@@ -66,7 +66,7 @@ codex mcp add "$MCP_SERVER_NAME" \
 
 echo "Starting MCP server..."
 cd "$ROOT_DIR"
-K_SERVICE="$K_SERVICE_VALUE" PYTHONPATH=src uv run uvicorn openapi_mcp_sdk.main:app \
+MCP_OPENAPI_ENV="$MCP_OPENAPI_ENV_VALUE" PYTHONPATH=src uv run uvicorn openapi_mcp_sdk.main:app \
     --host 0.0.0.0 --port 8080 --log-level warning &
 SERVER_PID=$!