pytest-api-cov 1.0.1__tar.gz → 1.1.0__tar.gz

{pytest_api_cov-1.0.1 → pytest_api_cov-1.1.0}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.4
 Name: pytest-api-cov
-Version: 1.0.1
-Summary: Api Coverage Report Pytest Plugin
+Version: 1.1.0
+Summary: Pytest Plugin to provide API Coverage statistics for Python Web Frameworks
 Author-email: Barnaby Gill <barnabasgill@gmail.com>
 License: Apache-2.0
 License-File: LICENSE
 Requires-Python: >=3.10
-Requires-Dist: fastapi>=0.116.1
-Requires-Dist: flask>=3.1.1
-Requires-Dist: httpx>=0.28.1
-Requires-Dist: pydantic>=2.11.7
-Requires-Dist: pytest>=8.4.1
-Requires-Dist: rich>=14.0.0
-Requires-Dist: starlette>=0.47.1
-Requires-Dist: tomli>=2.2.1
+Requires-Dist: fastapi>=0.68.0
+Requires-Dist: flask>=2.0.0
+Requires-Dist: httpx>=0.20.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pytest>=6.0.0
+Requires-Dist: rich>=10.0.0
+Requires-Dist: starlette>=0.14.0
+Requires-Dist: tomli>=1.2.0
 Description-Content-Type: text/markdown
 
 # pytest-api-cov
@@ -83,6 +83,10 @@ def read_root():
 def get_user(user_id: int):
     return {"user_id": user_id}
 
+@app.post("/users")
+def create_user(user: dict):
+    return {"message": "User created", "user": user}
+
 @app.get("/health")
 def health_check():
     return {"status": "ok"}
@@ -98,6 +102,10 @@ def test_root_endpoint(coverage_client):
 def test_get_user(coverage_client):
     response = coverage_client.get("/users/123")
     assert response.status_code == 200
+
+def test_create_user(coverage_client):
+    response = coverage_client.post("/users", json={"name": "John"})
+    assert response.status_code == 200
 ```
 
 Running `pytest --api-cov-report` produces:
@@ -105,27 +113,69 @@ Running `pytest --api-cov-report` produces:
 ```
 API Coverage Report
 Uncovered Endpoints:
-  [X] /health
+  ❌ GET    /health
 
 Total API Coverage: 66.67%
 ```
 
-Or running with advanced options `pytest --api-cov-report --api-cov-show-covered-endpoints --api-cov-exclusion-patterns="/users/*" --api-cov-show-excluded-endpoints --api-cov-report-path=api_coverage.json --api-cov-fail-under=49` produces:
+Or running with advanced options:
+```bash
+pytest --api-cov-report --api-cov-show-covered-endpoints --api-cov-exclusion-patterns="/users*" --api-cov-show-excluded-endpoints --api-cov-report-path=api_coverage.json
+```
 
 ```
 API Coverage Report
 Uncovered Endpoints:
-  [X] /health
+  ❌ GET    /health
 Covered Endpoints:
-  [.] /
+  ✅ GET    /
 Excluded Endpoints:
-  [-] /users/{user_id}
+  🚫 GET    /users/{user_id}
+  🚫 POST   /users
 
