pytest-api-cov 1.0.2__tar.gz → 1.1.1__tar.gz

{pytest_api_cov-1.0.2 → pytest_api_cov-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-api-cov
-Version: 1.0.2
+Version: 1.1.1
 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
@@ -209,14 +259,17 @@ show_uncovered_endpoints = true
 show_covered_endpoints = false
 show_excluded_endpoints = false
 
-# Exclude endpoints from coverage using simple wildcard patterns
+# Exclude endpoints from coverage using wildcard patterns with negation support
 # Use * for wildcard matching, all other characters are matched literally
+# Use ! at the start to negate a pattern (include what would otherwise be excluded)
 exclusion_patterns = [
     "/health",        # Exact match
     "/metrics",       # Exact match
     "/docs/*",        # Wildcard: matches /docs/swagger, /docs/openapi, etc.
     "/admin/*",       # Wildcard: matches all admin endpoints
-    "/api/v1.0/*"     # Exact version match (won't match /api/v1x0/*)
+    "!/admin/public", # Negation: include /admin/public even though /admin/* excludes it
+    "/api/v1.0/*",    # Exact version match (won't match /api/v1x0/*)
+    "!/api/v1.0/health" # Negation: include /api/v1.0/health even though /api/v1.0/* excludes it
 ]
 
 # Save detailed JSON report
@@ -230,6 +283,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
@@ -253,14 +311,20 @@ pytest --api-cov-report --api-cov-show-uncovered-endpoints=false
 # Save JSON report
 pytest --api-cov-report --api-cov-report-path=api_coverage.json
 
-# Exclude specific endpoints (supports wildcards)
+# Exclude specific endpoints (supports wildcards and negation)
 pytest --api-cov-report --api-cov-exclusion-patterns="/health" --api-cov-exclusion-patterns="/docs/*"
 
+# Exclude with negation (exclude all admin except admin/public)
+pytest --api-cov-report --api-cov-exclusion-patterns="/admin/*" --api-cov-exclusion-patterns="!/admin/public"
+
 # Verbose logging (shows discovery process)
 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.2 → pytest_api_cov-1.1.1}/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
@@ -191,14 +241,17 @@ show_uncovered_endpoints = true
 show_covered_endpoints = false
 show_excluded_endpoints = false
 
-# Exclude endpoints from coverage using simple wildcard patterns
+# Exclude endpoints from coverage using wildcard patterns with negation support
 # Use * for wildcard matching, all other characters are matched literally
+# Use ! at the start to negate a pattern (include what would otherwise be excluded)
 exclusion_patterns = [
     "/health",        # Exact match
     "/metrics",       # Exact match
     "/docs/*",        # Wildcard: matches /docs/swagger, /docs/openapi, etc.
     "/admin/*",       # Wildcard: matches all admin endpoints
-    "/api/v1.0/*"     # Exact version match (won't match /api/v1x0/*)
+    "!/admin/public", # Negation: include /admin/public even though /admin/* excludes it
+    "/api/v1.0/*",    # Exact version match (won't match /api/v1x0/*)
+    "!/api/v1.0/health" # Negation: include /api/v1.0/health even though /api/v1.0/* excludes it
 ]
 
 # Save detailed JSON report
@@ -212,6 +265,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
@@ -235,14 +293,20 @@ pytest --api-cov-report --api-cov-show-uncovered-endpoints=false
 # Save JSON report
 pytest --api-cov-report --api-cov-report-path=api_coverage.json
 
-# Exclude specific endpoints (supports wildcards)
+# Exclude specific endpoints (supports wildcards and negation)
 pytest --api-cov-report --api-cov-exclusion-patterns="/health" --api-cov-exclusion-patterns="/docs/*"
 
+# Exclude with negation (exclude all admin except admin/public)
+pytest --api-cov-report --api-cov-exclusion-patterns="/admin/*" --api-cov-exclusion-patterns="!/admin/public"
+
 # Verbose logging (shows discovery process)
 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.2 → pytest_api_cov-1.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytest-api-cov"
-version = "1.0.2"
+version = "1.1.1"
 description = "Pytest Plugin to provide API Coverage statistics for Python Web Frameworks"
 readme = "README.md"
 authors = [{ name = "Barnaby Gill", email = "barnabasgill@gmail.com" }]

{pytest_api_cov-1.0.2 → pytest_api_cov-1.1.1}/src/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-1.0.2 → pytest_api_cov-1.1.1}/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.2 → pytest_api_cov-1.1.1}/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.2 → pytest_api_cov-1.1.1}/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.2 → pytest_api_cov-1.1.1}/src/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-1.0.2 → pytest_api_cov-1.1.1}/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.2 → pytest_api_cov-1.1.1}/src/pytest_api_cov/report.py

@@ -30,21 +30,61 @@ def categorise_endpoints(
 ) -> Tuple[List[str], List[str], List[str]]:
     """Categorise endpoints into covered, uncovered, and excluded.
 
-    Exclusion patterns support simple wildcard matching:
+    Exclusion patterns support simple wildcard matching with negation:
     - Use * for wildcard (matches any characters)
+    - Use ! at the start to negate a pattern (include what would otherwise be excluded)
     - All other characters are matched literally
-    - Examples: "/admin/*", "/health", "/docs/*"
+    - Examples: "/admin/*", "/health", "!users/bob" (negates exclusion)
+    - Pattern order matters: exclusions are applied first, then negations override them
     """
     covered, uncovered, excluded = [], [], []
 
-    compiled_patterns = (
-        [re.compile("^" + re.escape(pattern).replace(r"\*", ".*") + "$") for pattern in exclusion_patterns]
-        if exclusion_patterns
-        else None
-    )
+    if not exclusion_patterns:
+        compiled_exclusions = None
+        compiled_negations = None
+    else:
+        # Separate exclusion and negation patterns
+        exclusion_only = [p for p in exclusion_patterns if not p.startswith("!")]
+        negation_only = [p[1:] for p in exclusion_patterns if p.startswith("!")]  # Remove the '!' prefix
+
+        compiled_exclusions = (
+            [re.compile("^" + re.escape(pattern).replace(r"\*", ".*") + "$") for pattern in exclusion_only]
+            if exclusion_only
+            else None
+        )
+        compiled_negations = (
+            [re.compile("^" + re.escape(pattern).replace(r"\*", ".*") + "$") for pattern in negation_only]
+            if negation_only
+            else None
+        )
 
     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_exclusions:
+            # 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_exclusions) or any(
+                    p.match(path_only) for p in compiled_exclusions
+                )
+            else:
+                is_excluded = any(p.match(endpoint) for p in compiled_exclusions)
+
+        # Check negation patterns - these override exclusions
+        if is_excluded and compiled_negations:
+            if " " in endpoint:
+                _, path_only = endpoint.split(" ", 1)
+                is_negated = any(p.match(endpoint) for p in compiled_negations) or any(
+                    p.match(path_only) for p in compiled_negations
+                )
+            else:
+                is_negated = any(p.match(endpoint) for p in compiled_negations)
+
+            if is_negated:
+                is_excluded = False  # Negation overrides exclusion
+
+        if is_excluded:
             excluded.append(endpoint)
             continue
         elif contains_escape_characters(endpoint):
@@ -67,7 +107,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: