mcp-api-test 0.1.0__tar.gz

mcp_api_test-0.1.0/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2026 Ryan Febriansyah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

mcp_api_test-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+prune log

mcp_api_test-0.1.0/PKG-INFO

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: mcp-api-test
+Version: 0.1.0
+Summary: MCP server for testing REST API with built-in assertions
+Author: Ryan Febriansyah
+Keywords: testing,mcp,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp
+Requires-Dist: httpx
+Requires-Dist: python-dotenv
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: respx; extra == "dev"
+Dynamic: license-file
+
+# api-test-mcp
+
+![image](https://gitlab.com/ryaneatfood/mcp-api-testing/badges/master/pipeline.svg)
+
+MCP server for REST API testing with assertions. Provides a `test_api` tool that accepts either a cURL command or structured request fields, runs the request, and validates against expected status codes and response fields
+
+## Prerequisites
+
+- Python >= 3.10
+- pip or uv for package installation
+
+## Install
+
+### From PyPI
+
+```bash
+pip install mcp-api-test
+```
+
+### From source
+
+```bash
+git clone git@gitlab.com:ryaneatfood/mcp-api-testing.git
+
+# change the directory
+cd api-test-mcp
+
+# install from source
+pip install -e .
+```
+
+This registers the `api-test-mcp` CLI command on your PATH. Verify with:
+
+```bash
+which api-test-mcp
+```
+
+## Testing with MCP Inspector
+
+The [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector) provides a browser-based UI to verify your server connects and responds correctly before wiring it into a client.
+
+Make sure `api-test-mcp` is installed on your PATH (see [Install](#install)), then run:
+
+```bash
+npx @modelcontextprotocol/inspector
+```
+
+This launches the inspector and opens `http://localhost:5173` in your browser. From the UI:
+
+1. Set **Transport Type** to `STDIO`
+2. Set **Command** to `api-test-mcp`
+3. Leave **Arguments** empty (your server needs none)
+4. Click **Connect**
+
+When the connection succeeds, the status badge changes to **Connected** and the inspector lists the `test_api` tool under the Tools tab. You can click the tool to open a form and run test calls interactively. This is useful for rapid iteration without restarting your MCP client.
+
+If the status shows "Failed to connect" double-check that `which api-test-mcp` resolves and that `pip install -e .` completed without errors
+
+## Running Tests
+
+Install test dependencies and run the suite:
+
+```bash
+# install test dependencies
+pip install pytest pytest-asyncio respx
+
+# run the whole test suite
+pytest -v
+```
+
+All integration tests use `respx` to mock HTTP responses. No real network calls are made, so the suite runs fast and offline. The test suite also consisted of unit test and integration test
+
+## OpenCode Setup
+
+Edit `opencode.json` (already configured at project root):
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "mcp": {
+    "api-test-mcp": {
+      "type": "local",
+      "command": ["api-test-mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+## Claude Desktop Setup
+
+Edit `claude_desktop_config.json` (usually at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+
+```json
+{
+  "mcpServers": {
+    "api-test-mcp": {
+      "command": "api-test-mcp"
+    }
+  }
+}
+```
+
+Restart Claude Desktop after saving.
+
+## Usage
+
+The `test_api` tool supports two modes:
+
+### cURL mode
+
+Pass a raw cURL command, and then the server parses method, URL, headers, and payload automatically into restructured data. Example prompt that you might be used:
+
+> "Please test this API using this cURL: `curl -X POST https://api.example.com/v1/users -H 'Authorization: Bearer xxx' -d '{"name":"test"}'`, ensure status code is 201 and response contains 'id'"
+
+### Structured mode
+
+Provide individual fields rather than used a cURL command. Example prompt:
+
+> "Please test this API at https://api.example.com/v1/users with method GET, and the request header is {"Content-Type":"application/json"}, ensure status code is 200 and response body contains 'data'" attribute
+
+### Assertions
+
+At the moment, this library provides built-in assertions that proved useful for testing the API, such as:
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `required_status_code` | `int` | Assert exact status code |
+| `required_status_code_range` | `str` | Assert status code is within a range (e.g. `"2xx"`, `"200-299"`) |
+| `required_response_fields` | `list[str]` | Assert fields exist in JSON response |
+| `required_response_contains` | `str` | Assert response body contains a substring |
+
+## Response
+
+The tool returns a formatted console string with box-drawing, pass/fail symbols, and a summary:
+
+### Passing (with assertions)
+
+```
+┌──────────────────────────────────────────────┐
+│ Api Test Result                              │
+└──────────────────────────────────────────────┘
+
+API Name        : create-user
+Method          : POST
+URL             : https://api.example.com/v1/users
+Status Code     : 201
+Response Time   : 142.35 ms
+Overall Result  : Passed
+
+Assertions
+--------------------------------------------------
+✓ status_code
+✓ response_field_exist
+
+Summary
+--------------------------------------------------
+Total Assertions : 2
+Passed           : 2
+Failed           : 0
+```
+
+### Failing (assertion mismatch)
+
+```
+┌──────────────────────────────────────────────┐
+│ Api Test Result                              │
+└──────────────────────────────────────────────┘
+
+API Name        : create-user
+Method          : POST
+URL             : https://api.example.com/v1/users
+Status Code     : 500
+Response Time   : 89.12 ms
+Overall Result  : Failed
+
+Assertions
+--------------------------------------------------
+✗ status_code
+
+Summary
+--------------------------------------------------
+Total Assertions : 1
+Passed           : 0
+Failed           : 1
+```
+
+### Network / runtime error
+
+```
+┌──────────────────────────────────────────────┐
+│ Api Test Result                              │
+└──────────────────────────────────────────────┘
+
+API Name        : check-service
+Method          : GET
+URL             : https://api.internal.example.com/v1/status
+Overall Result  : Failed
+
+Error
+--------------------------------------------------
+ConnectError: [Errno 8] nodename nor servname provided, or not known
+```
+
+## Logging
+
+The server writes logs to `log/mcp-api-test.log` at the project root. Useful for debugging failed requests or tracing tool calls.
+
+## Environment Variables
+
+The server loads a `.env` file via `python-dotenv` on startup. Useful for storing API keys, base URLs, etc. without hardcoding them in prompts.
+
+## Development
+
+```bash
+# Re-install after pulling changes
+pip install -e .
+
+# Run the MCP server directly
+api-test-mcp
+```
+
+To run the test suite:
+
+```bash
+pip install -e ".[dev]"
+pytest -v
+```

mcp_api_test-0.1.0/README.md

@@ -0,0 +1,228 @@
+# api-test-mcp
+
+![image](https://gitlab.com/ryaneatfood/mcp-api-testing/badges/master/pipeline.svg)
+
+MCP server for REST API testing with assertions. Provides a `test_api` tool that accepts either a cURL command or structured request fields, runs the request, and validates against expected status codes and response fields
+
+## Prerequisites
+
+- Python >= 3.10
+- pip or uv for package installation
+
+## Install
+
+### From PyPI
+
+```bash
+pip install mcp-api-test
+```
+
+### From source
+
+```bash
+git clone git@gitlab.com:ryaneatfood/mcp-api-testing.git
+
+# change the directory
+cd api-test-mcp
+
+# install from source
+pip install -e .
+```
+
+This registers the `api-test-mcp` CLI command on your PATH. Verify with:
+
+```bash
+which api-test-mcp
+```
+
+## Testing with MCP Inspector
+
+The [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector) provides a browser-based UI to verify your server connects and responds correctly before wiring it into a client.
+
+Make sure `api-test-mcp` is installed on your PATH (see [Install](#install)), then run:
+
+```bash
+npx @modelcontextprotocol/inspector
+```
+
+This launches the inspector and opens `http://localhost:5173` in your browser. From the UI:
+
+1. Set **Transport Type** to `STDIO`
+2. Set **Command** to `api-test-mcp`
+3. Leave **Arguments** empty (your server needs none)
+4. Click **Connect**
+
+When the connection succeeds, the status badge changes to **Connected** and the inspector lists the `test_api` tool under the Tools tab. You can click the tool to open a form and run test calls interactively. This is useful for rapid iteration without restarting your MCP client.
+
+If the status shows "Failed to connect" double-check that `which api-test-mcp` resolves and that `pip install -e .` completed without errors
+
+## Running Tests
+
+Install test dependencies and run the suite:
+
+```bash
+# install test dependencies
+pip install pytest pytest-asyncio respx
+
+# run the whole test suite
+pytest -v
+```
+
+All integration tests use `respx` to mock HTTP responses. No real network calls are made, so the suite runs fast and offline. The test suite also consisted of unit test and integration test
+
+## OpenCode Setup
+
+Edit `opencode.json` (already configured at project root):
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "mcp": {
+    "api-test-mcp": {
+      "type": "local",
+      "command": ["api-test-mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+## Claude Desktop Setup
+
+Edit `claude_desktop_config.json` (usually at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+
+```json
+{
+  "mcpServers": {
+    "api-test-mcp": {
+      "command": "api-test-mcp"
+    }
+  }
+}
+```
+
+Restart Claude Desktop after saving.
+
+## Usage
+
+The `test_api` tool supports two modes:
+
+### cURL mode
+
+Pass a raw cURL command, and then the server parses method, URL, headers, and payload automatically into restructured data. Example prompt that you might be used:
+
+> "Please test this API using this cURL: `curl -X POST https://api.example.com/v1/users -H 'Authorization: Bearer xxx' -d '{"name":"test"}'`, ensure status code is 201 and response contains 'id'"
+
+### Structured mode
+
+Provide individual fields rather than used a cURL command. Example prompt:
+
+> "Please test this API at https://api.example.com/v1/users with method GET, and the request header is {"Content-Type":"application/json"}, ensure status code is 200 and response body contains 'data'" attribute
+
+### Assertions
+
+At the moment, this library provides built-in assertions that proved useful for testing the API, such as:
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `required_status_code` | `int` | Assert exact status code |
+| `required_status_code_range` | `str` | Assert status code is within a range (e.g. `"2xx"`, `"200-299"`) |
+| `required_response_fields` | `list[str]` | Assert fields exist in JSON response |
+| `required_response_contains` | `str` | Assert response body contains a substring |
+
+## Response
+
+The tool returns a formatted console string with box-drawing, pass/fail symbols, and a summary:
+
+### Passing (with assertions)
+
+```
+┌──────────────────────────────────────────────┐
+│ Api Test Result                              │
+└──────────────────────────────────────────────┘
+
+API Name        : create-user
+Method          : POST
+URL             : https://api.example.com/v1/users
+Status Code     : 201
+Response Time   : 142.35 ms
+Overall Result  : Passed
+
+Assertions
+--------------------------------------------------
+✓ status_code
+✓ response_field_exist
+
+Summary
+--------------------------------------------------
+Total Assertions : 2
+Passed           : 2
+Failed           : 0
+```
+
+### Failing (assertion mismatch)
+
+```
+┌──────────────────────────────────────────────┐
+│ Api Test Result                              │
+└──────────────────────────────────────────────┘
+
+API Name        : create-user
+Method          : POST
+URL             : https://api.example.com/v1/users
+Status Code     : 500
+Response Time   : 89.12 ms
+Overall Result  : Failed
+
+Assertions
+--------------------------------------------------
+✗ status_code
+
+Summary
+--------------------------------------------------
+Total Assertions : 1
+Passed           : 0
+Failed           : 1
+```
+
+### Network / runtime error
+
+```
+┌──────────────────────────────────────────────┐
+│ Api Test Result                              │
+└──────────────────────────────────────────────┘
+
+API Name        : check-service
+Method          : GET
+URL             : https://api.internal.example.com/v1/status
+Overall Result  : Failed
+
+Error
+--------------------------------------------------
+ConnectError: [Errno 8] nodename nor servname provided, or not known
+```
+
+## Logging
+
+The server writes logs to `log/mcp-api-test.log` at the project root. Useful for debugging failed requests or tracing tool calls.
+
+## Environment Variables
+
+The server loads a `.env` file via `python-dotenv` on startup. Useful for storing API keys, base URLs, etc. without hardcoding them in prompts.
+
+## Development
+
+```bash
+# Re-install after pulling changes
+pip install -e .
+
+# Run the MCP server directly
+api-test-mcp
+```
+
+To run the test suite:
+
+```bash
+pip install -e ".[dev]"
+pytest -v
+```

mcp_api_test-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "mcp-api-test"
+version = "0.1.0"
+description = "MCP server for testing REST API with built-in assertions"
+readme = "README.md"
+authors = [
+  { name = "Ryan Febriansyah" }
+]
+
+requires-python = ">=3.10"
+dependencies = [
+  "mcp",
+  "httpx",
+  "python-dotenv"
+]
+
+keywords = ["testing", "mcp", "llm"]
+
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+]
+
+[project.scripts]
+api-test-mcp = "server:main"
+
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+py-modules = ["server", "__main__", "logger", "models", "utils"]
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-asyncio", "respx"]

mcp_api_test-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mcp_api_test-0.1.0/src/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for the initialize api-test-mcp package when run as a module"""
+
+from server import mcp
+
+if __name__ == "__main__":
+    mcp.run()

mcp_api_test-0.1.0/src/logger.py

@@ -0,0 +1,51 @@
+import logging
+import os
+
+
+class Logger:
+    """
+    A simple logger class that initialize a logger instance
+    """
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.logger = logging.getLogger(name)
+
+        if not self.logger.handlers:
+            self.logger.setLevel(logging.INFO)
+            formatter = logging.Formatter(
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            )
+
+            # only create for file handler, no need to display on console
+            log_directory = os.path.expanduser("log")
+            os.makedirs(log_directory, exist_ok=True)
+            log_file = os.path.join(log_directory, "mcp-api-test.log")
+            file_handler = logging.FileHandler(log_file)
+            file_handler.setLevel(logging.INFO)
+            file_handler.setFormatter(formatter)
+
+            self.logger.addHandler(file_handler)
+
+    def info(self, message: str, *args, **kwargs) -> None:
+        """
+        Log an info message with particular arguments
+        """
+        if args:
+            message = message % args
+        self.logger.info(message, **kwargs)
+
+    def error(self, message: str, *args, **kwargs) -> None:
+        """
+        Log an error message with particular arguments
+        """
+        if args:
+            message = message % args
+        self.logger.error(message, **kwargs)
+
+
+def get_logger(name: str) -> Logger:
+    """
+    Get a logger instance with the given name
+    """
+    return Logger(name=name)

mcp_api_test-0.1.0/src/mcp_api_test.egg-info/PKG-INFO

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: mcp-api-test
+Version: 0.1.0
+Summary: MCP server for testing REST API with built-in assertions
+Author: Ryan Febriansyah
+Keywords: testing,mcp,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp
+Requires-Dist: httpx
+Requires-Dist: python-dotenv
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: respx; extra == "dev"
+Dynamic: license-file
+
+# api-test-mcp
+
+![image](https://gitlab.com/ryaneatfood/mcp-api-testing/badges/master/pipeline.svg)
+
+MCP server for REST API testing with assertions. Provides a `test_api` tool that accepts either a cURL command or structured request fields, runs the request, and validates against expected status codes and response fields
+
+## Prerequisites
+
+- Python >= 3.10
+- pip or uv for package installation
+
+## Install
+
+### From PyPI
+
+```bash
+pip install mcp-api-test
+```
+
+### From source
+
+```bash
+git clone git@gitlab.com:ryaneatfood/mcp-api-testing.git
+
+# change the directory
+cd api-test-mcp
+
+# install from source
+pip install -e .
+```
+
+This registers the `api-test-mcp` CLI command on your PATH. Verify with:
+
+```bash
+which api-test-mcp
+```
+
+## Testing with MCP Inspector
+
+The [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector) provides a browser-based UI to verify your server connects and responds correctly before wiring it into a client.
+
+Make sure `api-test-mcp` is installed on your PATH (see [Install](#install)), then run:
+
+```bash
+npx @modelcontextprotocol/inspector
+```
+
+This launches the inspector and opens `http://localhost:5173` in your browser. From the UI:
+
+1. Set **Transport Type** to `STDIO`
+2. Set **Command** to `api-test-mcp`
+3. Leave **Arguments** empty (your server needs none)
+4. Click **Connect**
+
+When the connection succeeds, the status badge changes to **Connected** and the inspector lists the `test_api` tool under the Tools tab. You can click the tool to open a form and run test calls interactively. This is useful for rapid iteration without restarting your MCP client.
+
+If the status shows "Failed to connect" double-check that `which api-test-mcp` resolves and that `pip install -e .` completed without errors
+
+## Running Tests
+
+Install test dependencies and run the suite:
+
+```bash
+# install test dependencies
+pip install pytest pytest-asyncio respx
+
+# run the whole test suite
+pytest -v
+```
+
+All integration tests use `respx` to mock HTTP responses. No real network calls are made, so the suite runs fast and offline. The test suite also consisted of unit test and integration test
+
+## OpenCode Setup
+
+Edit `opencode.json` (already configured at project root):
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "mcp": {
+    "api-test-mcp": {
+      "type": "local",
+      "command": ["api-test-mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+## Claude Desktop Setup
+
+Edit `claude_desktop_config.json` (usually at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+
+```json
+{
+  "mcpServers": {
+    "api-test-mcp": {
+      "command": "api-test-mcp"
+    }
+  }
+}
+```
+
+Restart Claude Desktop after saving.
+
+## Usage
+
+The `test_api` tool supports two modes:
+
+### cURL mode
+
+Pass a raw cURL command, and then the server parses method, URL, headers, and payload automatically into restructured data. Example prompt that you might be used:
+
+> "Please test this API using this cURL: `curl -X POST https://api.example.com/v1/users -H 'Authorization: Bearer xxx' -d '{"name":"test"}'`, ensure status code is 201 and response contains 'id'"
+
+### Structured mode
+
+Provide individual fields rather than used a cURL command. Example prompt:
+
+> "Please test this API at https://api.example.com/v1/users with method GET, and the request header is {"Content-Type":"application/json"}, ensure status code is 200 and response body contains 'data'" attribute
+
+### Assertions
+
+At the moment, this library provides built-in assertions that proved useful for testing the API, such as:
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `required_status_code` | `int` | Assert exact status code |
+| `required_status_code_range` | `str` | Assert status code is within a range (e.g. `"2xx"`, `"200-299"`) |
+| `required_response_fields` | `list[str]` | Assert fields exist in JSON response |
+| `required_response_contains` | `str` | Assert response body contains a substring |
+
+## Response
+
+The tool returns a formatted console string with box-drawing, pass/fail symbols, and a summary:
+
+### Passing (with assertions)
+
+```
+┌──────────────────────────────────────────────┐
+│ Api Test Result                              │
+└──────────────────────────────────────────────┘
+
+API Name        : create-user
+Method          : POST
+URL             : https://api.example.com/v1/users
+Status Code     : 201
+Response Time   : 142.35 ms
+Overall Result  : Passed
+
+Assertions
+--------------------------------------------------
+✓ status_code
+✓ response_field_exist
+
+Summary
+--------------------------------------------------
+Total Assertions : 2
+Passed           : 2
+Failed           : 0
+```
+
+### Failing (assertion mismatch)
+
+```
+┌──────────────────────────────────────────────┐
+│ Api Test Result                              │
+└──────────────────────────────────────────────┘
+
+API Name        : create-user
+Method          : POST
+URL             : https://api.example.com/v1/users
+Status Code     : 500
+Response Time   : 89.12 ms
+Overall Result  : Failed
+
+Assertions
+--------------------------------------------------
+✗ status_code
+
+Summary
+--------------------------------------------------
+Total Assertions : 1
+Passed           : 0
+Failed           : 1
+```
+
+### Network / runtime error
+
+```
+┌──────────────────────────────────────────────┐
+│ Api Test Result                              │
+└──────────────────────────────────────────────┘
+
+API Name        : check-service
+Method          : GET
+URL             : https://api.internal.example.com/v1/status
+Overall Result  : Failed
+
+Error
+--------------------------------------------------
+ConnectError: [Errno 8] nodename nor servname provided, or not known
+```
+
+## Logging
+
+The server writes logs to `log/mcp-api-test.log` at the project root. Useful for debugging failed requests or tracing tool calls.
+
+## Environment Variables
+
+The server loads a `.env` file via `python-dotenv` on startup. Useful for storing API keys, base URLs, etc. without hardcoding them in prompts.
+
+## Development
+
+```bash
+# Re-install after pulling changes
+pip install -e .
+
+# Run the MCP server directly
+api-test-mcp
+```
+
+To run the test suite:
+
+```bash
+pip install -e ".[dev]"
+pytest -v
+```

mcp_api_test-0.1.0/src/mcp_api_test.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/__main__.py
+src/logger.py
+src/models.py
+src/server.py
+src/utils.py
+src/mcp_api_test.egg-info/PKG-INFO
+src/mcp_api_test.egg-info/SOURCES.txt
+src/mcp_api_test.egg-info/dependency_links.txt
+src/mcp_api_test.egg-info/entry_points.txt
+src/mcp_api_test.egg-info/requires.txt
+src/mcp_api_test.egg-info/top_level.txt
+tests/test_mcp_api_tools.py
+tests/test_parse_curl_command.py
+tests/test_parse_status_code.py

mcp_api_test-0.1.0/src/mcp_api_test.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mcp_api_test-0.1.0/src/mcp_api_test.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+api-test-mcp = server:main

mcp_api_test-0.1.0/src/mcp_api_test.egg-info/requires.txt

@@ -0,0 +1,8 @@
+mcp
+httpx
+python-dotenv
+
+[dev]
+pytest
+pytest-asyncio
+respx

mcp_api_test-0.1.0/src/mcp_api_test.egg-info/top_level.txt

@@ -0,0 +1,5 @@
+__main__
+logger
+models
+server
+utils

mcp_api_test-0.1.0/src/models.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, field
+from typing import List, Dict, Any
+
+
+@dataclass
+class AssertionResult:
+    assertion: str
+    passed: bool
+    expected: Any = None
+    actual: Any = None
+
+
+@dataclass
+class APITestResult:
+    api_name: str
+    passed: bool
+    method: str
+    url: str
+    status_code: int
+    response_time_ms: float
+    assertions: List[AssertionResult] = field(default_factory=list)
+    response_body: Any = None

mcp_api_test-0.1.0/src/server.py

@@ -0,0 +1,284 @@
+import sys
+import json
+import shlex
+import time
+import httpx
+from logger import get_logger
+from dotenv import load_dotenv
+from urllib.parse import urlparse
+from typing import Optional, Dict, Any, List
+from mcp.server.fastmcp import FastMCP
+from models import APITestResult, AssertionResult
+from utils import render_console_template_result, render_error_result
+
+load_dotenv()
+
+logger = get_logger(name="mcp-api-testing")
+
+
+mcp = FastMCP("api-test-mcp")
+
+
+def parse_status_code_range(range_str: str) -> tuple[int, int]:
+    """
+    Parse a status code range like '2xx' or '200-299' into (min, max) inclusive
+    """
+    range_str = range_str.strip()
+
+    if "xx" in range_str:
+        hundred = int(range_str[0])
+        return (hundred * 100, hundred * 100 + 99)
+
+    if "-" in range_str:
+        parts = range_str.split("-", 1)
+        return (int(parts[0]), int(parts[1]))
+
+    return (int(range_str), int(range_str))
+
+
+def parse_curl_command(command: str) -> Dict[str, Any]:
+    """
+    Parse a curl command into structured request data.
+    It will supports HTTP method, headers, request payload,
+    and base URL
+    """
+
+    tokens = shlex.split(command)
+
+    method = "GET"  # initial HTTP methods
+    headers = {}
+    payload = None
+    url = None
+
+    index = 0
+
+    while index < len(tokens):
+        token = tokens[index]
+
+        # moved from a global position into each specific branch,
+        # otherwise it will triggers a missing value error because
+        # it always trigger against every token including URLs
+        if token in ["-X", "--request"]:
+            if index + 1 >= len(tokens):
+                raise ValueError(
+                    f"Invalid curl command, option {token} is missing its value"
+                )
+            method = tokens[index + 1]
+            index += 2
+            continue
+
+        if token in ["-H", "--header"]:
+            if index + 1 >= len(tokens):
+                raise ValueError(
+                    f"Invalid curl command, option {token} is missing its value"
+                )
+            header_line = tokens[index + 1]
+            if ":" in header_line:
+                key, value = header_line.split(":", 1)
+                headers[key.strip()] = value.strip()
+
+            index += 2
+            continue
+
+        if token in ["-d", "--data"]:
+            if index + 1 >= len(tokens):
+                raise ValueError(
+                    f"Invalid curl command, option {token} is missing its value"
+                )
+            raw_data = tokens[index + 1]
+
+            try:
+                payload = json.loads(raw_data)
+            except Exception:
+                logger.error(
+                    message=f"Failed to parse request payload as JSON, using raw string instead. Error: {sys.exc_info()[0]}"
+                )
+                payload = raw_data
+
+            index += 2
+            continue
+
+        if token.startswith("http://") or token.startswith("https://"):
+            url = token
+
+        index += 1
+
+    if not url:
+        raise ValueError("URL must be provided in curl command")
+
+    parsed = urlparse(url=url)
+    base_url = f"{parsed.scheme}://{parsed.netloc}"
+    endpoint = parsed.path
+
+    if parsed.query:
+        endpoint += "?" + parsed.query
+
+    return {
+        "method": method.upper(),
+        "base_url": base_url,
+        "endpoint": endpoint,
+        "headers": headers,
+        "request_payload": payload,
+    }
+
+
+@mcp.tool()
+async def run_test_api(
+    api_name: str,
+    curl_command: Optional[str] = None,
+    base_url: Optional[str] = None,
+    endpoint: Optional[str] = None,
+    method: str = "GET",
+    headers: Optional[Dict[str, str]] = None,
+    payload: Optional[Dict[str, Any]] = None,
+    required_status_code: Optional[int] = None,
+    required_status_code_range: Optional[str] = None,
+    required_response_fields: Optional[List[str]] = None,
+    required_response_contains: Optional[str] = None,
+):
+    """
+    Test a given API services, it will supports either:
+
+    1. Shared cURL command and it will be structured
+    2. Or, pre-defined structured requests data
+
+    Example prompt:
+    `Please test this API based on this cURL, ensure status
+    code is 2xx, and response contains 'id'`
+    """
+    logger.info(message=f"Testing API: {api_name} with cURL: {curl_command}")
+    if curl_command:
+        parsed = parse_curl_command(command=curl_command)
+
+        method = parsed["method"]
+        base_url = parsed["base_url"]
+        endpoint = parsed["endpoint"]
+        headers = parsed["headers"]
+        payload = parsed["request_payload"]
+
+    if not base_url:
+        raise ValueError("`base_url` is required unless cURL command is used")
+
+    if not endpoint:
+        raise ValueError("`endpoint` is required unless cURL command is used")
+
+    full_path_url = f"{base_url.rstrip('/')}/{endpoint.lstrip('/')}"
+    method = method.upper()
+
+    start_time = time.perf_counter()
+    try:
+        async with httpx.AsyncClient(timeout=30) as client:
+            # prevent requests payload with None-type object or empty body
+            kwargs = {"method": method, "url": full_path_url, "headers": headers}
+            if payload is not None:
+                kwargs["json"] = payload
+            response = await client.request(**kwargs)
+            end_time = time.perf_counter()
+            response_time_ms = (end_time - start_time) * 1000
+    except Exception as e:
+        logger.error(
+            message=f"Error occurred while testing API: {api_name}, error: {str(e)}"
+        )
+        return render_error_result(
+            api_name=api_name, method=method, url=full_path_url, error=str(e)
+        )
+
+    try:
+        resp_body = response.json()
+    except Exception:
+        logger.error(
+            message=f"Failed to parse response body as JSON for API: {api_name}, using raw text instead."
+        )
+        resp_body = response.text
+
+    assertions = []
+
+    if required_status_code is not None:
+        passed = response.status_code == required_status_code
+        assertions.append(
+            {
+                "assertion": "status_code",
+                "expected": required_status_code,
+                "actual": response.status_code,
+                "passed": passed,
+            }
+        )
+
+    if required_status_code_range is not None:
+        # low refers to 1xx - 2xx and high refers to 3xx - 5xx
+        low, high = parse_status_code_range(required_status_code_range)
+        passed = low <= response.status_code <= high
+        assertions.append(
+            {
+                "assertion": "status_code_range",
+                "expected": required_status_code_range,
+                "actual": response.status_code,
+                "passed": passed,
+            }
+        )
+
+    if required_response_fields:
+        for field in required_response_fields:
+            if isinstance(resp_body, dict):
+                is_exist = field in resp_body
+            else:
+                is_exist = field in str(resp_body)
+            assertions.append(
+                {
+                    "assertion": "response_field_exist",
+                    "field": field,
+                    "passed": is_exist,
+                }
+            )
+
+    if required_response_contains is not None:
+        body_str = (
+            json.dumps(resp_body) if isinstance(resp_body, dict) else str(resp_body)
+        )
+        found = required_response_contains in body_str
+        assertions.append(
+            {
+                "assertion": "response_contains",
+                "expected": required_response_contains,
+                "passed": found,
+            }
+        )
+
+    assertion_objects = []
+    for a in assertions:
+        assertion_objects.append(
+            AssertionResult(
+                assertion=a["assertion"],
+                passed=a["passed"],
+                expected=a.get("expected"),
+                actual=a.get("actual"),
+            )
+        )
+
+    overall_result = (
+        all(a["passed"] for a in assertions) if assertions else response.is_success
+    )
+
+    result = APITestResult(
+        api_name=api_name,
+        passed=overall_result,
+        method=method,
+        url=full_path_url,
+        status_code=response.status_code,
+        response_time_ms=response_time_ms,
+        assertions=assertion_objects,
+        response_body=resp_body,
+    )
+
+    logger.info(message="Finished testing API, now returning the result to MCP core...")
+    return render_console_template_result(result=result)
+
+
+# expose this function so it can be called in toml files
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    logger.info(message="Initialize the mcp-api-testing...")
+    main()

mcp_api_test-0.1.0/src/utils.py

@@ -0,0 +1,65 @@
+"""Utility functions for MCP API testing"""
+
+from models import APITestResult
+
+
+def render_console_template_result(result: APITestResult) -> str:
+    """
+    Render the test result into a human-readable format for console output
+    """
+
+    divider = "-" * 50
+
+    passed_assertions = sum(1 for a in result.assertions if a.passed)
+    failed_assertions = len(result.assertions) - passed_assertions
+
+    lines = []
+
+    lines.append("┌──────────────────────────────────────────────┐")
+    lines.append("│ Api Test Result                              │")
+    lines.append("└──────────────────────────────────────────────┘")
+    lines.append("")
+    lines.append(f"API Name        : {result.api_name}")
+    lines.append(f"Method          : {result.method}")
+    lines.append(f"URL             : {result.url}")
+    lines.append(f"Status Code     : {result.status_code}")
+    lines.append(f"Response Time   : {result.response_time_ms} ms")
+    lines.append(f"Overall Result  : {'Passed' if result.passed else 'Failed'}")
+
+    lines.append("")
+    lines.append("Assertions")
+    lines.append(divider)
+
+    for assertion in result.assertions:
+        symbol = "✓" if assertion.passed else "x"
+        lines.append(f"{symbol} {assertion.assertion}")
+
+    lines.append("")
+    lines.append("Summary")
+    lines.append(divider)
+    lines.append(f"Total Assertions : {len(result.assertions)}")
+    lines.append(f"Passed           : {passed_assertions}")
+    lines.append(f"Failed           : {failed_assertions}")
+
+    return "\n".join(lines)
+
+
+def render_error_result(api_name: str, method: str, url: str, error: str) -> str:
+    """
+    Render a runtime error into the same console format as successful results
+    """
+    lines = [
+        "┌──────────────────────────────────────────────┐",
+        "│ Api Test Result                              │",
+        "└──────────────────────────────────────────────┘",
+        "",
+        f"API Name        : {api_name}",
+        f"Method          : {method}",
+        f"URL             : {url}",
+        f"Overall Result  : Failed",
+        "",
+        "Error",
+        "-" * 50,
+        error,
+    ]
+    return "\n".join(lines)

mcp_api_test-0.1.0/tests/test_mcp_api_tools.py

@@ -0,0 +1,24 @@
+"""Integration tests with mocked HTTP, without hitting a real network"""
+
+import pytest
+import respx
+import httpx
+from src.server import run_test_api
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_api_return_on_200():
+    respx.get("https://api.example.com/v1/users").mock(
+        return_value=httpx.Response(200, json={"userID": 1})
+    )
+
+    result = await run_test_api(
+        api_name="fetch-user-id",
+        base_url="https://api.example.com/",
+        endpoint="/v1/users",
+        method="GET",
+        required_status_code=200,
+    )
+
+    assert "passed" in str(result).lower() or "PASSED" in result

mcp_api_test-0.1.0/tests/test_parse_curl_command.py

@@ -0,0 +1,23 @@
+import pytest
+from src.server import parse_curl_command
+
+
+def test_basic_curl_command():
+    # no network needed, just pure logic
+    result = parse_curl_command(command="curl -X POST https://api.example.com/v1/users")
+    assert result["method"] == "POST"
+    assert result["base_url"] == "https://api.example.com"
+    assert result["endpoint"] == "/v1/users"
+    assert result["headers"] == {}
+    assert result["request_payload"] is None
+
+
+def test_missing_url_raises():
+    with pytest.raises(ValueError, match="URL must be provided"):
+        parse_curl_command("curl -X GET -H 'content-type: application/json'")
+
+
+def test_missing_value_raises():
+    # -X at the end with no specific HTTP method
+    with pytest.raises((ValueError, IndexError)):
+        parse_curl_command("curl https://api.example.com -X")

mcp_api_test-0.1.0/tests/test_parse_status_code.py

@@ -0,0 +1,16 @@
+import pytest
+from src.server import parse_status_code_range
+
+
+@pytest.mark.parametrize(
+    "range_str, low, high",
+    [
+        ("2xx", 200, 299),
+        ("4xx", 400, 499),
+        ("5xx", 500, 599),
+        ("200-204", 200, 204),
+        ("201", 201, 201),
+    ],
+)
+def test_parse_range_status_code(range_str, low, high):
+    assert parse_status_code_range(range_str=range_str) == (low, high)