-SUCCESS: Coverage of 50.0% meets requirement of 49.0%
+Total API Coverage: 50.0%
 
 JSON report saved to api_coverage.json
 ```
 
+## HTTP Method-Aware Coverage
+
+By default, pytest-api-cov tracks coverage for **each HTTP method separately**. This means `GET /users` and `POST /users` are treated as different endpoints for coverage purposes.
+
+### Method-Aware (Default Behavior)
+```
+Covered Endpoints:
+  ✅ GET    /users/{id}
+  ✅ POST   /users
+Uncovered Endpoints:
+  ❌ PUT    /users/{id}
+  ❌ DELETE /users/{id}
+
+Total API Coverage: 50.0%  # 2 out of 4 method-endpoint combinations
+```
+
+### Endpoint Grouping
+To group all methods on an endpoint are together, use:
+
+```bash
+pytest --api-cov-report --api-cov-group-methods-by-endpoint
+```
+
+Or in `pyproject.toml`:
+```toml
+[tool.pytest_api_cov]
+group_methods_by_endpoint = true
+```
+
+This would show:
+```
+Covered Endpoints:
+  ✅ /users/{id}  # Any method tested
+  ✅ /users       # Any method tested
+
+Total API Coverage: 100.0%  # All endpoints have at least one method tested
+```
+
 ## Advanced Configuration
 
 ### Setup Wizard
@@ -230,6 +280,11 @@ force_sugar_disabled = true
 
 # Wrap an existing custom test client fixture with coverage tracking
 client_fixture_name = "my_custom_client"
+
+# Group HTTP methods by endpoint for legacy behavior (default: false)
+# When true: treats GET /users and POST /users as one "/users" endpoint  
+# When false: treats them as separate "GET /users" and "POST /users" endpoints (recommended)
+group_methods_by_endpoint = false
 ```
 
 ### Command Line Options
@@ -261,6 +316,9 @@ pytest --api-cov-report -v
 
 # Debug logging (very detailed)
 pytest --api-cov-report -vv
+
+# Group HTTP methods by endpoint (legacy behavior)
+pytest --api-cov-report --api-cov-group-methods-by-endpoint
 ```
 
 ## Framework Support

{pytest_api_cov-1.0.1 → pytest_api_cov-1.1.0}/README.md

@@ -65,6 +65,10 @@ def read_root():
 def get_user(user_id: int):
     return {"user_id": user_id}
 
+@app.post("/users")
+def create_user(user: dict):
+    return {"message": "User created", "user": user}
+
 @app.get("/health")
 def health_check():
     return {"status": "ok"}
@@ -80,6 +84,10 @@ def test_root_endpoint(coverage_client):
 def test_get_user(coverage_client):
     response = coverage_client.get("/users/123")
     assert response.status_code == 200
+
+def test_create_user(coverage_client):
+    response = coverage_client.post("/users", json={"name": "John"})
+    assert response.status_code == 200
 ```
 
 Running `pytest --api-cov-report` produces:
@@ -87,27 +95,69 @@ Running `pytest --api-cov-report` produces:
 ```
 API Coverage Report
 Uncovered Endpoints:
-  [X] /health
+  ❌ GET    /health
 
 Total API Coverage: 66.67%
 ```
 
-Or running with advanced options `pytest --api-cov-report --api-cov-show-covered-endpoints --api-cov-exclusion-patterns="/users/*" --api-cov-show-excluded-endpoints --api-cov-report-path=api_coverage.json --api-cov-fail-under=49` produces:
+Or running with advanced options:
+```bash
+pytest --api-cov-report --api-cov-show-covered-endpoints --api-cov-exclusion-patterns="/users*" --api-cov-show-excluded-endpoints --api-cov-report-path=api_coverage.json
+```
 
 ```
 API Coverage Report
 Uncovered Endpoints:
-  [X] /health
+  ❌ GET    /health
 Covered Endpoints:
-  [.] /
+  ✅ GET    /
 Excluded Endpoints:
-  [-] /users/{user_id}
+  🚫 GET    /users/{user_id}
+  🚫 POST   /users
 
-SUCCESS: Coverage of 50.0% meets requirement of 49.0%
+Total API Coverage: 50.0%
 
 JSON report saved to api_coverage.json
 ```
 
+## HTTP Method-Aware Coverage
+
+By default, pytest-api-cov tracks coverage for **each HTTP method separately**. This means `GET /users` and `POST /users` are treated as different endpoints for coverage purposes.
+
+### Method-Aware (Default Behavior)
+```
+Covered Endpoints:
+  ✅ GET    /users/{id}
+  ✅ POST   /users
+Uncovered Endpoints:
+  ❌ PUT    /users/{id}
+  ❌ DELETE /users/{id}
+
+Total API Coverage: 50.0%  # 2 out of 4 method-endpoint combinations
+```
+
+### Endpoint Grouping
+To group all methods on an endpoint are together, use:
+
+```bash
+pytest --api-cov-report --api-cov-group-methods-by-endpoint
+```
+
+Or in `pyproject.toml`:
+```toml
+[tool.pytest_api_cov]
+group_methods_by_endpoint = true
+```
+
+This would show:
+```
+Covered Endpoints:
+  ✅ /users/{id}  # Any method tested
+  ✅ /users       # Any method tested
+
+Total API Coverage: 100.0%  # All endpoints have at least one method tested
+```
+
 ## Advanced Configuration
 
 ### Setup Wizard
