pytest-api-cov 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

pytest_api_cov/cli.py

@@ -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/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/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/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/plugin.py

@@ -189,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
@@ -250,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:
@@ -285,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/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/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:

{pytest_api_cov-1.0.2.dist-info → pytest_api_cov-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-api-cov
-Version: 1.0.2
+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
@@ -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.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pytest_api_cov/__init__.py,sha256=7ZX-XIlYwdB0AkSSaXG2O6mah3CBCjZGTiBSEf5dTqk,177
+pytest_api_cov/cli.py,sha256=1iDYhWZJ_wDU9nPov7FfNrpT5sIU7PmAGiuVqy4zFM4,7290
+pytest_api_cov/config.py,sha256=m9UsbKKcL5_Wb-lRMCpV-_mMpdYFDo0oV6vxxHKAB7k,3493
+pytest_api_cov/frameworks.py,sha256=0_8ZzVbeZ6U1ZZwuzCn82m-q5NcRlIOTtocV5zeIGd0,3955
+pytest_api_cov/models.py,sha256=AW7X4DzzsY-HtNsQMm5x55x95Q-10B2xhD9_XaXFDBw,5997
+pytest_api_cov/plugin.py,sha256=o2fqQv3M5HzlPYGXm-rDBxbPRHbiMEPpImJ4a5tum0s,16540
+pytest_api_cov/pytest_flags.py,sha256=oGTCv7T_Mj439PFrvB3LawmLFQYppZOOS1f_HOK1cJE,2408
+pytest_api_cov/report.py,sha256=hUBEIjK0TXEnamWV61_w6AZKHLh5mD0eXcrmTs61baQ,7600
+pytest_api_cov-1.1.0.dist-info/METADATA,sha256=uznGlaFxXlXM2FnGtRTtyDqM_nPerAaTMt8ubTQQvxY,12841
+pytest_api_cov-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pytest_api_cov-1.1.0.dist-info/entry_points.txt,sha256=hWqEhsBKzbwSwcxCzKgSA8NElQxk0K4PKERrYsi3csk,110
+pytest_api_cov-1.1.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+pytest_api_cov-1.1.0.dist-info/RECORD,,

pytest_api_cov-1.0.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-pytest_api_cov/__init__.py,sha256=7ZX-XIlYwdB0AkSSaXG2O6mah3CBCjZGTiBSEf5dTqk,177
-pytest_api_cov/cli.py,sha256=TCnldhRBi9BMLaPrnp7sfoWNc0Ktu8XnoRQKUuXFGWo,7186
-pytest_api_cov/config.py,sha256=51GaJgAtctAcNb2F-7Q65qZuNusf3_s1-4bE-AWv5QE,3323
-pytest_api_cov/frameworks.py,sha256=5d6wnEsb2BykPtpnpkv98GMPuyoG4elXRJ7vtGHF06A,3228
-pytest_api_cov/models.py,sha256=YiXLiEEyNREiodzn1pGqSNIHrm3zV6kFn0XgyN8_8Rs,4893
-pytest_api_cov/plugin.py,sha256=rZVTvhqKv5GCIbwgFRH3KcrwNXdecFDRrtbMepZfjs8,16118
-pytest_api_cov/pytest_flags.py,sha256=OX1NMcQHfI9uyPrZXj0Q_VG1daU8uKKB4sY-4JLm220,2175
-pytest_api_cov/report.py,sha256=VxfWag20V8o9ArbxOkR_gWQ2TE-sthrS0PCJvn4YCSU,6642
-pytest_api_cov-1.0.2.dist-info/METADATA,sha256=jR8gMyw5frvKQzWeyPrjHmACqa1S6xPZuYXgoshK9Vc,11303
-pytest_api_cov-1.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pytest_api_cov-1.0.2.dist-info/entry_points.txt,sha256=hWqEhsBKzbwSwcxCzKgSA8NElQxk0K4PKERrYsi3csk,110
-pytest_api_cov-1.0.2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-pytest_api_cov-1.0.2.dist-info/RECORD,,