qa360 2.2.1 → 2.2.13

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

@@ -0,0 +1,398 @@
+/**
+ * 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/cli/dist/core/adapters/osv-deps.d.ts

@@ -0,0 +1,123 @@
+/**
+ * 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;
+    }>;
+}