@@ -212,6 +262,11 @@ force_sugar_disabled = true
 
 # Wrap an existing custom test client fixture with coverage tracking
 client_fixture_name = "my_custom_client"
+
+# Group HTTP methods by endpoint for legacy behavior (default: false)
+# When true: treats GET /users and POST /users as one "/users" endpoint  
+# When false: treats them as separate "GET /users" and "POST /users" endpoints (recommended)
+group_methods_by_endpoint = false
 ```
 
 ### Command Line Options
@@ -243,6 +298,9 @@ pytest --api-cov-report -v
 
 # Debug logging (very detailed)
 pytest --api-cov-report -vv
+
+# Group HTTP methods by endpoint (legacy behavior)
+pytest --api-cov-report --api-cov-group-methods-by-endpoint
 ```
 
 ## Framework Support

{pytest_api_cov-1.0.1 → pytest_api_cov-1.1.0}/pyproject.toml

@@ -1,23 +1,21 @@
 [project]
 name = "pytest-api-cov"
-version = "1.0.1"
-description = "Api Coverage Report Pytest Plugin"
+version = "1.1.0"
+description = "Pytest Plugin to provide API Coverage statistics for Python Web Frameworks"
 readme = "README.md"
-authors = [
-    {name = "Barnaby Gill", email = "barnabasgill@gmail.com"},
-]
-license = {text = "Apache-2.0"}
+authors = [{ name = "Barnaby Gill", email = "barnabasgill@gmail.com" }]
+license = { text = "Apache-2.0" }
 requires-python = ">=3.10"
 
 dependencies = [
-    "fastapi>=0.116.1",
-    "flask>=3.1.1",
-    "httpx>=0.28.1",
-    "pydantic>=2.11.7",
-    "rich>=14.0.0",
-    "starlette>=0.47.1",
-    "tomli>=2.2.1",
-    "pytest>=8.4.1",
+    "fastapi>=0.68.0",
+    "flask>=2.0.0",
+    "httpx>=0.20.0",
+    "pydantic>=2.0.0",
+    "rich>=10.0.0",
+    "starlette>=0.14.0",
+    "tomli>=1.2.0",
+    "pytest>=6.0.0",
 ]
 
 [dependency-groups]
@@ -36,9 +34,7 @@ fail_under = 70
 show_covered_endpoints = true
 show_uncovered_endpoints = true
 show_excluded_endpoints = true
-exclusion_patterns = [
-    "xyz",
-]
+exclusion_patterns = ["xyz"]
 report_path = "reports/pytest_api_cov.json"
 
 [tool.pytest.ini_options]
@@ -46,10 +42,7 @@ testpaths = ["tests/unit", "tests/integration", "example/tests"]
 pythonpath = ["src"]
 
 [tool.coverage.report]
-exclude_lines = [
-    'if __name__ == "__main__":',
-    "if TYPE_CHECKING:",
-]
+exclude_lines = ['if __name__ == "__main__":', "if TYPE_CHECKING:"]
 show_missing = true
 
 
@@ -61,12 +54,7 @@ build-backend = "hatchling.build"
 packages = ["src/pytest_api_cov"]
 
 [tool.hatch.build.targets.sdist]
-include = [
-    "src/pytest_api_cov/",
-    "README.md",
-    "LICENSE",
-    "pyproject.toml",
-]
+include = ["src/pytest_api_cov/", "README.md", "LICENSE", "pyproject.toml"]
 
 # [[tool.uv.index]]
 # name = "testpypi"

{pytest_api_cov-1.0.1 → pytest_api_cov-1.1.0}/src/pytest_api_cov/cli.py

@@ -63,7 +63,7 @@ from {module_path} import {app_variable}
 @pytest.fixture
 def app():
     """Provide the {framework} app for API coverage testing.
-    
+
     You can import from any location - just change the import path above
     to match your project structure.
     """
@@ -117,6 +117,9 @@ show_excluded_endpoints = false
 
 # Wrap an existing custom test client fixture with coverage tracking (optional)
 # client_fixture_name = "my_custom_client"
+
+# Group HTTP methods by endpoint for legacy behavior (optional)
+# group_methods_by_endpoint = false
 """
 
 

{pytest_api_cov-1.0.1 → pytest_api_cov-1.1.0}/src/pytest_api_cov/config.py

@@ -21,6 +21,7 @@ class ApiCoverageReportConfig(BaseModel):
     force_sugar: bool = Field(False, alias="api-cov-force-sugar")
     force_sugar_disabled: bool = Field(False, alias="api-cov-force-sugar-disabled")
     client_fixture_name: str = Field("coverage_client", alias="api-cov-client-fixture-name")
+    group_methods_by_endpoint: bool = Field(False, alias="api-cov-group-methods-by-endpoint")
 
 
 def read_toml_config() -> Dict[str, Any]:
@@ -45,6 +46,7 @@ def read_session_config(session_config: Any) -> Dict[str, Any]:
         "api-cov-force-sugar": "force_sugar",
         "api-cov-force-sugar-disabled": "force_sugar_disabled",
         "api-cov-client-fixture-name": "client_fixture_name",
+        "api-cov-group-methods-by-endpoint": "group_methods_by_endpoint",
     }
     config = {}
     for opt, key in cli_options.items():

{pytest_api_cov-1.0.1 → pytest_api_cov-1.1.0}/src/pytest_api_cov/frameworks.py

@@ -21,8 +21,17 @@ class BaseAdapter:
 
 class FlaskAdapter(BaseAdapter):
     def get_endpoints(self) -> List[str]:
+        """Return list of 'METHOD /path' strings."""
         excluded_rules = ("/static/<path:filename>",)
-        return sorted([rule.rule for rule in self.app.url_map.iter_rules() if rule.rule not in excluded_rules])
+        endpoints = []
+
+        for rule in self.app.url_map.iter_rules():
+            if rule.rule not in excluded_rules:
+                for method in rule.methods:
+                    if method not in ("HEAD", "OPTIONS"):  # Skip automatic methods
+                        endpoints.append(f"{method} {rule.rule}")
+
+        return sorted(endpoints)
 
     def get_tracked_client(self, recorder: Optional["ApiCallRecorder"], test_name: str) -> Any:
         from flask.testing import FlaskClient
@@ -33,11 +42,13 @@ class FlaskAdapter(BaseAdapter):
         class TrackingFlaskClient(FlaskClient):
             def open(self, *args: Any, **kwargs: Any) -> Any:
                 path = kwargs.get("path") or (args[0] if args else None)
+                method = kwargs.get("method", "GET").upper()
+
                 if path and hasattr(self.application.url_map, "bind"):
                     try:
-                        endpoint_name, _ = self.application.url_map.bind("").match(path, method=kwargs.get("method"))
+                        endpoint_name, _ = self.application.url_map.bind("").match(path, method=method)
                         endpoint_rule_string = next(self.application.url_map.iter_rules(endpoint_name)).rule
-                        recorder.record_call(endpoint_rule_string, test_name)  # type: ignore[union-attr]
+                        recorder.record_call(endpoint_rule_string, test_name, method)  # type: ignore[union-attr]
                     except Exception:
                         pass
                 return super().open(*args, **kwargs)
@@ -47,9 +58,17 @@ class FlaskAdapter(BaseAdapter):
 
 class FastAPIAdapter(BaseAdapter):
     def get_endpoints(self) -> List[str]:
+        """Return list of 'METHOD /path' strings."""
         from fastapi.routing import APIRoute
 
-        return sorted([route.path for route in self.app.routes if isinstance(route, APIRoute)])
+        endpoints = []
+        for route in self.app.routes:
+            if isinstance(route, APIRoute):
+                for method in route.methods:
+                    if method not in ("HEAD", "OPTIONS"):
+                        endpoints.append(f"{method} {route.path}")
+
+        return sorted(endpoints)
 
     def get_tracked_client(self, recorder: Optional["ApiCallRecorder"], test_name: str) -> Any:
         from starlette.testclient import TestClient
@@ -61,7 +80,9 @@ class FastAPIAdapter(BaseAdapter):
             def send(self, *args: Any, **kwargs: Any) -> Any:
                 request = args[0]
                 if recorder is not None:
-                    recorder.record_call(request.url.path, test_name)
+                    method = request.method.upper()
+                    path = request.url.path
+                    recorder.record_call(path, test_name, method)
                 return super().send(*args, **kwargs)
 
         return TrackingFastAPIClient(self.app)

{pytest_api_cov-1.0.1 → pytest_api_cov-1.1.0}/src/pytest_api_cov/models.py

@@ -12,19 +12,27 @@ class ApiCallRecorder(BaseModel):
 
     calls: Dict[str, Set[str]] = Field(default_factory=dict)
 
-    def record_call(self, endpoint: str, test_name: str) -> None:
-        """Record that a test called an endpoint."""
-        if endpoint not in self.calls:
-            self.calls[endpoint] = set()
-        self.calls[endpoint].add(test_name)
-
-    def get_called_endpoints(self) -> List[str]:
-        """Get list of all endpoints that have been called."""
-        return list(self.calls.keys())
-
-    def get_callers(self, endpoint: str) -> Set[str]:
-        """Get the set of test names that called a specific endpoint."""
-        return self.calls.get(endpoint, set())
+    def record_call(self, endpoint: str, test_name: str, method: str = "GET") -> None:
+        """Record that a test called a specific method on an endpoint."""
+        endpoint_method = self._format_endpoint_key(method, endpoint)
+        if endpoint_method not in self.calls:
+            self.calls[endpoint_method] = set()
+        self.calls[endpoint_method].add(test_name)
+
+    @staticmethod
+    def _format_endpoint_key(method: str, endpoint: str) -> str:
+        """Format method and endpoint into a consistent key format."""
+        return f"{method.upper()} {endpoint}"
+
+    @staticmethod
+    def _parse_endpoint_key(endpoint_key: str) -> tuple[str, str]:
+        """Parse an endpoint key back into method and endpoint parts."""
+        if " " in endpoint_key:
+            method, endpoint = endpoint_key.split(" ", 1)
+            return method, endpoint
+        else:
+            # Handle legacy format without method
+            return "GET", endpoint_key
 
     def merge(self, other: "ApiCallRecorder") -> None:
         """Merge another recorder's data into this one."""
@@ -70,15 +78,17 @@ class EndpointDiscovery(BaseModel):
     endpoints: List[str] = Field(default_factory=list)
     discovery_source: str = Field(default="unknown")
 
-    def add_endpoint(self, endpoint: str) -> None:
-        """Add a discovered endpoint."""
-        if endpoint not in self.endpoints:
-            self.endpoints.append(endpoint)
+    def add_endpoint(self, endpoint: str, method: str = "GET") -> None:
+        """Add a discovered endpoint method."""
+        endpoint_method = ApiCallRecorder._format_endpoint_key(method, endpoint)
+        if endpoint_method not in self.endpoints:
+            self.endpoints.append(endpoint_method)
 
     def merge(self, other: "EndpointDiscovery") -> None:
         """Merge another discovery's endpoints into this one."""
         for endpoint in other.endpoints:
-            self.add_endpoint(endpoint)
+            if endpoint not in self.endpoints:
+                self.endpoints.append(endpoint)
 
     def __len__(self) -> int:
         """Return number of discovered endpoints."""
@@ -95,15 +105,24 @@ class SessionData(BaseModel):
     recorder: ApiCallRecorder = Field(default_factory=ApiCallRecorder)
     discovered_endpoints: EndpointDiscovery = Field(default_factory=EndpointDiscovery)
 
