api-tests-coverage 1.0.21 → 1.0.22

package/dist/src/generation/gap-extractor.js

@@ -0,0 +1,281 @@
+"use strict";
+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.buildSampleGaps = buildSampleGaps;
+exports.extractGaps = extractGaps;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/**
+ * Builds 5 synthetic sample gaps for onboarding / dry-run purposes.
+ * Used when coverage-summary.json has zero gaps or does not exist.
+ */
+function buildSampleGaps() {
+    return [
+        {
+            id: 'sample-gap-001',
+            type: 'endpoint:missing',
+            endpoint: { method: 'GET', path: '/api/v1/users' },
+            riskScore: 80,
+            sourceFile: undefined,
+            existingSimilarTests: [],
+        },
+        {
+            id: 'sample-gap-002',
+            type: 'parameter:missing',
+            endpoint: { method: 'POST', path: '/api/v1/orders' },
+            parameter: { name: 'customerId', in: 'body', required: true },
+            riskScore: 70,
+            sourceFile: undefined,
+            existingSimilarTests: [],
+        },
+        {
+            id: 'sample-gap-003',
+            type: 'business:missing',
+            businessRule: { id: 'BR-001', description: 'Order total must be positive' },
+            riskScore: 60,
+            sourceFile: undefined,
+            existingSimilarTests: [],
+        },
+        {
+            id: 'sample-gap-004',
+            type: 'error:missing-status',
+            endpoint: { method: 'DELETE', path: '/api/v1/items/{id}' },
+            riskScore: 65,
+            sourceFile: undefined,
+            existingSimilarTests: [],
+        },
+        {
+            id: 'sample-gap-005',
+            type: 'security:missing-auth',
+            endpoint: { method: 'PUT', path: '/api/v1/admin/settings' },
+            riskScore: 90,
+            sourceFile: undefined,
+            existingSimilarTests: [],
+        },
+    ];
+}
+/**
+ * Maps coverage summary type names to corresponding GapType values.
+ */
+function mapTypeToGapType(coverageType, index) {
+    var _a;
+    const mapping = {
+        endpoint: 'endpoint:missing',
+        parameter: 'parameter:missing',
+        business: 'business:missing',
+        integration: 'integration:missing-step',
+        error: 'error:missing-status',
+        security: 'security:missing-auth',
+        performance: 'performance:missing-sla',
+        resilience: 'resilience:missing-retry',
+    };
+    return (_a = mapping[coverageType]) !== null && _a !== void 0 ? _a : 'endpoint:missing';
+}
+/**
+ * Reads reports/coverage-summary.json and extracts uncovered items as DetectedGap[].
+ * When there are zero gaps (perfect coverage), returns buildSampleGaps() instead of [].
+ */
+function extractGaps(reportsDir) {
+    var _a, _b;
+    const summaryPath = path.join(reportsDir, 'coverage-summary.json');
+    if (!fs.existsSync(summaryPath)) {
+        return buildSampleGaps();
+    }
+    let summary;
+    try {
+        summary = JSON.parse(fs.readFileSync(summaryPath, 'utf-8'));
+    }
+    catch {
+        return buildSampleGaps();
+    }
+    const entries = (_a = summary.summary) !== null && _a !== void 0 ? _a : [];
+    const gaps = [];
+    let gapIndex = 0;
+    for (const entry of entries) {
+        const uncoveredCount = entry.totalItems - entry.coveredItems;
+        if (uncoveredCount <= 0)
+            continue;
+        const details = (_b = summary.details) === null || _b === void 0 ? void 0 : _b[entry.type];
+        const gapType = mapTypeToGapType(entry.type, gapIndex);
+        // Extract top gaps from details.topGaps if available
+        const topGaps = [];
+        if (details && typeof details === 'object' && 'topGaps' in details) {
+            const raw = details['topGaps'];
+            if (Array.isArray(raw)) {
+                for (const g of raw) {
+                    if (typeof g === 'string')
+                        topGaps.push(g);
+                }
+            }
+        }
+        // Extract uncovered items from details based on type
+        const uncoveredItems = extractUncoveredItems(entry.type, details);
+        if (uncoveredItems.length > 0) {
+            for (const item of uncoveredItems.slice(0, Math.max(uncoveredCount, 1))) {
+                gaps.push(buildGapFromItem(gapType, entry.type, item, gapIndex));
+                gapIndex++;
+            }
+        }
+        else {
+            // Fallback: create a single gap for the type
+            gaps.push({
+                id: `gap-${entry.type}-${gapIndex}`,
+                type: gapType,
+                riskScore: computeRiskScore(entry.coveragePercent),
+                existingSimilarTests: topGaps,
+            });
+            gapIndex++;
+        }
+    }
+    if (gaps.length === 0) {
+        return buildSampleGaps();
+    }
+    return gaps;
+}
+function computeRiskScore(coveragePercent) {
+    // Lower coverage → higher risk
+    return Math.round(Math.max(0, Math.min(100, 100 - coveragePercent)));
+}
+function extractUncoveredItems(coverageType, details) {
+    var _a, _b, _c, _d, _e;
+    if (!details || typeof details !== 'object')
+        return [];
+    const d = details;
+    switch (coverageType) {
+        case 'endpoint': {
+            const items = (_a = d['endpoints']) !== null && _a !== void 0 ? _a : d['items'];
+            if (Array.isArray(items)) {
+                return items.filter((i) => !i['covered'] && !i['isCovered']);
+            }
+            break;
+        }
+        case 'parameter': {
+            const params = (_b = d['parameters']) !== null && _b !== void 0 ? _b : d['items'];
+            if (Array.isArray(params)) {
+                return params.filter((p) => { var _a; return ((_a = p['ratio']) !== null && _a !== void 0 ? _a : 1) === 0; });
+            }
+            break;
+        }
+        case 'business': {
+            const rules = (_c = d['uncoveredRules']) !== null && _c !== void 0 ? _c : d['items'];
+            if (Array.isArray(rules)) {
+                return rules;
+            }
+            break;
+        }
+        case 'integration': {
+            const items = d['items'];
+            if (Array.isArray(items)) {
+                return items.filter((i) => !i['complete']);
+            }
+            break;
+        }
+        case 'error': {
+            const scenarios = (_d = d['uncoveredScenarios']) !== null && _d !== void 0 ? _d : d['items'];
+            if (Array.isArray(scenarios)) {
+                return scenarios;
+            }
+            break;
+        }
+        case 'security': {
+            const controls = (_e = d['uncoveredControls']) !== null && _e !== void 0 ? _e : d['items'];
+            if (Array.isArray(controls)) {
+                return controls;
+            }
+            break;
+        }
+    }
+    return [];
+}
+function buildGapFromItem(gapType, coverageType, item, index) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    const id = `gap-${coverageType}-${index}`;
+    const riskScore = computeRiskScore(0); // uncovered = high risk
+    switch (coverageType) {
+        case 'endpoint':
+            return {
+                id,
+                type: gapType,
+                endpoint: {
+                    method: String((_a = item['method']) !== null && _a !== void 0 ? _a : 'GET').toUpperCase(),
+                    path: String((_b = item['path']) !== null && _b !== void 0 ? _b : '/unknown'),
+                },
+                riskScore,
+                existingSimilarTests: [],
+            };
+        case 'parameter':
+            return {
+                id,
+                type: gapType,
+                parameter: {
+                    name: String((_c = item['name']) !== null && _c !== void 0 ? _c : 'param'),
+                    in: (_d = item['in']) !== null && _d !== void 0 ? _d : 'query',
+                    required: Boolean((_e = item['required']) !== null && _e !== void 0 ? _e : false),
+                },
+                riskScore,
+                existingSimilarTests: [],
+            };
+        case 'business':
+            return {
+                id,
+                type: gapType,
+                businessRule: {
+                    id: String((_f = item['id']) !== null && _f !== void 0 ? _f : id),
+                    description: String((_g = item['description']) !== null && _g !== void 0 ? _g : 'Business rule'),
+                },
+                riskScore,
+                existingSimilarTests: [],
+            };
+        case 'integration':
+            return {
+                id,
+                type: gapType,
+                integrationFlow: {
+                    id: String((_h = item['id']) !== null && _h !== void 0 ? _h : id),
+                    name: String((_j = item['name']) !== null && _j !== void 0 ? _j : 'Flow'),
+                    missingStep: String((_l = (_k = item['uncoveredSteps']) === null || _k === void 0 ? void 0 : _k[0]) !== null && _l !== void 0 ? _l : 'step'),
+                },
+                riskScore,
+                existingSimilarTests: [],
+            };
+        default:
+            return {
+                id,
+                type: gapType,
+                riskScore,
+                existingSimilarTests: [],
+            };
+    }
+}

package/dist/src/generation/template-renderer.d.ts

@@ -0,0 +1,10 @@
+import type { DetectedGap, GenerationContext, GapType } from './types';
+/** Common OWASP injection strings for security tests */
+export declare const OWASP_INJECTION_STRINGS: string[];
+/** Standard file header injected into every generated test file */
+export declare function renderFileHeader(gapId: string, gapType: GapType): string;
+/** Render test file content for a given gap and context */
+export declare function renderTemplate(gap: DetectedGap, ctx: GenerationContext): string;
+/** Returns the template name used for a given gap type */
+export declare function getTemplateName(gap: DetectedGap, ctx: GenerationContext): string;
+//# sourceMappingURL=template-renderer.d.ts.map

package/dist/src/generation/template-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-renderer.d.ts","sourceRoot":"","sources":["../../../src/generation/template-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvE,wDAAwD;AACxD,eAAO,MAAM,uBAAuB,EAAE,MAAM,EAW3C,CAAC;AAEF,mEAAmE;AACnE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAQxE;AA4eD,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAoC/E;AAED,0DAA0D;AAC1D,wBAAgB,eAAe,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAEhF"}