api-tests-coverage 1.0.18 → 1.0.20

package/dist/src/inference/routeInference.js

@@ -80,7 +80,18 @@ const JSDOC_ROUTE_PATTERN = /@route\s+\{(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)
  * Used to gate the URL+method object-form scan so we only activate it in
  * files that actually make HTTP calls (avoids scanning every JS file).
  */
-const HTTP_CLIENT_SIGNAL = /\$http|\bfetch\s*\(|\baxios\b/;
+const HTTP_CLIENT_SIGNAL = /\$http|\bfetch\s*\(|\baxios\b|\bsuperagent\b/;
+/**
+ * Matches client-side HTTP method calls: requests.get('/path'), api.post('/path'), etc.
+ * Group 1 = HTTP method, Group 2 = path literal starting with /
+ * Also handles: superagent.get(`${base}/path`) → captures the static suffix
+ */
+const HTTP_CLIENT_METHOD_CALL = /\b\w+\s*\.\s*(get|post|put|patch|delete|del|head|options)\s*\(\s*(?:[^'"`\n]*?\+\s*)?['"`](\/[^'"`?\n]+)/i;
+/**
+ * Signals that this JS/TS file is a client-side HTTP service layer.
+ * Expands on HTTP_CLIENT_SIGNAL to include superagent and common wrapper patterns.
+ */
+const HTTP_SERVICE_SIGNAL = /\bsuperagent\b|\brequests\s*\.\s*(?:get|post|put|delete|del)\b|\bapi\s*\.\s*(?:get|post|put|delete)\b/;
 /**
  * Matches a `url:` property that ends with a literal path segment starting
  * with `/`.  Handles both bare and concatenated forms:
@@ -162,6 +173,8 @@ function inferRoutesFromFile(filePath) {
     // We only enable the object-form method+url scanner for such files to
     // avoid false positives in ordinary JS/TS source.
     const usesHttpClient = HTTP_CLIENT_SIGNAL.test(content);
+    // Pre-check: does this file use a client-side HTTP service wrapper (requests.*, api.*, etc.)?
+    const usesHttpServiceWrapper = HTTP_SERVICE_SIGNAL.test(content);
     for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
         const line = lines[lineIdx];
         // 1a. router.method('/path', ...) — all on one line
@@ -239,6 +252,21 @@ function inferRoutesFromFile(filePath) {
                 }
             }
         }
+        // 6. Client-side HTTP method calls: requests.get('/path'), api.post('/path')
+        //    Only activate for files that contain HTTP service signals to avoid false positives
+        if (usesHttpServiceWrapper) {
+            const clientCallMatch = line.match(HTTP_CLIENT_METHOD_CALL);
+            if (clientCallMatch) {
+                let httpMethod = clientCallMatch[1].toLowerCase();
+                // Normalize 'del' → 'delete'
+                if (httpMethod === 'del')
+                    httpMethod = 'delete';
+                if (exports.HTTP_METHODS.includes(httpMethod)) {
+                    const routePath = clientCallMatch[2].split('?')[0]; // strip query string
+                    addRoute(httpMethod, routePath, lineIdx + 1, 'code');
+                }
+            }
+        }
     }
     return [...byKey.values()];
 }
@@ -400,7 +428,7 @@ function findNextMethodNameInJava(javaLines, fromLine) {
  *   @blueprint.route('/articles/<slug>', methods=['PUT'])
  *   @app.route('/tags')   ← defaults to GET
  */
-const FLASK_ROUTE = /@(\w+)\.route\s*\(\s*['"]([^'"]+)['"](?:\s*,\s*methods\s*=\s*\[([^\]]+)\])?\s*\)/;
+const FLASK_ROUTE = /@(\w+)\.route\s*\(\s*['"]([^'"]+)['"](?:[^\n]*?\bmethods\s*=\s*[\[(]([^\])\n]+)[\])])?/;
 /**
  * Matches FastAPI decorators.
  *   @app.get('/articles')
@@ -419,6 +447,22 @@ const FLASK_BLUEPRINT_CTOR = /(\w+)\s*=\s*Blueprint\s*\(\s*['"][^'"]+['"](?:\s*,
  *   router = APIRouter(prefix="/articles")
  */
 const FASTAPI_APIROUTER = /(\w+)\s*=\s*APIRouter\s*\([^)]*?prefix\s*=\s*['"]([^'"]+)['"]/;
+/**
+ * Scan ahead for a Python `def function_name(` line following a decorator.
+ * Skips additional decorator lines and stops at the first non-decorator,
+ * non-blank, non-comment line that is not a def.
+ */
+function findPythonHandlerFunction(lines, fromLine) {
+    for (let j = fromLine + 1; j < Math.min(fromLine + 6, lines.length); j++) {
+        const m = lines[j].match(/^def\s+(\w+)\s*\(/);
+        if (m)
+            return m[1];
+        // Skip decorator lines
+        if (!lines[j].trim().startsWith('@') && lines[j].trim().length > 0 && !lines[j].trim().startsWith('#'))
+            break;
+    }
+    return undefined;
+}
 /**
  * Infer routes from a Python (Flask/FastAPI) source file.
  */
@@ -432,10 +476,10 @@ function inferRoutesFromPythonFile(filePath) {
     }
     const lines = content.split('\n');
     const byKey = new Map();
-    const addRoute = (method, routePath, lineNumber) => {
+    const addRoute = (method, routePath, lineNumber, handlerFunction) => {
         const key = `${method}:${routePath}`;
         if (!byKey.has(key)) {
-            byKey.set(key, { method, path: routePath, sourceFile: filePath, lineNumber, discoveredVia: 'code' });
+            byKey.set(key, { method, path: routePath, handlerFunction, sourceFile: filePath, lineNumber, discoveredVia: 'code' });
         }
     };
     // Pass 1: Detect blueprint/router prefix for the file
@@ -463,18 +507,19 @@ function inferRoutesFromPythonFile(filePath) {
             const fullPath = localPrefix + (routePath.startsWith('/') ? routePath : '/' + routePath);
             // Normalize Flask <param> to {param}
             const normalizedPath = fullPath.replace(/<(?:\w+:)?(\w+)>/g, '{$1}');
+            const handlerFn = findPythonHandlerFunction(lines, i);
             if (methodsList) {
-                // Parse methods=['GET', 'POST'] → individual routes
+                // Parse methods=['GET', 'POST'] or methods=('GET', 'POST') → individual routes
                 const methods = methodsList.replace(/['"]/g, '').split(',').map((m) => m.trim().toLowerCase());
                 for (const m of methods) {
                     if (exports.HTTP_METHODS.includes(m)) {
-                        addRoute(m, normalizedPath, i + 1);
+                        addRoute(m, normalizedPath, i + 1, handlerFn);
                     }
                 }
             }
             else {
                 // Default to GET
-                addRoute('get', normalizedPath, i + 1);
+                addRoute('get', normalizedPath, i + 1, handlerFn);
             }
             continue;
         }
@@ -484,8 +529,9 @@ function inferRoutesFromPythonFile(filePath) {
             const httpMethod = fastapiMatch[2].toLowerCase();
             const routePath = fastapiMatch[3];
             const fullPath = localPrefix + (routePath.startsWith('/') ? routePath : '/' + routePath);
+            const handlerFn = findPythonHandlerFunction(lines, i);
             // FastAPI uses {param} natively
-            addRoute(httpMethod, fullPath, i + 1);
+            addRoute(httpMethod, fullPath, i + 1, handlerFn);
             continue;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-tests-coverage",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "CLI and library to measure how thoroughly your test suite exercises your API surface area",
   "main": "dist/src/lib/index.js",
   "types": "dist/src/lib/index.d.ts",