-    def record_call(self, endpoint: str, test_name: str) -> None:
+    def record_call(self, endpoint: str, test_name: str, method: str = "GET") -> None:
         """Record an API call."""
-        self.recorder.record_call(endpoint, test_name)
+        self.recorder.record_call(endpoint, test_name, method)
+
+    def add_discovered_endpoint(self, endpoint: str, method_or_source: str = "GET", source: str = "unknown") -> None:
+        """Add a discovered endpoint method."""
+        # Handle both old and new method signatures for backward compatibility
+        if method_or_source in ["flask_adapter", "fastapi_adapter", "worker", "unknown"]:
+            # Old signature: add_discovered_endpoint(endpoint, source)
+            method = "GET"
+            source = method_or_source
+        else:
+            # New signature: add_discovered_endpoint(endpoint, method, source)
+            method = method_or_source
 
-    def add_discovered_endpoint(self, endpoint: str, source: str = "unknown") -> None:
-        """Add a discovered endpoint."""
         if not self.discovered_endpoints.endpoints:
             self.discovered_endpoints.discovery_source = source
-        self.discovered_endpoints.add_endpoint(endpoint)
+        self.discovered_endpoints.add_endpoint(endpoint, method)
 
     def merge_worker_data(self, worker_recorder: Dict[str, Any], worker_endpoints: List[str]) -> None:
         """Merge data from a worker process."""

{pytest_api_cov-1.0.1 → pytest_api_cov-1.1.0}/src/pytest_api_cov/plugin.py

@@ -65,10 +65,21 @@ def auto_discover_app() -> Optional[Any]:
                                         f"✅ Auto-discovered {type(app).__name__} app in {filename} as '{attr_name}'"
                                     )
                                     # Check if there are more files to scan
-                                    remaining_files = [f for f in [p[0] for p in common_patterns[common_patterns.index((filename, attr_names)):]] if os.path.exists(f) and f != filename]
+                                    remaining_files = [
+                                        f
+                                        for f in [
+                                            p[0]
+                                            for p in common_patterns[common_patterns.index((filename, attr_names)) :]
+                                        ]
+                                        if os.path.exists(f) and f != filename
+                                    ]
                                     if remaining_files:
-                                        logger.debug(f"> Note: Also found files {remaining_files} but using first discovered app")
-                                        logger.debug(f"> To use a different app, create a conftest.py with an 'app' fixture")
+                                        logger.debug(
+                                            f"> Note: Also found files {remaining_files} but using first discovered app"
+                                        )
+                                        logger.debug(
+                                            "> To use a different app, create a conftest.py with an 'app' fixture"
+                                        )
                                     return app
                             else:
                                 logger.debug(f"> Found '{attr_name}' in {filename} but it's not a supported framework")
@@ -80,9 +91,9 @@ def auto_discover_app() -> Optional[Any]:
     # If we get here, no apps were found
     if found_files:
         logger.debug(f"> Found files {found_files} but no supported Flask/FastAPI apps in them")
-        logger.debug(f"> If your app is in one of these files with a different variable name,")
-        logger.debug(f"> create a conftest.py with an 'app' fixture to specify it")
-    
+        logger.debug("> If your app is in one of these files with a different variable name,")
+        logger.debug("> create a conftest.py with an 'app' fixture to specify it")
+
     logger.debug("> No app auto-discovered")
     return None
 
@@ -178,14 +189,15 @@ def wrap_client_with_coverage(client: Any, recorder: Any, test_name: str) -> Any
 
                 def tracked_method(*args: Any, **kwargs: Any) -> Any:
                     response = attr(*args, **kwargs)
-                    # Extract path from args[0]
+                    # Extract path from args[0] and method from function name
                     if args and recorder is not None:
                         path = args[0]
                         # Clean up the path to match endpoint format
                         if isinstance(path, str):
                             # Remove query parameters
                             path = path.partition("?")[0]
