qa360 2.1.7 → 2.2.0

package/dist/core/adapters/k6-perf.js

@@ -1,398 +0,0 @@
-/**
- * QA360 k6 Performance Adapter (Socle OOTB)
- * Short performance tests with P95 calculation
- */
-import { spawn } from 'child_process';
-import { writeFileSync, unlinkSync, existsSync } from 'fs';
-import { join } from 'path';
-import { SecurityRedactor } from '../security/redactor.js';
-export class K6PerfAdapter {
-    redactor;
-    workingDir;
-    constructor(workingDir = process.cwd()) {
-        this.redactor = SecurityRedactor.forLogs();
-        this.workingDir = workingDir;
-    }
-    /**
-     * Execute k6 performance test
-     */
-    async runPerfTest(config) {
-        const scriptPath = join(this.workingDir, 'k6-test-temp.js');
-        try {
-            // Generate k6 script
-            const script = this.generateK6Script(config);
-            writeFileSync(scriptPath, script);
-            console.log(`⚡ Running k6 performance test (${config.duration || '30s'}, ${config.vus || 5} VUs)`);
-            // Execute k6
-            const result = await this.executeK6(scriptPath, config);
-            return result;
-        }
-        finally {
-            // Cleanup temp script
-            if (existsSync(scriptPath)) {
-                unlinkSync(scriptPath);
-            }
-        }
-    }
-    /**
-     * Generate k6 test script
-     */
-    generateK6Script(config) {
-        const duration = config.duration || '30s';
-        const vus = config.vus || 5;
-        const p95Budget = config.budgets?.perf_p95_ms || 2000;
-        const scenarios = config.scenarios || {
-            load_test: {
-                executor: 'constant-vus',
-                vus: vus,
-                duration: duration
-            }
-        };
-        return `
-import http from 'k6/http';
-import { check, sleep } from 'k6';
-import { Rate } from 'k6/metrics';
-
-// Custom metrics
-export let errorRate = new Rate('errors');
-
-export let options = {
-  scenarios: ${JSON.stringify(scenarios, null, 2)},
-  thresholds: {
-    'http_req_duration': ['p(95)<${p95Budget}'],
-    'http_req_failed': ['rate<0.1'], // Less than 10% errors
-    'errors': ['rate<0.1']
-  }
-};
-
-export default function() {
-  const baseUrl = '${config.baseUrl}';
-  
-  // Main request
-  const response = http.get(baseUrl, {
-    headers: {
-      'User-Agent': 'QA360-k6-Perf/1.0'
-    }
-  });
-  
-  // Check response
-  const success = check(response, {
-    'status is 200-299': (r) => r.status >= 200 && r.status < 300,
-    'response time < ${p95Budget}ms': (r) => r.timings.duration < ${p95Budget}
-  });
-  
-  errorRate.add(!success);
-  
-  // Small delay between requests
-  sleep(0.1);
-}
-
-export function handleSummary(data) {
-  return {
-    'stdout': textSummary(data, { indent: ' ', enableColors: false }),
-    '/tmp/k6-summary.json': JSON.stringify(data, null, 2)
-  };
-}
-
-function textSummary(data, options = {}) {
-  const indent = options.indent || '';
-  const colors = options.enableColors !== false;
-  
-  let output = '';
-  
-  // Test run info
-  output += indent + 'Test Run Summary\\n';
-  output += indent + '================\\n\\n';
-  
-  // Scenarios
-  if (data.root_group && data.root_group.groups) {
-    for (const [name, group] of Object.entries(data.root_group.groups)) {
-      output += indent + \`Scenario: \${name}\\n\`;
-    }
-  }
-  
-  // Metrics
-  output += indent + 'Metrics:\\n';
-  for (const [name, metric] of Object.entries(data.metrics)) {
-    if (metric.type === 'trend') {
-      output += indent + \`  \${name}: avg=\${metric.values.avg.toFixed(2)}ms p95=\${metric.values['p(95)'].toFixed(2)}ms\\n\`;
-    } else if (metric.type === 'rate') {
-      output += indent + \`  \${name}: \${(metric.values.rate * 100).toFixed(2)}%\\n\`;
-    } else if (metric.type === 'counter') {
-      output += indent + \`  \${name}: \${metric.values.count}\\n\`;
-    }
-  }
-  
-  // Thresholds
-  if (data.thresholds) {
-    output += indent + '\\nThresholds:\\n';
-    for (const [name, threshold] of Object.entries(data.thresholds)) {
-      const status = threshold.ok ? '✓' : '✗';
-      output += indent + \`  \${status} \${name}\\n\`;
-    }
-  }
-  
-  return output;
-}
-`;
-    }
-    /**
-     * Execute k6 command
-     */
-    async executeK6(scriptPath, config) {
-        return new Promise((resolve) => {
-            let output = '';
-            let error = '';
-            const args = [
-                'run',
-                '--out', 'json=/tmp/k6-results.json',
-                '--summary-export', '/tmp/k6-summary.json',
-                scriptPath
-            ];
-            const child = spawn('k6', args, {
-                cwd: this.workingDir,
-                stdio: ['ignore', 'pipe', 'pipe']
-            });
-            const timeout = setTimeout(() => {
-                child.kill('SIGKILL');
-                resolve({
-                    success: false,
-                    metrics: this.getDefaultMetrics(),
-                    thresholds: {},
-                    error: `k6 test timed out after ${config.timeout || 120000}ms`
-                });
-            }, config.timeout || 120000);
-            if (child.stdout) {
-                child.stdout.on('data', (data) => {
-                    output += data.toString();
-                });
-            }
-            if (child.stderr) {
-                child.stderr.on('data', (data) => {
-                    error += data.toString();
-                });
-            }
-            child.on('close', (code) => {
-                clearTimeout(timeout);
-                if (code === 0) {
-                    // Parse results
-                    const result = this.parseK6Results(output, config);
-                    resolve(result);
-                }
-                else {
-                    resolve({
-                        success: false,
-                        metrics: this.getDefaultMetrics(),
-                        thresholds: {},
-                        error: this.redactor.redact(error || `k6 exited with code ${code}`),
-                        rawOutput: this.redactor.redact(output)
-                    });
-                }
-            });
-            child.on('error', (err) => {
-                clearTimeout(timeout);
-                resolve({
-                    success: false,
-                    metrics: this.getDefaultMetrics(),
-                    thresholds: {},
-                    error: `Failed to start k6: ${err.message}. Make sure k6 is installed.`
-                });
-            });
-        });
-    }
-    /**
-     * Parse k6 results from output
-     */
-    parseK6Results(output, config) {
-        try {
-            // Try to read JSON summary if available
-            const summaryPath = '/tmp/k6-summary.json';
-            let summaryData = null;
-            try {
-                if (existsSync(summaryPath)) {
-                    const summaryContent = require('fs').readFileSync(summaryPath, 'utf8');
-                    summaryData = JSON.parse(summaryContent);
-                    unlinkSync(summaryPath); // Cleanup
-                }
-            }
-            catch {
-                // Continue with text parsing
-            }
-            let metrics = this.getDefaultMetrics();
-            let thresholds = {};
-            if (summaryData && summaryData.metrics) {
-                // Parse from JSON summary
-                const m = summaryData.metrics;
-                metrics = {
-                    http_req_duration_p95: m.http_req_duration?.values?.['p(95)'] || 0,
-                    http_req_duration_avg: m.http_req_duration?.values?.avg || 0,
-                    http_req_failed_rate: (m.http_req_failed?.values?.rate || 0) * 100,
-                    http_reqs_total: m.http_reqs?.values?.count || 0,
-                    vus_max: m.vus_max?.values?.max || config.vus || 5,
-                    iterations: m.iterations?.values?.count || 0
-                };
-                // Parse thresholds
-                if (summaryData.thresholds) {
-                    for (const [name, threshold] of Object.entries(summaryData.thresholds)) {
-                        thresholds[name] = {
-                            passed: threshold.ok || false,
-                            value: 0, // Would need more parsing
-                            threshold: name
-                        };
-                    }
-                }
-            }
-            else {
-                // Fallback: parse from text output
-                metrics = this.parseTextMetrics(output);
-                thresholds = this.parseTextThresholds(output);
-            }
-            // Check if test passed based on budgets
-            const p95Budget = config.budgets?.perf_p95_ms || 2000;
-            const success = metrics.http_req_duration_p95 <= p95Budget &&
-                metrics.http_req_failed_rate < 10;
-            const junit = this.generateJUnit(metrics, success, config);
-            return {
-                success,
-                metrics,
-                thresholds,
-                rawOutput: this.redactor.redact(output),
-                junit
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                metrics: this.getDefaultMetrics(),
-                thresholds: {},
-                error: `Failed to parse k6 results: ${error}`,
-                rawOutput: this.redactor.redact(output)
-            };
-        }
-    }
-    /**
-     * Parse metrics from text output
-     */
-    parseTextMetrics(output) {
-        const metrics = this.getDefaultMetrics();
-        // Parse common patterns from k6 output
-        const patterns = {
-            http_req_duration_p95: /http_req_duration.*p\(95\)=([0-9.]+)ms/,
-            http_req_duration_avg: /http_req_duration.*avg=([0-9.]+)ms/,
-            http_req_failed_rate: /http_req_failed[.\s]*:\s*([0-9.]+)%/,
-            http_reqs_total: /http_reqs[.\s]*:\s*([0-9]+)/,
-            iterations: /iterations[.\s]*:\s*([0-9]+)/
-        };
-        for (const [key, pattern] of Object.entries(patterns)) {
-            const match = output.match(pattern);
-            if (match) {
-                metrics[key] = parseFloat(match[1]);
-            }
-        }
-        return metrics;
-    }
-    /**
-     * Parse thresholds from text output
-     */
-    parseTextThresholds(output) {
-        const thresholds = {};
-        // Look for threshold results (✓ or ✗)
-        const thresholdLines = output.split('\n').filter(line => line.includes('✓') || line.includes('✗') || line.includes('PASS') || line.includes('FAIL'));
-        for (const line of thresholdLines) {
-            const passed = line.includes('✓') || line.includes('PASS');
-            const name = line.replace(/[✓✗]/g, '').trim();
-            if (name) {
-                thresholds[name] = {
-                    passed,
-                    value: 0,
-                    threshold: name
-                };
-            }
-        }
-        return thresholds;
-    }
-    /**
-     * Generate JUnit XML
-     */
-    generateJUnit(metrics, success, config) {
-        const timestamp = new Date().toISOString();
-        const duration = (metrics.http_req_duration_avg / 1000).toFixed(3);
-        let junit = `<?xml version="1.0" encoding="UTF-8"?>
-<testsuite name="k6 Performance Test" tests="1" failures="${success ? 0 : 1}" time="${duration}" timestamp="${timestamp}">
-  <testcase name="Performance Test: ${config.baseUrl}" time="${duration}">
-`;
-        if (!success) {
-            const p95Budget = config.budgets?.perf_p95_ms || 2000;
-            junit += `    <failure message="Performance budget exceeded">
-P95 response time: ${metrics.http_req_duration_p95}ms (budget: ${p95Budget}ms)
-Average response time: ${metrics.http_req_duration_avg}ms
-Failed requests: ${metrics.http_req_failed_rate}%
-Total requests: ${metrics.http_reqs_total}
-    </failure>
-`;
-        }
-        junit += `  </testcase>
-</testsuite>`;
-        return junit;
-    }
-    /**
-     * Get default metrics structure
-     */
-    getDefaultMetrics() {
-        return {
-            http_req_duration_p95: 0,
-            http_req_duration_avg: 0,
-            http_req_failed_rate: 0,
-            http_reqs_total: 0,
-            vus_max: 0,
-            iterations: 0
-        };
-    }
-    /**
-     * Check if k6 is available
-     */
-    static async isAvailable() {
-        return new Promise((resolve) => {
-            const child = spawn('k6', ['version'], { stdio: 'pipe' });
-            child.on('close', (code) => {
-                resolve({
-                    available: code === 0,
-                    error: code !== 0 ? 'k6 not found. Install from https://k6.io/docs/get-started/installation/' : undefined
-                });
-            });
-            child.on('error', () => {
-                resolve({
-                    available: false,
-                    error: 'k6 not found. Install from https://k6.io/docs/get-started/installation/'
-                });
-            });
-        });
-    }
-    /**
-     * Validate performance test configuration
-     */
-    static validateConfig(config) {
-        const errors = [];
-        if (!config.baseUrl) {
-            errors.push('Performance test requires baseUrl');
-        }
-        else {
-            try {
-                new URL(config.baseUrl);
-            }
-            catch {
-                errors.push('Performance test baseUrl must be a valid URL');
-            }
-        }
-        if (config.vus !== undefined && (config.vus <= 0 || config.vus > 1000)) {
-            errors.push('VUs must be between 1 and 1000');
-        }
-        if (config.duration && !/^\d+[smh]$/.test(config.duration)) {
-            errors.push('Duration must be in format like "30s", "5m", "1h"');
-        }
-        return {
-            valid: errors.length === 0,
-            errors
-        };
-    }
-}

package/dist/core/adapters/osv-deps.d.ts

@@ -1,123 +0,0 @@
-/**
- * QA360 OSV Dependencies Adapter (Sécurité Réelle)
- * Scan vulnerabilities in package-lock.json / pnpm-lock.yaml
- */
-import { PackSecurity } from '../types/pack-v1.js';
-export interface OsvScanConfig {
-    workingDir: string;
-    security?: PackSecurity;
-    timeout?: number;
-    lockFiles?: string[];
-}
-export interface OsvVulnerability {
-    id: string;
-    summary: string;
-    severity: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW' | 'UNKNOWN';
-    package: {
-        name: string;
-        version: string;
-        ecosystem: string;
-    };
-    affected: Array<{
-        package: {
-            name: string;
-            ecosystem: string;
-        };
-        ranges: Array<{
-            type: string;
-            events: Array<{
-                introduced?: string;
-                fixed?: string;
-            }>;
-        }>;
-    }>;
-    references: Array<{
-        type: string;
-        url: string;
-    }>;
-}
-export interface OsvScanResult {
-    success: boolean;
-    vulnerabilities: OsvVulnerability[];
-    summary: {
-        total: number;
-        critical: number;
-        high: number;
-        medium: number;
-        low: number;
-        unknown: number;
-    };
-    budgetCheck: {
-        critical_passed: boolean;
-        high_passed: boolean;
-        medium_passed: boolean;
-    };
-    scannedFiles: string[];
-    error?: string;
-    rawOutput?: string;
-    junit?: string;
-    errorCode?: string;
-}
-export declare class OsvDepsAdapter {
-    private redactor;
-    private workingDir;
-    constructor(workingDir?: string);
-    /**
-     * Execute OSV dependency scan
-     */
-    runDependencyScan(config: OsvScanConfig): Promise<OsvScanResult>;
-    /**
-     * Find lock files in working directory
-     */
-    private findLockFiles;
-    /**
-     * Execute OSV scanner on lock files
-     */
-    private executeOsvScan;
-    /**
-     * Parse OSV scanner results
-     */
-    private parseOsvResults;
-    /**
-     * Fallback API-based scanning when osv-scanner not available
-     */
-    private fallbackApiScan;
-    /**
-     * Map severity from various formats to standard levels
-     */
-    private mapSeverity;
-    /**
-     * Calculate vulnerability summary
-     */
-    private calculateSummary;
-    /**
-     * Generate budget check based on security config
-     */
-    private generateBudgetCheck;
-    /**
-     * Get empty summary structure
-     */
-    private getEmptySummary;
-    /**
-     * Get default budget check structure
-     */
-    private getDefaultBudgetCheck;
-    /**
-     * Generate JUnit XML report
-     */
-    private generateJUnit;
-    /**
-     * Validate OSV scan configuration
-     */
-    static validateConfig(config: OsvScanConfig): {
-        valid: boolean;
-        errors: string[];
-    };
-    /**
-     * Check if OSV scanner is available
-     */
-    static isAvailable(): Promise<{
-        available: boolean;
-        error?: string;
-    }>;
-}