norn-cli 1.3.17 → 1.3.19

package/out/coverageCalculator.js

@@ -0,0 +1,756 @@
+"use strict";
+/**
+ * Coverage Calculator for Swagger/OpenAPI specs
+ *
+ * Calculates what percentage of swagger-defined endpoints and their
+ * response codes are covered by test sequences.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWorkspaceCoverage = calculateWorkspaceCoverage;
+exports.getCoverage = getCoverage;
+exports.refreshCoverage = refreshCoverage;
+exports.recalculateCoverageAfterExecution = recalculateCoverageAfterExecution;
+exports.clearCoverageCache = clearCoverageCache;
+exports.onCoverageUpdate = onCoverageUpdate;
+const vscode = __importStar(require("vscode"));
+const fs = __importStar(require("fs"));
+const swaggerParser_1 = require("./swaggerParser");
+const nornapiParser_1 = require("./nornapiParser");
+/**
+ * Extract the path portion from a full URL and normalize it for swagger matching.
+ * e.g., "https://petstore.swagger.io/v2/store/inventory" -> "/store/inventory"
+ *
+ * We need to strip the base URL (which typically includes version like /v2) to match swagger paths.
+ */
+function extractSwaggerPath(fullUrl, swaggerBaseUrl) {
+    try {
+        // If it's already just a path (starts with /), return as-is
+        if (fullUrl.startsWith('/')) {
+            return fullUrl;
+        }
+        const url = new URL(fullUrl);
+        // Decode the pathname to convert %7B to { and %7D to }
+        let path = decodeURIComponent(url.pathname);
+        // If we have a swagger base URL, try to strip it from the path
+        if (swaggerBaseUrl) {
+            try {
+                const baseUrl = new URL(swaggerBaseUrl);
+                const basePath = decodeURIComponent(baseUrl.pathname);
+                // If the path starts with the base path (e.g., /v2), strip it
+                if (basePath && basePath !== '/' && path.startsWith(basePath)) {
+                    path = path.substring(basePath.length);
+                    // Ensure path starts with /
+                    if (!path.startsWith('/')) {
+                        path = '/' + path;
+                    }
+                }
+            }
+            catch {
+                // Ignore base URL parsing errors
+            }
+        }
+        return path || '/';
+    }
+    catch {
+        // If URL parsing fails, try to extract path manually
+        const match = fullUrl.match(/https?:\/\/[^\/]+(\/.*)/);
+        return match ? match[1] : fullUrl;
+    }
+}
+/**
+ * Extract swagger URL from .nornapi file content
+ */
+function extractSwaggerUrl(content) {
+    const match = content.match(/^swagger\s+["']?(https?:\/\/[^\s"']+)["']?\s*$/m);
+    return match?.[1];
+}
+/**
+ * Parse assert status lines from sequence content.
+ * Returns array of status codes/patterns (e.g., ["200", "2xx", "404"])
+ */
+function extractAssertedStatusCodes(sequenceContent) {
+    const codes = [];
+    const lines = sequenceContent.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Match various assert status patterns:
+        // - assert status == 200
+        // - assert $1.status == 200
+        // - assert response.status == 200
+        // - assert inventory.status == 200
+        // - assert variableName.status >= 400
+        const statusMatch = trimmed.match(/^assert\s+(?:(?:\$\d+|[a-zA-Z_][a-zA-Z0-9_]*)\.)?status\s*(?:==|>=|<=|>|<|!=)?\s*(\d{3}|[1-5]xx)$/i);
+        if (statusMatch) {
+            codes.push(statusMatch[1].toLowerCase());
+            continue;
+        }
+        // Also match simpler patterns like: assert status 200
+        const simpleMatch = trimmed.match(/^assert\s+status\s+(\d{3}|[1-5]xx)$/i);
+        if (simpleMatch) {
+            codes.push(simpleMatch[1].toLowerCase());
+        }
+    }
+    return codes;
+}
+/**
+ * Check if a wildcard pattern matches a status code
+ * e.g., "2xx" matches "200", "201", "204"
+ */
+function wildcardMatches(pattern, code) {
+    const lowerPattern = pattern.toLowerCase();
+    // Exact match
+    if (lowerPattern === code) {
+        return true;
+    }
+    // Wildcard match (2xx, 4xx, 5xx)
+    if (/^[1-5]xx$/.test(lowerPattern)) {
+        const patternPrefix = lowerPattern[0];
+        return code.startsWith(patternPrefix);
+    }
+    return false;
+}
+/**
+ * Check if a concrete URL path matches a swagger endpoint path template
+ * e.g., "/pet/1" matches "/pet/{petId}"
+ *       "/v2/pet/123" matches "/pet/{petId}" (with base path /v2)
+ */
+function pathMatchesSwaggerEndpoint(urlPath, swaggerPath) {
+    // Normalize paths - remove leading/trailing slashes for comparison
+    const normalizedUrl = urlPath.replace(/^\/+|\/+$/g, '');
+    const normalizedSwagger = swaggerPath.replace(/^\/+|\/+$/g, '');
+    const urlParts = normalizedUrl.split('/');
+    const swaggerParts = normalizedSwagger.split('/');
+    // Try matching from different starting positions to handle base paths
+    // e.g., URL /v2/pet/1 should match swagger /pet/{petId} if base is /v2
+    for (let offset = 0; offset <= urlParts.length - swaggerParts.length; offset++) {
+        let matches = true;
+        for (let i = 0; i < swaggerParts.length; i++) {
+            const urlPart = urlParts[offset + i];
+            const swaggerPart = swaggerParts[i];
+            // Path parameter in swagger (e.g., {petId}) matches any value
+            if (swaggerPart.startsWith('{') && swaggerPart.endsWith('}')) {
+                // Path parameter matches any non-empty value
+                if (!urlPart || urlPart.length === 0) {
+                    matches = false;
+                    break;
+                }
+            }
+            else if (urlPart !== swaggerPart) {
+                // Static segments must match exactly
+                matches = false;
+                break;
+            }
+        }
+        if (matches) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Extract API calls from sequence content.
+ * Returns array of { endpointName, assertedCodes, method?, url? }
+ *
+ * @param sequenceContent - The content of the sequence to analyze
+ * @param allSequences - Map of all sequences by name (for following run SequenceName calls)
+ * @param allNamedRequests - Map of named request blocks by name (for following run NamedRequest calls)
+ * @param visited - Set of already visited sequence names (to prevent infinite recursion)
+ */
+function extractApiCalls(sequenceContent, allSequences, allNamedRequests, visited) {
+    const calls = [];
+    const lines = sequenceContent.split('\n');
+    const visitedSet = visited || new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Check for "run Name" or "var x = run Name" calls
+        const runMatch = line.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?run\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\(.*?\))?$/i);
+        if (runMatch) {
+            const targetName = runMatch[1];
+            // Avoid infinite recursion
+            if (!visitedSet.has(targetName)) {
+                visitedSet.add(targetName);
+                // First check if it's a sequence
+                if (allSequences) {
+                    const subSequenceContent = allSequences.get(targetName);
+                    if (subSequenceContent) {
+                        // Recursively extract API calls from the sub-sequence
+                        const subCalls = extractApiCalls(subSequenceContent, allSequences, allNamedRequests, visitedSet);
+                        calls.push(...subCalls);
+                        continue;
+                    }
+                }
+                // Then check if it's a named request block
+                if (allNamedRequests) {
+                    const namedRequest = allNamedRequests.get(targetName);
+                    if (namedRequest) {
+                        // Look for assert status lines following this run command
+                        const assertedCodes = [];
+                        for (let j = i + 1; j < lines.length; j++) {
+                            const nextLine = lines[j].trim();
+                            // Stop at next request, sequence end, or other control flow
+                            if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i.test(nextLine) ||
+                                /^end\s+sequence$/i.test(nextLine) ||
+                                /^run\s+/i.test(nextLine) ||
+                                /^if\s+/i.test(nextLine) ||
+                                /^foreach\s+/i.test(nextLine)) {
+                                break;
+                            }
+                            // Check for assert status
+                            const statusMatch = nextLine.match(/^assert\s+(?:(?:\$\d+|[a-zA-Z_][a-zA-Z0-9_]*)\.)?status\s*(?:==|>=|<=|>|<|!=)?\s*(\d{3}|[1-5]xx)$/i);
+                            if (statusMatch) {
+                                assertedCodes.push(statusMatch[1].toLowerCase());
+                            }
+                        }
+                        // Add this as a URL-based API call (will be matched by URL later)
+                        calls.push({
+                            endpointName: `__url__${namedRequest.method}__${namedRequest.url}`,
+                            assertedCodes,
+                            method: namedRequest.method,
+                            url: namedRequest.url
+                        });
+                        continue;
+                    }
+                }
+            }
+            continue;
+        }
+        // Match API request by name with optional variable assignment:
+        // - GET EndpointName
+        // - GET EndpointName(args)
+        // - GET EndpointName(args) HeaderGroup
+        // - var result = GET EndpointName
+        // - var inventory = GET GetInventory
+        // - var order = GET GetOrderById(1)
+        const apiCallMatch = line.match(/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\s*\(.*?\))?(?:\s+[a-zA-Z_][a-zA-Z0-9_]*)?$/i);
+        if (apiCallMatch) {
+            const endpointName = apiCallMatch[2];
+            // Look for assert status lines following this request (until next request or end)
+            const assertedCodes = [];
+            for (let j = i + 1; j < lines.length; j++) {
+                const nextLine = lines[j].trim();
+                // Stop at next request, sequence end, or other control flow
+                // Also stop if we see another var assignment with HTTP method
+                if (/^(?:var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*)?(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/i.test(nextLine) ||
+                    /^end\s+sequence$/i.test(nextLine) ||
+                    /^run\s+/i.test(nextLine) ||
+                    /^if\s+/i.test(nextLine) ||
+                    /^foreach\s+/i.test(nextLine)) {
+                    break;
+                }
+                // Check for assert status with variable name or $N reference
+                const statusMatch = nextLine.match(/^assert\s+(?:(?:\$\d+|[a-zA-Z_][a-zA-Z0-9_]*)\.)?status\s*(?:==|>=|<=|>|<|!=)?\s*(\d{3}|[1-5]xx)$/i);
+                if (statusMatch) {
+                    assertedCodes.push(statusMatch[1].toLowerCase());
+                }
+                // Simpler pattern
+                const simpleMatch = nextLine.match(/^assert\s+status\s+(\d{3}|[1-5]xx)$/i);
+                if (simpleMatch) {
+                    assertedCodes.push(simpleMatch[1].toLowerCase());
+                }
+            }
+            calls.push({ endpointName, assertedCodes });
+        }
+    }
+    return calls;
+}
+/**
+ * Extract all test sequences from a .norn file content.
+ * Only "test sequence" blocks count towards coverage, not regular "sequence" blocks.
+ */
+function extractTestSequences(content) {
+    const sequences = [];
+    const lines = content.split('\n');
+    let currentSequence = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Match only "test sequence Name" - regular sequences don't count towards coverage
+        const sequenceMatch = line.match(/^test\s+sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\([^)]*\))?$/);
+        if (sequenceMatch) {
+            currentSequence = { name: sequenceMatch[1], startLine: i };
+            continue;
+        }
+        // Match sequence end
+        if (/^end\s+sequence$/i.test(line) && currentSequence) {
+            const sequenceContent = lines.slice(currentSequence.startLine, i + 1).join('\n');
+            sequences.push({ name: currentSequence.name, content: sequenceContent });
+            currentSequence = null;
+        }
+    }
+    return sequences;
+}
+/**
+ * Extract ALL sequences from a .norn file content (both test and regular).
+ * Used to build a map for following "run SequenceName" calls.
+ */
+function extractAllSequences(content) {
+    const sequences = new Map();
+    const lines = content.split('\n');
+    let currentSequence = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Match both "test sequence Name" and "sequence Name"
+        const testSequenceMatch = line.match(/^test\s+sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\([^)]*\))?$/);
+        const sequenceMatch = line.match(/^sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\([^)]*\))?$/);
+        if (testSequenceMatch || sequenceMatch) {
+            const name = testSequenceMatch ? testSequenceMatch[1] : sequenceMatch[1];
+            currentSequence = { name, startLine: i };
+            continue;
+        }
+        // Match sequence end
+        if (/^end\s+sequence$/i.test(line) && currentSequence) {
+            const sequenceContent = lines.slice(currentSequence.startLine + 1, i).join('\n');
+            sequences.set(currentSequence.name, sequenceContent);
+            currentSequence = null;
+        }
+    }
+    return sequences;
+}
+/**
+ * Extract named request blocks from a .norn file content.
+ * Named requests are blocks like [RequestName] followed by HTTP method + URL.
+ */
+function extractNamedRequests(content) {
+    const requests = new Map();
+    const lines = content.split('\n');
+    let currentRequest = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Match named request start: [RequestName]
+        const nameMatch = line.match(/^\[([a-zA-Z_][a-zA-Z0-9_-]*)\]$/);
+        if (nameMatch) {
+            // Save previous request if exists
+            if (currentRequest) {
+                const requestContent = lines.slice(currentRequest.startLine + 1, i).join('\n').trim();
+                const parsed = parseRequestContent(requestContent);
+                if (parsed) {
+                    requests.set(currentRequest.name, { ...parsed, content: requestContent });
+                }
+            }
+            currentRequest = { name: nameMatch[1], startLine: i };
+            continue;
+        }
+        // Check for sequence start or end - terminates named request block
+        if (/^(?:test\s+)?sequence\s+/i.test(line) || /^end\s+sequence$/i.test(line)) {
+            if (currentRequest) {
+                const requestContent = lines.slice(currentRequest.startLine + 1, i).join('\n').trim();
+                const parsed = parseRequestContent(requestContent);
+                if (parsed) {
+                    requests.set(currentRequest.name, { ...parsed, content: requestContent });
+                }
+                currentRequest = null;
+            }
+        }
+    }
+    // Don't forget the last request
+    if (currentRequest) {
+        const requestContent = lines.slice(currentRequest.startLine + 1).join('\n').trim();
+        const parsed = parseRequestContent(requestContent);
+        if (parsed) {
+            requests.set(currentRequest.name, { ...parsed, content: requestContent });
+        }
+    }
+    return requests;
+}
+/**
+ * Parse the content of a named request block to extract method and URL.
+ */
+function parseRequestContent(content) {
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Match: GET "url" or GET url or POST "url" etc.
+        const match = trimmed.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+["']?([^"'\s]+)["']?/i);
+        if (match) {
+            return { method: match[1].toUpperCase(), url: match[2] };
+        }
+    }
+    return null;
+}
+/**
+ * Calculate coverage for the entire workspace
+ * @param useCachedSpecs If true, only fetch swagger specs for new URLs (used after execution)
+ */
+async function calculateWorkspaceCoverage(useCachedSpecs = false) {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) {
+        return {
+            total: 0,
+            covered: 0,
+            percentage: 0,
+            specs: [],
+            hasSwagger: false
+        };
+    }
+    // Step 1: Find all .nornapi files and extract swagger URLs + endpoint mappings
+    const nornapiFiles = await vscode.workspace.findFiles('**/*.nornapi', '**/node_modules/**');
+    const swaggerUrls = new Map(); // swagger URL -> list of nornapi files
+    // Store endpoint info temporarily - we'll create mappings after fetching swagger specs
+    const pendingEndpoints = [];
+    for (const file of nornapiFiles) {
+        try {
+            const content = fs.readFileSync(file.fsPath, 'utf-8');
+            const swaggerUrl = extractSwaggerUrl(content);
+            if (swaggerUrl) {
+                // Track this nornapi file for this swagger URL
+                if (!swaggerUrls.has(swaggerUrl)) {
+                    swaggerUrls.set(swaggerUrl, []);
+                }
+                swaggerUrls.get(swaggerUrl).push({ url: swaggerUrl, filePath: file.fsPath });
+                // Parse endpoints from this nornapi file
+                const nornApiDef = (0, nornapiParser_1.parseNornApiFile)(content);
+                for (const endpoint of nornApiDef.endpoints) {
+                    // Store for later processing after we have swagger specs
+                    pendingEndpoints.push({
+                        endpoint: { name: endpoint.name, method: endpoint.method, path: endpoint.path },
+                        swaggerUrl,
+                        filePath: file.fsPath
+                    });
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error reading .nornapi file ${file.fsPath}:`, error);
+        }
+    }
+    if (swaggerUrls.size === 0) {
+        return {
+            total: 0,
+            covered: 0,
+            percentage: 0,
+            specs: [],
+            hasSwagger: false
+        };
+    }
+    // Detect new swagger URLs (not seen before)
+    const currentUrls = new Set(swaggerUrls.keys());
+    const newUrls = new Set();
+    for (const url of currentUrls) {
+        if (!knownSwaggerUrls.has(url)) {
+            newUrls.add(url);
+        }
+    }
+    // Update known URLs
+    knownSwaggerUrls = currentUrls;
+    // Step 2: Find all .norn files and extract API calls with assert status
+    const nornFiles = await vscode.workspace.findFiles('**/*.norn', '**/node_modules/**');
+    // Map: endpoint name -> list of asserted status codes (from all sequences)
+    const coverageByName = new Map();
+    // First pass: build a combined map of all sequences across all files
+    // This allows test sequences to call sub-sequences defined in other files
+    const allSequencesMap = new Map();
+    const allNamedRequestsMap = new Map();
+    for (const file of nornFiles) {
+        try {
+            const content = fs.readFileSync(file.fsPath, 'utf-8');
+            const fileSequences = extractAllSequences(content);
+            for (const [name, seqContent] of fileSequences) {
+                allSequencesMap.set(name, seqContent);
+            }
+            const fileNamedRequests = extractNamedRequests(content);
+            for (const [name, reqInfo] of fileNamedRequests) {
+                allNamedRequestsMap.set(name, reqInfo);
+            }
+        }
+        catch (error) {
+            console.error(`Error reading .norn file ${file.fsPath}:`, error);
+        }
+    }
+    // Track URL-based API calls separately (for matching by URL instead of endpoint name)
+    const coverageByUrl = new Map();
+    // Second pass: extract API calls from test sequences, following run commands
+    for (const file of nornFiles) {
+        try {
+            const content = fs.readFileSync(file.fsPath, 'utf-8');
+            const testSequences = extractTestSequences(content);
+            for (const sequence of testSequences) {
+                // Pass the map of all sequences and named requests so we can follow "run" calls
+                const apiCalls = extractApiCalls(sequence.content, allSequencesMap, allNamedRequestsMap);
+                for (const call of apiCalls) {
+                    // Check if this is a URL-based call (from a named request block)
+                    if (call.url && call.method) {
+                        const key = `${call.method} ${call.url}`;
+                        if (!coverageByUrl.has(key)) {
+                            coverageByUrl.set(key, { method: call.method, url: call.url, assertedCodes: new Set() });
+                        }
+                        for (const code of call.assertedCodes) {
+                            coverageByUrl.get(key).assertedCodes.add(code);
+                        }
+                    }
+                    else {
+                        // Regular endpoint name-based call
+                        if (!coverageByName.has(call.endpointName)) {
+                            coverageByName.set(call.endpointName, new Set());
+                        }
+                        for (const code of call.assertedCodes) {
+                            coverageByName.get(call.endpointName).add(code);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error reading .norn file ${file.fsPath}:`, error);
+        }
+    }
+    // Step 3: For each swagger spec, calculate coverage
+    // First fetch all specs so we have baseUrl for path normalization
+    const swaggerSpecs = new Map();
+    for (const [swaggerUrl] of swaggerUrls) {
+        try {
+            const swaggerSpec = await (0, swaggerParser_1.getCachedSwaggerSpec)(swaggerUrl);
+            swaggerSpecs.set(swaggerUrl, swaggerSpec);
+        }
+        catch (error) {
+            console.error(`Error fetching swagger spec ${swaggerUrl}:`, error);
+        }
+    }
+    // Now create endpoint mappings with proper path normalization
+    const endpointMappings = [];
+    for (const pending of pendingEndpoints) {
+        const spec = swaggerSpecs.get(pending.swaggerUrl);
+        if (spec) {
+            // Extract the swagger-style path from the full URL
+            const swaggerPath = extractSwaggerPath(pending.endpoint.path, spec.baseUrl);
+            const swaggerKey = `${pending.endpoint.method} ${swaggerPath}`;
+            endpointMappings.push({
+                name: pending.endpoint.name,
+                swaggerKey,
+                swaggerUrl: pending.swaggerUrl,
+                filePath: pending.filePath
+            });
+        }
+    }
+    const specs = [];
+    for (const [swaggerUrl, swaggerSpec] of swaggerSpecs) {
+        const coverageResult = calculateCoverageForSpec(swaggerUrl, swaggerSpec, endpointMappings.filter(m => m.swaggerUrl === swaggerUrl), coverageByName, coverageByUrl);
+        specs.push(coverageResult);
+    }
+    // Step 4: Aggregate results
+    let totalCodes = 0;
+    let coveredCodes = 0;
+    for (const spec of specs) {
+        totalCodes += spec.total;
+        coveredCodes += spec.covered;
+    }
+    return {
+        total: totalCodes,
+        covered: coveredCodes,
+        percentage: totalCodes > 0 ? Math.round((coveredCodes / totalCodes) * 100) : 0,
+        specs,
+        hasSwagger: true
+    };
+}
+/**
+ * Calculate coverage for a single swagger spec
+ */
+function calculateCoverageForSpec(swaggerUrl, spec, endpointMappings, coverageByName, coverageByUrl) {
+    const endpoints = [];
+    let total = 0;
+    let covered = 0;
+    // Build a lookup from swagger key to endpoint names
+    const keyToNames = new Map();
+    for (const mapping of endpointMappings) {
+        if (!keyToNames.has(mapping.swaggerKey)) {
+            keyToNames.set(mapping.swaggerKey, []);
+        }
+        keyToNames.get(mapping.swaggerKey).push(mapping.name);
+    }
+    // Process each endpoint in the swagger spec
+    for (const section of spec.sections) {
+        for (const endpoint of section.endpoints) {
+            const swaggerKey = `${endpoint.method} ${endpoint.path}`;
+            const names = keyToNames.get(swaggerKey) || [];
+            // Get all asserted codes for any name that maps to this endpoint
+            const allAssertedCodes = new Set();
+            const coveredByNames = {}; // code -> names that cover it
+            for (const name of names) {
+                const codes = coverageByName.get(name);
+                if (codes) {
+                    for (const code of codes) {
+                        allAssertedCodes.add(code);
+                        // Track which names cover which codes
+                        for (const responseCode of endpoint.responseCodes) {
+                            if (wildcardMatches(code, responseCode)) {
+                                if (!coveredByNames[responseCode]) {
+                                    coveredByNames[responseCode] = [];
+                                }
+                                if (!coveredByNames[responseCode].includes(name)) {
+                                    coveredByNames[responseCode].push(name);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Also check URL-based coverage (from named request blocks)
+            // Match URLs to swagger endpoints by comparing the path portion
+            for (const [, urlCoverage] of coverageByUrl) {
+                // Check if method matches
+                if (urlCoverage.method.toUpperCase() !== endpoint.method.toUpperCase()) {
+                    continue;
+                }
+                // Try to match URL to swagger endpoint path
+                // Extract the path from the full URL
+                try {
+                    const url = new URL(urlCoverage.url);
+                    const urlPath = url.pathname;
+                    // Check if URL path matches the swagger endpoint path
+                    // Handle path parameters like /pet/{petId} matching /pet/1
+                    if (pathMatchesSwaggerEndpoint(urlPath, endpoint.path)) {
+                        for (const code of urlCoverage.assertedCodes) {
+                            allAssertedCodes.add(code);
+                        }
+                    }
+                }
+                catch {
+                    // Invalid URL, skip
+                }
+            }
+            // Calculate coverage for each response code
+            const responseCodes = [];
+            let endpointCovered = 0;
+            for (const code of endpoint.responseCodes) {
+                let isCovered = false;
+                const coveredBy = coveredByNames[code] || [];
+                // Check if any asserted code matches this response code
+                for (const assertedCode of allAssertedCodes) {
+                    if (wildcardMatches(assertedCode, code)) {
+                        isCovered = true;
+                        break;
+                    }
+                }
+                responseCodes.push({
+                    code,
+                    covered: isCovered,
+                    coveredBy
+                });
+                total++;
+                if (isCovered) {
+                    covered++;
+                    endpointCovered++;
+                }
+            }
+            endpoints.push({
+                method: endpoint.method,
+                path: endpoint.path,
+                tag: endpoint.tag,
+                summary: endpoint.summary,
+                responseCodes,
+                totalCodes: endpoint.responseCodes.length,
+                coveredCodes: endpointCovered
+            });
+        }
+    }
+    // Sort endpoints by tag, then by path
+    endpoints.sort((a, b) => {
+        if (a.tag !== b.tag) {
+            return a.tag.localeCompare(b.tag);
+        }
+        return a.path.localeCompare(b.path);
+    });
+    return {
+        total,
+        covered,
+        percentage: total > 0 ? Math.round((covered / total) * 100) : 0,
+        endpoints,
+        swaggerUrl,
+        swaggerTitle: spec.title,
+        lastUpdated: new Date()
+    };
+}
+// Cached coverage result for status bar updates
+let cachedCoverage = null;
+let coverageUpdateListeners = [];
+// Track known swagger URLs to detect new ones
+let knownSwaggerUrls = new Set();
+/**
+ * Get cached coverage or calculate if not available
+ */
+async function getCoverage() {
+    if (!cachedCoverage) {
+        cachedCoverage = await calculateWorkspaceCoverage();
+        notifyCoverageListeners();
+    }
+    return cachedCoverage;
+}
+/**
+ * Force recalculate coverage - re-fetches swagger specs
+ */
+async function refreshCoverage() {
+    cachedCoverage = await calculateWorkspaceCoverage();
+    notifyCoverageListeners();
+    return cachedCoverage;
+}
+/**
+ * Recalculate coverage after execution - only re-scans .norn files,
+ * uses cached swagger specs unless new URLs are detected
+ */
+async function recalculateCoverageAfterExecution() {
+    cachedCoverage = await calculateWorkspaceCoverage(true);
+    notifyCoverageListeners();
+    return cachedCoverage;
+}
+/**
+ * Clear cached coverage
+ */
+function clearCoverageCache() {
+    cachedCoverage = null;
+}
+/**
+ * Register a listener for coverage updates
+ */
+function onCoverageUpdate(listener) {
+    coverageUpdateListeners.push(listener);
+    return {
+        dispose: () => {
+            const index = coverageUpdateListeners.indexOf(listener);
+            if (index !== -1) {
+                coverageUpdateListeners.splice(index, 1);
+            }
+        }
+    };
+}
+/**
+ * Notify all listeners of coverage update
+ */
+function notifyCoverageListeners() {
+    if (cachedCoverage) {
+        for (const listener of coverageUpdateListeners) {
+            listener(cachedCoverage);
+        }
+    }
+}
+//# sourceMappingURL=coverageCalculator.js.map