-                            recorder.record_call(path, test_name)
+                            method = name.upper()  # get -> GET, post -> POST, etc.
+                            recorder.record_call(path, test_name, method)
                     return response
 
                 return tracked_method
@@ -239,8 +251,10 @@ def coverage_client(request: pytest.FixtureRequest) -> Any:
                     if not coverage_data.discovered_endpoints.endpoints:
                         endpoints = adapter.get_endpoints()
                         framework_name = type(app).__name__
-                        for endpoint in endpoints:
-                            coverage_data.add_discovered_endpoint(endpoint, f"{framework_name.lower()}_adapter")
+                        for endpoint_method in endpoints:
+                            # endpoint_method is now in "METHOD /path" format
+                            method, path = endpoint_method.split(" ", 1)
+                            coverage_data.add_discovered_endpoint(path, method, f"{framework_name.lower()}_adapter")
                         logger.info(f"> pytest-api-coverage: Discovered {len(endpoints)} endpoints.")
                         logger.debug(f"> Discovered endpoints: {endpoints}")
                 except Exception as e:
@@ -274,8 +288,10 @@ def coverage_client(request: pytest.FixtureRequest) -> Any:
         try:
             endpoints = adapter.get_endpoints()
             framework_name = type(app).__name__
-            for endpoint in endpoints:
-                coverage_data.add_discovered_endpoint(endpoint, f"{framework_name.lower()}_adapter")
+            for endpoint_method in endpoints:
+                # endpoint_method is now in "METHOD /path" format
+                method, path = endpoint_method.split(" ", 1)
+                coverage_data.add_discovered_endpoint(path, method, f"{framework_name.lower()}_adapter")
             logger.info(f"> pytest-api-coverage: Discovered {len(endpoints)} endpoints.")
             logger.debug(f"> Discovered endpoints: {endpoints}")
         except Exception as e:

{pytest_api_cov-1.0.1 → pytest_api_cov-1.1.0}/src/pytest_api_cov/pytest_flags.py

@@ -74,3 +74,9 @@ def add_pytest_api_cov_flags(parser: pytest.Parser) -> None:
         default=None,
         help="Name of existing test client fixture to wrap with coverage tracking",
     )
+    parser.addoption(
+        "--api-cov-group-methods-by-endpoint",
+        action="store_true",
+        default=False,
+        help="Group HTTP methods by endpoint for legacy behavior (default: method-aware coverage)",
+    )

{pytest_api_cov-1.0.1 → pytest_api_cov-1.1.0}/src/pytest_api_cov/report.py

@@ -44,7 +44,19 @@ def categorise_endpoints(
     )
 
     for endpoint in endpoints:
-        if compiled_patterns and any(p.match(endpoint) for p in compiled_patterns):
+        # Check exclusion patterns against both full "METHOD /path" and just "/path"
+        is_excluded = False
+        if compiled_patterns:
+            # Extract path from "METHOD /path" format for pattern matching
+            if " " in endpoint:
+                _, path_only = endpoint.split(" ", 1)
+                is_excluded = any(p.match(endpoint) for p in compiled_patterns) or any(
+                    p.match(path_only) for p in compiled_patterns
+                )
+            else:
+                is_excluded = any(p.match(endpoint) for p in compiled_patterns)
+
+        if is_excluded:
             excluded.append(endpoint)
             continue
         elif contains_escape_characters(endpoint):
@@ -67,7 +79,15 @@ def print_endpoints(
     if endpoints:
         console.print(f"[{style}]{label}[/]:")
         for endpoint in endpoints:
-            console.print(f"  {symbol} [{style}]{endpoint}[/]")
+            # Format endpoint with consistent spacing for HTTP methods
+            if " " in endpoint:
+                method, path = endpoint.split(" ", 1)
+                # Pad method to 6 characters (longest common method is DELETE)
+                formatted_endpoint = f"{method:<6} {path}"
+            else:
+                # Handle legacy format without method
+                formatted_endpoint = endpoint
+            console.print(f"  {symbol} [{style}]{formatted_endpoint}[/]")
 
 
 def compute_coverage(covered_count: int, uncovered_count: int) -> float: